Apple's open-source XNU kernel on Android phones: its own loader and drivers, Metal on the Adreno. Runs from RAM; a reboot gives the phone back to Android.
C
HFS Plus built into the kernel (Apple's hfs-627.100.6), and a virtio disk that writes (virtio_blk=2) to try it on
shimoku7483aceb83817c
diff --git a/drivers/storage/hakios.virtio_blk.c b/drivers/storage/hakios.virtio_blk.cindex 449f1d1..85b5b24 100644--- a/drivers/storage/hakios.virtio_blk.c+++ b/drivers/storage/hakios.virtio_blk.c@@ -19,8 +19,9 @@* That is slow in principle and entirely adequate here -- reads come from the APFS* driver's own block cache misses, and the host is serving them out of its page cache.*- * Read only. A write request is refused: nothing in this port has any business writing- * to the image, and refusing is one less way to damage it by accident.+ * Read only, unless the boot-arg is virtio_blk=2: then it writes too, for trying a file system that writes (HFS Plus,+ * the data volume) on a disk image before it is let near the phone's flash. With 1 a write request is refused, which+ * is one less way to damage an image that is only to be read.*/#include <kern/clock.h>@@ -75,6 +76,7 @@ extern uint64_t kvtophys(vm_offset_t va);/* the request types we use */#define VIRTIO_BLK_T_IN 0+#define VIRTIO_BLK_T_OUT 1#define VIRTIO_BLK_S_OK 0#define VIRTIO_BLK_SECTOR 512 /* virtio-blk counts in these, always */@@ -129,6 +131,8 @@ struct blk_device {struct blk_req_hdr *hdr;volatile uint8_t *status;uint16_t seen; /* how far the used ring has been read */+ vm_offset_t bounce; /* BLK_MAX_XFER of wired memory the device reads and writes */+ uint64_t bounce_phys[BLK_MAX_XFER / PAGE_MIN_SIZE];uint64_t capacity; /* in 512-byte sectors */lck_mtx_t lock;};@@ -136,6 +140,7 @@ struct blk_device {static LCK_GRP_DECLARE(blk_lck_grp, "hakios-virtio-blk");static struct blk_device blk_dev;static bool blk_ready;+static bool blk_writable; /* virtio_blk=2 */static int blk_bmajor = -1, blk_cmajor = -1;/* One of this driver's devices: every request is a trip through the hypervisor */@@ -166,13 +171,13 @@ reg_write64(struct blk_device *d, uint32_t reg, uint64_t value)}/*- * One read. `data` is kernel memory that need not be page aligned and whose pages need- * not be next to each other in physical memory, so it goes on the queue a page at a time.+ * One read, or one write. The device works on the driver's own wired pages (d->bounce), and `data` is copied in or+ * out: a file system's buffer is not always memory whose physical address kvtophys() can give (a write after a+ * remount had QEMU refuse the descriptor), and a copy of 64 KB costs nothing next to the trip to the host.*/static int-blk_read(struct blk_device *d, uint64_t offset, void *data, size_t len)+blk_io(struct blk_device *d, bool write, uint64_t offset, void *data, size_t len){- vm_offset_t va = (vm_offset_t)data;uint16_t idx = 0;size_t done = 0;uint64_t deadline;@@ -196,7 +201,7 @@ blk_read(struct blk_device *d, uint64_t offset, void *data, size_t len)return ENXIO;}- d->hdr->type = VIRTIO_BLK_T_IN;+ d->hdr->type = write ? VIRTIO_BLK_T_OUT : VIRTIO_BLK_T_IN;d->hdr->reserved = 0;d->hdr->sector = offset / VIRTIO_BLK_SECTOR;*d->status = 0xff;@@ -208,21 +213,16 @@ blk_read(struct blk_device *d, uint64_t offset, void *data, size_t len)d->desc[0].next = 1;idx = 1;- /* then the data, one descriptor per run of bytes inside a page */+ /* then the data, one descriptor per page of the bounce buffer */+ if (write) {+ bcopy(data, (void *)d->bounce, len);+ }while (done < len) {- vm_offset_t at = va + done;- size_t chunk = PAGE_SIZE - (at & PAGE_MASK);+ size_t chunk = MIN(PAGE_SIZE, len - done);- if (chunk > len - done) {- chunk = len - done;- }- if (idx >= 1 + BLK_MAX_DATA_DESC) {- lck_mtx_unlock(&d->lock);- return EINVAL;- }- d->desc[idx].addr = kvtophys(at);+ d->desc[idx].addr = d->bounce_phys[done / PAGE_SIZE];d->desc[idx].len = (uint32_t)chunk;- d->desc[idx].flags = DESC_F_WRITE | DESC_F_NEXT;+ d->desc[idx].flags = (write ? 0 : DESC_F_WRITE) | DESC_F_NEXT;d->desc[idx].next = (uint16_t)(idx + 1);idx++;done += chunk;@@ -250,8 +250,8 @@ blk_read(struct blk_device *d, uint64_t offset, void *data, size_t len)break;}if (mach_absolute_time() > deadline) {- printf("virtio-blk: a read of %lu bytes at %llu went unanswered\n",- (unsigned long)len, offset);+ printf("virtio-blk: a %s of %lu bytes at %llu went unanswered\n",+ write ? "write" : "read", (unsigned long)len, offset);/** The request stays published on the queue and the caller may reuse its buffer: a late* answer would land in it, and the next request would take this stale completion as@@ -266,9 +266,11 @@ blk_read(struct blk_device *d, uint64_t offset, void *data, size_t len)reg_write(d, VIRTIO_INTERRUPT_ACK, reg_read(d, 0x060)); /* keep the device quiet */if (*d->status != VIRTIO_BLK_S_OK) {- printf("virtio-blk: a read of %lu bytes at %llu failed with status %u\n",- (unsigned long)len, offset, *d->status);+ printf("virtio-blk: a %s of %lu bytes at %llu failed with status %u\n",+ write ? "write" : "read", (unsigned long)len, offset, *d->status);error = EIO;+ } else if (!write) {+ bcopy((void *)d->bounce, data, len);}lck_mtx_unlock(&d->lock);return error;@@ -282,7 +284,7 @@ blk_dev_open(__unused dev_t dev, int flags, __unused int devtype, __unused proc_if (!blk_ready) {return ENXIO;}- if (flags & FWRITE) {+ if ((flags & FWRITE) && !blk_writable) {return EROFS;}return 0;@@ -308,8 +310,8 @@ blk_dev_strategy(buf_t bp)buf_biodone(bp);return;}- if (!(buf_flags(bp) & B_READ)) {- buf_seterror(bp, EROFS); /* this device never writes */+ if (!(buf_flags(bp) & B_READ) && !blk_writable) {+ buf_seterror(bp, EROFS); /* this device writes only with virtio_blk=2 */buf_biodone(bp);return;}@@ -327,9 +329,18 @@ blk_dev_strategy(buf_t bp)len = (size_t)(d->capacity * VIRTIO_BLK_SECTOR - offset);}- error = 0;+ /*+ * A file system's cluster I/O (HFS Plus's) hands over a buffer of pages that has no kernel address yet:+ * buf_dataptr() of it is an offset, and buf_map() is what gives it one.+ */+ caddr_t mapped;+ if ((error = buf_map(bp, &mapped)) != 0) {+ buf_seterror(bp, error);+ buf_biodone(bp);+ return;+ }{- uint8_t *dst = (uint8_t *)buf_dataptr(bp);+ uint8_t *dst = (uint8_t *)mapped;size_t done = 0;while (done < len && error == 0) {@@ -338,11 +349,12 @@ blk_dev_strategy(buf_t bp)if (chunk > BLK_MAX_XFER) {chunk = BLK_MAX_XFER;}- error = blk_read(d, offset + done, dst + done, chunk);+ error = blk_io(d, !(buf_flags(bp) & B_READ), offset + done, dst + done, chunk);done += chunk;}buf_setresid(bp, (uint32_t)(buf_count(bp) - (error ? 0 : done)));}+ buf_unmap(bp);if (error) {buf_seterror(bp, error);}@@ -377,11 +389,16 @@ blk_dev_ioctl(__unused dev_t dev, u_long cmd, caddr_t data, __unused int fflag,*(uint64_t *)data = d->capacity;return 0;case DKIOCISWRITABLE:- *(uint32_t *)data = 0;+ *(uint32_t *)data = blk_writable;return 0;case DKIOCGETMAXBLOCKCOUNTREAD:+ case DKIOCGETMAXBLOCKCOUNTWRITE:*(uint64_t *)data = BLK_MAX_XFER / VIRTIO_BLK_SECTOR;return 0;+ case DKIOCSYNCHRONIZE:+ case DKIOCSYNCHRONIZECACHE:+ /* no VIRTIO_BLK_F_FLUSH is taken, so the device writes through: a write that came back is on the disk */+ return 0;default:return ENOTTY;}@@ -402,6 +419,13 @@ blk_dev_read(__unused dev_t dev, struct uio *uio, __unused int ioflag)uio, VIRTIO_BLK_SECTOR);}+static int+blk_dev_write(__unused dev_t dev, struct uio *uio, __unused int ioflag)+{+ return physio(blk_dev_strategy, NULL, dev, B_WRITE, (u_int (*)(buf_t))blk_dev_size,+ uio, VIRTIO_BLK_SECTOR);+}+static const struct bdevsw blk_bdevsw = {.d_open = blk_dev_open,.d_close = blk_dev_close,@@ -416,7 +440,7 @@ static const struct cdevsw blk_cdevsw = {.d_open = blk_dev_open,.d_close = blk_dev_close,.d_read = blk_dev_read,- .d_write = eno_rdwrt,+ .d_write = blk_dev_write,.d_ioctl = blk_dev_ioctl,.d_stop = eno_stop,.d_reset = eno_reset,@@ -446,6 +470,13 @@ blk_attach(struct blk_device *d, int slot)d->used = (struct vq_used *)(d->page + OFFSET_USED);d->hdr = (struct blk_req_hdr *)(d->page + OFFSET_HDR);d->status = (volatile uint8_t *)(d->page + OFFSET_STATUS);+ if (kmem_alloc(kernel_map, &d->bounce, BLK_MAX_XFER,+ KMA_KOBJECT | KMA_ZERO | KMA_DATA, VM_KERN_MEMORY_IOKIT) != KERN_SUCCESS) {+ return false;+ }+ for (int i = 0; i < BLK_MAX_XFER / PAGE_SIZE; i++) {+ d->bounce_phys[i] = kvtophys(d->bounce + (vm_offset_t)i * PAGE_SIZE);+ }reg_write(d, VIRTIO_STATUS, 0); /* reset */reg_write(d, VIRTIO_STATUS, STATUS_ACKNOWLEDGE);@@ -497,6 +528,7 @@ hakios_virtio_blk_init(void)if (!PE_parse_boot_argn("virtio_blk", &enabled, sizeof(enabled)) || !enabled) {return;}+ blk_writable = enabled == 2;bus = ml_io_map(VIRTIO_BUS, VIRTIO_SLOTS * VIRTIO_SLOT_SIZE);for (slot = 0; slot < VIRTIO_SLOTS; slot++) {d->regs = bus + (vm_offset_t)slot * VIRTIO_SLOT_SIZE;@@ -532,9 +564,9 @@ hakios_virtio_blk_init(void)return;}blk_ready = true;- printf("virtio-blk: /dev/rvblk0 in slot %d, %llu sectors of %u (%llu MB)\n",+ printf("virtio-blk: /dev/rvblk0 in slot %d, %llu sectors of %u (%llu MB)%s\n",slot, d->capacity, VIRTIO_BLK_SECTOR,- d->capacity * VIRTIO_BLK_SECTOR / (1024 * 1024));+ d->capacity * VIRTIO_BLK_SECTOR / (1024 * 1024), blk_writable ? ", writable" : "");return;}printf("virtio-blk: no block device on the bus\n");diff --git a/qemu/run-hfs-test.sh b/qemu/run-hfs-test.shnew file mode 100755index 0000000..a3bc035--- /dev/null+++ b/qemu/run-hfs-test.sh@@ -0,0 +1,22 @@+#!/bin/bash+# HFS Plus, built into the kernel, on a disk image of its own: userland/src/hfs_test.c as process 1 of a tiny APFS root,+# the volume on a writable virtio disk (virtio_blk=2). Run it twice on the same image to see what the first run wrote+# still there ("boot number 2").+# usage: qemu/run-hfs-test.sh [IMAGE] (default: a new 256 MB volume in qemu/hfs-test/)+# needs: the kernel built (make kernel), mkfs.hfsplus (hfsprogs) in $PATH or $MKFS+cd "$(dirname "$(readlink -f "$0")")/.." || exit 1+W=qemu/hfs-test+mkdir -p $W/root/dev $W/root/mnt $W/root/sbin+IMG=${1:-$W/hfs.img}+if [ ! -f "$IMG" ]; then+ truncate -s 256M "$IMG"+ "${MKFS:-mkfs.hfsplus}" -s -J -U 0 -G 0 -M 755 -v Data "$IMG" || exit 1+fi+. ./xnu-env.sh+xnu-clang -arch arm64 -Os -static -nostdlib -ffreestanding -fno-stack-protector -fno-builtin \+ -Wl,-e,__start -Wl,-pagezero_size,0x100000000 -o $W/root/sbin/launchd userland/src/hfs_test.c || exit 1+python3 tools/apfs/mkapfs.py -o $W/root.apfs Root=$W/root >/dev/null || exit 1+xnuloader/mkpayload.py -o qemu/payload.bin kernel=hakios-kernel ramdisk=$W/root.apfs \+ --cmdline "cpus=1 debug=0x8 rd=md0 virtio_blk=2" >/dev/null || exit 1+qemu/run.sh 60 -global virtio-mmio.force-legacy=false \+ -drive file="$IMG",format=raw,if=none,id=hd -device virtio-blk-device,drive=hd | grep -a "hfs_test\|^hfs:\|^jnl:\|virtio-blk\|panic("diff --git a/userland/src/hfs_test.c b/userland/src/hfs_test.cnew file mode 100644index 0000000..43c2601--- /dev/null+++ b/userland/src/hfs_test.c@@ -0,0 +1,223 @@+/*+ * hfs_test: HFS Plus, built into the kernel (bsd/hfs), on a disk of its own -- what the data volume on the phone's flash+ * will be asked to do, tried first in QEMU on a virtio disk.+ *+ * A static program with no libc, run as process 1 from a tiny APFS root that has /dev, /mnt and this as+ * /sbin/launchd (qemu/run-hfs-test.sh). It mounts the volume, reads its size, writes a megabyte, reads it back,+ * renames, counts its own boots in a file on the volume, unmounts, mounts again and checks everything is still+ * there. Every step prints one line; the last is "hfs_test: ALL OK" or the step that failed.+ */+typedef unsigned long u64;+typedef unsigned int u32;+typedef unsigned short u16;++static long+sys6(long num, long a, long b, long c, long d, long e, long f)+{+ register long x16 __asm__("x16") = num;+ register long x0 __asm__("x0") = a;+ register long x1 __asm__("x1") = b;+ register long x2 __asm__("x2") = c;+ register long x3 __asm__("x3") = d;+ register long x4 __asm__("x4") = e;+ register long x5 __asm__("x5") = f;+ long carry;+ __asm__ volatile ("svc #0x80\n cset %1, cs" : "+r" (x0), "=r" (carry) : "r" (x16), "r" (x1), "r" (x2), "r" (x3),+ "r" (x4), "r" (x5) : "memory", "cc");+ return carry ? -x0 : x0;+}+#define sys3(n, a, b, c) sys6(n, (long)(a), (long)(b), (long)(c), 0, 0, 0)++enum { SYS_exit = 1, SYS_read = 3, SYS_write = 4, SYS_open = 5, SYS_close = 6, SYS_unlink = 10, SYS_fsync = 95,+ SYS_rename = 128, SYS_mkdir = 136, SYS_unmount = 159, SYS_mount = 167, SYS_lseek = 199, SYS_statfs64 = 345 };+#define O_RDONLY 0+#define O_RDWR 2+#define O_CREAT 0x200+#define O_TRUNC 0x400++static unsigned long+slen(const char *s)+{+ unsigned long n = 0;+ while (s[n]) {+ n++;+ }+ return n;+}++static long console = -1;++static void+say(const char *s)+{+ sys3(SYS_write, console, s, slen(s));+}++static void+num(long v)+{+ char b[24];+ int i = 23;+ int neg = v < 0;+ b[i] = 0;+ if (neg) {+ v = -v;+ }+ do {+ b[--i] = '0' + v % 10;+ v /= 10;+ } while (v);+ if (neg) {+ b[--i] = '-';+ }+ say(b + i);+}++static void+fail(const char *what, long err)+{+ say("hfs_test: FAILED: ");+ say(what);+ say(" (");+ num(err);+ say(")\n");+ sys3(SYS_exit, 1, 0, 0);+}++/* struct hfs_mount_args as user space passes it (bsd/hfs/hfs_mount.h) */+struct hfs_args {+ const char *fspec;+ u32 uid, gid;+ u16 mask, pad;+ u32 encoding;+ int tz[2];+ int flags, journal_tbuffer_size, journal_flags, journal_disable;+};++static char buf[1 << 20], back[1 << 20];++static long+mount_hfs(void)+{+ struct hfs_args a = { .fspec = "/dev/rvblk0" };+ return sys6(SYS_mount, (long)"hfs", (long)"/mnt", 0, (long)&a, 0, 0);+}++static void+fill(char *p, u32 seed)+{+ for (u32 i = 0; i < sizeof(buf); i++) {+ seed = seed * 1103515245 + 12345;+ p[i] = (char)(seed >> 16);+ }+}++static int+same(const char *a, const char *b, unsigned long n)+{+ for (unsigned long i = 0; i < n; i++) {+ if (a[i] != b[i]) {+ return 0;+ }+ }+ return 1;+}++static long+read_all(const char *path, char *into, unsigned long n)+{+ long fd = sys3(SYS_open, path, O_RDONLY, 0), got = 0, r;+ if (fd < 0) {+ return fd;+ }+ while (got < (long)n && (r = sys3(SYS_read, fd, into + got, n - got)) > 0) {+ got += r;+ }+ sys3(SYS_close, fd, 0, 0);+ return got;+}++void+_start(void)+{+ long r, fd;+ unsigned char sfs[2168];++ console = sys3(SYS_open, "/dev/console", O_RDWR, 0);+ say("hfs_test: start\n");+ if ((r = mount_hfs()) < 0) {+ fail("mount hfs /dev/rvblk0 on /mnt", r);+ }+ say("hfs_test: mounted\n");++ if ((r = sys3(SYS_statfs64, "/mnt", sfs, 0)) < 0) {+ fail("statfs /mnt", r);+ }+ u32 bsize = *(u32 *)(sfs + 0);+ u64 blocks = *(u64 *)(sfs + 8), bfree = *(u64 *)(sfs + 16);+ say("hfs_test: statfs: type ");+ say((const char *)(sfs + 72));+ say(", ");+ num((long)(blocks * bsize >> 20));+ say(" MB, free ");+ num((long)(bfree * bsize >> 20));+ say(" MB\n");++ /* the boots this volume has seen: a counter in a file on it */+ char cnt[8] = { 0 };+ long boots = 0;+ if (read_all("/mnt/boots", cnt, 8) == 8) {+ boots = *(long *)cnt;+ }+ boots++;+ *(long *)cnt = boots;+ if ((fd = sys3(SYS_open, "/mnt/boots", O_RDWR | O_CREAT | O_TRUNC, 0644)) < 0 || sys3(SYS_write, fd, cnt, 8) != 8 ||+ sys3(SYS_fsync, fd, 0, 0) < 0) {+ fail("write /mnt/boots", fd);+ }+ sys3(SYS_close, fd, 0, 0);+ say("hfs_test: this volume's boot number ");+ num(boots);+ say("\n");++ sys3(SYS_mkdir, "/mnt/d", 0755, 0);+ fill(buf, (u32)boots);+ if ((fd = sys3(SYS_open, "/mnt/d/f", O_RDWR | O_CREAT | O_TRUNC, 0644)) < 0) {+ fail("create /mnt/d/f", fd);+ }+ if ((r = sys3(SYS_write, fd, buf, sizeof(buf))) != (long)sizeof(buf)) {+ fail("write 1 MB", r);+ }+ if ((r = sys3(SYS_fsync, fd, 0, 0)) < 0) {+ fail("fsync", r);+ }+ sys3(SYS_close, fd, 0, 0);+ if ((r = read_all("/mnt/d/f", back, sizeof(back))) != (long)sizeof(back) || !same(buf, back, sizeof(buf))) {+ fail("read the megabyte back", r);+ }+ say("hfs_test: 1 MB written and read back the same\n");+ sys3(SYS_unlink, "/mnt/d/g", 0, 0);+ if ((r = sys3(SYS_rename, "/mnt/d/f", "/mnt/d/g", 0)) < 0) {+ fail("rename", r);+ }++ if ((r = sys3(SYS_unmount, "/mnt", 0, 0)) < 0) {+ fail("unmount", r);+ }+ if ((r = mount_hfs()) < 0) {+ fail("mount again", r);+ }+ for (unsigned long i = 0; i < sizeof(back); i++) {+ back[i] = 0;+ }+ if ((r = read_all("/mnt/d/g", back, sizeof(back))) != (long)sizeof(back) || !same(buf, back, sizeof(buf))) {+ fail("the megabyte after unmount and mount", r);+ }+ if ((r = sys3(SYS_unmount, "/mnt", 0, 0)) < 0) {+ fail("unmount again", r);+ }+ say("hfs_test: after unmount and mount, the same; boots counted ");+ num(boots);+ say("\nhfs_test: ALL OK\n");+ sys3(SYS_exit, 0, 0, 0);+}diff --git a/xnu/files/bsd/hfs/BTree.c b/xnu/files/bsd/hfs/BTree.cnew file mode 100644index 0000000..a305ee5--- /dev/null+++ b/xnu/files/bsd/hfs/BTree.c@@ -0,0 +1,2088 @@+/*+ * Copyright (c) 2000-2015 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@+ */+/*+ File: BTree.c++ Contains: Implementation of public interface routines for B-tree manager.++ Version: HFS Plus 1.0++ Written by: Gordon Sheridan and Bill Bruffey++ Copyright: (c) 1992-1999 by Apple Inc., all rights reserved.++ File Ownership:++ DRI: Don Brady++ Other Contact: Mark Day++ Technology: File Systems++ Writers:++ (msd) Mark Day+ (DSH) Deric Horn+ (djb) Don Brady++ Change History (most recent first):+ <MOSXS> 9/22/99 ser Added routines BTGetLastSync and BTSetLastSync+ <MOSXS> 6/1/99 djb Sync up with Mac OS 8.6.+ <MOSXS> 6/30/98 djb In BTOpenPath make sure nodes are contiguous on disk (radar #2249539).+ <MOSXS> 4/15/98 djb In BTOpenPath need to clear nodeRec.buffer if GetBlockProc fails.+ <MOSXS> 4/11/98 djb Add RequireFileLock checking to all external entry points.++ <MOSXS> 03/23/98 djb In BTOpenPath use kTrashBlock option when releasing the header so+ that we get a full node when we call GetNode.++ <CS9> 12/12/97 djb Radar #2202682, BTIterateRecord with kBTreeCurrentRecord was not+ checking if we had a record and could call BlockMove with an+ uninitialize source pointer (causing a bus error).+ <CS8> 10/24/97 msd In BTIterateRecord, when moving to the previous or next record+ and we have to move to another node, see if we need to release+ the node about to be "shifted out" (opposite sibling of the+ direction we need to move).+ <CS7> 7/25/97 DSH BTSearchRecord now takes a heuristicHint, nodeNum, and tries it+ before calling SearchBTree+ <CS6> 7/24/97 djb GetBlockProc now take a file refnum instead of an FCB ptr.+ <CS5> 7/22/97 djb Move trace points from BTreeWrapper.c to here.+ <CS4> 7/21/97 djb LogEndTime now takes an error code.+ <CS3> 7/16/97 DSH FilesInternal.i renamed FileMgrInternal.i to avoid name+ collision+ <CS2> 5/19/97 djb Add summary traces to BTIterateRecord.+ <CS1> 4/23/97 djb first checked in++ <HFS7> 2/19/97 djb Enable variable sized index keys for HFS+ volumes. Added node+ cache to support nodes larger than 512 bytes.+ <HFS6> 1/27/97 djb Calls to InsertTree and DeleteTree are now recursive (to support+ variable sized index keys).+ <HFS5> 1/13/97 djb Added support for getting current record to BTIterateRecord.+ <HFS4> 1/6/97 djb Initialize "BigKeys" attribute in BTOpen.+ <HFS3> 1/3/97 djb Added support for large keys.+ <HFS2> 12/23/96 djb On exit map fsBTEmptyErr and fsBTEndOfIterationErr to+ fsBTRecordNotFoundErr.+ <HFS1> 12/19/96 djb first checked in++ History applicable to original Scarecrow Design:++ <13> 10/25/96 ser Changing for new VFPI+ <12> 10/18/96 ser Converting over VFPI changes+ <11> 9/17/96 dkh More BTree statistics. Modified hint checks to not bail out when+ an error is returned from GetNode.+ <10> 9/16/96 dkh Revised BTree statistics.+ <9> 8/23/96 dkh Remove checks for multiple paths to BTree file. Need to add+ equivalent mechanism later.+ <8> 6/20/96 dkh Radar #1358740. Switch from using Pools to debug MemAllocators.+ <7> 3/14/96 jev Fix BTreeSetRecord, recordFound was not set for the case of a+ simple replace causing the leafRecords count to get bumped even+ though we didn't have to add a record.+ <6> 3/1/96 prp Fix lint problems. Bug in BTSetRecord that does not initialize+ recordFound.+ <5> 1/22/96 dkh Add #include Memory.h+ <4> 1/10/96 msd Use the real function names from Math64.i.+ <3> 1/4/96 jev Fix BTItererateRecord for the condition when the iterator+ position routine does not find the record and we are looking for+ the next record. In such a case, if the node's forrward link is+ non-zero, we have to keep iterating next and not return+ fsBTEndOfIterationErr error.+ <2> 12/7/95 dkh D10E2 build. Changed usage of Ref data type to LogicalAddress.+ <1> 10/18/95 rst Moved from Scarecrow project.++ <24> 7/18/95 mbb Change MoveData & ClearBytes to BlockMoveData & BlockZero.+ <23> 1/31/95 prp GetBlockProc interface uses a 64 bit node number.+ <22> 1/12/95 wjk Adopt Model FileSystem changes in D5.+ <21> 11/16/94 prp Add IsItAHint routine and use it whenever hint's node number was+ used for testing.+ <20> 11/10/94 prp BTGetInfo name collides with the same name in FileManagerPriv.i.+ Change it to BTGetInformation.+ <19> 9/30/94 prp Get in sync with D2 interface changes.+ <18> 7/22/94 wjk Convert to the new set of header files.+ <17> 12/9/93 wjk Cleanup usage of char, Byte, int8, UInt8, etc.+ <16> 12/2/93 wjk Move from Makefiles to BuildFiles. Fit into the ModernOS and+ NRCmds environments.+ <15> 11/30/93 wjk Move from Makefiles to BuildFiles. Fit into the ModernOS and+ NRCmds environments.+ <14> 9/30/93 gs Rename E_NoGetNodeProc and E_NoReleaseNodeProc to+ E_NoXxxxBlockProc.+ <13> 8/31/93 prp Use Set64U instead of Set64.+ <12> 8/16/93 prp In BTSearchRecord, if the input hint found the node and record,+ set the local nodeNum variable correctly so that the resultant+ iterator gets set correctly.+ <11> 7/1/93 gs Fix bug in BTIterateRecord related to kBTreePrevRecord+ operation.+ <10> 6/2/93 gs Update for changes to FSErrors.h and add some comments.+ <9> 5/24/93 gs Fix bug in BTInsert/Set/ReplaceRecord which didn't set node hint+ properly in some cases.+ <8> 5/24/93 gs Do NOT map fsBTEmptyErr to fsBTRecordNotFoundErr in BTSearchRecord.+ <7> 5/24/93 gs Rename BTFlush to BTFlushPath.+ <6> 5/21/93 gs Add hint optimization to Set/Replace routines.+ <5> 5/10/93 gs Remove Panic from BTInitialize for small logicalEOF. Implement+ Insert, Set, Replace, and Delete.+ <4> 3/23/93 gs Finish BTInitialize.+ <3> 2/8/93 gs Implement BTSearchRecord and BTIterateRecord.+ <2> 12/8/92 gs Implement Open and Close routines.+ <1> 11/15/92 gs first checked in++*/++#include "BTreesPrivate.h"+#include "hfs_btreeio.h"++//////////////////////////////////// Globals ////////////////////////////////////+++/////////////////////////// BTree Module Entry Points ///////////////////////////++++/*-------------------------------------------------------------------------------+Routine: BTOpenPath - Open a file for access as a B*Tree.++Function: Create BTree control block for a file, if necessary. Validates the+ file to be sure it looks like a BTree file.+++Input: filePtr - pointer to file to open as a B-tree+ keyCompareProc - pointer to client's KeyCompare function++Result: noErr - success+ paramErr - required ptr was nil+ fsBTInvalidFileErr -+ memFullErr -+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus BTOpenPath(FCB *filePtr, KeyCompareProcPtr keyCompareProc)+{+ OSStatus err;+ BTreeControlBlockPtr btreePtr;+ BTHeaderRec *header;+ NodeRec nodeRec;++ ////////////////////// Preliminary Error Checking ///////////////////////////++ if ( filePtr == nil )+ {+ return paramErr;+ }++ /*+ * Subsequent opens allow key compare proc to be changed.+ */+ if ( filePtr->fcbBTCBPtr != nil && keyCompareProc != nil) {+ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;+ btreePtr->keyCompareProc = keyCompareProc;+ return noErr;+ }++ if ( filePtr->fcbEOF < kMinNodeSize )+ return fsBTInvalidFileErr;+++ //////////////////////// Allocate Control Block /////////////////////////////++ btreePtr = hfs_malloc_type(BTreeControlBlock);++ btreePtr->getBlockProc = GetBTreeBlock;+ btreePtr->releaseBlockProc = ReleaseBTreeBlock;+ btreePtr->setEndOfForkProc = ExtendBTreeFile;+ btreePtr->keyCompareProc = keyCompareProc;++ /////////////////////////// Read Header Node ////////////////////////////////++ nodeRec.buffer = nil; // so we can call ReleaseNode+ btreePtr->fileRefNum = GetFileRefNumFromFCB(filePtr);+ filePtr->fcbBTCBPtr = (Ptr) btreePtr; // attach btree cb to file++ /* Prefer doing I/O a physical block at a time */+ nodeRec.blockSize = VTOHFS(btreePtr->fileRefNum)->hfs_physical_block_size;++ /* Start with the allocation block size for regular files. */+ if (FTOC(filePtr)->c_fileid >= kHFSFirstUserCatalogNodeID)+ {+ nodeRec.blockSize = FCBTOVCB(filePtr)->blockSize;+ }+ REQUIRE_FILE_LOCK(btreePtr->fileRefNum, false);++ // it is now safe to call M_ExitOnError (err)++ err = SetBTreeBlockSize (btreePtr->fileRefNum, nodeRec.blockSize, 1);+ M_ExitOnError (err);+++ err = GetBTreeBlock(btreePtr->fileRefNum,+ kHeaderNodeNum,+ kGetBlock,+ &nodeRec );+ if (err != noErr)+ {+ nodeRec.buffer = nil;+ nodeRec.blockHeader = nil;+ Panic("BTOpen: getNodeProc returned error getting header node.");+ goto ErrorExit;+ }+ ++btreePtr->numGetNodes;+ header = (BTHeaderRec*) ((uintptr_t)nodeRec.buffer + sizeof(BTNodeDescriptor));+++ ///////////////////////////// verify header /////////////////////////////////++ err = VerifyHeader (filePtr, header);+ M_ExitOnError (err);+++ ///////////////////// Initalize fields from header //////////////////////////++ PanicIf ( (FCBTOVCB(filePtr)->vcbSigWord != 0x4244) && (header->nodeSize == 512), " BTOpenPath: wrong node size for HFS+ volume!"); // 0x4244 = 'BD'++ btreePtr->treeDepth = header->treeDepth;+ btreePtr->rootNode = header->rootNode;+ btreePtr->leafRecords = header->leafRecords;+ btreePtr->firstLeafNode = header->firstLeafNode;+ btreePtr->lastLeafNode = header->lastLeafNode;+ btreePtr->nodeSize = header->nodeSize;+ btreePtr->maxKeyLength = header->maxKeyLength;+ btreePtr->totalNodes = header->totalNodes;+ btreePtr->freeNodes = header->freeNodes;+ if (FTOC(filePtr)->c_fileid >= kHFSFirstUserCatalogNodeID)+ filePtr->ff_clumpsize = header->clumpSize;+ btreePtr->btreeType = header->btreeType;++ btreePtr->keyCompareType = header->keyCompareType;++ btreePtr->attributes = header->attributes;++ if ( btreePtr->maxKeyLength > 40 )+ btreePtr->attributes |= (kBTBigKeysMask + kBTVariableIndexKeysMask); //�� we need a way to save these attributes++ /////////////////////// Initialize dynamic fields ///////////////////////////++ btreePtr->version = kBTreeVersion;+ btreePtr->flags = 0;+ btreePtr->writeCount = 1;++ /////////////////////////// Check Header Node ///////////////////////////////++ // set kBadClose attribute bit, and UpdateNode++ /* b-tree node size must be at least as big as the logical block size */+ if (btreePtr->nodeSize < VTOHFS(btreePtr->fileRefNum)->hfs_logical_block_size)+ {+ /*+ * If this tree has any records or the media is writeable then+ * we cannot mount using the current physical block size.+ */+ if (btreePtr->leafRecords > 0 ||+ VTOHFS(btreePtr->fileRefNum)->hfs_flags & HFS_WRITEABLE_MEDIA)+ {+ err = fsBTBadNodeSize;+ goto ErrorExit;+ }+ }++ /*+ * If the actual node size is different than the amount we read,+ * then release and trash this block, and re-read with the correct+ * node size.+ */+ if ( btreePtr->nodeSize != nodeRec.blockSize )+ {+ err = SetBTreeBlockSize (btreePtr->fileRefNum, btreePtr->nodeSize, 32);+ M_ExitOnError (err);++ /*+ * Need to use kTrashBlock option to force the+ * buffer cache to read the entire node+ */+ err = ReleaseBTreeBlock(btreePtr->fileRefNum, &nodeRec, kTrashBlock);+ ++btreePtr->numReleaseNodes;+ M_ExitOnError (err);++ err = GetNode (btreePtr, kHeaderNodeNum, 0, &nodeRec );+ M_ExitOnError (err);+ }++ //�� total nodes * node size <= LEOF?+++ err = ReleaseNode (btreePtr, &nodeRec);+ M_ExitOnError (err);++ /*+ * Under Mac OS, b-tree nodes can be non-contiguous on disk when the+ * allocation block size is smaller than the b-tree node size.+ *+ * If journaling is turned on for this volume we can't deal with this+ * situation and so we bail out. If journaling isn't on it's ok as+ * hfs_strategy_fragmented() deals with it. Journaling can't support+ * this because it assumes that if you give it a block that it's+ * contiguous on disk.+ */+ if ( FCBTOHFS(filePtr)->jnl && !NodesAreContiguous(FCBTOVCB(filePtr), filePtr, btreePtr->nodeSize) ) {+ return fsBTInvalidNodeErr;+ }++ //////////////////////////////// Success ////////////////////////////////////++ //�� align LEOF to multiple of node size? - just on close++ return noErr;+++ /////////////////////// Error - Clean up and Exit ///////////////////////////++ErrorExit:++ filePtr->fcbBTCBPtr = nil;+ (void) ReleaseNode (btreePtr, &nodeRec);+ hfs_free_type(btreePtr, BTreeControlBlock);++ return err;+}++++/*-------------------------------------------------------------------------------+Routine: BTClosePath - Flush BTree Header and Deallocate Memory for BTree.++Function: Flush the BTreeControlBlock fields to header node, and delete BTree control+ block and key descriptor associated with the file if filePtr is last+ path of type kBTreeType ('btre').+++Input: filePtr - pointer to file to delete BTree control block for.++Result: noErr - success+ fsBTInvalidFileErr -+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus BTClosePath (FCB *filePtr)+{+ OSStatus err;+ BTreeControlBlockPtr btreePtr;++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;++ if (btreePtr == nil)+ return fsBTInvalidFileErr;++ REQUIRE_FILE_LOCK(btreePtr->fileRefNum, false);++ ////////////////////// Check for other BTree Paths //////////////////////////++ btreePtr->attributes &= ~kBTBadCloseMask; // clear "bad close" attribute bit+ err = UpdateHeader (btreePtr, true);+ M_ExitOnError (err);++ hfs_free_type(btreePtr, BTreeControlBlock);+ filePtr->fcbBTCBPtr = nil;++ return noErr;++ /////////////////////// Error - Clean Up and Exit ///////////////////////////++ErrorExit:++ return err;+}++++/*-------------------------------------------------------------------------------+Routine: BTSearchRecord - Search BTree for a record with a matching key.++Function: Search for position in B*Tree indicated by searchKey. If a valid node hint+ is provided, it will be searched first, then SearchTree will be called.+ If a BTreeIterator is provided, it will be set to the position found as+ a result of the search. If a record exists at that position, and a BufferDescriptor+ is supplied, the record will be copied to the buffer (as much as will fit),+ and recordLen will be set to the length of the record.++ If an error other than fsBTRecordNotFoundErr occurs, the BTreeIterator, if any,+ is invalidated, and recordLen is set to 0.+++Input: pathPtr - pointer to path for BTree file.+ searchKey - pointer to search key to match.+ hintPtr - pointer to hint (may be nil)++Output: record - pointer to BufferDescriptor containing record+ recordLen - length of data at recordPtr+ iterator - pointer to BTreeIterator indicating position result of search++Result: noErr - success, record contains copy of record found+ fsBTRecordNotFoundErr - record was not found, no data copied+ fsBTInvalidFileErr - no BTreeControlBlock is allocated for the fork+ fsBTInvalidKeyLengthErr -+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus BTSearchRecord (FCB *filePtr,+ BTreeIterator *searchIterator,+ FSBufferDescriptor *record,+ u_int16_t *recordLen,+ BTreeIterator *resultIterator )+{+ OSStatus err;+ BTreeControlBlockPtr btreePtr;+ TreePathTable treePathTable;+ u_int32_t nodeNum = 0;+ BlockDescriptor node;+ u_int16_t index = 0;+ BTreeKeyPtr keyPtr = NULL;+ RecordPtr recordPtr;+ u_int16_t len;+ Boolean foundRecord;+ Boolean validHint;++ if (filePtr == nil)+ {+ return paramErr;+ }++ if (searchIterator == nil)+ {+ return paramErr;+ }++ node.buffer = nil;+ node.blockHeader = nil;++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;+ if (btreePtr == nil)+ {+ return fsBTInvalidFileErr;+ }++ REQUIRE_FILE_LOCK(btreePtr->fileRefNum, true);++ foundRecord = false;++ ////////////////////////////// Take A Hint //////////////////////////////////++ err = IsItAHint (btreePtr, searchIterator, &validHint);+ M_ExitOnError (err);++ if (validHint)+ {+ nodeNum = searchIterator->hint.nodeNum;++ err = GetNode (btreePtr, nodeNum, kGetNodeHint, &node);+ if( err == noErr )+ {+ if ( ((BTNodeDescriptor*) node.buffer)->kind == kBTLeafNode &&+ ((BTNodeDescriptor*) node.buffer)->numRecords > 0 )+ {+ foundRecord = SearchNode (btreePtr, node.buffer, &searchIterator->key, &index);++ //�� if !foundRecord, we could still skip tree search if ( 0 < index < numRecords )+ }++ if (foundRecord == false)+ {+ err = ReleaseNode (btreePtr, &node);+ M_ExitOnError (err);+ }+ else+ {+ ++btreePtr->numValidHints;+ }+ }++ if( foundRecord == false )+ (void) BTInvalidateHint( searchIterator );+ }+++ //////////////////////////// Search The Tree ////////////////////////////////++ if (foundRecord == false)+ {+ err = SearchTree ( btreePtr, &searchIterator->key, treePathTable, &nodeNum, &node, &index);+ switch (err)+ {+ case noErr:+ foundRecord = true;+ break;+ case fsBTRecordNotFoundErr:+ break;+ default:+ goto ErrorExit;+ }+ }+++ //////////////////////////// Get the Record /////////////////////////////////++ if (foundRecord == true)+ {+ //XXX Should check for errors! Or BlockMove could choke on recordPtr!!!+ GetRecordByIndex (btreePtr, node.buffer, index, &keyPtr, &recordPtr, &len);++ if (recordLen != nil) *recordLen = len;++ if (record != nil)+ {+ ByteCount recordSize;++ recordSize = record->itemCount * record->itemSize;++ if (len > recordSize) len = recordSize;++ BlockMoveData (recordPtr, record->bufferAddress, len);+ }+ }+++ /////////////////////// Success - Update Iterator ///////////////////////////++ if (resultIterator != nil)+ {+ if (foundRecord) {+ resultIterator->hint.writeCount = btreePtr->writeCount;+ resultIterator->hint.nodeNum = nodeNum;+ resultIterator->hint.index = index;+ }+#if DEBUG+ resultIterator->hint.reserved1 = 0;+ resultIterator->hint.reserved2 = 0;+ resultIterator->version = 0;+ resultIterator->reserved = 0;+#endif+ // copy the key in the BTree when found rather than searchIterator->key to get proper case/diacriticals+ if (foundRecord == true)+ BlockMoveData ((Ptr)keyPtr, (Ptr)&resultIterator->key, CalcKeySize(btreePtr, keyPtr));+ else+ BlockMoveData ((Ptr)&searchIterator->key, (Ptr)&resultIterator->key, CalcKeySize(btreePtr, &searchIterator->key));+ }++ err = ReleaseNode (btreePtr, &node);+ M_ExitOnError (err);++ if (foundRecord == false) return fsBTRecordNotFoundErr;+ else return noErr;+++ /////////////////////// Error - Clean Up and Exit ///////////////////////////++ErrorExit:++ if (recordLen != nil)+ *recordLen = 0;++ if (resultIterator != nil)+ {+ resultIterator->hint.writeCount = 0;+ resultIterator->hint.nodeNum = 0;+ resultIterator->hint.index = 0;+ resultIterator->hint.reserved1 = 0;+ resultIterator->hint.reserved2 = 0;++ resultIterator->version = 0;+ resultIterator->reserved = 0;+ resultIterator->key.length16 = 0; // zero out two bytes to cover both types of keys+ }++ if ( err == fsBTEmptyErr )+ err = fsBTRecordNotFoundErr;++ return err;+}++++/*-------------------------------------------------------------------------------+Routine: BTIterateRecord - Find the first, next, previous, or last record.++Function: Find the first, next, previous, or last record in the BTree++Input: pathPtr - pointer to path iterate records for.+ operation - iteration operation (first,next,prev,last)+ iterator - pointer to iterator indicating start position++Output: iterator - iterator is updated to indicate new position+ newKeyPtr - pointer to buffer to copy key found by iteration+ record - pointer to buffer to copy record found by iteration+ recordLen - length of record++Result: noErr - success+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus BTIterateRecord (FCB *filePtr,+ BTreeIterationOperation operation,+ BTreeIterator *iterator,+ FSBufferDescriptor *record,+ u_int16_t *recordLen )+{+ OSStatus err;+ BTreeControlBlockPtr btreePtr;+ BTreeKeyPtr keyPtr;+ RecordPtr recordPtr;+ u_int16_t len;++ Boolean foundRecord;+ u_int32_t nodeNum;++ BlockDescriptor left, node, right;+ u_int16_t index;+++ ////////////////////////// Priliminary Checks ///////////////////////////////++ left.buffer = nil;+ left.blockHeader = nil;+ right.buffer = nil;+ right.blockHeader = nil;+ node.buffer = nil;+ node.blockHeader = nil;+++ if (filePtr == nil)+ {+ return paramErr;+ }++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;+ if (btreePtr == nil)+ {+ return fsBTInvalidFileErr; //�� handle properly+ }++ REQUIRE_FILE_LOCK(btreePtr->fileRefNum, true);++ if ((operation != kBTreeFirstRecord) &&+ (operation != kBTreeNextRecord) &&+ (operation != kBTreeCurrentRecord) &&+ (operation != kBTreePrevRecord) &&+ (operation != kBTreeLastRecord))+ {+ err = fsInvalidIterationMovmentErr;+ goto ErrorExit;+ }++ /////////////////////// Find First or Last Record ///////////////////////////++ if ((operation == kBTreeFirstRecord) || (operation == kBTreeLastRecord))+ {+ if (operation == kBTreeFirstRecord) nodeNum = btreePtr->firstLeafNode;+ else nodeNum = btreePtr->lastLeafNode;++ if (nodeNum == 0)+ {+ err = fsBTEmptyErr;+ goto ErrorExit;+ }++ err = GetNode (btreePtr, nodeNum, 0, &node);+ M_ExitOnError (err);++ if ( ((NodeDescPtr) node.buffer)->kind != kBTLeafNode ||+ ((NodeDescPtr) node.buffer)->numRecords <= 0 )+ {+ err = ReleaseNode (btreePtr, &node);+ M_ExitOnError (err);++ err = fsBTInvalidNodeErr;+ printf ("hfs: BTIterateRecord() found invalid btree node on volume %s\n", FCBTOVCB(filePtr)->vcbVN);+ hfs_mark_inconsistent(FCBTOVCB(filePtr), HFS_INCONSISTENCY_DETECTED);+ goto ErrorExit;+ }++ if (operation == kBTreeFirstRecord) index = 0;+ else index = ((BTNodeDescriptor*) node.buffer)->numRecords - 1;++ goto CopyData; //�� is there a cleaner way?+ }+++ //////////////////////// Find Iterator Position /////////////////////////////++ // Not called for (operation == kBTreeFirstRecord || operation == kBTreeLastRecord)+ err = FindIteratorPosition (btreePtr, iterator,+ &left, &node, &right, &nodeNum, &index, &foundRecord);+ M_ExitOnError (err);+++ ///////////////////// Find Next Or Previous Record //////////////////////////++ if (operation == kBTreePrevRecord)+ {+ if (index > 0)+ {+ --index;+ }+ else+ {+ if (left.buffer == nil)+ {+ nodeNum = ((NodeDescPtr) node.buffer)->bLink;+ if ( nodeNum > 0)+ {+ // BTree nodes are always grabbed in left to right order.+ // Therefore release the current node before looking up the+ // left node.+ err = ReleaseNode(btreePtr, &node);+ M_ExitOnError(err);++ // Look up the left node+ err = GetNode (btreePtr, nodeNum, 0, &left);+ M_ExitOnError (err);++ // Look up the current node again+ err = GetRightSiblingNode (btreePtr, left.buffer, &node);+ M_ExitOnError (err);+ } else {+ err = fsBTStartOfIterationErr;+ goto ErrorExit;+ }+ }+ // Before we stomp on "right", we'd better release it if needed+ if (right.buffer != nil) {+ err = ReleaseNode(btreePtr, &right);+ M_ExitOnError(err);+ }+ right = node;+ node = left;+ left.buffer = nil;+ index = ((NodeDescPtr) node.buffer)->numRecords -1;+ }+ }+ else if (operation == kBTreeNextRecord)+ {+ if ((foundRecord != true) &&+ (((NodeDescPtr) node.buffer)->fLink == 0) &&+ (index == ((NodeDescPtr) node.buffer)->numRecords))+ {+ err = fsBTEndOfIterationErr;+ goto ErrorExit;+ }++ // we did not find the record but the index is already positioned correctly+ if ((foundRecord == false) && (index != ((NodeDescPtr) node.buffer)->numRecords))+ goto CopyData;++ // we found the record OR we have to look in the next node+ if (index < ((NodeDescPtr) node.buffer)->numRecords -1)+ {+ ++index;+ }+ else+ {+ if (right.buffer == nil)+ {+ nodeNum = ((NodeDescPtr) node.buffer)->fLink;+ if ( nodeNum > 0)+ {+ err = GetNode (btreePtr, nodeNum, 0, &right);+ M_ExitOnError (err);+ } else {+ err = fsBTEndOfIterationErr;+ goto ErrorExit;+ }+ }+ // Before we stomp on "left", we'd better release it if needed+ if (left.buffer != nil) {+ err = ReleaseNode(btreePtr, &left);+ M_ExitOnError(err);+ }+ left = node;+ node = right;+ right.buffer = nil;+ index = 0;+ }+ }+ else // operation == kBTreeCurrentRecord+ {+ // make sure we have something... <CS9>+ if ((foundRecord != true) &&+ (index >= ((NodeDescPtr) node.buffer)->numRecords))+ {+ err = fsBTEndOfIterationErr;+ goto ErrorExit;+ }+ }++ //////////////////// Copy Record And Update Iterator ////////////////////////++CopyData:++ // added check for errors <CS9>+ err = GetRecordByIndex (btreePtr, node.buffer, index, &keyPtr, &recordPtr, &len);+ M_ExitOnError (err);++ if (recordLen != nil)+ *recordLen = len;++ if (record != nil)+ {+ ByteCount recordSize;++ recordSize = record->itemCount * record->itemSize;++ if (len > recordSize) len = recordSize;++ BlockMoveData (recordPtr, record->bufferAddress, len);+ }++ if (iterator != nil) // first & last do not require iterator+ {+ iterator->hint.writeCount = btreePtr->writeCount;+ iterator->hint.nodeNum = nodeNum;+ iterator->hint.index = index;+ iterator->hint.reserved1 = 0;+ iterator->hint.reserved2 = 0;++ iterator->version = 0;+ iterator->reserved = 0;++ /* SER+ * Check for infinite loops by making sure we do not+ * process more leaf records, than can possibly be (or the BTree header+ * is seriously damaged)....a brute force method.+ */+ if ((operation == kBTreeFirstRecord) || (operation == kBTreeLastRecord))+ iterator->hitCount = 1;+ else if (operation != kBTreeCurrentRecord)+ iterator->hitCount += 1;+ /* Always use the highest max, in case the grows while iterating */+ iterator->maxLeafRecs = max(btreePtr->leafRecords, iterator->maxLeafRecs);++#if 0+ if (iterator->hitCount > iterator->maxLeafRecs + kNumLeafRecSlack)+ {+ err = fsBTInvalidNodeErr;+ printf ("hfs: BTIterateRecord() found invalid btree node on volume %s\n", FCBTOVCB(filePtr)->vcbVN);+ hfs_mark_inconsistent(FCBTOVCB(filePtr), HFS_INCONSISTENCY_DETECTED);+ goto ErrorExit;+ }+#endif++ BlockMoveData ((Ptr)keyPtr, (Ptr)&iterator->key, CalcKeySize(btreePtr, keyPtr));+ }+++ ///////////////////////////// Release Nodes /////////////////////////////////++ err = ReleaseNode (btreePtr, &node);+ M_ExitOnError (err);++ if (left.buffer != nil)+ {+ err = ReleaseNode (btreePtr, &left);+ M_ExitOnError (err);+ }++ if (right.buffer != nil)+ {+ err = ReleaseNode (btreePtr, &right);+ M_ExitOnError (err);+ }++ return noErr;++ /////////////////////// Error - Clean Up and Exit ///////////////////////////++ErrorExit:++ (void) ReleaseNode (btreePtr, &left);+ (void) ReleaseNode (btreePtr, &node);+ (void) ReleaseNode (btreePtr, &right);++ if (recordLen != nil)+ *recordLen = 0;++ if (iterator != nil)+ {+ iterator->hint.writeCount = 0;+ iterator->hint.nodeNum = 0;+ iterator->hint.index = 0;+ iterator->hint.reserved1 = 0;+ iterator->hint.reserved2 = 0;++ iterator->version = 0;+ iterator->reserved = 0;+ iterator->key.length16 = 0;+ }++ if ( err == fsBTEmptyErr || err == fsBTEndOfIterationErr )+ err = fsBTRecordNotFoundErr;++ return err;+}+++/*-------------------------------------------------------------------------------+Routine: BTIterateRecords++Function: Find a series of records++Input: filePtr - b-tree file+ operation - iteration operation (first,next,prev,last)+ iterator - pointer to iterator indicating start position+ callBackProc - pointer to routince to process a record+ callBackState - pointer to state data (used by callBackProc)++Output: iterator - iterator is updated to indicate new position++Result: noErr - success+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus+BTIterateRecords(FCB *filePtr, BTreeIterationOperation operation, BTreeIterator *iterator,+ IterateCallBackProcPtr callBackProc, void * callBackState)+{+ OSStatus err;+ BTreeControlBlockPtr btreePtr;+ BTreeKeyPtr keyPtr;+ RecordPtr recordPtr;+ u_int16_t len;+ Boolean foundRecord;+ u_int32_t nodeNum;+ BlockDescriptor left, node, right;+ u_int16_t index;+++ ////////////////////////// Priliminary Checks ///////////////////////////////++ left.buffer = nil;+ left.blockHeader = nil;+ right.buffer = nil;+ right.blockHeader = nil;+ node.buffer = nil;+ node.blockHeader = nil;++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;++ REQUIRE_FILE_LOCK(btreePtr->fileRefNum, true);++ if ((operation != kBTreeFirstRecord) &&+ (operation != kBTreeNextRecord) &&+ (operation != kBTreeCurrentRecord) &&+ (operation != kBTreePrevRecord) &&+ (operation != kBTreeLastRecord))+ {+ err = fsInvalidIterationMovmentErr;+ goto ErrorExit;+ }++ /////////////////////// Find First or Last Record ///////////////////////////++ if ((operation == kBTreeFirstRecord) || (operation == kBTreeLastRecord))+ {+ if (operation == kBTreeFirstRecord)+ nodeNum = btreePtr->firstLeafNode;+ else+ nodeNum = btreePtr->lastLeafNode;++ if (nodeNum == 0)+ {+ err = fsBTEmptyErr;+ goto ErrorExit;+ }++ err = GetNode(btreePtr, nodeNum, 0, &node);+ M_ExitOnError(err);++ if ( ((NodeDescPtr)node.buffer)->kind != kBTLeafNode ||+ ((NodeDescPtr)node.buffer)->numRecords <= 0 )+ {+ err = ReleaseNode(btreePtr, &node);+ M_ExitOnError(err);++ err = fsBTInvalidNodeErr;+ printf ("hfs: BTIterateRecords() found invalid btree node on volume %s\n", FCBTOVCB(filePtr)->vcbVN);+ hfs_mark_inconsistent(FCBTOVCB(filePtr), HFS_INCONSISTENCY_DETECTED);+ goto ErrorExit;+ }++ if (operation == kBTreeFirstRecord)+ index = 0;+ else+ index = ((BTNodeDescriptor*) node.buffer)->numRecords - 1;++ goto ProcessData;+ }++ //////////////////////// Find Iterator Position /////////////////////////////++ // Not called for (operation == kBTreeFirstRecord || operation == kBTreeLastRecord)+ err = FindIteratorPosition(btreePtr, iterator, &left, &node, &right,+ &nodeNum, &index, &foundRecord);+ if (err == fsBTRecordNotFoundErr)+ err = 0;+ M_ExitOnError(err);+++ ///////////////////// Find Next Or Previous Record //////////////////////////++ if (operation == kBTreePrevRecord)+ {+ if (index > 0)+ {+ --index;+ }+ else+ {+ if (left.buffer == nil)+ {+ nodeNum = ((NodeDescPtr) node.buffer)->bLink;+ if ( nodeNum > 0)+ {+ // BTree nodes are always grabbed in left to right order.+ // Therefore release the current node before looking up the+ // left node.+ err = ReleaseNode(btreePtr, &node);+ M_ExitOnError(err);++ // Look up the left node+ err = GetNode (btreePtr, nodeNum, 0, &left);+ M_ExitOnError (err);++ // Look up the current node again+ err = GetRightSiblingNode (btreePtr, left.buffer, &node);+ M_ExitOnError (err);+ } else {+ err = fsBTStartOfIterationErr;+ goto ErrorExit;+ }+ }+ // Before we stomp on "right", we'd better release it if needed+ if (right.buffer != nil) {+ err = ReleaseNode(btreePtr, &right);+ M_ExitOnError(err);+ }+ right = node;+ node = left;+ left.buffer = nil;+ index = ((NodeDescPtr) node.buffer)->numRecords -1;+ }+ }+ else if (operation == kBTreeNextRecord)+ {+ if ((foundRecord != true) &&+ (((NodeDescPtr)node.buffer)->fLink == 0) &&+ (index == ((NodeDescPtr)node.buffer)->numRecords))+ {+ err = fsBTEndOfIterationErr;+ goto ErrorExit;+ }++ // we did not find the record but the index is already positioned correctly+ if ((foundRecord == false) && (index != ((NodeDescPtr)node.buffer)->numRecords))+ goto ProcessData;++ // we found the record OR we have to look in the next node+ if (index < ((NodeDescPtr)node.buffer)->numRecords -1)+ {+ ++index;+ }+ else+ {+ if (right.buffer == nil)+ {+ nodeNum = ((NodeDescPtr)node.buffer)->fLink;+ if ( nodeNum > 0)+ {+ err = GetNode(btreePtr, nodeNum, 0, &right);+ M_ExitOnError(err);+ } else {+ err = fsBTEndOfIterationErr;+ goto ErrorExit;+ }+ }+ // Before we stomp on "left", we'd better release it if needed+ if (left.buffer != nil) {+ err = ReleaseNode(btreePtr, &left);+ M_ExitOnError(err);+ }+ left = node;+ node = right;+ right.buffer = nil;+ index = 0;+ }+ }+ else // operation == kBTreeCurrentRecord+ {+ // make sure we have something... <CS9>+ if ((foundRecord != true) &&+ (index >= ((NodeDescPtr)node.buffer)->numRecords))+ {+ err = fsBTEndOfIterationErr;+ goto ErrorExit;+ }+ }++ //////////////////// Process Records Using Callback ////////////////////////++ProcessData:+ err = GetRecordByIndex(btreePtr, node.buffer, index, &keyPtr, &recordPtr, &len);+ if (err) {+ err = btBadNode;+ goto ErrorExit;+ }++ while (err == 0) {+ if (callBackProc(keyPtr, recordPtr, callBackState) == 0)+ break;++ if ((index+1) < ((NodeDescPtr)node.buffer)->numRecords) {+ ++index;+ } else {+ if (right.buffer == nil)+ {+ nodeNum = ((NodeDescPtr)node.buffer)->fLink;+ if ( nodeNum > 0)+ {+ err = GetNode(btreePtr, nodeNum, 0, &right);+ M_ExitOnError(err);+ } else {+ err = fsBTEndOfIterationErr;+ break;+ }+ }+ // Before we stomp on "left", we'd better release it if needed+ if (left.buffer != nil) {+ err = ReleaseNode(btreePtr, &left);+ M_ExitOnError(err);+ }+ left = node;+ node = right;+ right.buffer = nil;+ index = 0;+ }+ err = GetRecordByIndex(btreePtr, node.buffer, index,+ &keyPtr, &recordPtr, &len);+ if (err) {+ err = btBadNode;+ goto ErrorExit;+ }+ }+++ ///////////////// Update Iterator to Last Item Processed /////////////////////+++ if (iterator != nil) // first & last have optional iterator+ {+ iterator->hint.writeCount = btreePtr->writeCount;+ iterator->hint.nodeNum = nodeNum;+ iterator->hint.index = index;+ iterator->version = 0;++ BlockMoveData((Ptr)keyPtr, (Ptr)&iterator->key, CalcKeySize(btreePtr, keyPtr));+ }+ M_ExitOnError(err);+++ ///////////////////////////// Release Nodes /////////////////////////////////++ err = ReleaseNode(btreePtr, &node);+ M_ExitOnError(err);++ if (left.buffer != nil)+ {+ err = ReleaseNode(btreePtr, &left);+ M_ExitOnError(err);+ }++ if (right.buffer != nil)+ {+ err = ReleaseNode(btreePtr, &right);+ M_ExitOnError(err);+ }++ return noErr;++ /////////////////////// Error - Clean Up and Exit ///////////////////////////++ErrorExit:++ (void) ReleaseNode(btreePtr, &left);+ (void) ReleaseNode(btreePtr, &node);+ (void) ReleaseNode(btreePtr, &right);++ if (iterator != nil)+ {+ iterator->hint.writeCount = 0;+ iterator->hint.nodeNum = 0;+ iterator->hint.index = 0;+ iterator->version = 0;+ iterator->key.length16 = 0;+ }++ if ( err == fsBTEmptyErr || err == fsBTEndOfIterationErr )+ err = fsBTRecordNotFoundErr;++ return err;+}+++//////////////////////////////// BTInsertRecord /////////////////////////////////++OSStatus BTInsertRecord (FCB *filePtr,+ BTreeIterator *iterator,+ FSBufferDescriptor *record,+ u_int16_t recordLen )+{+ OSStatus err;+ BTreeControlBlockPtr btreePtr;+ TreePathTable treePathTable;+ u_int32_t nodesNeeded;+ BlockDescriptor nodeRec;+ u_int32_t insertNodeNum;+ u_int16_t index;+ Boolean recordFit;++ ////////////////////////// Priliminary Checks ///////////////////////////////++ nodeRec.buffer = nil; // so we can call ReleaseNode+ nodeRec.blockHeader = nil;++ err = CheckInsertParams (filePtr, iterator, record, recordLen);+ if (err != noErr)+ return err;++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;++ REQUIRE_FILE_LOCK(btreePtr->fileRefNum, false);+++ ///////////////////////// Find Insert Position //////////////////////////////++ // always call SearchTree for Insert+ err = SearchTree (btreePtr, &iterator->key, treePathTable, &insertNodeNum, &nodeRec, &index);++ switch (err) // set/replace/insert decision point+ {+ case noErr: err = fsBTDuplicateRecordErr;+ goto ErrorExit;++ case fsBTRecordNotFoundErr: break;++ case fsBTEmptyErr: // if tree empty add 1st leaf node++ if (btreePtr->freeNodes == 0)+ {+ err = ExtendBTree (btreePtr, btreePtr->totalNodes + 1);+ M_ExitOnError (err);+ }++ err = AllocateNode (btreePtr, &insertNodeNum);+ M_ExitOnError (err);++ err = GetNewNode (btreePtr, insertNodeNum, &nodeRec);+ M_ExitOnError (err);++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &nodeRec);++ ((NodeDescPtr)nodeRec.buffer)->kind = kBTLeafNode;+ ((NodeDescPtr)nodeRec.buffer)->height = 1;++ recordFit = InsertKeyRecord (btreePtr, nodeRec.buffer, 0,+ &iterator->key, KeyLength(btreePtr, &iterator->key),+ record->bufferAddress, recordLen );+ if (recordFit != true)+ {+ err = fsBTRecordTooLargeErr;+ goto ErrorExit;+ }++ /*+ * Update the B-tree control block. Do this before+ * calling UpdateNode since it will compare the node's+ * height with treeDepth.+ */+ btreePtr->treeDepth = 1;+ btreePtr->rootNode = insertNodeNum;+ btreePtr->firstLeafNode = insertNodeNum;+ btreePtr->lastLeafNode = insertNodeNum;++ err = UpdateNode (btreePtr, &nodeRec, 0, kLockTransaction);+ M_ExitOnError (err);++ M_BTreeHeaderDirty (btreePtr);++ goto Success;++ default: goto ErrorExit;+ }++ if (index > 0)+ {+ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &nodeRec);++ recordFit = InsertKeyRecord (btreePtr, nodeRec.buffer, index,+ &iterator->key, KeyLength(btreePtr, &iterator->key),+ record->bufferAddress, recordLen);+ if (recordFit == true)+ {+ err = UpdateNode (btreePtr, &nodeRec, 0, kLockTransaction);+ M_ExitOnError (err);++ goto Success;+ }+ }++ /////////////////////// Extend File If Necessary ////////////////////////////++ if ((btreePtr->treeDepth + 1UL) > btreePtr->freeNodes)+ {+ nodesNeeded = btreePtr->treeDepth + 1 + btreePtr->totalNodes - btreePtr->freeNodes;+ if (nodesNeeded > CalcMapBits (btreePtr)) // we'll need to add a map node too!+ ++nodesNeeded;++ err = ExtendBTree (btreePtr, nodesNeeded);+ M_ExitOnError (err);+ }++ // no need to delete existing record++ err = InsertTree (btreePtr, treePathTable, &iterator->key, record->bufferAddress,+ recordLen, &nodeRec, index, 1, kInsertRecord, &insertNodeNum);+ M_ExitOnError (err);+++ //////////////////////////////// Success ////////////////////////////////////++Success:+ ++btreePtr->writeCount;+ ++btreePtr->leafRecords;+ M_BTreeHeaderDirty (btreePtr);++ // create hint+ iterator->hint.writeCount = btreePtr->writeCount;+ iterator->hint.nodeNum = insertNodeNum;+ iterator->hint.index = 0; // unused+ iterator->hint.reserved1 = 0;+ iterator->hint.reserved2 = 0;++ return noErr;+++ ////////////////////////////// Error Exit ///////////////////////////////////++ErrorExit:++ (void) ReleaseNode (btreePtr, &nodeRec);++ iterator->hint.writeCount = 0;+ iterator->hint.nodeNum = 0;+ iterator->hint.index = 0;+ iterator->hint.reserved1 = 0;+ iterator->hint.reserved2 = 0;++ if (err == fsBTEmptyErr)+ err = fsBTRecordNotFoundErr;++ return err;+}+++//////////////////////////////// BTReplaceRecord ////////////////////////////////++OSStatus BTReplaceRecord (FCB *filePtr,+ BTreeIterator *iterator,+ FSBufferDescriptor *record,+ u_int16_t recordLen )+{+ OSStatus err;+ BTreeControlBlockPtr btreePtr;+ TreePathTable treePathTable;+ u_int32_t nodesNeeded;+ BlockDescriptor nodeRec;+ u_int32_t insertNodeNum;+ u_int16_t index;+ Boolean recordFit;+ Boolean validHint;+++ ////////////////////////// Priliminary Checks ///////////////////////////////++ nodeRec.buffer = nil; // so we can call ReleaseNode+ nodeRec.blockHeader = nil;++ err = CheckInsertParams (filePtr, iterator, record, recordLen);+ if (err != noErr)+ return err;++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;++ REQUIRE_FILE_LOCK(btreePtr->fileRefNum, false);++ ////////////////////////////// Take A Hint //////////////////////////////////++ err = IsItAHint (btreePtr, iterator, &validHint);+ M_ExitOnError (err);++ if (validHint)+ {+ insertNodeNum = iterator->hint.nodeNum;++ err = GetNode (btreePtr, insertNodeNum, kGetNodeHint, &nodeRec);+ if( err == noErr )+ {+ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &nodeRec);++ err = TrySimpleReplace (btreePtr, nodeRec.buffer, iterator, record, recordLen, &recordFit);+ M_ExitOnError (err);++ if (recordFit)+ {+ err = UpdateNode (btreePtr, &nodeRec, 0, 0);+ M_ExitOnError (err);++ ++btreePtr->numValidHints;++ goto Success;+ }+ else+ {+ (void) BTInvalidateHint( iterator );+ }++ err = ReleaseNode (btreePtr, &nodeRec);+ M_ExitOnError (err);+ }+ else+ {+ (void) BTInvalidateHint( iterator );+ }+ }+++ ////////////////////////////// Get A Clue ///////////////////////////////////++ err = SearchTree (btreePtr, &iterator->key, treePathTable, &insertNodeNum, &nodeRec, &index);+ M_ExitOnError (err); // record must exit for Replace++ // optimization - if simple replace will work then don't extend btree+ // �� if we tried this before, and failed because it wouldn't fit then we shouldn't try this again...++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &nodeRec);++ err = TrySimpleReplace (btreePtr, nodeRec.buffer, iterator, record, recordLen, &recordFit);+ M_ExitOnError (err);++ if (recordFit)+ {+ err = UpdateNode (btreePtr, &nodeRec, 0, 0);+ M_ExitOnError (err);++ goto Success;+ }+++ //////////////////////////// Make Some Room /////////////////////////////////++ if ((btreePtr->treeDepth + 1UL) > btreePtr->freeNodes)+ {+ nodesNeeded = btreePtr->treeDepth + 1 + btreePtr->totalNodes - btreePtr->freeNodes;+ if (nodesNeeded > CalcMapBits (btreePtr)) // we'll need to add a map node too!+ ++nodesNeeded;++ err = ExtendBTree (btreePtr, nodesNeeded);+ M_ExitOnError (err);+ }++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &nodeRec);++ DeleteRecord (btreePtr, nodeRec.buffer, index); // delete existing key/record++ err = InsertTree (btreePtr, treePathTable, &iterator->key, record->bufferAddress,+ recordLen, &nodeRec, index, 1, kReplaceRecord, &insertNodeNum);+ M_ExitOnError (err);++ ++btreePtr->writeCount; /* writeCount changes only if the tree structure changed */++Success:+ // create hint+ iterator->hint.writeCount = btreePtr->writeCount;+ iterator->hint.nodeNum = insertNodeNum;+ iterator->hint.index = 0; // unused+ iterator->hint.reserved1 = 0;+ iterator->hint.reserved2 = 0;++ return noErr;+++ ////////////////////////////// Error Exit ///////////////////////////////////++ErrorExit:++ (void) ReleaseNode (btreePtr, &nodeRec);++ iterator->hint.writeCount = 0;+ iterator->hint.nodeNum = 0;+ iterator->hint.index = 0;+ iterator->hint.reserved1 = 0;+ iterator->hint.reserved2 = 0;++ return err;+}++++//////////////////////////////// BTUpdateRecord ////////////////////////////////++OSStatus+BTUpdateRecord(FCB *filePtr, BTreeIterator *iterator,+ IterateCallBackProcPtr callBackProc, void * callBackState)+{+ OSStatus err;+ BTreeControlBlockPtr btreePtr;+ TreePathTable treePathTable;+ BlockDescriptor nodeRec;+ RecordPtr recordPtr;+ BTreeKeyPtr keyPtr;+ u_int32_t insertNodeNum;+ u_int16_t recordLen;+ u_int16_t index;+ Boolean validHint;+++ ////////////////////////// Priliminary Checks ///////////////////////////////++ nodeRec.buffer = nil; // so we can call ReleaseNode+ nodeRec.blockHeader = nil;++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;++ REQUIRE_FILE_LOCK(btreePtr->fileRefNum, true);++ ////////////////////////////// Take A Hint //////////////////////////////////++ err = IsItAHint (btreePtr, iterator, &validHint);+ M_ExitOnError (err);++ if (validHint)+ {+ insertNodeNum = iterator->hint.nodeNum;++ err = GetNode (btreePtr, insertNodeNum, kGetNodeHint, &nodeRec);+ if (err == noErr)+ {+ if (((NodeDescPtr)nodeRec.buffer)->kind == kBTLeafNode &&+ SearchNode (btreePtr, nodeRec.buffer, &iterator->key, &index))+ {+ err = GetRecordByIndex(btreePtr, nodeRec.buffer, index, &keyPtr, &recordPtr, &recordLen);+ M_ExitOnError (err);++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &nodeRec);++ err = callBackProc(keyPtr, recordPtr, callBackState);+ M_ExitOnError (err);++ err = UpdateNode (btreePtr, &nodeRec, 0, 0);+ M_ExitOnError (err);++ ++btreePtr->numValidHints;++ goto Success;+ }+ else+ {+ (void) BTInvalidateHint( iterator );+ }++ err = ReleaseNode (btreePtr, &nodeRec);+ M_ExitOnError (err);+ }+ else+ {+ (void) BTInvalidateHint( iterator );+ }+ }++ ////////////////////////////// Get A Clue ///////////////////////////////////++ err = SearchTree (btreePtr, &iterator->key, treePathTable, &insertNodeNum, &nodeRec, &index);+ M_ExitOnError (err);++ err = GetRecordByIndex(btreePtr, nodeRec.buffer, index, &keyPtr, &recordPtr, &recordLen);+ M_ExitOnError (err);++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &nodeRec);++ err = callBackProc(keyPtr, recordPtr, callBackState);+ M_ExitOnError (err);++ err = UpdateNode (btreePtr, &nodeRec, 0, 0);+ M_ExitOnError (err);++Success:+ // create hint+ iterator->hint.writeCount = btreePtr->writeCount;+ iterator->hint.nodeNum = insertNodeNum;+ iterator->hint.index = 0;+ iterator->hint.reserved1 = 0;+ iterator->hint.reserved2 = 0;+ return noErr;++ ////////////////////////////// Error Exit ///////////////////////////////////++ErrorExit:++ (void) ReleaseNode (btreePtr, &nodeRec);++ iterator->hint.writeCount = 0;+ iterator->hint.nodeNum = 0;+ iterator->hint.index = 0;+ iterator->hint.reserved1 = 0;+ iterator->hint.reserved2 = 0;+ return err;+}++++//////////////////////////////// BTDeleteRecord /////////////////////////////////++OSStatus BTDeleteRecord (FCB *filePtr,+ BTreeIterator *iterator )+{+ OSStatus err;+ BTreeControlBlockPtr btreePtr;+ TreePathTable treePathTable;+ BlockDescriptor nodeRec;+ u_int32_t nodesNeeded;+ u_int32_t nodeNum;+ u_int16_t index;+++ ////////////////////////// Priliminary Checks ///////////////////////////////++ nodeRec.buffer = nil; // so we can call ReleaseNode+ nodeRec.blockHeader = nil;++ M_ReturnErrorIf (filePtr == nil, paramErr);+ M_ReturnErrorIf (iterator == nil, paramErr);++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;+ if (btreePtr == nil)+ {+ err = fsBTInvalidFileErr;+ goto ErrorExit;+ }++ REQUIRE_FILE_LOCK(btreePtr->fileRefNum, false);+++ /////////////////////////////// Find Key ////////////////////////////////////++ // check hint for simple delete case (index > 0, numRecords > 2)++ err = SearchTree (btreePtr, &iterator->key, treePathTable, &nodeNum, &nodeRec, &index);+ M_ExitOnError (err); // record must exit for Delete+++ /////////////////////// Extend File If Necessary ////////////////////////////++ /*+ * Worst case: we delete the first record in the tree and+ * following key is sufficiently larger to cause all parents to+ * require splitting and we need a new root node and a new map+ * node.+ */+ if (index == 0 && btreePtr->treeDepth + 1 > btreePtr->freeNodes)+ {+ nodesNeeded = btreePtr->treeDepth + btreePtr->totalNodes;+ if (nodesNeeded > CalcMapBits (btreePtr))+ ++nodesNeeded;++ if (nodesNeeded - btreePtr->totalNodes > btreePtr->freeNodes) {+ err = ExtendBTree (btreePtr, nodesNeeded);+ M_ExitOnError (err);+ }+ }++ ///////////////////////////// Delete Record /////////////////////////////////++ err = DeleteTree (btreePtr, treePathTable, &nodeRec, index, 1);+ M_ExitOnError (err);++ ++btreePtr->writeCount;+ --btreePtr->leafRecords;+ M_BTreeHeaderDirty (btreePtr);++ iterator->hint.nodeNum = 0;++ return noErr;++ ////////////////////////////// Error Exit ///////////////////////////////////++ErrorExit:+ (void) ReleaseNode (btreePtr, &nodeRec);++ return err;+}++++OSStatus BTGetInformation (FCB *filePtr,+ u_int16_t file_version,+ BTreeInfoRec *info )+{+#pragma unused (file_version)++ BTreeControlBlockPtr btreePtr;+++ M_ReturnErrorIf (filePtr == nil, paramErr);++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;++ /*+ * XXX SER+ * This should not require the whole tree to be locked, just maybe the BTreeControlBlockPtr+ *+ * REQUIRE_FILE_LOCK(btreePtr->fileRefNum, true);+ */++ M_ReturnErrorIf (btreePtr == nil, fsBTInvalidFileErr);+ M_ReturnErrorIf (info == nil, paramErr);++ //�� check version?++ info->nodeSize = btreePtr->nodeSize;+ info->maxKeyLength = btreePtr->maxKeyLength;+ info->treeDepth = btreePtr->treeDepth;+ info->numRecords = btreePtr->leafRecords;+ info->numNodes = btreePtr->totalNodes;+ info->numFreeNodes = btreePtr->freeNodes;+ info->lastfsync = btreePtr->lastfsync;+ info->keyCompareType = btreePtr->keyCompareType;+ return noErr;+}++// XXXdbg+OSStatus+BTIsDirty(FCB *filePtr)+{+ BTreeControlBlockPtr btreePtr;++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;+ return TreeIsDirty(btreePtr);+}++/*-------------------------------------------------------------------------------+Routine: BTFlushPath - Flush BTreeControlBlock to Header Node.++Function: Brief_description_of_the_function_and_any_side_effects+++Input: pathPtr - pointer to path control block for B*Tree file to flush++Output: none++Result: noErr - success+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus BTFlushPath (FCB *filePtr)+{+ OSStatus err;+ BTreeControlBlockPtr btreePtr;+++ M_ReturnErrorIf (filePtr == nil, paramErr);++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;++ M_ReturnErrorIf (btreePtr == nil, fsBTInvalidFileErr);++ REQUIRE_FILE_LOCK(btreePtr->fileRefNum, true);++ err = UpdateHeader (btreePtr, false);++ return err;+}+++/*-------------------------------------------------------------------------------+Routine: BTReload - Reload B-tree Header Data.++Function: Reload B-tree header data from disk. This is called after fsck+ has made repairs to the root filesystem. The filesystem is+ mounted read-only when BTReload is caled.+++Input: filePtr - the B*Tree file that needs its header updated++Output: none++Result: noErr - success+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus+BTReloadData(FCB *filePtr)+{+ OSStatus err;+ BTreeControlBlockPtr btreePtr;+ BlockDescriptor node;+ BTHeaderRec *header;+++ node.buffer = nil;+ node.blockHeader = nil;++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;+ if (btreePtr == nil)+ return (fsBTInvalidFileErr);++ REQUIRE_FILE_LOCK(btreePtr->fileRefNum, false);++ err = GetNode(btreePtr, kHeaderNodeNum, 0, &node);+ if (err != noErr)+ return (err);++ header = (BTHeaderRec*)((char *)node.buffer + sizeof(BTNodeDescriptor));+ if ((err = VerifyHeader (filePtr, header)) == 0) {+ btreePtr->treeDepth = header->treeDepth;+ btreePtr->rootNode = header->rootNode;+ btreePtr->leafRecords = header->leafRecords;+ btreePtr->firstLeafNode = header->firstLeafNode;+ btreePtr->lastLeafNode = header->lastLeafNode;+ btreePtr->maxKeyLength = header->maxKeyLength;+ btreePtr->totalNodes = header->totalNodes;+ btreePtr->freeNodes = header->freeNodes;+ btreePtr->btreeType = header->btreeType;++ btreePtr->flags &= (~kBTHeaderDirty);+ }++ (void) ReleaseNode(btreePtr, &node);++ return err;+}+++/*-------------------------------------------------------------------------------+Routine: BTInvalidateHint - Invalidates the hint within a BTreeInterator.++Function: Invalidates the hint within a BTreeInterator.+++Input: iterator - pointer to BTreeIterator++Output: iterator - iterator with the hint.nodeNum cleared++Result: noErr - success+ paramErr - iterator == nil+-------------------------------------------------------------------------------*/+++OSStatus BTInvalidateHint (BTreeIterator *iterator )+{+ if (iterator == nil)+ return paramErr;++ iterator->hint.nodeNum = 0;++ return noErr;+}+++++/*-------------------------------------------------------------------------------+Routine: BTGetLastSync++Function: Returns the last time that this btree was flushed, does not include header.++Input: filePtr - pointer file control block++Output: lastfsync - time in seconds of last update++Result: noErr - success+ paramErr - iterator == nil+-------------------------------------------------------------------------------*/+++OSStatus BTGetLastSync (FCB *filePtr,+ u_int32_t *lastsync)+{+ BTreeControlBlockPtr btreePtr;+++ M_ReturnErrorIf (filePtr == nil, paramErr);++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;++ /* Maybe instead of requiring a lock..an atomic set might be more appropriate */+ REQUIRE_FILE_LOCK(btreePtr->fileRefNum, true);++ M_ReturnErrorIf (btreePtr == nil, fsBTInvalidFileErr);+ M_ReturnErrorIf (lastsync == nil, paramErr);++ *lastsync = btreePtr->lastfsync;++ return noErr;+}+++++/*-------------------------------------------------------------------------------+Routine: BTSetLastSync++Function: Sets the last time that this btree was flushed, does not include header.+++Input: fcb - pointer file control block++Output: lastfsync - time in seconds of last update++Result: noErr - success+ paramErr - iterator == nil+-------------------------------------------------------------------------------*/+++OSStatus BTSetLastSync (FCB *filePtr,+ u_int32_t lastsync)+{+ BTreeControlBlockPtr btreePtr;+++ M_ReturnErrorIf (filePtr == nil, paramErr);++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;++ /* Maybe instead of requiring a lock..an atomic set might be more appropriate */+ REQUIRE_FILE_LOCK(btreePtr->fileRefNum, true);++ M_ReturnErrorIf (btreePtr == nil, fsBTInvalidFileErr);+ M_ReturnErrorIf (lastsync == 0, paramErr);++ btreePtr->lastfsync = lastsync;++ return noErr;+}++OSStatus BTHasContiguousNodes (FCB *filePtr)+{+ BTreeControlBlockPtr btreePtr;+++ M_ReturnErrorIf (filePtr == nil, paramErr);++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;++ REQUIRE_FILE_LOCK(btreePtr->fileRefNum, true);++ M_ReturnErrorIf (btreePtr == nil, fsBTInvalidFileErr);++ return NodesAreContiguous(FCBTOVCB(filePtr), filePtr, btreePtr->nodeSize);+}+++/*-------------------------------------------------------------------------------+Routine: BTGetUserData++Function: Read the user data area of the b-tree header node.++-------------------------------------------------------------------------------*/+OSStatus+BTGetUserData(FCB *filePtr, void * dataPtr, int dataSize)+{+ BTreeControlBlockPtr btreePtr;+ BlockDescriptor node;+ char * offset;+ OSStatus err;++ if (dataSize > kBTreeHeaderUserBytes)+ return (EINVAL);+ node.buffer = nil;+ node.blockHeader = nil;++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;+ if (btreePtr == nil)+ return (fsBTInvalidFileErr);++ REQUIRE_FILE_LOCK(btreePtr->fileRefNum, false);++ err = GetNode(btreePtr, kHeaderNodeNum, 0, &node);+ if (err)+ return (err);++ offset = (char *)node.buffer + sizeof(BTNodeDescriptor) + sizeof(BTHeaderRec);+ bcopy(offset, dataPtr, dataSize);++ (void) ReleaseNode(btreePtr, &node);++ return (0);+}+++/*-------------------------------------------------------------------------------+Routine: BTSetUserData++Function: Write the user data area of the b-tree header node.+-------------------------------------------------------------------------------*/+OSStatus+BTSetUserData(FCB *filePtr, void * dataPtr, int dataSize)+{+ BTreeControlBlockPtr btreePtr;+ BlockDescriptor node;+ char * offset;+ OSStatus err;++ if (dataSize > kBTreeHeaderUserBytes)+ return (EINVAL);+ node.buffer = nil;+ node.blockHeader = nil;++ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;+ if (btreePtr == nil)+ return (fsBTInvalidFileErr);++ REQUIRE_FILE_LOCK(btreePtr->fileRefNum, false);++ err = GetNode(btreePtr, kHeaderNodeNum, 0, &node);+ if (err)+ return (err);++ ModifyBlockStart(btreePtr->fileRefNum, &node);++ offset = (char *)node.buffer + sizeof(BTNodeDescriptor) + sizeof(BTHeaderRec);+ bcopy(dataPtr, offset, dataSize);++ err = UpdateNode (btreePtr, &node, 0, 0);++ return (err);+}+diff --git a/xnu/files/bsd/hfs/BTreeAllocate.c b/xnu/files/bsd/hfs/BTreeAllocate.cnew file mode 100644index 0000000..d9b3b63--- /dev/null+++ b/xnu/files/bsd/hfs/BTreeAllocate.c@@ -0,0 +1,748 @@+/*+ * Copyright (c) 2000-2003, 2005-2015 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@+ */+/*+ File: BTreeAllocate.c++ Contains: BTree Node Allocation routines for the BTree Module.++ Version: xxx put the technology version here xxx++ Written by: Gordon Sheridan and Bill Bruffey++ Copyright: (c) 1992-1999 by Apple Inc., all rights reserved.++ File Ownership:++ DRI: Don Brady++ Other Contact: Mark Day++ Technology: File Systems++ Writers:++ (djb) Don Brady+ (ser) Scott Roberts+ (msd) Mark Day++ Change History (most recent first):++ <MOSXS> 6/1/99 djb Sync up with Mac OS 8.6.+ <CS3> 11/24/97 djb Remove some debug code (Panic calls).+ <CS2> 7/24/97 djb CallbackProcs now take refnum instead of an FCB.+ <CS1> 4/23/97 djb first checked in++ <HFS2> 2/19/97 djb Change E_BadNodeType to fsBTBadNodeType.+ <HFS1> 12/19/96 djb first checked in++ History applicable to original Scarecrow Design:++ <4> 10/25/96 ser Changing for new VFPI+ <3> 10/18/96 ser Converting over VFPI changes+ <2> 1/10/96 msd Change 64-bit math to use real function names from Math64.i.+ <1> 10/18/95 rst Moved from Scarecrow project.++ <8> 1/12/95 wjk Adopt Model FileSystem changes in D5.+ <7> 9/30/94 prp Get in sync with D2 interface changes.+ <6> 7/22/94 wjk Convert to the new set of header files.+ <5> 8/31/93 prp Use U64SetU instead of S64Set.+ <4> 5/21/93 gs Fix ExtendBTree bug.+ <3> 5/10/93 gs Fix pointer arithmetic bug in AllocateNode.+ <2> 3/23/93 gs finish ExtendBTree routine.+ <1> 2/8/93 gs first checked in+ <0> 1/1/93 gs begin AllocateNode and FreeNode++*/++#include "hfs_btreeio.h"+#include "hfs_endian.h"+#include "BTreesPrivate.h"++///////////////////// Routines Internal To BTreeAllocate.c //////////////////////++static OSStatus GetMapNode (BTreeControlBlockPtr btreePtr,+ BlockDescriptor *nodePtr,+ u_int16_t **mapPtr,+ u_int16_t *mapSize );++/////////////////////////////////////////////////////////////////////////////////++/*-------------------------------------------------------------------------------++Routine: AllocateNode - Find Free Node, Mark It Used, and Return Node Number.++Function: Searches the map records for the first free node, marks it "in use" and+ returns the node number found. This routine should really only be called+ when we know there are free blocks, otherwise it's just a waste of time.++Note: We have to examine map nodes a word at a time rather than a long word+ because the External BTree Mgr used map records that were not an integral+ number of long words. Too bad. In our spare time could develop a more+ sophisticated algorithm that read map records by long words (and long+ word aligned) and handled the spare bytes at the beginning and end+ appropriately.++Input: btreePtr - pointer to control block for BTree file++Output: nodeNum - number of node allocated+++Result: noErr - success+ fsBTNoMoreMapNodesErr - no free blocks were found+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus AllocateNode (BTreeControlBlockPtr btreePtr, u_int32_t *nodeNum)+{+ OSStatus err;+ BlockDescriptor node;+ u_int16_t *mapPtr, *pos;+ u_int16_t mapSize, size;+ u_int16_t freeWord;+ u_int16_t mask;+ u_int16_t bitOffset;+ u_int32_t nodeNumber;+++ nodeNumber = 0; // first node number of header map record+ node.buffer = nil; // clear node.buffer to get header node+ // - and for ErrorExit+ node.blockHeader = nil;++ while (true)+ {+ err = GetMapNode (btreePtr, &node, &mapPtr, &mapSize);+ M_ExitOnError (err);++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &node);++ //////////////////////// Find Word with Free Bit ////////////////////////////++ pos = mapPtr;+ size = mapSize;+ size >>= 1; // convert to number of words+ //�� assumes mapRecords contain an integral number of words++ while ( size-- )+ {+ if ( *pos++ != 0xFFFF ) // assume test fails, and increment pos+ break;+ }++ --pos; // whoa! backup++ if (*pos != 0xFFFF) // hey, we got one!+ break;++ nodeNumber += mapSize << 3; // covert to number of bits (nodes)+ }++ ///////////////////////// Find Free Bit in Word /////////////////////////////++ freeWord = SWAP_BE16 (*pos);+ bitOffset = 15;+ mask = 0x8000;++ do {+ if ( (freeWord & mask) == 0)+ break;+ mask >>= 1;+ } while (--bitOffset);++ ////////////////////// Calculate Free Node Number ///////////////////////////++ nodeNumber += ((pos - mapPtr) << 4) + (15 - bitOffset); // (pos-mapPtr) = # of words!+++ ///////////////////////// Check for End of Map //////////////////////////////++ if (nodeNumber >= btreePtr->totalNodes)+ {+ err = fsBTFullErr;+ goto ErrorExit;+ }++ /////////////////////////// Allocate the Node ///////////////////////////////++ *pos |= SWAP_BE16 (mask); // set the map bit for the node++ err = UpdateNode (btreePtr, &node, 0, kLockTransaction);+ M_ExitOnError (err);++ --btreePtr->freeNodes;+ M_BTreeHeaderDirty(btreePtr);++ /* Account for allocations from node reserve */+ BTUpdateReserve(btreePtr, 1);++ *nodeNum = nodeNumber;++ return noErr;++////////////////////////////////// Error Exit ///////////////////////////////////++ErrorExit:++ (void) ReleaseNode (btreePtr, &node);+ *nodeNum = 0;++ return err;+}++++/*-------------------------------------------------------------------------------++Routine: FreeNode - Clear allocation bit for node.++Function: Finds the bit representing the node specified by nodeNum in the node+ map and clears the bit.+++Input: btreePtr - pointer to control block for BTree file+ nodeNum - number of node to mark free++Output: none++Result: noErr - success+ fsBTNoMoreMapNodesErr - node number is beyond end of node map+ != noErr - GetNode or ReleaseNode encountered some difficulty+-------------------------------------------------------------------------------*/++OSStatus FreeNode (BTreeControlBlockPtr btreePtr, u_int32_t nodeNum)+{+ OSStatus err;+ BlockDescriptor node;+ u_int32_t nodeIndex;+ u_int16_t mapSize = 0;+ u_int16_t *mapPos = NULL;+ u_int16_t bitOffset;+++ //////////////////////////// Find Map Record ////////////////////////////////+ nodeIndex = 0; // first node number of header map record+ node.buffer = nil; // invalidate node.buffer to get header node+ node.blockHeader = nil;++ while (nodeNum >= nodeIndex)+ {+ err = GetMapNode (btreePtr, &node, &mapPos, &mapSize);+ M_ExitOnError (err);++ nodeIndex += mapSize << 3; // covert to number of bits (nodes)+ }++ //////////////////////////// Mark Node Free /////////////////////////////////++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &node);++ nodeNum -= (nodeIndex - (mapSize << 3)); // relative to this map record+ bitOffset = 15 - (nodeNum & 0x0000000F); // last 4 bits are bit offset+ mapPos += nodeNum >> 4; // point to word containing map bit++ M_SWAP_BE16_ClearBitNum (*mapPos, bitOffset); // clear it++ err = UpdateNode (btreePtr, &node, 0, kLockTransaction);+ M_ExitOnError (err);++ ++btreePtr->freeNodes;+ M_BTreeHeaderDirty(btreePtr);++ return noErr;++ErrorExit:++ (void) ReleaseNode (btreePtr, &node);++ return err;+}++++/*-------------------------------------------------------------------------------++Routine: ExtendBTree - Call FSAgent to extend file, and allocate necessary map nodes.++Function: This routine calls the the FSAgent to extend the end of fork, if necessary,+ to accomodate the number of nodes requested. It then allocates as many+ map nodes as are necessary to account for all the nodes in the B*Tree.+ If newTotalNodes is less than the current number of nodes, no action is+ taken.++Note: Internal HFS File Manager BTree Module counts on an integral number of+ long words in map records, although they are not long word aligned.++Input: btreePtr - pointer to control block for BTree file+ newTotalNodes - total number of nodes the B*Tree is to extended to++Output: none++Result: noErr - success+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus ExtendBTree (BTreeControlBlockPtr btreePtr,+ u_int32_t newTotalNodes )+{+ OSStatus err;+ FCB *filePtr;+ FSSize minEOF, maxEOF;+ u_int16_t nodeSize;+ u_int32_t oldTotalNodes;+ u_int32_t newMapNodes;+ u_int32_t mapBits, totalMapBits;+ u_int32_t recStartBit;+ u_int32_t nodeNum, nextNodeNum;+ u_int32_t firstNewMapNodeNum, lastNewMapNodeNum;+ BlockDescriptor mapNode, newNode;+ u_int16_t *mapPos;+ u_int16_t *mapStart;+ u_int16_t mapSize;+ u_int16_t mapNodeRecSize;+ u_int32_t bitInWord, bitInRecord;+ u_int16_t mapIndex;+++ oldTotalNodes = btreePtr->totalNodes;+ if (newTotalNodes <= oldTotalNodes) // we're done!+ return noErr;++ nodeSize = btreePtr->nodeSize;+ filePtr = GetFileControlBlock(btreePtr->fileRefNum);++ mapNode.buffer = nil;+ mapNode.blockHeader = nil;+ newNode.buffer = nil;+ newNode.blockHeader = nil;++ mapNodeRecSize = nodeSize - sizeof(BTNodeDescriptor) - 6; // 2 bytes of free space (see note)+++ //////////////////////// Count Bits In Node Map /////////////////////////////++ totalMapBits = 0;+ do {+ err = GetMapNode (btreePtr, &mapNode, &mapStart, &mapSize);+ M_ExitOnError (err);++ mapBits = mapSize << 3; // mapSize (in bytes) * 8+ recStartBit = totalMapBits; // bit number of first bit in map record+ totalMapBits += mapBits;++ } while ( ((BTNodeDescriptor*)mapNode.buffer)->fLink != 0 );++#if DEBUG+ if (totalMapBits != CalcMapBits (btreePtr))+ Panic ("ExtendBTree: totalMapBits != CalcMapBits");+#endif++ /////////////////////// Extend LEOF If Necessary ////////////////////////////++ minEOF = (u_int64_t)newTotalNodes * (u_int64_t)nodeSize;+ if ( (u_int64_t)filePtr->fcbEOF < minEOF )+ {+ maxEOF = (u_int64_t)0x7fffffffLL * (u_int64_t)nodeSize;++ err = btreePtr->setEndOfForkProc (btreePtr->fileRefNum, minEOF, maxEOF);+ M_ExitOnError (err);+ }+++ //////////////////// Calc New Total Number Of Nodes /////////////////////////++ newTotalNodes = filePtr->fcbEOF / nodeSize; // hack!+ // do we wish to perform any verification of newTotalNodes at this point?++ btreePtr->totalNodes = newTotalNodes; // do we need to update freeNodes here too?+++ ////////////// Calculate Number Of New Map Nodes Required ///////////////////++ newMapNodes = 0;+ if (newTotalNodes > totalMapBits)+ {+ newMapNodes = (((newTotalNodes - totalMapBits) >> 3) / mapNodeRecSize) + 1;+ firstNewMapNodeNum = oldTotalNodes;+ lastNewMapNodeNum = firstNewMapNodeNum + newMapNodes - 1;+ }+ else+ {+ err = ReleaseNode (btreePtr, &mapNode);+ M_ExitOnError (err);++ goto Success;+ }+++ /////////////////////// Initialize New Map Nodes ////////////////////////////+ // XXXdbg - this is the correct place for this:+ ModifyBlockStart(btreePtr->fileRefNum, &mapNode);++ ((BTNodeDescriptor*)mapNode.buffer)->fLink = firstNewMapNodeNum;++ nodeNum = firstNewMapNodeNum;+ while (true)+ {+ err = GetNewNode (btreePtr, nodeNum, &newNode);+ M_ExitOnError (err);++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &newNode);++ ((NodeDescPtr)newNode.buffer)->numRecords = 1;+ ((NodeDescPtr)newNode.buffer)->kind = kBTMapNode;++ // set free space offset+ *(u_int16_t *)((Ptr)newNode.buffer + nodeSize - 4) = nodeSize - 6;++ if (nodeNum++ == lastNewMapNodeNum)+ break;++ ((BTNodeDescriptor*)newNode.buffer)->fLink = nodeNum; // point to next map node++ err = UpdateNode (btreePtr, &newNode, 0, kLockTransaction);+ M_ExitOnError (err);+ }++ err = UpdateNode (btreePtr, &newNode, 0, kLockTransaction);+ M_ExitOnError (err);+++ ///////////////////// Mark New Map Nodes Allocated //////////////////////////++ nodeNum = firstNewMapNodeNum;+ do {+ bitInRecord = nodeNum - recStartBit;++ while (bitInRecord >= mapBits)+ {+ nextNodeNum = ((NodeDescPtr)mapNode.buffer)->fLink;+ if ( nextNodeNum == 0)+ {+ err = fsBTNoMoreMapNodesErr;+ goto ErrorExit;+ }++ err = UpdateNode (btreePtr, &mapNode, 0, kLockTransaction);+ M_ExitOnError (err);++ err = GetNode (btreePtr, nextNodeNum, 0, &mapNode);+ M_ExitOnError (err);++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &mapNode);++ mapIndex = 0;++ mapStart = (u_int16_t *) GetRecordAddress (btreePtr, mapNode.buffer, mapIndex);+ mapSize = GetRecordSize (btreePtr, mapNode.buffer, mapIndex);++#if DEBUG+ if (mapSize != M_MapRecordSize (btreePtr->nodeSize) )+ {+ Panic ("ExtendBTree: mapSize != M_MapRecordSize");+ }+#endif++ mapBits = mapSize << 3; // mapSize (in bytes) * 8+ recStartBit = totalMapBits; // bit number of first bit in map record+ totalMapBits += mapBits;++ bitInRecord = nodeNum - recStartBit;+ }++ mapPos = mapStart + ((nodeNum - recStartBit) >> 4);+ bitInWord = 15 - ((nodeNum - recStartBit) & 0x0000000F);++ M_SWAP_BE16_SetBitNum (*mapPos, bitInWord);++ ++nodeNum;++ } while (nodeNum <= lastNewMapNodeNum);++ err = UpdateNode (btreePtr, &mapNode, 0, kLockTransaction);+ M_ExitOnError (err);+++ //////////////////////////////// Success ////////////////////////////////////++Success:++ btreePtr->totalNodes = newTotalNodes;+ btreePtr->freeNodes += (newTotalNodes - oldTotalNodes) - newMapNodes;++ M_BTreeHeaderDirty(btreePtr);++ /* Force the b-tree header changes to disk */+ (void) UpdateHeader (btreePtr, true);++ return noErr;+++ ////////////////////////////// Error Exit ///////////////////////////////////++ErrorExit:++ (void) ReleaseNode (btreePtr, &mapNode);+ (void) ReleaseNode (btreePtr, &newNode);++ return err;+}++++/*-------------------------------------------------------------------------------++Routine: GetMapNode - Get the next map node and pointer to the map record.++Function: Given a BlockDescriptor to a map node in nodePtr, GetMapNode releases+ it and gets the next node. If nodePtr->buffer is nil, then the header+ node is retrieved.+++Input: btreePtr - pointer to control block for BTree file+ nodePtr - pointer to a BlockDescriptor of a map node++Output: nodePtr - pointer to the BlockDescriptor for the next map node+ mapPtr - pointer to the map record within the map node+ mapSize - number of bytes in the map record++Result: noErr - success+ fsBTNoMoreMapNodesErr - we've run out of map nodes+ fsBTInvalidNodeErr - bad node, or not node type kMapNode+ != noErr - failure+-------------------------------------------------------------------------------*/++static+OSStatus GetMapNode (BTreeControlBlockPtr btreePtr,+ BlockDescriptor *nodePtr,+ u_int16_t **mapPtr,+ u_int16_t *mapSize )+{+ OSStatus err;+ u_int16_t mapIndex;+ u_int32_t nextNodeNum;++ if (nodePtr->buffer != nil) // if iterator is valid...+ {+ nextNodeNum = ((NodeDescPtr)nodePtr->buffer)->fLink;+ if (nextNodeNum == 0)+ {+ err = fsBTNoMoreMapNodesErr;+ goto ErrorExit;+ }++ err = ReleaseNode (btreePtr, nodePtr);+ M_ExitOnError (err);++ err = GetNode (btreePtr, nextNodeNum, 0, nodePtr);+ M_ExitOnError (err);++ if ( ((NodeDescPtr)nodePtr->buffer)->kind != kBTMapNode)+ {+ err = fsBTBadNodeType;+ goto ErrorExit;+ }++ ++btreePtr->numMapNodesRead;+ mapIndex = 0;+ } else {+ err = GetNode (btreePtr, kHeaderNodeNum, 0, nodePtr);+ M_ExitOnError (err);++ if ( ((NodeDescPtr)nodePtr->buffer)->kind != kBTHeaderNode)+ {+ err = fsBTInvalidHeaderErr; //�� or fsBTBadNodeType+ goto ErrorExit;+ }++ mapIndex = 2;+ }+++ *mapPtr = (u_int16_t *) GetRecordAddress (btreePtr, nodePtr->buffer, mapIndex);+ *mapSize = GetRecordSize (btreePtr, nodePtr->buffer, mapIndex);++ return noErr;+++ErrorExit:++ (void) ReleaseNode (btreePtr, nodePtr);++ *mapPtr = nil;+ *mapSize = 0;++ return err;+}++++////////////////////////////////// CalcMapBits //////////////////////////////////++u_int32_t CalcMapBits (BTreeControlBlockPtr btreePtr)+{+ u_int32_t mapBits;++ mapBits = M_HeaderMapRecordSize (btreePtr->nodeSize) << 3;++ while (mapBits < btreePtr->totalNodes)+ mapBits += M_MapRecordSize (btreePtr->nodeSize) << 3;++ return mapBits;+}+++/*-------------------------------------------------------------------------------+Routine: BTZeroUnusedNodes++Function: Write zeros to all nodes in the B-tree that are not currently in use.+-------------------------------------------------------------------------------*/+int+BTZeroUnusedNodes(FCB *filePtr)+{+ int err;+ vnode_t vp;+ BTreeControlBlockPtr btreePtr;+ BlockDescriptor mapNode;+ buf_t bp;+ u_int32_t nodeNumber;+ u_int16_t *mapPtr, *pos;+ u_int16_t mapSize, size;+ u_int16_t mask;+ u_int16_t bitNumber;+ u_int16_t word;+ int numWritten;++ vp = FTOV(filePtr);+ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;+ bp = NULL;+ nodeNumber = 0;+ mapNode.buffer = nil;+ mapNode.blockHeader = nil;+ numWritten = 0;++ /* Iterate over map nodes. */+ while (true)+ {+ err = GetMapNode (btreePtr, &mapNode, &mapPtr, &mapSize);+ if (err)+ {+ err = MacToVFSError(err);+ goto ErrorExit;+ }++ pos = mapPtr;+ size = mapSize;+ size >>= 1; /* convert to number of 16-bit words */++ /* Iterate over 16-bit words in the map record. */+ while (size--)+ {+ if (*pos != 0xFFFF) /* Anything free in this word? */+ {+ word = SWAP_BE16(*pos);++ /* Iterate over bits in the word. */+ for (bitNumber = 0, mask = 0x8000;+ bitNumber < 16;+ ++bitNumber, mask >>= 1)+ {+ if (word & mask)+ continue; /* This node is in use. */++ if (nodeNumber + bitNumber >= btreePtr->totalNodes)+ {+ /* We've processed all of the nodes. */+ goto done;+ }++ /*+ * Get a buffer full of zeros and write it to the unused+ * node. Since we'll probably be writing a lot of nodes,+ * bypass the journal (to avoid a transaction that's too+ * big). Instead, this behaves more like clearing out+ * nodes when extending a B-tree (eg., ClearBTNodes).+ */+ bp = buf_getblk(vp, nodeNumber + bitNumber, btreePtr->nodeSize, 0, 0, BLK_META);+ if (bp == NULL)+ {+ printf("hfs: BTZeroUnusedNodes: unable to read node %u\n", nodeNumber + bitNumber);+ err = EIO;+ goto ErrorExit;+ }++ if (buf_flags(bp) & B_LOCKED) {+ /*+ * This node is already part of a transaction and will be written when+ * the transaction is committed, so don't write it here. If we did, then+ * we'd hit a panic in hfs_vnop_bwrite because the B_LOCKED bit is still set.+ */+ buf_brelse(bp);+ continue;+ }++ buf_clear(bp);+ buf_markaged(bp);++ /*+ * Try not to hog the buffer cache. Wait for the write+ * every 32 nodes. If VNOP_BWRITE reports an error, bail out and bubble+ * it up to the function calling us. If we tried to update a read-only+ * mount on read-only media, for example, catching the error will let+ * us alert the callers of this function that they should maintain+ * the mount in read-only mode.++ */+ ++numWritten;+ if (numWritten % 32 == 0) {+ err = VNOP_BWRITE(bp);+ if (err) {+ goto ErrorExit;+ }+ }+ else {+ buf_bawrite(bp);+ }+ }+ }++ /* Go to the next word in the bitmap */+ ++pos;+ nodeNumber += 16;+ }+ }++ErrorExit:+done:+ (void) ReleaseNode(btreePtr, &mapNode);++ return err;+}diff --git a/xnu/files/bsd/hfs/BTreeMiscOps.c b/xnu/files/bsd/hfs/BTreeMiscOps.cnew file mode 100644index 0000000..4f89b78--- /dev/null+++ b/xnu/files/bsd/hfs/BTreeMiscOps.c@@ -0,0 +1,676 @@+/*+ * Copyright (c) 2000-2003, 2005-2015 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@+ */+/*+ File: BTreeMiscOps.c++ Contains: Miscellaneous operations for the BTree Module.++ Version: xxx put the technology version here xxx++ Written by: Gordon Sheridan and Bill Bruffey++ Copyright: (c) 1992-1999 by Apple Inc., all rights reserved.++ File Ownership:++ DRI: Don Brady++ Other Contact: Mark Day++ Technology: File Systems++ Writers:++ (DSH) Deric Horn+ (msd) Mark Day+ (djb) Don Brady++ Change History (most recent first):++ <MOSXS> 6/1/99 djb Sync up with Mac OS 8.6.+ <CS2> 9/4/97 djb Optimize TrySimpleReplace for the case where record size is not+ changing.+ <CS1> 4/23/97 djb first checked in++ <HFS7> 3/31/97 djb Move ClearMemory to Utilities.c.+ <HFS6> 3/17/97 DSH Casting for DFA+ <HFS5> 2/27/97 msd Remove temporary fix from last revision. BTree EOF's should be+ correct now, so check for strict equality.+ <HFS4> 2/26/97 msd Fix a casting problem in ClearMemory. TEMPORARY FIX: Made+ VerifyHeader more lenient, allowing the EOF to be greater than+ the amount actually used by nodes; this should really be fixed+ in the formatting code (which needs to compute the real BTree+ sizes before writing the volume header).+ <HFS3> 2/19/97 djb Added ClearMemory. Changed CalcKeyLength to KeyLength.+ <HFS2> 1/3/97 djb Added support for large keys.+ <HFS1> 12/19/96 djb first checked in++ History applicable to original Scarecrow Design:++ <9> 10/25/96 ser Changing for new VFPI+ <8> 10/18/96 ser Converting over VFPI changes+ <7> 9/17/96 dkh More BTree statistics. Change IsItAHint to not always check to+ see if the hint node is allocated.+ <6> 9/16/96 dkh Revised BTree statistics.+ <5> 6/20/96 dkh Radar #1358740. Change from using Pools to debug MemAllocators.+ <4> 1/22/96 dkh Change Pools.i inclusion to PoolsPriv.i+ <3> 1/10/96 msd Change 64-bit math to use real function names from Math64.i.+ <2> 12/7/95 dkh D10E2 build. Changed usage of Ref data type to LogicalAddress.+ <1> 10/18/95 rst Moved from Scarecrow project.++ <19> 4/26/95 prp In UpdateHeader, clear the dirty flag after the BTree is updated.+ <18> 1/12/95 wjk Adopt Model FileSystem changes in D5.+ <17> 11/16/94 prp Add IsItAHint routine and use it whenever hint's node number was+ used for testing.+ <16> 10/5/94 bk add pools.h include file+ <15> 9/30/94 prp Get in sync with D2 interface changes.+ <14> 7/22/94 wjk Convert to the new set of header files.+ <13> 12/2/93 wjk Move from Makefiles to BuildFiles. Fit into the ModernOS and+ NRCmds environments.+ <12> 11/30/93 wjk Move from Makefiles to BuildFiles. Fit into the ModernOS and+ NRCmds environments.+ <11> 11/23/93 wjk Changes required to compile on the RS6000.+ <10> 8/31/93 prp Use U64SetU instead of S64Set.+ <9> 6/2/93 gs Update for changes to FSErrors.h and add some comments.+ <8> 5/21/93 gs Modify UpdateHeader to write out attributes. Remove+ Get/UpdateNode from TrySimpleReplace.+ <7> 5/10/93 gs Add TrySimpleReplace routine.+ <6> 3/23/93 gs Change MoveData to take void * instead of Ptr. Add UpdateHeader+ and ClearBytes routines.+ <5> 2/8/93 gs Add FindIteratorPosition.+ <4> 12/10/92 gs Implement CheckKeyDescriptor and the KeyDescriptor interpreter.+ <3> 12/8/92 gs Add GetKeyDescriptor, VerifyHeader, and Alloc/Dealloc memory+ routines.+ <2> 12/2/92 gs Add CompareKeys routine.+ <1> 11/15/92 gs first checked in++*/++#include "BTreesPrivate.h"+#include "hfs_btreeio.h"+++////////////////////////////// Routine Definitions //////////////////////////////++/*-------------------------------------------------------------------------------+Routine: CalcKeyRecordSize - Return size of combined key/record structure.++Function: Rounds keySize and recSize so they will end on word boundaries.+ Does NOT add size of offset.++Input: keySize - length of key (including length field)+ recSize - length of record data++Output: none++Result: u_int16_t - size of combined key/record that will be inserted in btree+-------------------------------------------------------------------------------*/++u_int16_t CalcKeyRecordSize (u_int16_t keySize,+ u_int16_t recSize )+{+ if ( M_IsOdd (keySize) ) keySize += 1; // pad byte++ if (M_IsOdd (recSize) ) recSize += 1; // pad byte++ return (keySize + recSize);+}++++/*-------------------------------------------------------------------------------+Routine: VerifyHeader - Validate fields of the BTree header record.++Function: Examines the fields of the BTree header record to determine if the+ fork appears to contain a valid BTree.++Input: forkPtr - pointer to fork control block+ header - pointer to BTree header+++Result: noErr - success+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus VerifyHeader (FCB *filePtr,+ BTHeaderRec *header )+{+ u_int64_t forkSize;+ u_int32_t totalNodes;+++ switch (header->nodeSize) // node size == 512*2^n+ {+ case 512:+ case 1024:+ case 2048:+ case 4096:+ case 8192:+ case 16384:+ case 32768: break;+ default: return fsBTInvalidHeaderErr; //�� E_BadNodeType+ }++ totalNodes = header->totalNodes;++ forkSize = (u_int64_t)totalNodes * (u_int64_t)header->nodeSize;++ if ( forkSize > (u_int64_t)filePtr->fcbEOF )+ return fsBTInvalidHeaderErr;++ if ( header->freeNodes >= totalNodes )+ return fsBTInvalidHeaderErr;++ if ( header->rootNode >= totalNodes )+ return fsBTInvalidHeaderErr;++ if ( header->firstLeafNode >= totalNodes )+ return fsBTInvalidHeaderErr;++ if ( header->lastLeafNode >= totalNodes )+ return fsBTInvalidHeaderErr;++ if ( header->treeDepth > kMaxTreeDepth )+ return fsBTInvalidHeaderErr;+++ /////////////////////////// Check BTree Type ////////////////////////////////++ switch (header->btreeType)+ {+ case 0: // HFS Type - no Key Descriptor+ case kUserBTreeType: // with Key Descriptors etc.+ case kReservedBTreeType: // Desktop Mgr BTree ?+ break;++ default: return fsBTUnknownVersionErr;+ }++ return noErr;+}++++OSStatus TreeIsDirty(BTreeControlBlockPtr btreePtr)+{+ return (btreePtr->flags & kBTHeaderDirty);+}++++/*-------------------------------------------------------------------------------+Routine: UpdateHeader - Write BTreeInfoRec fields to Header node.++Function: Checks the kBTHeaderDirty flag in the BTreeInfoRec and updates the+ header node if necessary.++Input: btreePtr - pointer to BTreeInfoRec+++Result: noErr - success+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus UpdateHeader(BTreeControlBlockPtr btreePtr, Boolean forceWrite)+{+ OSStatus err;+ BlockDescriptor node;+ BTHeaderRec *header;+ u_int32_t options;++ if ((btreePtr->flags & kBTHeaderDirty) == 0) // btree info already flushed+ return noErr;++ err = GetNode (btreePtr, kHeaderNodeNum, 0, &node );+ if (err != noErr) {+ return err;+ }++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &node);++ header = (BTHeaderRec*) ((char *)node.buffer + sizeof(BTNodeDescriptor));++ header->treeDepth = btreePtr->treeDepth;+ header->rootNode = btreePtr->rootNode;+ header->leafRecords = btreePtr->leafRecords;+ header->firstLeafNode = btreePtr->firstLeafNode;+ header->lastLeafNode = btreePtr->lastLeafNode;+ header->nodeSize = btreePtr->nodeSize; //�� this shouldn't change+ header->maxKeyLength = btreePtr->maxKeyLength; //�� neither should this+ header->totalNodes = btreePtr->totalNodes;+ header->freeNodes = btreePtr->freeNodes;+ header->btreeType = btreePtr->btreeType;++ // ignore header->clumpSize; //�� rename this field?++ if (forceWrite)+ options = kForceWriteBlock;+ else+ options = kLockTransaction;++ err = UpdateNode (btreePtr, &node, 0, options);++ btreePtr->flags &= (~kBTHeaderDirty);++ return err;+}++++/*-------------------------------------------------------------------------------+Routine: FindIteratorPosition - One_line_description.++Function: Brief_description_of_the_function_and_any_side_effects++Algorithm: see FSC.BT.BTIterateRecord.PICT++Note: //�� document side-effects of bad node hints++Input: btreePtr - description+ iterator - description+++Output: iterator - description+ left - description+ middle - description+ right - description+ nodeNum - description+ returnIndex - description+ foundRecord - description+++Result: noErr - success+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus FindIteratorPosition (BTreeControlBlockPtr btreePtr,+ BTreeIteratorPtr iterator,+ BlockDescriptor *left,+ BlockDescriptor *middle,+ BlockDescriptor *right,+ u_int32_t *returnNodeNum,+ u_int16_t *returnIndex,+ Boolean *foundRecord )+{+ OSStatus err;+ Boolean foundIt;+ u_int32_t nodeNum;+ u_int16_t leftIndex, index, rightIndex;+ Boolean validHint;++ // assume btreePtr valid+ // assume left, middle, right point to BlockDescriptors+ // assume nodeNum points to u_int32_t+ // assume index points to u_int16_t+ // assume foundRecord points to Boolean++ left->buffer = nil;+ left->blockHeader = nil;+ middle->buffer = nil;+ middle->blockHeader = nil;+ right->buffer = nil;+ right->blockHeader = nil;++ foundIt = false;++ if (iterator == nil) // do we have an iterator?+ {+ err = fsBTInvalidIteratorErr;+ goto ErrorExit;+ }++ err = IsItAHint (btreePtr, iterator, &validHint);+ M_ExitOnError (err);++ nodeNum = iterator->hint.nodeNum;+ if (! validHint) // does the hint appear to be valid?+ {+ goto SearchTheTree;+ }++ err = GetNode (btreePtr, nodeNum, kGetNodeHint, middle);+ if( err == fsBTInvalidNodeErr ) // returned if nodeNum is out of range+ goto SearchTheTree;++ M_ExitOnError (err);++ if ( ((NodeDescPtr) middle->buffer)->kind != kBTLeafNode ||+ ((NodeDescPtr) middle->buffer)->numRecords <= 0 )+ {+ goto SearchTheTree;+ }++ foundIt = SearchNode (btreePtr, middle->buffer, &iterator->key, &index);+ if (foundIt == true)+ {+ ++btreePtr->numValidHints;+ goto SuccessfulExit;+ }+ iterator->hint.nodeNum = 0;++ if (index == 0)+ {+ if (((NodeDescPtr) middle->buffer)->bLink == 0) // before 1st btree record+ {+ goto SuccessfulExit;+ }++ nodeNum = ((NodeDescPtr) middle->buffer)->bLink;++ // BTree nodes are always grabbed in left to right order.+ // Therefore release the current node before looking up the+ // left node.+ err = ReleaseNode(btreePtr, middle);+ M_ExitOnError(err);++ // Look up the left node+ err = GetNode (btreePtr, nodeNum, 0, left);+ M_ExitOnError (err);++ // Look up the current node again+ err = GetRightSiblingNode (btreePtr, left->buffer, middle);+ M_ExitOnError (err);++ if ( ((NodeDescPtr) left->buffer)->kind != kBTLeafNode ||+ ((NodeDescPtr) left->buffer)->numRecords <= 0 )+ {+ goto SearchTheTree;+ }++ foundIt = SearchNode (btreePtr, left->buffer, &iterator->key, &leftIndex);+ if (foundIt == true)+ {+ *right = *middle;+ *middle = *left;+ left->buffer = nil;+ index = leftIndex;++ goto SuccessfulExit;+ }++ if (leftIndex == 0) // we're lost!+ {+ goto SearchTheTree;+ }+ else if (leftIndex >= ((NodeDescPtr) left->buffer)->numRecords)+ {+ nodeNum = ((NodeDescPtr) left->buffer)->fLink;++ PanicIf (index != 0, "FindIteratorPosition: index != 0"); //�� just checking...+ goto SuccessfulExit;+ }+ else+ {+ *right = *middle;+ *middle = *left;+ left->buffer = nil;+ index = leftIndex;++ goto SuccessfulExit;+ }+ }+ else if (index >= ((NodeDescPtr) middle->buffer)->numRecords)+ {+ if (((NodeDescPtr) middle->buffer)->fLink == 0) // beyond last record+ {+ goto SuccessfulExit;+ }++ nodeNum = ((NodeDescPtr) middle->buffer)->fLink;++ err = GetRightSiblingNode (btreePtr, middle->buffer, right);+ M_ExitOnError (err);++ if ( ((NodeDescPtr) right->buffer)->kind != kBTLeafNode ||+ ((NodeDescPtr) right->buffer)->numRecords <= 0 )+ {+ goto SearchTheTree;+ }++ foundIt = SearchNode (btreePtr, right->buffer, &iterator->key, &rightIndex);+ if (rightIndex >= ((NodeDescPtr) right->buffer)->numRecords) // we're lost+ {+ goto SearchTheTree;+ }+ else // we found it, or rightIndex==0, or rightIndex<numRecs+ {+ *left = *middle;+ *middle = *right;+ right->buffer = nil;+ index = rightIndex;++ goto SuccessfulExit;+ }+ }+++ //////////////////////////// Search The Tree ////////////////////////////////++SearchTheTree:+ {+ TreePathTable treePathTable; // so we only use stack space if we need to++ err = ReleaseNode (btreePtr, left); M_ExitOnError (err);+ err = ReleaseNode (btreePtr, middle); M_ExitOnError (err);+ err = ReleaseNode (btreePtr, right); M_ExitOnError (err);++ err = SearchTree ( btreePtr, &iterator->key, treePathTable, &nodeNum, middle, &index);+ switch (err) //�� separate find condition from exceptions+ {+ case noErr: foundIt = true; break;+ case fsBTRecordNotFoundErr: break;+ default: goto ErrorExit;+ }+ }++ /////////////////////////////// Success! ////////////////////////////////////++SuccessfulExit:++ *returnNodeNum = nodeNum;+ *returnIndex = index;+ *foundRecord = foundIt;++ return noErr;+++ ////////////////////////////// Error Exit ///////////////////////////////////++ErrorExit:++ (void) ReleaseNode (btreePtr, left);+ (void) ReleaseNode (btreePtr, middle);+ (void) ReleaseNode (btreePtr, right);++ *returnNodeNum = 0;+ *returnIndex = 0;+ *foundRecord = false;++ return err;+}++++/////////////////////////////// CheckInsertParams ///////////////////////////////++OSStatus CheckInsertParams (FCB *filePtr,+ BTreeIterator *iterator,+ FSBufferDescriptor *record,+ u_int16_t recordLen )+{+ BTreeControlBlockPtr btreePtr;++ if (filePtr == nil) return paramErr;+ if (recordLen == 0) return paramErr;+ btreePtr = (BTreeControlBlockPtr) filePtr->fcbBTCBPtr;+ if (btreePtr == nil) return fsBTInvalidFileErr;+ if (iterator == nil) return paramErr;+ if (record == nil) return paramErr;++ // check total key/record size limit+ if ( CalcKeyRecordSize (CalcKeySize(btreePtr, &iterator->key), recordLen) > (btreePtr->nodeSize >> 1))+ return fsBTRecordTooLargeErr;++ return noErr;+}++++/*-------------------------------------------------------------------------------+Routine: TrySimpleReplace - Attempts a simple insert, set, or replace.++Function: If a hint exitst for the iterator, attempt to find the key in the hint+ node. If the key is found, an insert operation fails. If the is not+ found, a replace operation fails. If the key was not found, and the+ insert position is greater than 0 and less than numRecords, the record+ is inserted, provided there is enough freeSpace. If the key was found,+ and there is more freeSpace than the difference between the new record+ and the old record, the old record is deleted and the new record is+ inserted.++Assumptions: iterator key has already been checked by CheckKey+++Input: btreePtr - description+ iterator - description+ record - description+ recordLen - description+ operation - description+++Output: recordInserted - description+++Result: noErr - success+ E_RecordExits - insert operation failure+ != noErr - GetNode, ReleaseNode, UpdateNode returned an error+-------------------------------------------------------------------------------*/++OSStatus TrySimpleReplace (BTreeControlBlockPtr btreePtr,+ NodeDescPtr nodePtr,+ BTreeIterator *iterator,+ FSBufferDescriptor *record,+ u_int16_t recordLen,+ Boolean *recordInserted )+{+ u_int32_t oldSpace;+ u_int32_t spaceNeeded;+ u_int16_t index;+ u_int16_t keySize;+ Boolean foundIt;+ Boolean didItFit;+++ *recordInserted = false; // we'll assume this won't work...++ if ( nodePtr->kind != kBTLeafNode )+ return noErr; // we're in the weeds!++ foundIt = SearchNode (btreePtr, nodePtr, &iterator->key, &index);++ if ( foundIt == false )+ return noErr; // we might be lost...++ keySize = CalcKeySize(btreePtr, &iterator->key); // includes length field++ spaceNeeded = CalcKeyRecordSize (keySize, recordLen);++ oldSpace = GetRecordSize (btreePtr, nodePtr, index);++ if ( spaceNeeded == oldSpace )+ {+ u_int8_t * dst;++ dst = GetRecordAddress (btreePtr, nodePtr, index);++ if ( M_IsOdd (keySize) )+ ++keySize; // add pad byte++ dst += keySize; // skip over key to point at record++ BlockMoveData(record->bufferAddress, dst, recordLen); // blast away...++ *recordInserted = true;+ }+ else if ( (GetNodeFreeSize(btreePtr, nodePtr) + oldSpace) >= spaceNeeded)+ {+ DeleteRecord (btreePtr, nodePtr, index);++ didItFit = InsertKeyRecord (btreePtr, nodePtr, index,+ &iterator->key, KeyLength(btreePtr, &iterator->key),+ record->bufferAddress, recordLen);+ PanicIf (didItFit == false, "TrySimpleInsert: InsertKeyRecord returned false!");++ *recordInserted = true;+ }+ // else not enough space...++ return noErr;+}+++/*-------------------------------------------------------------------------------+Routine: IsItAHint - checks the hint within a BTreeInterator.++Function: checks the hint within a BTreeInterator. If it is non-zero, it may+ possibly be valid.++Input: btreePtr - pointer to control block for BTree file+ iterator - pointer to BTreeIterator++Output: answer - true if the hint looks reasonable+ - false if the hint is 0++Result: noErr - success+-------------------------------------------------------------------------------*/+++OSStatus IsItAHint (BTreeControlBlockPtr btreePtr, BTreeIterator *iterator, Boolean *answer)+{+ ++btreePtr->numHintChecks;++#if DEBUG+ if (iterator->hint.nodeNum >= btreePtr->totalNodes)+ {+ *answer = false;+ } else++#endif+ if (iterator->hint.nodeNum == 0)+ {+ *answer = false;+ }+ else+ {+ *answer = true;+ ++btreePtr->numPossibleHints;+ }++ return noErr;+}diff --git a/xnu/files/bsd/hfs/BTreeNodeOps.c b/xnu/files/bsd/hfs/BTreeNodeOps.cnew file mode 100644index 0000000..9fee0b4--- /dev/null+++ b/xnu/files/bsd/hfs/BTreeNodeOps.c@@ -0,0 +1,1036 @@+/*+ * Copyright (c) 2000, 2002, 2005-2015 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@+ */+/*+ File: BTreeNodeOps.c++ Contains: Single-node operations for the BTree Module.++ Version: xxx put the technology version here xxx++ Written by: Gordon Sheridan and Bill Bruffey++ Copyright: (c) 1992-1999 by Apple Inc., all rights reserved.++ File Ownership:++ DRI: Don Brady++ Other Contact: Mark Day++ Technology: File Systems++ Writers:++ (msd) Mark Day+ (djb) Don Brady++ Change History (most recent first):++ <MOSXS> 6/1/99 djb Sync up with Mac OS 8.6.+ <MOSXS> 4/113/99 djb Fix key size checking bug in CheckNode.+ <MOSXS> 3/19/99 djb Added key size checking to CheckNode.+ <MOSXS> 3/26/98 djb Added PrintNode for debugging.+ <CS5> 9/4/97 djb Removed GetRightSiblingNode and GetLeftSiblingNode - they are+ now macros. SearchNode is now in BTreeSearchNode.a.+ <CS4> 8/22/97 djb Turn off debugging code in CheckKey.+ <CS3> 7/24/97 djb Add summary traces for Get/Rel Node. Made GetRecordOffset into a+ macro. Only call CheckNode if the node came from disk.+ <CS2> 7/21/97 msd Make GetRecordByIndex check its record index input; it now+ returns an OSStatus.+ <CS1> 4/23/97 djb first checked in++ <HFS3> 2/19/97 djb Changes to support big node cache.+ <HFS2> 1/3/97 djb Added support for large keys.+ <HFS1> 12/19/96 djb first checked in+++ History applicable to original Scarecrow Design:++ <6> 10/25/96 ser Changing for new VFPI+ <5> 9/17/96 dkh Add bounds checking to GetNode. Update GetNode to not assert+ that CheckNode failed if the node is all zeroes. This can happen+ if the hint case if the fetched node has been deallocated+ <4> 3/7/96 dkh Change GetNewNode() to not use kGetEmptyBlock. Instead use+ kGetBlock to fetch a block from the disk itself. ��� Why?+ <3> 1/22/96 dkh Add #include Memory.h+ <2> 1/10/96 msd Change 64-bit math to use real function names from Math64.i.+ <1> 10/18/95 rst Moved from Scarecrow project.++ <17> 7/18/95 mbb Change MoveData & ClearBytes to BlockMoveData & BlockZero.+ <16> 1/31/95 prp GetBlockProc interface uses a 64 bit node number.+ <15> 1/12/95 wjk Adopt Model FileSystem changes in D5.+ <14> 9/30/94 prp Get in sync with D2 interface changes.+ <13> 7/25/94 wjk Eliminate usage of BytePtr in favor of UInt8 *.+ <12> 7/22/94 wjk Convert to the new set of header files.+ <11> 12/2/93 wjk Move from Makefiles to BuildFiles. Fit into the ModernOS and+ NRCmds environments.+ <10> 11/30/93 wjk Change some Ptr's to BytePtr's in function definitions so they+ agree with their prototypes.+ <9> 8/31/93 prp Use U64SetU instead of S64Set.+ <8> 5/21/93 gs Maintain statistical counters on Get/Release node routines.+ <7> 5/10/93 gs Change keySize parameter to keyLength for InsertKeyRecord+ routine. Calculate number of bytes in key from keyLength to+ account for length and pad bytes. Add GetChildNodeNum routine.+ <6> 3/23/93 gs Add InsertKeyRecord routine.+ <5> 2/8/93 gs Fix bug in SearchNode that caused "off by 1" error when final+ compare was searchKey > trialKey. Add UpdateNode.+ <4> 12/10/92 gs Change keyLength field of key to 'length'.+ <3> 12/8/92 gs Incorporate suggestions from preliminary code review.+ <2> 12/2/92 gs Implement routines.+ <1> 11/15/92 gs Define routine interfaces.++*/++#include "BTreesPrivate.h"++++///////////////////////// BTree Module Node Operations //////////////////////////+//+// GetNode - Call FS Agent to get node+// GetNewNode - Call FS Agent to get a new node+// ReleaseNode - Call FS Agent to release node obtained by GetNode.+// UpdateNode - Mark a node as dirty and call FS Agent to release it.+//+// ClearNode - Clear a node to all zeroes.+//+// InsertRecord - Inserts a record into a BTree node.+// InsertKeyRecord - Inserts a key and record pair into a BTree node.+// DeleteRecord - Deletes a record from a BTree node.+//+// SearchNode - Return index for record that matches key.+// LocateRecord - Return pointer to key and data, and size of data.+//+// GetNodeDataSize - Return the amount of space used for data in the node.+// GetNodeFreeSize - Return the amount of free space in the node.+//+// GetRecordOffset - Return the offset for record "index".+// GetRecordAddress - Return address of record "index".+// GetOffsetAddress - Return address of offset for record "index".+//+// InsertOffset - Inserts a new offset into a node.+// DeleteOffset - Deletes an offset from a node.+//+/////////////////////////////////////////////////////////////////////////////////++++////////////////////// Routines Internal To BTreeNodeOps.c //////////////////////++u_int16_t GetRecordOffset (BTreeControlBlockPtr btree,+ NodeDescPtr node,+ u_int16_t index );++u_int16_t *GetOffsetAddress (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ u_int16_t index );++void InsertOffset (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ u_int16_t index,+ u_int16_t delta );++void DeleteOffset (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ u_int16_t index );+++/////////////////////////////////////////////////////////////////////////////////++#define GetRecordOffset(btreePtr,node,index) (*(short *) ((u_int8_t *)(node) + (btreePtr)->nodeSize - ((index) << 1) - kOffsetSize))+++/*-------------------------------------------------------------------------------++Routine: GetNode - Call FS Agent to get node++Function: Gets an existing BTree node from FS Agent and verifies it.++Input: btreePtr - pointer to BTree control block+ nodeNum - number of node to request++Output: nodePtr - pointer to beginning of node (nil if error)++Result:+ noErr - success+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus GetNode (BTreeControlBlockPtr btreePtr,+ u_int32_t nodeNum,+ u_int32_t flags,+ NodeRec *nodePtr )+{+ OSStatus err;+ GetBlockProcPtr getNodeProc;+ u_int32_t options;+++ // is nodeNum within proper range?+ if( nodeNum >= btreePtr->totalNodes )+ {+ Panic("GetNode:nodeNum >= totalNodes");+ err = fsBTInvalidNodeErr;+ goto ErrorExit;+ }++ nodePtr->blockSize = btreePtr->nodeSize; // indicate the size of a node++ options = kGetBlock;+ if ( flags & kGetNodeHint )+ {+ options |= kGetBlockHint;+ }++ getNodeProc = btreePtr->getBlockProc;+ err = getNodeProc (btreePtr->fileRefNum,+ nodeNum,+ options,+ nodePtr );++ if (err != noErr)+ {+ Panic ("GetNode: getNodeProc returned error.");+ goto ErrorExit;+ }+ ++btreePtr->numGetNodes;++ return noErr;++ErrorExit:+ nodePtr->buffer = nil;+ nodePtr->blockHeader = nil;++ return err;+}++++/*-------------------------------------------------------------------------------++Routine: GetNewNode - Call FS Agent to get a new node++Function: Gets a new BTree node from FS Agent and initializes it to an empty+ state.++Input: btreePtr - pointer to BTree control block+ nodeNum - number of node to request++Output: returnNodePtr - pointer to beginning of node (nil if error)++Result: noErr - success+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus GetNewNode (BTreeControlBlockPtr btreePtr,+ u_int32_t nodeNum,+ NodeRec *returnNodePtr )+{+ OSStatus err;+ NodeDescPtr node;+ void *pos;+ GetBlockProcPtr getNodeProc;+++ //////////////////////// get buffer for new node ////////////////////////////++ returnNodePtr->blockSize = btreePtr->nodeSize; // indicate the size of a node++ getNodeProc = btreePtr->getBlockProc;+ err = getNodeProc (btreePtr->fileRefNum,+ nodeNum,+ kGetBlock+kGetEmptyBlock,+ returnNodePtr );++ if (err != noErr)+ {+ Panic ("GetNewNode: getNodeProc returned error.");+ // returnNodePtr->buffer = nil;+ return err;+ }+ ++btreePtr->numGetNewNodes;+++ ////////////////////////// initialize the node //////////////////////////////++ node = returnNodePtr->buffer;++ ClearNode (btreePtr, node); // clear the node++ pos = (char *)node + btreePtr->nodeSize - 2; // find address of last offset+ *(u_int16_t *)pos = sizeof (BTNodeDescriptor); // set offset to beginning of free space+++ return noErr;+}++++/*-------------------------------------------------------------------------------++Routine: ReleaseNode - Call FS Agent to release node obtained by GetNode.++Function: Informs the FS Agent that a BTree node may be released.++Input: btreePtr - pointer to BTree control block+ nodeNum - number of node to release++Result: noErr - success+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus ReleaseNode (BTreeControlBlockPtr btreePtr,+ NodePtr nodePtr )+{+ OSStatus err;+ ReleaseBlockProcPtr releaseNodeProc;+++ err = noErr;++ if (nodePtr->buffer != nil)+ {+ releaseNodeProc = btreePtr->releaseBlockProc;+ err = releaseNodeProc (btreePtr->fileRefNum,+ nodePtr,+ kReleaseBlock );+ PanicIf (err, "ReleaseNode: releaseNodeProc returned error.");+ ++btreePtr->numReleaseNodes;+ }++ nodePtr->buffer = nil;+ nodePtr->blockHeader = nil;++ return err;+}+++++/*-------------------------------------------------------------------------------++Routine: TrashNode - Call FS Agent to release node obtained by GetNode, and+ not store it...mark it as bad.++Function: Informs the FS Agent that a BTree node may be released and thrown away.++Input: btreePtr - pointer to BTree control block+ nodeNum - number of node to release++Result: noErr - success+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus TrashNode (BTreeControlBlockPtr btreePtr,+ NodePtr nodePtr )+{+ OSStatus err;+ ReleaseBlockProcPtr releaseNodeProc;+++ err = noErr;++ if (nodePtr->buffer != nil)+ {+ releaseNodeProc = btreePtr->releaseBlockProc;+ err = releaseNodeProc (btreePtr->fileRefNum,+ nodePtr,+ kReleaseBlock | kTrashBlock );+ PanicIf (err, "TrashNode: releaseNodeProc returned error.");+ ++btreePtr->numReleaseNodes;+ }++ nodePtr->buffer = nil;+ nodePtr->blockHeader = nil;++ return err;+}++++/*-------------------------------------------------------------------------------++Routine: UpdateNode - Mark a node as dirty and call FS Agent to release it.++Function: Marks a BTree node dirty and informs the FS Agent that it may be released.++Input: btreePtr - pointer to BTree control block+ nodeNum - number of node to release+ transactionID - ID of transaction this node update is a part of+ flags - special flags to pass to ReleaseNodeProc++Result: noErr - success+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus UpdateNode (BTreeControlBlockPtr btreePtr,+ NodePtr nodePtr,+ u_int32_t transactionID,+ u_int32_t flags )+{+#pragma unused(transactionID)++ OSStatus err;+ ReleaseBlockProcPtr releaseNodeProc;+++ err = noErr;++ if (nodePtr->buffer != nil) // Why call UpdateNode if nil ?!?+ {+ releaseNodeProc = btreePtr->releaseBlockProc;+ err = releaseNodeProc (btreePtr->fileRefNum,+ nodePtr,+ flags | kMarkBlockDirty );+ ++btreePtr->numUpdateNodes;+ M_ExitOnError (err);+ }++ nodePtr->buffer = nil;+ nodePtr->blockHeader = nil;++ return noErr;++ErrorExit:++ return err;+}++/*-------------------------------------------------------------------------------++Routine: ClearNode - Clear a node to all zeroes.++Function: Writes zeroes from beginning of node for nodeSize bytes.++Input: btreePtr - pointer to BTree control block+ node - pointer to node to clear++Result: none+-------------------------------------------------------------------------------*/++void ClearNode (BTreeControlBlockPtr btreePtr, NodeDescPtr node )+{+ ClearMemory( node, btreePtr->nodeSize );+}++/*-------------------------------------------------------------------------------++Routine: InsertRecord - Inserts a record into a BTree node.++Function:++Note: Record size must be even!++Input: btreePtr - pointer to BTree control block+ node - pointer to node to insert the record+ index - position record is to be inserted+ recPtr - pointer to record to insert++Result: noErr - success+ fsBTFullErr - record larger than remaining free space.+-------------------------------------------------------------------------------*/++Boolean InsertRecord (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ u_int16_t index,+ RecordPtr recPtr,+ u_int16_t recSize )+{+ u_int16_t freeSpace;+ u_int16_t indexOffset;+ u_int16_t freeOffset;+ u_int16_t bytesToMove;+ void *src;+ void *dst;++ //// will new record fit in node?++ freeSpace = GetNodeFreeSize (btreePtr, node);+ //�� we could get freeOffset & calc freeSpace+ if ( freeSpace < recSize + 2)+ {+ return false;+ }+++ //// make hole for new record++ indexOffset = GetRecordOffset (btreePtr, node, index);+ freeOffset = GetRecordOffset (btreePtr, node, node->numRecords);++ src = ((Ptr) node) + indexOffset;+ dst = ((Ptr) src) + recSize;+ bytesToMove = freeOffset - indexOffset;+ if (bytesToMove)+ MoveRecordsRight (src, dst, bytesToMove);+++ //// adjust offsets for moved records++ InsertOffset (btreePtr, node, index, recSize);+++ //// move in the new record++ dst = ((Ptr) node) + indexOffset;+ MoveRecordsLeft (recPtr, dst, recSize);++ return true;+}++++/*-------------------------------------------------------------------------------++Routine: InsertKeyRecord - Inserts a record into a BTree node.++Function:++Note: Record size must be even!++Input: btreePtr - pointer to BTree control block+ node - pointer to node to insert the record+ index - position record is to be inserted+ keyPtr - pointer to key for record to insert+ keyLength - length of key (or maxKeyLength)+ recPtr - pointer to record to insert+ recSize - number of bytes to copy for record++Result: noErr - success+ fsBTFullErr - record larger than remaining free space.+-------------------------------------------------------------------------------*/++Boolean InsertKeyRecord (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ u_int16_t index,+ KeyPtr keyPtr,+ u_int16_t keyLength,+ RecordPtr recPtr,+ u_int16_t recSize )+{+ u_int16_t freeSpace;+ u_int16_t indexOffset;+ u_int16_t freeOffset;+ u_int16_t bytesToMove;+ u_int8_t * src;+ u_int8_t * dst;+ u_int16_t keySize;+ u_int16_t rawKeyLength;+ u_int16_t sizeOfLength;++ //// calculate actual key size++ if ( btreePtr->attributes & kBTBigKeysMask )+ keySize = keyLength + sizeof(u_int16_t);+ else+ keySize = keyLength + sizeof(u_int8_t);++ if ( M_IsOdd (keySize) )+ ++keySize; // add pad byte+++ //// will new record fit in node?++ freeSpace = GetNodeFreeSize (btreePtr, node);+ //�� we could get freeOffset & calc freeSpace+ if ( freeSpace < keySize + recSize + 2)+ {+ return false;+ }+++ //// make hole for new record++ indexOffset = GetRecordOffset (btreePtr, node, index);+ freeOffset = GetRecordOffset (btreePtr, node, node->numRecords);++ src = ((u_int8_t *) node) + indexOffset;+ dst = ((u_int8_t *) src) + keySize + recSize;+ bytesToMove = freeOffset - indexOffset;+ if (bytesToMove)+ MoveRecordsRight (src, dst, bytesToMove);+++ //// adjust offsets for moved records++ InsertOffset (btreePtr, node, index, keySize + recSize);+++ //// copy record key++ dst = ((u_int8_t *) node) + indexOffset;++ if ( btreePtr->attributes & kBTBigKeysMask )+ {+ *((u_int16_t *)dst) = keyLength; // use keyLength rather than key.length+ dst = (u_int8_t *) (((u_int16_t *)dst) + 1);+ rawKeyLength = keyPtr->length16;+ sizeOfLength = 2;+ }+ else+ {+ *dst++ = keyLength; // use keyLength rather than key.length+ rawKeyLength = keyPtr->length8;+ sizeOfLength = 1;+ }++ MoveRecordsLeft ( ((u_int8_t *) keyPtr) + sizeOfLength, dst, rawKeyLength); // copy key++ // any pad bytes?+ bytesToMove = keySize - rawKeyLength;+ if (bytesToMove)+ ClearMemory (dst + rawKeyLength, bytesToMove); // clear pad bytes in index key+++ //// copy record data++ dst = ((u_int8_t *) node) + indexOffset + keySize;+ MoveRecordsLeft (recPtr, dst, recSize);++ return true;+}++++/*-------------------------------------------------------------------------------++Routine: DeleteRecord - Deletes a record from a BTree node.++Function:++Input: btreePtr - pointer to BTree control block+ node - pointer to node to insert the record+ index - position record is to be inserted++Result: none+-------------------------------------------------------------------------------*/++void DeleteRecord (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ u_int16_t index )+{+ int16_t indexOffset;+ int16_t nextOffset;+ int16_t freeOffset;+ int16_t bytesToMove;+ void *src;+ void *dst;++ //// compress records+ indexOffset = GetRecordOffset (btreePtr, node, index);+ nextOffset = GetRecordOffset (btreePtr, node, index + 1);+ freeOffset = GetRecordOffset (btreePtr, node, node->numRecords);++ src = ((Ptr) node) + nextOffset;+ dst = ((Ptr) node) + indexOffset;+ bytesToMove = freeOffset - nextOffset;+ if (bytesToMove)+ MoveRecordsLeft (src, dst, bytesToMove);++ //// Adjust the offsets+ DeleteOffset (btreePtr, node, index);++ /* clear out new free space */+ bytesToMove = nextOffset - indexOffset;+ ClearMemory(GetRecordAddress(btreePtr, node, node->numRecords), bytesToMove);++}++++/*-------------------------------------------------------------------------------++Routine: SearchNode - Return index for record that matches key.++Function: Returns the record index for the record that matches the search key.+ If no record was found that matches the search key, the "insert index"+ of where the record should go is returned instead.++Algorithm: A binary search algorithm is used to find the specified key.++Input: btreePtr - pointer to BTree control block+ node - pointer to node that contains the record+ searchKey - pointer to the key to match++Output: index - pointer to beginning of key for record++Result: true - success (index = record index)+ false - key did not match anything in node (index = insert index)+-------------------------------------------------------------------------------*/+Boolean+SearchNode( BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ KeyPtr searchKey,+ u_int16_t *returnIndex )+{+ int32_t lowerBound;+ int32_t upperBound;+ int32_t index;+ int32_t result;+ KeyPtr trialKey;+ u_int16_t *offset;+ KeyCompareProcPtr compareProc = btreePtr->keyCompareProc;++ lowerBound = 0;+ upperBound = node->numRecords - 1;+ offset = (u_int16_t *) ((u_int8_t *)(node) + (btreePtr)->nodeSize - kOffsetSize);++ while (lowerBound <= upperBound) {+ index = (lowerBound + upperBound) >> 1;++ trialKey = (KeyPtr) ((u_int8_t *)node + *(offset - index));++ result = compareProc(searchKey, trialKey);++ if (result < 0) {+ upperBound = index - 1; /* search < trial */+ } else if (result > 0) {+ lowerBound = index + 1; /* search > trial */+ } else {+ *returnIndex = index; /* search == trial */+ return true;+ }+ }++ *returnIndex = lowerBound; /* lowerBound is insert index */+ return false;+}+++/*-------------------------------------------------------------------------------++Routine: GetRecordByIndex - Return pointer to key and data, and size of data.++Function: Returns a pointer to beginning of key for record, a pointer to the+ beginning of the data for the record, and the size of the record data+ (does not include the size of the key).++Input: btreePtr - pointer to BTree control block+ node - pointer to node that contains the record+ index - index of record to get++Output: keyPtr - pointer to beginning of key for record+ dataPtr - pointer to beginning of data for record+ dataSize - size of the data portion of the record++Result: none+-------------------------------------------------------------------------------*/++OSStatus GetRecordByIndex (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ u_int16_t index,+ KeyPtr *keyPtr,+ u_int8_t * *dataPtr,+ u_int16_t *dataSize )+{+ u_int16_t offset;+ u_int16_t nextOffset;+ u_int16_t keySize;++ //+ // Make sure index is valid (in range 0..numRecords-1)+ //+ if (index >= node->numRecords)+ return fsBTRecordNotFoundErr;++ //// find keyPtr+ offset = GetRecordOffset (btreePtr, node, index);+ *keyPtr = (KeyPtr) ((Ptr)node + offset);++ //// find dataPtr+ keySize = CalcKeySize(btreePtr, *keyPtr);+ if ( M_IsOdd (keySize) )+ ++keySize; // add pad byte++ offset += keySize; // add the key length to find data offset+ *dataPtr = (u_int8_t *) node + offset;++ //// find dataSize+ nextOffset = GetRecordOffset (btreePtr, node, index + 1);+ *dataSize = nextOffset - offset;++ return noErr;+}++++/*-------------------------------------------------------------------------------++Routine: GetNodeDataSize - Return the amount of space used for data in the node.++Function: Gets the size of the data currently contained in a node, excluding+ the node header. (record data + offset overhead)++Input: btreePtr - pointer to BTree control block+ node - pointer to node that contains the record++Result: - number of bytes used for data and offsets in the node.+-------------------------------------------------------------------------------*/++u_int16_t GetNodeDataSize (BTreeControlBlockPtr btreePtr, NodeDescPtr node )+{+ u_int16_t freeOffset;++ freeOffset = GetRecordOffset (btreePtr, node, node->numRecords);++ return freeOffset + (node->numRecords << 1) - sizeof (BTNodeDescriptor);+}++++/*-------------------------------------------------------------------------------++Routine: GetNodeFreeSize - Return the amount of free space in the node.++Function:++Input: btreePtr - pointer to BTree control block+ node - pointer to node that contains the record++Result: - number of bytes of free space in the node.+-------------------------------------------------------------------------------*/++u_int16_t GetNodeFreeSize (BTreeControlBlockPtr btreePtr, NodeDescPtr node )+{+ u_int16_t freeOffset;++ freeOffset = GetRecordOffset (btreePtr, node, node->numRecords); //�� inline?++ return btreePtr->nodeSize - freeOffset - (node->numRecords << 1) - kOffsetSize;+}++++/*-------------------------------------------------------------------------------++Routine: GetRecordOffset - Return the offset for record "index".++Function:++Input: btreePtr - pointer to BTree control block+ node - pointer to node that contains the record+ index - record to obtain offset for++Result: - offset (in bytes) from beginning of node of record specified by index+-------------------------------------------------------------------------------*/+// make this a macro (for inlining)+#if 0+u_int16_t GetRecordOffset (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ u_int16_t index )+{+ void *pos;+++ pos = (u_int8_t *)node + btreePtr->nodeSize - (index << 1) - kOffsetSize;++ return *(short *)pos;+}+#endif++++/*-------------------------------------------------------------------------------++Routine: GetRecordAddress - Return address of record "index".++Function:++Input: btreePtr - pointer to BTree control block+ node - pointer to node that contains the record+ index - record to obtain offset address for++Result: - pointer to record "index".+-------------------------------------------------------------------------------*/+// make this a macro (for inlining)+#if 0+u_int8_t * GetRecordAddress (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ u_int16_t index )+{+ u_int8_t * pos;++ pos = (u_int8_t *)node + GetRecordOffset (btreePtr, node, index);++ return pos;+}+#endif++++/*-------------------------------------------------------------------------------++Routine: GetRecordSize - Return size of record "index".++Function:++Note: This does not work on the FreeSpace index!++Input: btreePtr - pointer to BTree control block+ node - pointer to node that contains the record+ index - record to obtain record size for++Result: - size of record "index".+-------------------------------------------------------------------------------*/++u_int16_t GetRecordSize (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ u_int16_t index )+{+ u_int16_t *pos;++ pos = (u_int16_t *) ((Ptr)node + btreePtr->nodeSize - (index << 1) - kOffsetSize);++ return *(pos-1) - *pos;+}++++/*-------------------------------------------------------------------------------+Routine: GetOffsetAddress - Return address of offset for record "index".++Function:++Input: btreePtr - pointer to BTree control block+ node - pointer to node that contains the record+ index - record to obtain offset address for++Result: - pointer to offset for record "index".+-------------------------------------------------------------------------------*/++u_int16_t *GetOffsetAddress (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ u_int16_t index )+{+ void *pos;++ pos = (Ptr)node + btreePtr->nodeSize - (index << 1) -2;++ return (u_int16_t *)pos;+}++++/*-------------------------------------------------------------------------------+Routine: GetChildNodeNum - Return child node number from index record "index".++Function: Returns the first u_int32_t stored after the key for record "index".++Assumes: The node is an Index Node.+ The key.length stored at record "index" is ODD. //�� change for variable length index keys++Input: btreePtr - pointer to BTree control block+ node - pointer to node that contains the record+ index - record to obtain child node number from++Result: - child node number from record "index".+-------------------------------------------------------------------------------*/++u_int32_t GetChildNodeNum (BTreeControlBlockPtr btreePtr,+ NodeDescPtr nodePtr,+ u_int16_t index )+{+ u_int8_t * pos;++ pos = GetRecordAddress (btreePtr, nodePtr, index);+ pos += CalcKeySize(btreePtr, (BTreeKey *) pos); // key.length + size of length field++ return *(u_int32_t *)pos;+}++++/*-------------------------------------------------------------------------------+Routine: InsertOffset - Add an offset and adjust existing offsets by delta.++Function: Add an offset at 'index' by shifting 'index+1' through the last offset+ and adjusting them by 'delta', the size of the record to be inserted.+ The number of records contained in the node is also incremented.++Input: btreePtr - pointer to BTree control block+ node - pointer to node+ index - index at which to insert record+ delta - size of record to be inserted++Result: none+-------------------------------------------------------------------------------*/++void InsertOffset (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ u_int16_t index,+ u_int16_t delta )+{+ u_int16_t *src, *dst;+ u_int16_t numOffsets;++ src = GetOffsetAddress (btreePtr, node, node->numRecords); // point to free offset+ dst = src - 1; // point to new offset+ numOffsets = node->numRecords++ - index; // subtract index & postincrement++ do {+ *dst++ = *src++ + delta; // to tricky?+ } while (numOffsets--);+}++++/*-------------------------------------------------------------------------------++Routine: DeleteOffset - Delete an offset.++Function: Delete the offset at 'index' by shifting 'index+1' through the last offset+ and adjusting them by the size of the record 'index'.+ The number of records contained in the node is also decremented.++Input: btreePtr - pointer to BTree control block+ node - pointer to node+ index - index at which to delete record++Result: none+-------------------------------------------------------------------------------*/++void DeleteOffset (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ u_int16_t index )+{+ u_int16_t *src, *dst;+ u_int16_t numOffsets;+ u_int16_t delta;++ dst = GetOffsetAddress (btreePtr, node, index);+ src = dst - 1;+ delta = *src - *dst;+ numOffsets = --node->numRecords - index; // predecrement numRecords & subtract index++ while (numOffsets--)+ {+ *--dst = *--src - delta; // work our way left+ }+}++diff --git a/xnu/files/bsd/hfs/BTreeNodeReserve.c b/xnu/files/bsd/hfs/BTreeNodeReserve.cnew file mode 100644index 0000000..c75af1f--- /dev/null+++ b/xnu/files/bsd/hfs/BTreeNodeReserve.c@@ -0,0 +1,336 @@+/*+ * Copyright (c) 2004-2015 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@+ */+#include "BTreesPrivate.h"+#include "sys/malloc.h"+#include <kern/locks.h>+++/*+ * B-tree Node Reserve+ *+ * BTReserveSpace+ * BTReleaseReserve+ * BTUpdateReserve+ *+ * Each kernel thread can have it's own reserve of b-tree+ * nodes. This reserve info is kept in a hash table.+ *+ * Don't forget to call BTReleaseReserve when you're finished+ * or you will leave stale node reserves in the hash.+ */+++/*+ * BE CAREFUL WHEN INCREASING THE SIZE OF THIS STRUCT!+ *+ * It must remain equal in size to the opaque cat_cookie_t+ * struct (in hfs_catalog.h).+ */+struct nreserve {+ LIST_ENTRY(nreserve) nr_hash; /* hash chain */+ int nr_nodecnt; /* count of nodes held in reserve */+ int nr_newnodes; /* nodes that were allocated */+ struct vnode *nr_btvp; /* b-tree file vnode */+ void *nr_tag; /* unique tag (per thread) */+};++#define NR_GET_TAG() (current_thread())++#define NR_CACHE 17++#define NR_HASH(btvp, tag) \+ (&nr_hashtbl[((((intptr_t)(btvp)) >> 8) ^ ((intptr_t)(tag) >> 4)) & nr_hashmask])++LIST_HEAD(nodereserve, nreserve) *nr_hashtbl;++u_long nr_hashmask;++lck_grp_t * nr_lck_grp;+lck_grp_attr_t * nr_lck_grp_attr;+lck_attr_t * nr_lck_attr;++lck_mtx_t nr_mutex;++/* Internal Node Reserve Hash Routines (private) */+static void nr_insert (struct vnode *, struct nreserve *nrp, int);+static void nr_delete (struct vnode *, struct nreserve *nrp, int *);+static void nr_update (struct vnode *, int);+++/*+ * BTReserveSetup - initialize the node reserve hash table+ */+void BTReserveSetup(void)+{+ if (sizeof(struct nreserve) != sizeof(cat_cookie_t))+ panic("hfs: BTReserveSetup: nreserve size != opaque struct size");++ nr_hashtbl = hashinit(NR_CACHE, M_TEMP, &nr_hashmask);++ nr_lck_grp_attr= lck_grp_attr_alloc_init();+ nr_lck_grp = lck_grp_alloc_init("btree_node_reserve", nr_lck_grp_attr);++ nr_lck_attr = lck_attr_alloc_init();++ lck_mtx_init(&nr_mutex, nr_lck_grp, nr_lck_attr);+}+++/*+ * BTReserveSpace - obtain a node reserve (for current thread)+ *+ * Used by the Catalog Layer (hfs_catalog.c) to reserve space.+ *+ * When data is NULL, we only insure that there's enough space+ * but it is not reserved (assumes you keep the b-tree lock).+ */+int+BTReserveSpace(FCB *file, int operations, void* data)+{+ BTreeControlBlock *btree;+ int rsrvNodes, availNodes, totalNodes;+ int height;+ int inserts, deletes;+ u_int32_t clumpsize;+ int err = 0;++ btree = (BTreeControlBlockPtr)file->fcbBTCBPtr;+ clumpsize = file->ff_clumpsize;++ REQUIRE_FILE_LOCK(btree->fileRefNum, true);++ /*+ * The node reserve is based on the number of b-tree+ * operations (insert/deletes) and the height of the+ * tree.+ */+ height = btree->treeDepth;+ if (height < 2)+ height = 2; /* prevent underflow in rsrvNodes calculation */+ inserts = operations & 0xffff;+ deletes = operations >> 16;++ /*+ * Allow for at least one root split.+ *+ * Each delete operation can propogate a big key up the+ * index. This can cause a split at each level up.+ *+ * Each insert operation can cause a local split and a+ * split at each level up.+ */+ rsrvNodes = 1 + (deletes * (height - 2)) + (inserts * (height - 1));++ availNodes = btree->freeNodes - btree->reservedNodes;++ if (rsrvNodes > availNodes) {+ u_int32_t reqblks, freeblks, rsrvblks;+ uint32_t bt_rsrv;+ struct hfsmount *hfsmp;++ /*+ * For UNIX conformance, we try and reserve the MIN of either 5% of+ * total file blocks or 10MB worth of blocks, for growing existing+ * files. On non-HFS filesystems, creating a new directory entry may+ * not cause additional disk space to be allocated, but on HFS, creating+ * a new entry could cause the b-tree to grow. As a result, we take+ * some precautions here to prevent that on configurations that try to+ * satisfy conformance.+ */+ hfsmp = VTOVCB(btree->fileRefNum);+ rsrvblks = ((u_int64_t)hfsmp->allocLimit * 5) / 100;+ if (hfsmp->blockSize > HFS_BT_MAXRESERVE) {+ bt_rsrv = 1;+ }+ else {+ bt_rsrv = (HFS_BT_MAXRESERVE / hfsmp->blockSize);+ }+ rsrvblks = MIN(rsrvblks, bt_rsrv);++ freeblks = hfs_freeblks(hfsmp, 0);+ if (freeblks <= rsrvblks) {+ /* When running low, disallow adding new items. */+ if ((inserts > 0) && (deletes == 0)) {+ return (ENOSPC);+ }+ freeblks = 0;+ } else {+ freeblks -= rsrvblks;+ }+ reqblks = clumpsize / hfsmp->blockSize;++ if (reqblks > freeblks) {+ reqblks = ((rsrvNodes - availNodes) * btree->nodeSize) / hfsmp->blockSize;+ /* When running low, disallow adding new items. */+ if ((reqblks > freeblks) && (inserts > 0) && (deletes == 0)) {+ return (ENOSPC);+ }+ file->ff_clumpsize = freeblks * hfsmp->blockSize;+ }+ totalNodes = rsrvNodes + btree->totalNodes - availNodes;++ /* See if we also need a map node */+ if (totalNodes > (int)CalcMapBits(btree)) {+ ++totalNodes;+ }+ if ((err = ExtendBTree(btree, totalNodes))) {+ goto out;+ }+ }+ /* Save this reserve if this is a persistent request. */+ if (data) {+ btree->reservedNodes += rsrvNodes;+ nr_insert(btree->fileRefNum, (struct nreserve *)data, rsrvNodes);+ }+out:+ /* Put clump size back if it was changed. */+ if (file->ff_clumpsize != clumpsize)+ file->ff_clumpsize = clumpsize;++ return (err);+}+++/*+ * BTReleaseReserve - release the node reserve held by current thread+ *+ * Used by the Catalog Layer (hfs_catalog.c) to relinquish reserved space.+ */+int+BTReleaseReserve(FCB *file, void* data)+{+ BTreeControlBlock *btree;+ int nodecnt;++ btree = (BTreeControlBlockPtr)file->fcbBTCBPtr;++ REQUIRE_FILE_LOCK(btree->fileRefNum, true);++ nr_delete(btree->fileRefNum, (struct nreserve *)data, &nodecnt);++ if (nodecnt)+ btree->reservedNodes -= nodecnt;++ return (0);+}++/*+ * BTUpdateReserve - update a node reserve for allocations that occurred.+ */+void+BTUpdateReserve(BTreeControlBlockPtr btreePtr, int nodes)+{+ nr_update(btreePtr->fileRefNum, nodes);+}+++/*----------------------------------------------------------------------------*/+/* Node Reserve Hash Functions (private) */+++int nrinserts = 0;+int nrdeletes = 0;++/*+ * Insert a new node reserve.+ */+static void+nr_insert(struct vnode * btvp, struct nreserve *nrp, int nodecnt)+{+ struct nodereserve *nrhead;+ struct nreserve *tmp_nrp;+ void * tag = NR_GET_TAG();++ /*+ * Check the cache - there may already be a reserve+ */+ lck_mtx_lock(&nr_mutex);+ nrhead = NR_HASH(btvp, tag);+ for (tmp_nrp = nrhead->lh_first; tmp_nrp;+ tmp_nrp = tmp_nrp->nr_hash.le_next) {+ if ((tmp_nrp->nr_tag == tag) && (tmp_nrp->nr_btvp == btvp)) {+ nrp->nr_tag = 0;+ tmp_nrp->nr_nodecnt += nodecnt;+ lck_mtx_unlock(&nr_mutex);+ return;+ }+ }++ nrp->nr_nodecnt = nodecnt;+ nrp->nr_newnodes = 0;+ nrp->nr_btvp = btvp;+ nrp->nr_tag = tag;+ LIST_INSERT_HEAD(nrhead, nrp, nr_hash);+ ++nrinserts;+ lck_mtx_unlock(&nr_mutex);+}++/*+ * Delete a node reserve.+ */+static void+nr_delete(struct vnode * btvp, struct nreserve *nrp, int *nodecnt)+{+ void * tag = NR_GET_TAG();++ lck_mtx_lock(&nr_mutex);+ if (nrp->nr_tag) {+ if ((nrp->nr_tag != tag) || (nrp->nr_btvp != btvp))+ panic("hfs: nr_delete: invalid NR (%p)", nrp);+ LIST_REMOVE(nrp, nr_hash);+ *nodecnt = nrp->nr_nodecnt;+ bzero(nrp, sizeof(struct nreserve));+ ++nrdeletes;+ } else {+ *nodecnt = 0;+ }+ lck_mtx_unlock(&nr_mutex);+}+++/*+ * Update a node reserve for any allocations that occurred.+ */+static void+nr_update(struct vnode * btvp, int nodecnt)+{+ struct nodereserve *nrhead;+ struct nreserve *nrp;+ void* tag = NR_GET_TAG();++ lck_mtx_lock(&nr_mutex);++ nrhead = NR_HASH(btvp, tag);+ for (nrp = nrhead->lh_first; nrp; nrp = nrp->nr_hash.le_next) {+ if ((nrp->nr_tag == tag) && (nrp->nr_btvp == btvp)) {+ nrp->nr_newnodes += nodecnt;+ break;+ }+ }+ lck_mtx_unlock(&nr_mutex);+}diff --git a/xnu/files/bsd/hfs/BTreeScanner.c b/xnu/files/bsd/hfs/BTreeScanner.cnew file mode 100644index 0000000..6ebf78a--- /dev/null+++ b/xnu/files/bsd/hfs/BTreeScanner.c@@ -0,0 +1,410 @@+/*+ * Copyright (c) 1996-2015 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@+ *+ * @(#)BTreeScanner.c+ */+#include <sys/kernel.h>+#include "hfs_endian.h"++#include "BTreeScanner.h"++static int FindNextLeafNode( BTScanState *scanState, Boolean avoidIO );+static int ReadMultipleNodes( BTScanState *scanState );+++//_________________________________________________________________________________+//+// Routine: BTScanNextRecord+//+// Purpose: Return the next leaf record in a scan.+//+// Inputs:+// scanState Scanner's current state+// avoidIO If true, don't do any I/O to refill the buffer+//+// Outputs:+// key Key of found record (points into buffer)+// data Data of found record (points into buffer)+// dataSize Size of data in found record+//+// Result:+// noErr Found a valid record+// btNotFound No more records+// ??? Needed to do I/O to get next node, but avoidIO set+//+// Notes:+// This routine returns pointers to the found record's key and data. It+// does not copy the key or data to a caller-supplied buffer (like+// GetBTreeRecord would). The caller must not modify the key or data.+//_________________________________________________________________________________++int BTScanNextRecord( BTScanState * scanState,+ Boolean avoidIO,+ void * * key,+ void * * data,+ u_int32_t * dataSize )+{+ int err;+ u_int16_t dataSizeShort;++ err = noErr;++ //+ // If this is the first call, there won't be any nodes in the buffer, so go+ // find the first first leaf node (if any).+ //+ if ( scanState->nodesLeftInBuffer == 0 )+ {+ err = FindNextLeafNode( scanState, avoidIO );+ }++ while ( err == noErr )+ {+ // See if we have a record in the current node+ err = GetRecordByIndex( scanState->btcb, scanState->currentNodePtr,+ scanState->recordNum, (KeyPtr *) key,+ (u_int8_t **) data, &dataSizeShort );++ if ( err == noErr )+ {+ ++scanState->recordsFound;+ ++scanState->recordNum;+ if (dataSize != NULL)+ *dataSize = dataSizeShort;+ return noErr;+ }+ else if (err > 0)+ {+ // We didn't get the node through the cache, so we can't invalidate it.+ //XXX Should we do something else to avoid seeing the same record again?+ return err;+ }++ // We're done with the current node. See if we've returned all the records+ if ( scanState->recordsFound >= scanState->btcb->leafRecords )+ {+ return btNotFound;+ }++ // Move to the first record of the next leaf node+ scanState->recordNum = 0;+ err = FindNextLeafNode( scanState, avoidIO );+ }++ //+ // If we got an EOF error from FindNextLeafNode, then there are no more leaf+ // records to be found.+ //+ if ( err == fsEndOfIterationErr )+ err = btNotFound;++ return err;++} /* BTScanNextRecord */+++//_________________________________________________________________________________+//+// Routine: FindNextLeafNode+//+// Purpose: Point to the next leaf node in the buffer. Read more nodes+// into the buffer if needed (and allowed).+//+// Inputs:+// scanState Scanner's current state+// avoidIO If true, don't do any I/O to refill the buffer+//+// Result:+// noErr Found a valid record+// fsEndOfIterationErr No more nodes in file+// ??? Needed to do I/O to get next node, but avoidIO set+//_________________________________________________________________________________++static int FindNextLeafNode( BTScanState *scanState, Boolean avoidIO )+{+ int err;+ BlockDescriptor block;+ FileReference fref;++ err = noErr; // Assume everything will be OK++ while ( 1 )+ {+ if ( scanState->nodesLeftInBuffer == 0 )+ {+ // Time to read some more nodes into the buffer+ if ( avoidIO )+ {+ return fsBTTimeOutErr;+ }+ else+ {+ // read some more nodes into buffer+ err = ReadMultipleNodes( scanState );+ if ( err != noErr )+ break;+ }+ }+ else+ {+ // Adjust the node counters and point to the next node in the buffer+ ++scanState->nodeNum;+ --scanState->nodesLeftInBuffer;++ // If we've looked at all nodes in the tree, then we're done+ if ( scanState->nodeNum >= scanState->btcb->totalNodes )+ return fsEndOfIterationErr;++ if ( scanState->nodesLeftInBuffer == 0 )+ {+ scanState->recordNum = 0;+ continue;+ }++ scanState->currentNodePtr = (BTNodeDescriptor *)(((u_int8_t *)scanState->currentNodePtr)+ + scanState->btcb->nodeSize);+ }++ /* Fake a BlockDescriptor */+ block.blockHeader = NULL; /* No buffer cache buffer */+ block.buffer = scanState->currentNodePtr;+ block.blockNum = scanState->nodeNum;+ block.blockSize = scanState->btcb->nodeSize;+ block.blockReadFromDisk = 1;+ block.isModified = 0;++ fref = scanState->btcb->fileRefNum;++ /* This node was read from disk, so it must be swapped/checked.+ * Since we are reading multiple nodes, we might have read an+ * unused node. Therefore we allow swapping of unused nodes.+ */+ err = hfs_swap_BTNode(&block, fref, kSwapBTNodeBigToHost, true);+ if ( err != noErr ) {+ printf("hfs: FindNextLeafNode: Error from hfs_swap_BTNode (node %u)\n", scanState->nodeNum);+ continue;+ }++ if ( scanState->currentNodePtr->kind == kBTLeafNode )+ break;+ }++ return err;++} /* FindNextLeafNode */+++//_________________________________________________________________________________+//+// Routine: ReadMultipleNodes+//+// Purpose: Read one or more nodes into the buffer.+//+// Inputs:+// theScanStatePtr Scanner's current state+//+// Result:+// noErr One or nodes were read+// fsEndOfIterationErr No nodes left in file, none in buffer+//_________________________________________________________________________________++static int ReadMultipleNodes( BTScanState *theScanStatePtr )+{+ int myErr = E_NONE;+ BTreeControlBlockPtr myBTreeCBPtr;+ daddr64_t myPhyBlockNum;+ u_int32_t myBufferSize;+ struct vnode * myDevPtr;+ unsigned int myBlockRun;+ u_int32_t myBlocksInBufferCount;++ // release old buffer if we have one+ if ( theScanStatePtr->bufferPtr != NULL )+ {+ buf_markinvalid(theScanStatePtr->bufferPtr);+ buf_brelse( theScanStatePtr->bufferPtr );+ theScanStatePtr->bufferPtr = NULL;+ theScanStatePtr->currentNodePtr = NULL;+ }++ myBTreeCBPtr = theScanStatePtr->btcb;++ // map logical block in catalog btree file to physical block on volume+ myErr = hfs_bmap(myBTreeCBPtr->fileRefNum, theScanStatePtr->nodeNum,+ &myDevPtr, &myPhyBlockNum, &myBlockRun);+ if ( myErr != E_NONE )+ {+ goto ExitThisRoutine;+ }++ // bmap block run gives us the remaining number of valid blocks (number of blocks+ // minus the first). so if there are 10 valid blocks our run number will be 9.+ // blocks, in our case is the same as nodes (both are 4K)+ myBlocksInBufferCount = (theScanStatePtr->bufferSize / myBTreeCBPtr->nodeSize );+ myBufferSize = theScanStatePtr->bufferSize;+ if ( (myBlockRun + 1) < myBlocksInBufferCount )+ {+ myBufferSize = (myBlockRun + 1) * myBTreeCBPtr->nodeSize;+ }++ // now read blocks from the device+ myErr = (int)buf_meta_bread(myDevPtr,+ myPhyBlockNum,+ myBufferSize,+ NOCRED,+ &theScanStatePtr->bufferPtr );+ if ( myErr != E_NONE )+ {+ goto ExitThisRoutine;+ }++ theScanStatePtr->nodesLeftInBuffer = buf_count(theScanStatePtr->bufferPtr) / theScanStatePtr->btcb->nodeSize;+ theScanStatePtr->currentNodePtr = (BTNodeDescriptor *) buf_dataptr(theScanStatePtr->bufferPtr);++ExitThisRoutine:+ return myErr;++} /* ReadMultipleNodes */++++//_________________________________________________________________________________+//+// Routine: BTScanInitialize+//+// Purpose: Prepare to start a new BTree scan, or resume a previous one.+//+// Inputs:+// btreeFile The B-Tree's file control block+// startingNode Initial node number+// startingRecord Initial record number within node+// recordsFound Number of valid records found so far+// bufferSize Size (in bytes) of buffer+//+// Outputs:+// scanState Scanner's current state; pass to other scanner calls+//+// Notes:+// To begin a new scan and see all records in the B-Tree, pass zeroes for+// startingNode, startingRecord, and recordsFound.+//+// To resume a scan from the point of a previous BTScanTerminate, use the+// values returned by BTScanTerminate as input for startingNode, startingRecord,+// and recordsFound.+//+// When resuming a scan, the caller should check the B-tree's write count. If+// it is different from the write count when the scan was terminated, then the+// tree may have changed and the current state may be incorrect. In particular,+// you may see some records more than once, or never see some records. Also,+// the scanner may not be able to detect when all leaf records have been seen,+// and will have to scan through many empty nodes.+//+// XXX�Perhaps the write count should be managed by BTScanInitialize and+// XXX BTScanTerminate? This would avoid the caller having to peek at+// XXX internal B-Tree structures.+//_________________________________________________________________________________++int BTScanInitialize( const FCB * btreeFile,+ u_int32_t startingNode,+ u_int32_t startingRecord,+ u_int32_t recordsFound,+ u_int32_t bufferSize,+ BTScanState * scanState )+{+ BTreeControlBlock *btcb;++ //+ // Make sure this is a valid B-Tree file+ //+ btcb = (BTreeControlBlock *) btreeFile->fcbBTCBPtr;+ if (btcb == NULL)+ return fsBTInvalidFileErr;++ //+ // Make sure buffer size is big enough, and a multiple of the+ // B-Tree node size+ //+ if ( bufferSize < btcb->nodeSize )+ return paramErr;+ bufferSize = (bufferSize / btcb->nodeSize) * btcb->nodeSize;++ //+ // Set up the scanner's state+ //+ scanState->bufferSize = bufferSize;+ scanState->bufferPtr = NULL;+ scanState->btcb = btcb;+ scanState->nodeNum = startingNode;+ scanState->recordNum = startingRecord;+ scanState->currentNodePtr = NULL;+ scanState->nodesLeftInBuffer = 0; // no nodes currently in buffer+ scanState->recordsFound = recordsFound;+ microuptime(&scanState->startTime); // initialize our throttle++ return noErr;++} /* BTScanInitialize */+++//_________________________________________________________________________________+//+// Routine: BTScanTerminate+//+// Purpose: Return state information about a scan so that it can be resumed+// later via BTScanInitialize.+//+// Inputs:+// scanState Scanner's current state+//+// Outputs:+// nextNode Node number to resume a scan (pass to BTScanInitialize)+// nextRecord Record number to resume a scan (pass to BTScanInitialize)+// recordsFound Valid records seen so far (pass to BTScanInitialize)+//_________________________________________________________________________________++int BTScanTerminate( BTScanState * scanState,+ u_int32_t * startingNode,+ u_int32_t * startingRecord,+ u_int32_t * recordsFound )+{+ *startingNode = scanState->nodeNum;+ *startingRecord = scanState->recordNum;+ *recordsFound = scanState->recordsFound;++ if ( scanState->bufferPtr != NULL )+ {+ buf_markinvalid(scanState->bufferPtr);+ buf_brelse( scanState->bufferPtr );+ scanState->bufferPtr = NULL;+ scanState->currentNodePtr = NULL;+ }++ return noErr;++} /* BTScanTerminate */++diff --git a/xnu/files/bsd/hfs/BTreeScanner.h b/xnu/files/bsd/hfs/BTreeScanner.hnew file mode 100644index 0000000..05a1043--- /dev/null+++ b/xnu/files/bsd/hfs/BTreeScanner.h@@ -0,0 +1,122 @@+/*+ * Copyright (c) 1996-2004 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@+ *+ * @(#)BTreeScanner.h+ */++#ifndef _BTREESCANNER_H_+#define _BTREESCANNER_H_++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE+#include <sys/time.h>++#include "FileMgrInternal.h"+#include "BTreesPrivate.h"++// amount of time we are allowed to process a catalog search (in � secs)+// NOTE - code assumes kMaxMicroSecsInKernel is less than 1,000,000+enum { kMaxMicroSecsInKernel = (1000 * 100) }; // 1 tenth of a second++// btree node scanner buffer size. at 32K we get 8 nodes. this is the size used+// in Mac OS 9+enum { kCatSearchBufferSize = (32 * 1024) };+++/*+ * ============ W A R N I N G ! ============+ * DO NOT INCREASE THE SIZE OF THIS STRUCT!+ * It must be less than or equal to the size of+ * the opaque searchstate struct (in sys/attr.h).+ */+/* Private description used in hfs_search */+struct CatPosition+{+ u_int32_t writeCount; /* The BTree's write count (to see if the catalog writeCount */+ /* changed since the last search). If 0, the rest */+ /* of the record is invalid, start from beginning. */+ u_int32_t nextNode; /* node number to resume search */+ u_int32_t nextRecord; /* record number to resume search */+ u_int32_t recordsFound; /* number of leaf records seen so far */+};+typedef struct CatPosition CatPosition;+++/*+ BTScanState - This structure is used to keep track of the current state+ of a BTree scan. It contains both the dynamic state information (like+ the current node number and record number) and information that is static+ for the duration of a scan (such as buffer pointers).++ NOTE: recordNum may equal or exceed the number of records in the node+ number nodeNum. If so, then the next attempt to get a record will move+ to a new node number.+*/+struct BTScanState+{+ // The following fields are set up once at initialization time.+ // They are not changed during a scan.+ u_int32_t bufferSize;+ struct buf * bufferPtr;+ BTreeControlBlock * btcb;++ // The following fields are the dynamic state of the current scan.+ u_int32_t nodeNum; // zero is first node+ u_int32_t recordNum; // zero is first record+ BTNodeDescriptor * currentNodePtr; // points to current node within buffer+ u_int32_t nodesLeftInBuffer; // number of valid nodes still in the buffer+ u_int32_t recordsFound; // number of leaf records seen so far+ struct timeval startTime; // time we started catalog search+};+typedef struct BTScanState BTScanState;+++/* *********************** PROTOTYPES *********************** */++int BTScanInitialize( const FCB * btreeFile,+ u_int32_t startingNode,+ u_int32_t startingRecord,+ u_int32_t recordsFound,+ u_int32_t bufferSize,+ BTScanState * scanState );++int BTScanNextRecord( BTScanState * scanState,+ Boolean avoidIO,+ void * * key,+ void * * data,+ u_int32_t * dataSize );++int BTScanTerminate( BTScanState * scanState,+ u_int32_t * startingNode,+ u_int32_t * startingRecord,+ u_int32_t * recordsFound );++#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */+#endif /* !_BTREESCANNER_H_ */diff --git a/xnu/files/bsd/hfs/BTreeTreeOps.c b/xnu/files/bsd/hfs/BTreeTreeOps.cnew file mode 100644index 0000000..74cd04e--- /dev/null+++ b/xnu/files/bsd/hfs/BTreeTreeOps.c@@ -0,0 +1,1338 @@+/*+ * Copyright (c) 2000-2015 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@+ */+/*+ File: BTreeTreeOps.c++ Contains: Multi-node tree operations for the BTree Module.++ Version: xxx put the technology version here xxx++ Written by: Gordon Sheridan and Bill Bruffey++ Copyright: (c) 1992-1999 by Apple Inc., all rights reserved.++ File Ownership:++ DRI: Don Brady++ Other Contact: Mark Day++ Technology: File Systems++ Writers:++ (msd) Mark Day+ (DSH) Deric Horn+ (djb) Don Brady++ Change History (most recent first):++ <MOSXS> 6/1/99 djb Sync up with Mac OS 8.6.+ <CS5> 12/8/97 djb Radar #2200632, CollapseTree wasn't marking root node dirty.+ <CS4> 11/24/97 djb Radar #2005325, InsertLevel incorrectly handled root splits!+ <CS3> 10/17/97 msd Conditionalize DebugStrs.+ <CS2> 5/16/97 msd InsertNode() needs a return statement in ErrorExit.+ <CS1> 4/23/97 djb first checked in++ <HFS8> 3/17/97 DSH Conditionalize out Panic assertion for SC.+ <HFS7> 3/3/97 djb Removed DebugStr in InsertLevel.+ <HFS6> 2/19/97 djb Major re-write of insert code; added InsertLevel and InsertNode.+ <HFS5> 1/27/97 djb InsertTree and DeleteTree are now recursive and support variable+ sized index keys.+ <HFS4> 1/16/97 djb Removed DebugStr in SearchTree. Added initial support for+ variable sized index keys.+ <HFS3> 1/3/97 djb Changed len8 to length8.+ <HFS2> 1/3/97 djb Added support for large keys.+ <HFS1> 12/19/96 djb first checked in++ History applicable to original Scarecrow Design:++ <3> 10/25/96 ser Changing for new VFPI+ <2> 1/22/96 dkh Add #include Memory.h+ <1> 10/18/95 rst Moved from Scarecrow project.++ <12> 7/18/95 mbb Change MoveData & ClearBytes to BlockMoveData & BlockZero.+ <11> 9/30/94 prp Get in sync with D2 interface changes.+ <10> 7/25/94 wjk Eliminate usage of BytePtr in favor of UInt8 *.+ <9> 7/22/94 wjk Convert to the new set of header files.+ <8> 12/2/93 wjk Move from Makefiles to BuildFiles. Fit into the ModernOS and+ NRCmds environments.+ <7> 11/30/93 wjk Change some Ptr's to BytePtr's in function definitions so they+ agree with their prototypes.+ <6> 5/21/93 gs Debug DeleteTree. Modify InsertTree for BTReplaceRecord.+ <5> 5/10/93 gs Modify RotateLeft, and add DeleteTree, CollapseTree routines.+ <4> 3/23/93 gs revise RotateLeft to use InsertKeyRecord instead of+ InsertRecord.+ <3> 3/23/93 gs Implement SplitLeft, InsertTree routine.+ <2> 2/8/93 gs Implement SearchTree, and RotateLeft.+ <1> 11/15/92 gs first checked in++*/++#include "BTreesPrivate.h"+#include "hfs_btreeio.h"++//+/////////////////////// Routines Internal To BTree Module ///////////////////////+//+// SearchTree+// InsertTree+//+////////////////////// Routines Internal To BTreeTreeOps.c //////////////////////++static OSStatus AddNewRootNode (BTreeControlBlockPtr btreePtr,+ NodeDescPtr leftNode,+ NodeDescPtr rightNode );++static OSStatus CollapseTree (BTreeControlBlockPtr btreePtr,+ BlockDescriptor *blockPtr );++static OSStatus RotateLeft (BTreeControlBlockPtr btreePtr,+ NodeDescPtr leftNode,+ NodeDescPtr rightNode,+ u_int16_t rightInsertIndex,+ KeyPtr keyPtr,+ u_int8_t * recPtr,+ u_int16_t recSize,+ u_int16_t *insertIndex,+ u_int32_t *insertNodeNum,+ Boolean *recordFit,+ u_int16_t *recsRotated );++static Boolean RotateRecordLeft (BTreeControlBlockPtr btreePtr,+ NodeDescPtr leftNode,+ NodeDescPtr rightNode );++static OSStatus SplitLeft (BTreeControlBlockPtr btreePtr,+ BlockDescriptor *leftNode,+ BlockDescriptor *rightNode,+ u_int32_t rightNodeNum,+ u_int16_t index,+ KeyPtr keyPtr,+ u_int8_t * recPtr,+ u_int16_t recSize,+ u_int16_t *insertIndex,+ u_int32_t *insertNodeNum,+ u_int16_t *recsRotated );++++static OSStatus InsertLevel (BTreeControlBlockPtr btreePtr,+ TreePathTable treePathTable,+ InsertKey *primaryKey,+ InsertKey *secondaryKey,+ BlockDescriptor *targetNode,+ u_int16_t index,+ u_int16_t level,+ u_int32_t *insertNode );++static OSErr InsertNode (BTreeControlBlockPtr btreePtr,+ InsertKey *key,+ BlockDescriptor *rightNode,+ u_int32_t node,+ u_int16_t index,+ u_int32_t *newNode,+ u_int16_t *newIndex,+ BlockDescriptor *leftNode,+ Boolean *updateParent,+ Boolean *insertParent,+ Boolean *rootSplit );++static u_int16_t GetKeyLength (const BTreeControlBlock *btreePtr,+ const BTreeKey *key,+ Boolean forLeafNode );++++//////////////////////// BTree Multi-node Tree Operations ///////////////////////+++/*-------------------------------------------------------------------------------++Routine: SearchTree - Search BTree for key and set up Tree Path Table.++Function: Searches BTree for specified key, setting up the Tree Path Table to+ reflect the search path.+++Input: btreePtr - pointer to control block of BTree to search+ keyPtr - pointer to the key to search for+ treePathTable - pointer to the tree path table to construct++Output: nodeNum - number of the node containing the key position+ iterator - BTreeIterator specifying record or insert position++Result: noErr - key found, index is record index+ fsBTRecordNotFoundErr - key not found, index is insert index+ fsBTEmptyErr - key not found, return params are nil+ otherwise - catastrophic failure (GetNode/ReleaseNode failed)+-------------------------------------------------------------------------------*/++OSStatus SearchTree (BTreeControlBlockPtr btreePtr,+ BTreeKeyPtr searchKey,+ TreePathTable treePathTable,+ u_int32_t *nodeNum,+ BlockDescriptor *nodePtr,+ u_int16_t *returnIndex )+{+ OSStatus err;+ int16_t level; // Expected depth of current node+ u_int32_t curNodeNum; // Current node we're searching+ NodeRec nodeRec;+ u_int16_t index;+ Boolean keyFound;+ int8_t nodeKind; // Kind of current node (index/leaf)+ KeyPtr keyPtr;+ u_int8_t * dataPtr;+ u_int16_t dataSize;+++ curNodeNum = btreePtr->rootNode;+ level = btreePtr->treeDepth;++ if (level == 0) // is the tree empty?+ {+ err = fsBTEmptyErr;+ goto ErrorExit;+ }++ //�� for debugging...+ treePathTable [0].node = 0;+ treePathTable [0].index = 0;++ while (true)+ {+ //+ // [2550929] Node number 0 is the header node. It is never a valid+ // index or leaf node. If we're ever asked to search through node 0,+ // something has gone wrong (typically a bad child node number, or+ // we found a node full of zeroes that we thought was an index node).+ //+ if (curNodeNum == 0)+ {+// Panic("SearchTree: curNodeNum is zero!");+ err = btBadNode;+ goto ErrorExit;+ }++ err = GetNode (btreePtr, curNodeNum, 0, &nodeRec);+ if (err != noErr)+ {+ goto ErrorExit;+ }++ //+ // [2550929] Sanity check the node height and node type. We expect+ // particular values at each iteration in the search. This checking+ // quickly finds bad pointers, loops, and other damage to the+ // hierarchy of the B-tree.+ //+ if (((BTNodeDescriptor*)nodeRec.buffer)->height != level)+ {+// Panic("Incorrect node height");+ err = btBadNode;+ goto ReleaseAndExit;+ }+ nodeKind = ((BTNodeDescriptor*)nodeRec.buffer)->kind;+ if (level == 1)+ {+ // Nodes at level 1 must be leaves, by definition+ if (nodeKind != kBTLeafNode)+ {+ // Panic("Incorrect node type: expected leaf");+ err = btBadNode;+ goto ReleaseAndExit;+ }+ }+ else+ {+ // A node at any other depth must be an index node+ if (nodeKind != kBTIndexNode)+ {+// Panic("Incorrect node type: expected index");+ err = btBadNode;+ goto ReleaseAndExit;+ }+ }++ keyFound = SearchNode (btreePtr, nodeRec.buffer, searchKey, &index);++ treePathTable [level].node = curNodeNum;++ if (nodeKind == kBTLeafNode)+ {+ treePathTable [level].index = index;+ break; // were done...+ }++ if ( (keyFound != true) && (index != 0))+ --index;++ treePathTable [level].index = index;++ err = GetRecordByIndex (btreePtr, nodeRec.buffer, index, &keyPtr, &dataPtr, &dataSize);+ if (err != noErr)+ {+ // [2550929] If we got an error, it is probably because the index was bad+ // (typically a corrupt node that confused SearchNode). Invalidate the node+ // so we won't accidentally use the corrupted contents. NOTE: the Mac OS 9+ // sources call this InvalidateNode.++ (void) TrashNode(btreePtr, &nodeRec);+ goto ErrorExit;+ }++ // Get the child pointer out of this index node. We're now done with the current+ // node and can continue the search with the child node.+ curNodeNum = *(u_int32_t *)dataPtr;+ err = ReleaseNode (btreePtr, &nodeRec);+ if (err != noErr)+ {+ goto ErrorExit;+ }++ // The child node should be at a level one less than the parent.+ --level;+ }++ *nodeNum = curNodeNum;+ *nodePtr = nodeRec;+ *returnIndex = index;++ if (keyFound)+ return noErr; // searchKey found, index identifies record in node+ else+ return fsBTRecordNotFoundErr; // searchKey not found, index identifies insert point++ReleaseAndExit:+ (void) ReleaseNode(btreePtr, &nodeRec);+ // fall into ErrorExit++ErrorExit:++ *nodeNum = 0;+ nodePtr->buffer = nil;+ nodePtr->blockHeader = nil;+ *returnIndex = 0;++ return err;+}+++++////////////////////////////////// InsertTree ///////////////////////////////////++OSStatus InsertTree ( BTreeControlBlockPtr btreePtr,+ TreePathTable treePathTable,+ KeyPtr keyPtr,+ u_int8_t * recPtr,+ u_int16_t recSize,+ BlockDescriptor *targetNode,+ u_int16_t index,+ u_int16_t level,+ Boolean replacingKey,+ u_int32_t *insertNode )+{+ InsertKey primaryKey;+ OSStatus err;++ primaryKey.keyPtr = keyPtr;+ primaryKey.keyLength = GetKeyLength(btreePtr, primaryKey.keyPtr, (level == 1));+ primaryKey.recPtr = recPtr;+ primaryKey.recSize = recSize;+ primaryKey.replacingKey = replacingKey;+ primaryKey.skipRotate = false;++ err = InsertLevel (btreePtr, treePathTable, &primaryKey, nil,+ targetNode, index, level, insertNode );++ return err;++} // End of InsertTree+++////////////////////////////////// InsertLevel //////////////////////////////////++OSStatus InsertLevel (BTreeControlBlockPtr btreePtr,+ TreePathTable treePathTable,+ InsertKey *primaryKey,+ InsertKey *secondaryKey,+ BlockDescriptor *targetNode,+ u_int16_t index,+ u_int16_t level,+ u_int32_t *insertNode )+{+ OSStatus err;+ BlockDescriptor leftNode;+ u_int32_t targetNodeNum;+ u_int32_t newNodeNum;+ u_int16_t newIndex;+ Boolean insertParent;+ Boolean updateParent;+ Boolean newRoot;+ InsertKey insertKey;++#if defined(applec) && !defined(__SC__)+ PanicIf ((level == 1) && (((NodeDescPtr)targetNode->buffer)->kind != kBTLeafNode), " InsertLevel: non-leaf at level 1! ");+#endif+ leftNode.buffer = nil;+ leftNode.blockHeader = nil;+ targetNodeNum = treePathTable [level].node;++ insertParent = false;+ updateParent = false;++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, targetNode);++ ////// process first insert //////++ err = InsertNode (btreePtr, primaryKey, targetNode, targetNodeNum, index,+ &newNodeNum, &newIndex, &leftNode, &updateParent, &insertParent, &newRoot );+ M_ExitOnError (err);++ if ( newRoot )+ {+ // Extend the treePathTable by adding an entry for the new+ // root node that references the current targetNode.+ //+ // If inserting the secondaryKey changes the first key of+ // the target node, then we'll have to update the second+ // key in the new root node.++ treePathTable [level + 1].node = btreePtr->rootNode;+ treePathTable [level + 1].index = 1; // 1 since we always split/rotate left+ }++ if ( level == 1 )+ *insertNode = newNodeNum;++ ////// process second insert (if any) //////++ if ( secondaryKey != nil )+ {+ Boolean temp;++ err = InsertNode (btreePtr, secondaryKey, targetNode, newNodeNum, newIndex,+ &newNodeNum, &newIndex, &leftNode, &updateParent, &insertParent, &temp);+ M_ExitOnError (err);+ }++ //////////////////////// Update Parent(s) ///////////////////////////////++ if ( insertParent || updateParent )+ {+ BlockDescriptor parentNode;+ u_int32_t parentNodeNum;+ KeyPtr keyPtr;+ u_int8_t * recPtr;+ u_int16_t recSize;++ parentNode.buffer = nil;+ parentNode.blockHeader = nil;++ secondaryKey = nil;++ PanicIf ( (level == btreePtr->treeDepth), " InsertLevel: unfinished insert!?");++ ++level;++ // Get Parent Node data...+ index = treePathTable [level].index;+ parentNodeNum = treePathTable [level].node;++ PanicIf ( parentNodeNum == 0, " InsertLevel: parent node is zero!?");++ err = GetNode (btreePtr, parentNodeNum, 0, &parentNode); // released as target node in next level up+ M_ExitOnError (err);+ ////////////////////////// Update Parent Index //////////////////////////////++ if ( updateParent )+ {+ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &parentNode);++ //���debug: check if ptr == targetNodeNum+ GetRecordByIndex (btreePtr, parentNode.buffer, index, &keyPtr, &recPtr, &recSize);+ PanicIf( (*(u_int32_t *) recPtr) != targetNodeNum, " InsertLevel: parent ptr doesn't match target node!");++ // need to delete and re-insert this parent key/ptr+ // we delete it here and it gets re-inserted in the+ // InsertLevel call below.+ DeleteRecord (btreePtr, parentNode.buffer, index);++ primaryKey->keyPtr = (KeyPtr) GetRecordAddress( btreePtr, targetNode->buffer, 0 );+ primaryKey->keyLength = GetKeyLength(btreePtr, primaryKey->keyPtr, false);+ primaryKey->recPtr = (u_int8_t *) &targetNodeNum;+ primaryKey->recSize = sizeof(targetNodeNum);+ primaryKey->replacingKey = kReplaceRecord;+ primaryKey->skipRotate = insertParent; // don't rotate left if we have two inserts occuring+ }++ ////////////////////////// Add New Parent Index /////////////////////////////++ if ( insertParent )+ {+ InsertKey *insertKeyPtr;++ if ( updateParent )+ {+ insertKeyPtr = &insertKey;+ secondaryKey = &insertKey;+ }+ else+ {+ insertKeyPtr = primaryKey;+ }++ insertKeyPtr->keyPtr = (KeyPtr) GetRecordAddress (btreePtr, leftNode.buffer, 0);+ insertKeyPtr->keyLength = GetKeyLength(btreePtr, insertKeyPtr->keyPtr, false);+ insertKeyPtr->recPtr = (u_int8_t *) &((NodeDescPtr)targetNode->buffer)->bLink;+ insertKeyPtr->recSize = sizeof(u_int32_t);+ insertKeyPtr->replacingKey = kInsertRecord;+ insertKeyPtr->skipRotate = false; // a rotate is OK during second insert+ }++ err = InsertLevel (btreePtr, treePathTable, primaryKey, secondaryKey,+ &parentNode, index, level, insertNode );+ M_ExitOnError (err);+ }++ err = UpdateNode (btreePtr, targetNode, 0, kLockTransaction); // all done with target+ M_ExitOnError (err);++ err = UpdateNode (btreePtr, &leftNode, 0, kLockTransaction); // all done with left sibling+ M_ExitOnError (err);++ return noErr;++ErrorExit:++ (void) ReleaseNode (btreePtr, targetNode);+ (void) ReleaseNode (btreePtr, &leftNode);++ Panic (" InsertLevel: an error occurred!");++ return err;++} // End of InsertLevel++++////////////////////////////////// InsertNode ///////////////////////////////////++static OSErr InsertNode (BTreeControlBlockPtr btreePtr,+ InsertKey *key,++ BlockDescriptor *rightNode,+ u_int32_t node,+ u_int16_t index,++ u_int32_t *newNode,+ u_int16_t *newIndex,++ BlockDescriptor *leftNode,+ Boolean *updateParent,+ Boolean *insertParent,+ Boolean *rootSplit )+{+ BlockDescriptor *targetNode = NULL;+ u_int32_t leftNodeNum;+ u_int16_t recsRotated;+ OSErr err;+ Boolean recordFit;++ *rootSplit = false;++ PanicIf ( rightNode->buffer == leftNode->buffer, " InsertNode: rightNode == leftNode, huh?");++ leftNodeNum = ((NodeDescPtr) rightNode->buffer)->bLink;+++ /////////////////////// Try Simple Insert ///////////////////////////////++ /* sanity check our left and right nodes here. */+ if (node == leftNodeNum) {+ if (leftNode->buffer == NULL) {+ err = fsBTInvalidNodeErr;+ M_ExitOnError(err);+ }+ else{+ targetNode = leftNode;+ }+ }+ else {+ // we can assume right node is initialized.+ targetNode = rightNode;+ }+++ recordFit = InsertKeyRecord (btreePtr, targetNode->buffer, index, key->keyPtr, key->keyLength, key->recPtr, key->recSize);++ if ( recordFit )+ {+ *newNode = node;+ *newIndex = index;++ if ( (index == 0) && (((NodeDescPtr) targetNode->buffer)->height != btreePtr->treeDepth) )+ *updateParent = true; // the first record changed so we need to update the parent+ }+++ //////////////////////// Try Rotate Left ////////////////////////////////++ if ( !recordFit && leftNodeNum > 0 )+ {+ PanicIf ( leftNode->buffer != nil, " InsertNode: leftNode already acquired!");++ if ( leftNode->buffer == nil )+ {+ err = GetNode (btreePtr, leftNodeNum, 0, leftNode); // will be released by caller or a split below+ M_ExitOnError (err);+ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, leftNode);+ }++ PanicIf ( ((NodeDescPtr) leftNode->buffer)->fLink != node, " InsertNode, RotateLeft: invalid sibling link!" );++ if ( !key->skipRotate ) // are rotates allowed?+ {+ err = RotateLeft (btreePtr, leftNode->buffer, rightNode->buffer, index, key->keyPtr, key->recPtr,+ key->recSize, newIndex, newNode, &recordFit, &recsRotated );+ M_ExitOnError (err);++ if ( recordFit )+ {+ if ( key->replacingKey || (recsRotated > 1) || (index > 0) )+ *updateParent = true;+ }+ }+ }+++ //////////////////////// Try Split Left /////////////////////////////////++ if ( !recordFit )+ {+ // might not have left node...+ err = SplitLeft (btreePtr, leftNode, rightNode, node, index, key->keyPtr,+ key->recPtr, key->recSize, newIndex, newNode, &recsRotated);+ M_ExitOnError (err);++ // if we split root node - add new root++ if ( ((NodeDescPtr) rightNode->buffer)->height == btreePtr->treeDepth )+ {+ err = AddNewRootNode (btreePtr, leftNode->buffer, rightNode->buffer); // Note: does not update TPT+ M_ExitOnError (err);+ *rootSplit = true;+ }+ else+ {+ *insertParent = true;++ if ( key->replacingKey || (recsRotated > 1) || (index > 0) )+ *updateParent = true;+ }+ }++ return noErr;++ErrorExit:+ (void) ReleaseNode (btreePtr, leftNode);+ return err;++} // End of InsertNode+++/*-------------------------------------------------------------------------------+Routine: DeleteTree - One_line_description.++Function: Brief_description_of_the_function_and_any_side_effects++ToDo:++Input: btreePtr - description+ treePathTable - description+ targetNode - description+ index - description++Result: noErr - success+ != noErr - failure+-------------------------------------------------------------------------------*/++OSStatus DeleteTree (BTreeControlBlockPtr btreePtr,+ TreePathTable treePathTable,+ BlockDescriptor *targetNode,+ u_int16_t index,+ u_int16_t level )+{+ OSStatus err;+ BlockDescriptor parentNode;+ BTNodeDescriptor *targetNodePtr;+ u_int32_t targetNodeNum;+ Boolean deleteRequired;+ Boolean updateRequired;++ // XXXdbg - initialize these to null in case we get an+ // error and try to exit before it's initialized+ parentNode.buffer = nil;+ parentNode.blockHeader = nil;++ deleteRequired = false;+ updateRequired = false;++ targetNodeNum = treePathTable[level].node;+ targetNodePtr = targetNode->buffer;+ PanicIf (targetNodePtr == nil, "DeleteTree: targetNode has nil buffer!");++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, targetNode);++ DeleteRecord (btreePtr, targetNodePtr, index);++ //�� coalesce remaining records?++ if ( targetNodePtr->numRecords == 0 ) // did we delete the last record?+ {+ BlockDescriptor siblingNode;+ u_int32_t siblingNodeNum;++ deleteRequired = true;++ siblingNode.buffer = nil;+ siblingNode.blockHeader = nil;++ ////////////////// Get Siblings & Update Links //////////////////////////++ siblingNodeNum = targetNodePtr->bLink; // Left Sibling Node+ if ( siblingNodeNum != 0 )+ {+ err = GetNode (btreePtr, siblingNodeNum, 0, &siblingNode);+ M_ExitOnError (err);++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &siblingNode);++ ((NodeDescPtr)siblingNode.buffer)->fLink = targetNodePtr->fLink;+ err = UpdateNode (btreePtr, &siblingNode, 0, kLockTransaction);+ M_ExitOnError (err);+ }+ else if ( targetNodePtr->kind == kBTLeafNode ) // update firstLeafNode+ {+ btreePtr->firstLeafNode = targetNodePtr->fLink;+ }++ siblingNodeNum = targetNodePtr->fLink; // Right Sibling Node+ if ( siblingNodeNum != 0 )+ {+ err = GetNode (btreePtr, siblingNodeNum, 0, &siblingNode);+ M_ExitOnError (err);++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &siblingNode);++ ((NodeDescPtr)siblingNode.buffer)->bLink = targetNodePtr->bLink;+ err = UpdateNode (btreePtr, &siblingNode, 0, kLockTransaction);+ M_ExitOnError (err);+ }+ else if ( targetNodePtr->kind == kBTLeafNode ) // update lastLeafNode+ {+ btreePtr->lastLeafNode = targetNodePtr->bLink;+ }++ //////////////////////// Free Empty Node ////////////////////////////////++ ClearNode (btreePtr, targetNodePtr);++ err = UpdateNode (btreePtr, targetNode, 0, kLockTransaction);+ M_ExitOnError (err);++ err = FreeNode (btreePtr, targetNodeNum);+ M_ExitOnError (err);+ }+ else if ( index == 0 ) // did we delete the first record?+ {+ updateRequired = true; // yes, so we need to update parent+ }+++ if ( level == btreePtr->treeDepth ) // then targetNode->buffer is the root node+ {+ deleteRequired = false;+ updateRequired = false;++ if ( targetNode->buffer == nil ) // then root was freed and the btree is empty+ {+ btreePtr->rootNode = 0;+ btreePtr->treeDepth = 0;+ }+ else if ( ((NodeDescPtr)targetNode->buffer)->numRecords == 1 )+ {+ err = CollapseTree (btreePtr, targetNode);+ M_ExitOnError (err);+ }+ }+++ if ( updateRequired || deleteRequired )+ {+ ++level; // next level++ //// Get Parent Node and index+ index = treePathTable [level].index;+ err = GetNode (btreePtr, treePathTable[level].node, 0, &parentNode);+ M_ExitOnError (err);++ if ( updateRequired )+ {+ KeyPtr keyPtr;+ u_int8_t * recPtr;+ u_int16_t recSize;+ u_int32_t insertNode;++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &parentNode);++ //���debug: check if ptr == targetNodeNum+ GetRecordByIndex (btreePtr, parentNode.buffer, index, &keyPtr, &recPtr, &recSize);+ PanicIf( (*(u_int32_t *) recPtr) != targetNodeNum, " DeleteTree: parent ptr doesn't match targetNodeNum!!");++ // need to delete and re-insert this parent key/ptr+ DeleteRecord (btreePtr, parentNode.buffer, index);++ keyPtr = (KeyPtr) GetRecordAddress( btreePtr, targetNode->buffer, 0 );+ recPtr = (u_int8_t *) &targetNodeNum;+ recSize = sizeof(targetNodeNum);++ err = InsertTree (btreePtr, treePathTable, keyPtr, recPtr, recSize,+ &parentNode, index, level, kReplaceRecord, &insertNode);+ M_ExitOnError (err);+ }+ else // deleteRequired+ {+ err = DeleteTree (btreePtr, treePathTable, &parentNode, index, level);+ M_ExitOnError (err);+ }+ }+++ err = UpdateNode (btreePtr, targetNode, 0, kLockTransaction);+ M_ExitOnError (err);++ return noErr;++ErrorExit:++ (void) ReleaseNode (btreePtr, targetNode);+ (void) ReleaseNode (btreePtr, &parentNode);++ return err;++} // end DeleteTree++++///////////////////////////////// CollapseTree //////////////////////////////////++static OSStatus CollapseTree (BTreeControlBlockPtr btreePtr,+ BlockDescriptor *blockPtr )+{+ OSStatus err;+ u_int32_t originalRoot;+ u_int32_t nodeNum;++ originalRoot = btreePtr->rootNode;++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, blockPtr);++ while (true)+ {+ if ( ((NodeDescPtr)blockPtr->buffer)->numRecords > 1)+ break; // this will make a fine root node++ if ( ((NodeDescPtr)blockPtr->buffer)->kind == kBTLeafNode)+ break; // we've hit bottom++ nodeNum = btreePtr->rootNode;+ btreePtr->rootNode = GetChildNodeNum (btreePtr, blockPtr->buffer, 0);+ --btreePtr->treeDepth;++ //// Clear and Free Current Old Root Node ////+ ClearNode (btreePtr, blockPtr->buffer);+ err = UpdateNode (btreePtr, blockPtr, 0, kLockTransaction);+ M_ExitOnError (err);+ err = FreeNode (btreePtr, nodeNum);+ M_ExitOnError (err);++ //// Get New Root Node+ err = GetNode (btreePtr, btreePtr->rootNode, 0, blockPtr);+ M_ExitOnError (err);++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, blockPtr);+ }++ if (btreePtr->rootNode != originalRoot)+ M_BTreeHeaderDirty (btreePtr);++ err = UpdateNode (btreePtr, blockPtr, 0, kLockTransaction); // always update!+ M_ExitOnError (err);++ return noErr;+++/////////////////////////////////// ErrorExit ///////////////////////////////////++ErrorExit:+ (void) ReleaseNode (btreePtr, blockPtr);+ return err;+}++++////////////////////////////////// RotateLeft ///////////////////////////////////++/*-------------------------------------------------------------------------------++Routine: RotateLeft - One_line_description.++Function: Brief_description_of_the_function_and_any_side_effects++Algorithm: if rightIndex > insertIndex, subtract 1 for actual rightIndex++Input: btreePtr - description+ leftNode - description+ rightNode - description+ rightInsertIndex - description+ keyPtr - description+ recPtr - description+ recSize - description++Output: insertIndex+ insertNodeNum - description+ recordFit - description+ recsRotated++Result: noErr - success+ != noErr - failure+-------------------------------------------------------------------------------*/++static OSStatus RotateLeft (BTreeControlBlockPtr btreePtr,+ NodeDescPtr leftNode,+ NodeDescPtr rightNode,+ u_int16_t rightInsertIndex,+ KeyPtr keyPtr,+ u_int8_t * recPtr,+ u_int16_t recSize,+ u_int16_t *insertIndex,+ u_int32_t *insertNodeNum,+ Boolean *recordFit,+ u_int16_t *recsRotated )+{+ OSStatus err;+ int32_t insertSize;+ int32_t nodeSize;+ int32_t leftSize, rightSize;+ int32_t moveSize = 0;+ u_int16_t keyLength;+ u_int16_t lengthFieldSize;+ u_int16_t index, moveIndex;+ Boolean didItFit;++ ///////////////////// Determine If Record Will Fit //////////////////////////++ keyLength = GetKeyLength(btreePtr, keyPtr, (rightNode->kind == kBTLeafNode));++ // the key's length field is 8-bits in HFS and 16-bits in HFS++ if ( btreePtr->attributes & kBTBigKeysMask )+ lengthFieldSize = sizeof(u_int16_t);+ else+ lengthFieldSize = sizeof(u_int8_t);++ insertSize = keyLength + lengthFieldSize + recSize + sizeof(u_int16_t);++ if ( M_IsOdd (insertSize) )+ ++insertSize; // add pad byte;++ nodeSize = btreePtr->nodeSize;++ // add size of insert record to right node+ rightSize = nodeSize - GetNodeFreeSize (btreePtr, rightNode) + insertSize;+ leftSize = nodeSize - GetNodeFreeSize (btreePtr, leftNode);++ moveIndex = 0;++ while ( leftSize < rightSize )+ {+ if ( moveIndex < rightInsertIndex )+ {+ moveSize = GetRecordSize (btreePtr, rightNode, moveIndex) + 2;+ }+ else if ( moveIndex == rightInsertIndex )+ {+ moveSize = insertSize;+ }+ else // ( moveIndex > rightInsertIndex )+ {+ moveSize = GetRecordSize (btreePtr, rightNode, moveIndex - 1) + 2;+ }++ leftSize += moveSize;+ rightSize -= moveSize;+ ++moveIndex;+ }++ if ( leftSize > nodeSize ) // undo last move+ {+ leftSize -= moveSize;+ rightSize += moveSize;+ --moveIndex;+ }++ if ( rightSize > nodeSize ) // record won't fit - failure, but not error+ {+ *insertIndex = 0;+ *insertNodeNum = 0;+ *recordFit = false;+ *recsRotated = 0;++ return noErr;+ }++ // we've found balance point, moveIndex == number of records moved into leftNode+++ //////////////////////////// Rotate Records /////////////////////////////////++ *recsRotated = moveIndex;+ *recordFit = true;+ index = 0;++ while ( index < moveIndex )+ {+ if ( index == rightInsertIndex ) // insert new record in left node+ {+ u_int16_t leftInsertIndex;++ leftInsertIndex = leftNode->numRecords;++ didItFit = InsertKeyRecord (btreePtr, leftNode, leftInsertIndex,+ keyPtr, keyLength, recPtr, recSize);+ if ( !didItFit )+ {+ Panic ("RotateLeft: InsertKeyRecord (left) returned false!");+ err = fsBTBadRotateErr;+ goto ErrorExit;+ }++ *insertIndex = leftInsertIndex;+ *insertNodeNum = rightNode->bLink;+ }+ else+ {+ didItFit = RotateRecordLeft (btreePtr, leftNode, rightNode);+ if ( !didItFit )+ {+ Panic ("RotateLeft: RotateRecordLeft returned false!");+ err = fsBTBadRotateErr;+ goto ErrorExit;+ }+ }++ ++index;+ }++ if ( moveIndex <= rightInsertIndex ) // then insert new record in right node+ {+ rightInsertIndex -= index; // adjust for records already rotated++ didItFit = InsertKeyRecord (btreePtr, rightNode, rightInsertIndex,+ keyPtr, keyLength, recPtr, recSize);+ if ( !didItFit )+ {+ Panic ("RotateLeft: InsertKeyRecord (right) returned false!");+ err = fsBTBadRotateErr;+ goto ErrorExit;+ }++ *insertIndex = rightInsertIndex;+ *insertNodeNum = leftNode->fLink;+ }+++ return noErr;+++ ////////////////////////////// Error Exit ///////////////////////////////////++ErrorExit:++ *insertIndex = 0;+ *insertNodeNum = 0;+ *recordFit = false;+ *recsRotated = 0;++ return err;+}++++/////////////////////////////////// SplitLeft ///////////////////////////////////++static OSStatus SplitLeft (BTreeControlBlockPtr btreePtr,+ BlockDescriptor *leftNode,+ BlockDescriptor *rightNode,+ u_int32_t rightNodeNum,+ u_int16_t index,+ KeyPtr keyPtr,+ u_int8_t * recPtr,+ u_int16_t recSize,+ u_int16_t *insertIndex,+ u_int32_t *insertNodeNum,+ u_int16_t *recsRotated )+{+ OSStatus err;+ NodeDescPtr left, right;+ u_int32_t newNodeNum;+ Boolean recordFit;+++ ///////////////////////////// Compare Nodes /////////////////////////////////++ right = rightNode->buffer;+ left = leftNode->buffer;++ PanicIf ( right->bLink != 0 && left == 0, " SplitLeft: left sibling missing!?" );++ /* type should be kBTLeafNode or kBTIndexNode */++ if ( (right->height == 1) && (right->kind != kBTLeafNode) )+ return fsBTInvalidNodeErr;++ if ( left != nil )+ {+ if ( left->fLink != rightNodeNum )+ return fsBTInvalidNodeErr; //�� E_BadSibling ?++ if ( left->height != right->height )+ return fsBTInvalidNodeErr; //�� E_BadNodeHeight ?++ if ( left->kind != right->kind )+ return fsBTInvalidNodeErr; //�� E_BadNodeType ?+ }+++ ///////////////////////////// Allocate Node /////////////////////////////////++ err = AllocateNode (btreePtr, &newNodeNum);+ M_ExitOnError (err);+++ /////////////// Update Forward Link In Original Left Node ///////////////////++ if ( left != nil )+ {+ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, leftNode);++ left->fLink = newNodeNum;+ err = UpdateNode (btreePtr, leftNode, 0, kLockTransaction);+ M_ExitOnError (err);+ }+++ /////////////////////// Initialize New Left Node ////////////////////////////++ err = GetNewNode (btreePtr, newNodeNum, leftNode);+ M_ExitOnError (err);++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, leftNode);++ left = leftNode->buffer;+ left->fLink = rightNodeNum;+++ // Steal Info From Right Node++ left->bLink = right->bLink;+ left->kind = right->kind;+ left->height = right->height;++ right->bLink = newNodeNum; // update Right bLink++ if ( (left->kind == kBTLeafNode) && (left->bLink == 0) )+ {+ // if we're adding a new first leaf node - update BTreeInfoRec++ btreePtr->firstLeafNode = newNodeNum;+ M_BTreeHeaderDirty (btreePtr); //�� AllocateNode should have set the bit already...+ }++ ////////////////////////////// Rotate Left //////////////////////////////////++ err = RotateLeft (btreePtr, left, right, index, keyPtr, recPtr, recSize,+ insertIndex, insertNodeNum, &recordFit, recsRotated);++ M_ExitOnError (err);++ return noErr;++ErrorExit:++ (void) ReleaseNode (btreePtr, leftNode);+ (void) ReleaseNode (btreePtr, rightNode);++ //�� Free new node if allocated?++ *insertIndex = 0;+ *insertNodeNum = 0;+ *recsRotated = 0;++ return err;+}++++/////////////////////////////// RotateRecordLeft ////////////////////////////////++static Boolean RotateRecordLeft (BTreeControlBlockPtr btreePtr,+ NodeDescPtr leftNode,+ NodeDescPtr rightNode )+{+ u_int16_t size;+ u_int8_t * recPtr;+ Boolean recordFit;++ size = GetRecordSize (btreePtr, rightNode, 0);+ recPtr = GetRecordAddress (btreePtr, rightNode, 0);++ recordFit = InsertRecord (btreePtr, leftNode, leftNode->numRecords, recPtr, size);++ if ( !recordFit )+ return false;++ DeleteRecord (btreePtr, rightNode, 0);++ return true;+}+++//////////////////////////////// AddNewRootNode /////////////////////////////////++static OSStatus AddNewRootNode (BTreeControlBlockPtr btreePtr,+ NodeDescPtr leftNode,+ NodeDescPtr rightNode )+{+ OSStatus err;+ BlockDescriptor rootNode;+ u_int32_t rootNum;+ KeyPtr keyPtr;+ Boolean didItFit;+ u_int16_t keyLength;++ rootNode.buffer = nil;+ rootNode.blockHeader = nil;++ PanicIf (leftNode == nil, "AddNewRootNode: leftNode == nil");+ PanicIf (rightNode == nil, "AddNewRootNode: rightNode == nil");+++ /////////////////////// Initialize New Root Node ////////////////////////////++ err = AllocateNode (btreePtr, &rootNum);+ M_ExitOnError (err);++ err = GetNewNode (btreePtr, rootNum, &rootNode);+ M_ExitOnError (err);++ // XXXdbg+ ModifyBlockStart(btreePtr->fileRefNum, &rootNode);++ ((NodeDescPtr)rootNode.buffer)->kind = kBTIndexNode;+ ((NodeDescPtr)rootNode.buffer)->height = ++btreePtr->treeDepth;+++ ///////////////////// Insert Left Node Index Record /////////////////////////++ keyPtr = (KeyPtr) GetRecordAddress (btreePtr, leftNode, 0);+ keyLength = GetKeyLength(btreePtr, keyPtr, false);++ didItFit = InsertKeyRecord ( btreePtr, rootNode.buffer, 0, keyPtr, keyLength,+ (u_int8_t *) &rightNode->bLink, 4 );++ PanicIf ( !didItFit, "AddNewRootNode:InsertKeyRecord failed for left index record");+++ //////////////////// Insert Right Node Index Record /////////////////////////++ keyPtr = (KeyPtr) GetRecordAddress (btreePtr, rightNode, 0);+ keyLength = GetKeyLength(btreePtr, keyPtr, false);++ didItFit = InsertKeyRecord ( btreePtr, rootNode.buffer, 1, keyPtr, keyLength,+ (u_int8_t *) &leftNode->fLink, 4 );++ PanicIf ( !didItFit, "AddNewRootNode:InsertKeyRecord failed for right index record");+++ /////////////////////////// Release Root Node ///////////////////////////////++ err = UpdateNode (btreePtr, &rootNode, 0, kLockTransaction);+ M_ExitOnError (err);++ // update BTreeInfoRec++ btreePtr->rootNode = rootNum;+ M_BTreeHeaderDirty(btreePtr);++ return noErr;+++ ////////////////////////////// Error Exit ///////////////////////////////////++ErrorExit:++ return err;+}+++static u_int16_t GetKeyLength ( const BTreeControlBlock *btreePtr, const BTreeKey *key, Boolean forLeafNode )+{+ u_int16_t length;++ if ( forLeafNode || btreePtr->attributes & kBTVariableIndexKeysMask )+ length = KeyLength (btreePtr, key); // just use actual key length+ else+ length = btreePtr->maxKeyLength; // fixed sized index key (i.e. HFS) //�� shouldn't we clear the pad bytes?++ return length;+}+diff --git a/xnu/files/bsd/hfs/BTreeWrapper.c b/xnu/files/bsd/hfs/BTreeWrapper.cnew file mode 100644index 0000000..86e9bf1--- /dev/null+++ b/xnu/files/bsd/hfs/BTreeWrapper.c@@ -0,0 +1,189 @@+/*+ * Copyright (c) 2000, 2002, 2005-2015 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@+ */++#include "BTreesPrivate.h"+#include <sys/kernel.h>+#include <libkern/libkern.h>+++// local routines+static OSErr CheckBTreeKey(const BTreeKey *key, const BTreeControlBlock *btcb);++#if DEBUG+static Boolean ValidHFSRecord(const void *record, const BTreeControlBlock *btcb, u_int16_t recordSize);+#endif++OSErr ReplaceBTreeRecord(FileReference refNum, const void* key, u_int32_t hint, void *newData, u_int16_t dataSize, u_int32_t *newHint)+{+ FSBufferDescriptor btRecord;+ struct BTreeIterator *iterator = NULL;+ FCB *fcb;+ BTreeControlBlock *btcb;+ OSStatus result;++ iterator = hfs_malloc_type(struct BTreeIterator);++ fcb = GetFileControlBlock(refNum);+ btcb = (BTreeControlBlock*) fcb->fcbBTCBPtr;++ btRecord.bufferAddress = newData;+ btRecord.itemSize = dataSize;+ btRecord.itemCount = 1;++ iterator->hint.nodeNum = hint;++ result = CheckBTreeKey((const BTreeKey *) key, btcb);+ if (result) {+ goto ErrorExit;+ }++ BlockMoveData(key, &iterator->key, CalcKeySize(btcb, (const BTreeKey *) key)); //�� should we range check against maxkeylen?++#if DEBUG+ if ( !ValidHFSRecord(newData, btcb, dataSize) )+ DebugStr("ReplaceBTreeRecord: bad record?");+#endif++ result = BTReplaceRecord( fcb, iterator, &btRecord, dataSize );++ *newHint = iterator->hint.nodeNum;++ErrorExit:++ hfs_free_type(iterator, struct BTreeIterator);+ return result;+}++++static OSErr CheckBTreeKey(const BTreeKey *key, const BTreeControlBlock *btcb)+{+ u_int16_t keyLen;++ if ( btcb->attributes & kBTBigKeysMask )+ keyLen = key->length16;+ else+ keyLen = key->length8;++ if ( (keyLen < 6) || (keyLen > btcb->maxKeyLength) )+ {+ hfs_debug("CheckBTreeKey: bad key length!");+ return fsBTInvalidKeyLengthErr;+ }++ return noErr;+}++#if DEBUG++static Boolean ValidHFSRecord(const void *record, const BTreeControlBlock *btcb, u_int16_t recordSize)+{+ u_int32_t cNodeID;++ if (btcb->maxKeyLength == kHFSPlusExtentKeyMaximumLength )+ {+ return ( recordSize == sizeof(HFSPlusExtentRecord) );+ } else { // Catalog record+ const CatalogRecord *catalogRecord = (const CatalogRecord*) record;++ switch(catalogRecord->recordType)+ {+ case kHFSPlusFolderRecord:+ {+ if ( recordSize != sizeof(HFSPlusCatalogFolder) )+ return false;+ if ( catalogRecord->hfsPlusFolder.flags != 0 )+ return false;+ if ( catalogRecord->hfsPlusFolder.valence > 0x7FFF )+ return false;++ cNodeID = catalogRecord->hfsPlusFolder.folderID;++ if ( (cNodeID == 0) || (cNodeID < 16 && cNodeID > 2) )+ return false;+ }+ break;++ case kHFSPlusFileRecord:+ {+// u_int16_t i;+ const HFSPlusExtentDescriptor *dataExtent;+ const HFSPlusExtentDescriptor *rsrcExtent;++ if ( recordSize != sizeof(HFSPlusCatalogFile) )+ return false;+ if ( (catalogRecord->hfsPlusFile.flags & ~(0x83)) != 0 )+ return false;++ cNodeID = catalogRecord->hfsPlusFile.fileID;++ if ( cNodeID < 16 )+ return false;++ // make sure 0 � LEOF � PEOF for both forks++ dataExtent = (const HFSPlusExtentDescriptor*) &catalogRecord->hfsPlusFile.dataFork.extents;+ rsrcExtent = (const HFSPlusExtentDescriptor*) &catalogRecord->hfsPlusFile.resourceFork.extents;++#if 0+ for (i = 0; i < kHFSPlusExtentDensity; ++i)+ {+ if ( (dataExtent[i].blockCount > 0) && (dataExtent[i].startBlock == 0) )+ return false;+ if ( (rsrcExtent[i].blockCount > 0) && (rsrcExtent[i].startBlock == 0) )+ return false;+ }+#endif+ }+ break;++ case kHFSPlusFileThreadRecord:+ case kHFSPlusFolderThreadRecord:+ {+ if ( recordSize > sizeof(HFSPlusCatalogThread) || recordSize < (sizeof(HFSPlusCatalogThread) - sizeof(HFSUniStr255)))+ return false;++ cNodeID = catalogRecord->hfsPlusThread.parentID;+ if ( (cNodeID == 0) || (cNodeID < 16 && cNodeID > 2) )+ return false;++ if ( (catalogRecord->hfsPlusThread.nodeName.length == 0) ||+ (catalogRecord->hfsPlusThread.nodeName.length > 255) )+ return false;+ }+ break;++ default:+ return false;+ }+ }++ return true; // record appears to be OK+}++#endif // DEBUGdiff --git a/xnu/files/bsd/hfs/BTreesInternal.h b/xnu/files/bsd/hfs/BTreesInternal.hnew file mode 100644index 0000000..11a7842--- /dev/null+++ b/xnu/files/bsd/hfs/BTreesInternal.h@@ -0,0 +1,368 @@+/*+ * Copyright (c) 2000-2014 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@+ */+/*+ File: BTreesInternal.h++ Contains: IPI to File Manager B-tree++ Version: HFS Plus 1.0++ Copyright: (c) 1996-1998 by Apple Inc., all rights reserved.++ File Ownership:++ DRI: Don Brady++ Other Contact: Mark Day++ Technology: File Systems++ Writers:++ (msd) Mark Day+ (DSH) Deric Horn+ (djb) Don Brady++ Change History (most recent first):++ <RHAP> 9/22/99 ser Added prototypes for BTGetLastSync and BTSetLastSync+ <RHAP> 6/22/98 djb Add ERR_BASE to btree error codes to make them negative (for MacOS X only).++ <CS7> 7/28/97 msd Add enum for fsBTTimeOutErr.+ <CS6> 7/25/97 DSH Added heuristicHint as parameter to BTSearchRecord.+ <CS5> 7/24/97 djb Add blockReadFromDisk flag to BlockDescriptor. Callbacks now use+ a file refNum instead of an FCB.+ <CS4> 7/16/97 DSH FilesInternal.i renamed FileMgrInternal.i to avoid name+ collision+ <CS3> 6/2/97 DSH Added SetEndOfForkProc() prototype, so Attributes.c can call it+ directly.+ <CS2> 5/19/97 djb kMaxKeyLength is now 520.+ <CS1> 4/28/97 djb first checked in++ <HFS6> 3/17/97 DSH Remove Key Comparison prototype, already in FilesInternal.h.+ <HFS5> 2/19/97 djb Add SetBlockSizeProcPtr. Add blockSize field to BlockDescriptor.+ Remove E_ type error enums.+ <HFS4> 1/27/97 djb Include Types.h and FilesInternal.h.+ <HFS3> 1/13/97 djb Added kBTreeCurrentRecord for BTIterateRecord.+ <HFS2> 1/3/97 djb Added support for large keys.+ <HFS1> 12/19/96 djb first checked in++*/++#ifndef __BTREESINTERNAL__+#define __BTREESINTERNAL__++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE++#ifndef __FILEMGRINTERNAL__+#include "FileMgrInternal.h"+#endif++enum {+ fsBTInvalidHeaderErr = btBadHdr,+ fsBTBadRotateErr = dsBadRotate,+ fsBTInvalidNodeErr = btBadNode,+ fsBTRecordTooLargeErr = btNoFit,+ fsBTRecordNotFoundErr = btNotFound,+ fsBTDuplicateRecordErr = btExists,+ fsBTFullErr = btNoSpaceAvail,++ fsBTInvalidFileErr = ERR_BASE + 0x0302, /* no BTreeCB has been allocated for fork*/+ fsBTrFileAlreadyOpenErr = ERR_BASE + 0x0303,+ fsBTInvalidIteratorErr = ERR_BASE + 0x0308,+ fsBTEmptyErr = ERR_BASE + 0x030A,+ fsBTNoMoreMapNodesErr = ERR_BASE + 0x030B,+ fsBTBadNodeSize = ERR_BASE + 0x030C,+ fsBTBadNodeType = ERR_BASE + 0x030D,+ fsBTInvalidKeyLengthErr = ERR_BASE + 0x030E,+ fsBTStartOfIterationErr = ERR_BASE + 0x0353,+ fsBTEndOfIterationErr = ERR_BASE + 0x0354,+ fsBTUnknownVersionErr = ERR_BASE + 0x0355,+ fsBTTreeTooDeepErr = ERR_BASE + 0x0357,+ fsIteratorExitedScopeErr = ERR_BASE + 0x0A02, /* iterator exited the scope*/+ fsIteratorScopeExceptionErr = ERR_BASE + 0x0A03, /* iterator is undefined due to error or movement of scope locality*/+ fsUnknownIteratorMovementErr = ERR_BASE + 0x0A04, /* iterator movement is not defined*/+ fsInvalidIterationMovmentErr = ERR_BASE + 0x0A05, /* iterator movement is invalid in current context*/+ fsClientIDMismatchErr = ERR_BASE + 0x0A06, /* wrong client process ID*/+ fsEndOfIterationErr = ERR_BASE + 0x0A07, /* there were no objects left to return on iteration*/+ fsBTTimeOutErr = ERR_BASE + 0x0A08 /* BTree scan interrupted -- no time left for physical I/O */+};++struct BlockDescriptor{+ void *buffer;+ void *blockHeader;+ daddr64_t blockNum; /* logical block number (used by hfs_swap_BTNode) */+ ByteCount blockSize;+ Boolean blockReadFromDisk;+ Byte isModified; // XXXdbg - for journaling+ Byte reserved[2];+};+typedef struct BlockDescriptor BlockDescriptor;+typedef BlockDescriptor *BlockDescPtr;+++struct FSBufferDescriptor {+ void * bufferAddress;+ ByteCount itemSize;+ ItemCount itemCount;+};+typedef struct FSBufferDescriptor FSBufferDescriptor;++typedef FSBufferDescriptor *FSBufferDescriptorPtr;+++/*+ Fork Level Access Method Block get options+*/+enum {+ kGetBlock = 0x00000000,+ kGetBlockHint = 0x00000001, // if set, the block is being looked up using hint+ kForceReadBlock = 0x00000002, //�� how does this relate to Read/Verify? Do we need this?+ kGetEmptyBlock = 0x00000008+};+typedef u_int32_t GetBlockOptions;++/*+ Fork Level Access Method Block release options+*/+enum {+ kReleaseBlock = 0x00000000,+ kForceWriteBlock = 0x00000001,+ kMarkBlockDirty = 0x00000002,+ kTrashBlock = 0x00000004,+ kLockTransaction = 0x00000100+};+typedef u_int32_t ReleaseBlockOptions;++typedef u_int64_t FSSize;+typedef u_int32_t ForkBlockNumber;++/*============================================================================+ Fork Level Buffered I/O Access Method+============================================================================*/++typedef OSStatus (* GetBlockProcPtr) (FileReference fileRefNum,+ u_int32_t blockNum,+ GetBlockOptions options,+ BlockDescriptor *block );+++typedef OSStatus (* ReleaseBlockProcPtr) (FileReference fileRefNum,+ BlockDescPtr blockPtr,+ ReleaseBlockOptions options );++typedef OSStatus (* SetEndOfForkProcPtr) (FileReference fileRefNum,+ FSSize minEOF,+ FSSize maxEOF );++typedef OSStatus (* SetBlockSizeProcPtr) (FileReference fileRefNum,+ ByteCount blockSize,+ ItemCount minBlockCount );++OSStatus SetEndOfForkProc ( FileReference fileRefNum, FSSize minEOF, FSSize maxEOF );+++/*+ B*Tree Information Version+*/++enum BTreeInformationVersion{+ kBTreeInfoVersion = 0+};++/*+ B*Tree Iteration Operation Constants+*/++enum BTreeIterationOperations{+ kBTreeFirstRecord,+ kBTreeNextRecord,+ kBTreePrevRecord,+ kBTreeLastRecord,+ kBTreeCurrentRecord+};+typedef u_int16_t BTreeIterationOperation;+++/*+ Btree types: 0 is HFS CAT/EXT file, 1~127 are AppleShare B*Tree files, 128~254 unused+ hfsBtreeType EQU 0 ; control file+ validBTType EQU $80 ; user btree type starts from 128+ userBT1Type EQU $FF ; 255 is our Btree type. Used by BTInit and BTPatch+*/++enum BTreeTypes{+ kHFSBTreeType = 0, // control file+ kUserBTreeType = 128, // user btree type starts from 128+ kReservedBTreeType = 255 //+};++#define kBTreeHeaderUserBytes 128+++typedef BTreeKey *BTreeKeyPtr;+++/*+ BTreeInfoRec Structure - for BTGetInformation+*/+struct BTreeInfoRec{+ u_int16_t version;+ u_int16_t nodeSize;+ u_int16_t maxKeyLength;+ u_int16_t treeDepth;+ u_int32_t lastfsync; /* Last time that this was fsynced */+ ItemCount numRecords;+ ItemCount numNodes;+ ItemCount numFreeNodes;+ u_int8_t keyCompareType;+ u_int8_t reserved[3];+};+typedef struct BTreeInfoRec BTreeInfoRec;+typedef BTreeInfoRec *BTreeInfoPtr;++/*+ BTreeHint can never be exported to the outside. Use u_int32_t BTreeHint[4],+ u_int8_t BTreeHint[16], etc.+ */+struct BTreeHint{+ ItemCount writeCount;+ u_int32_t nodeNum; // node the key was last seen in+ u_int16_t index; // index then key was last seen at+ u_int16_t reserved1;+ u_int32_t reserved2;+};+typedef struct BTreeHint BTreeHint;+typedef BTreeHint *BTreeHintPtr;++/*+ BTree Iterator+*/+struct BTreeIterator{+ BTreeHint hint;+ u_int16_t version;+ u_int16_t reserved;+ u_int32_t hitCount; // Total number of leaf records hit+ u_int32_t maxLeafRecs; // Max leaf records over iteration+ BTreeKey key;+};+typedef struct BTreeIterator BTreeIterator;+typedef BTreeIterator *BTreeIteratorPtr;+++/*============================================================================+ B*Tree SPI+============================================================================*/++/*+ Key Comparison Function ProcPtr Type - for BTOpenPath+*/+//typedef int32_t (* KeyCompareProcPtr)(BTreeKeyPtr a, BTreeKeyPtr b);+++typedef int32_t (* IterateCallBackProcPtr)(BTreeKeyPtr key, void * record, void * state);+++extern OSStatus BTOpenPath(FCB *filePtr, KeyCompareProcPtr keyCompareProc);++extern OSStatus BTClosePath (FCB *filePtr );+++extern OSStatus BTSearchRecord (FCB *filePtr,+ BTreeIterator *searchIterator,+ FSBufferDescriptor *btRecord,+ u_int16_t *recordLen,+ BTreeIterator *resultIterator );++extern OSStatus BTIterateRecord (FCB *filePtr,+ BTreeIterationOperation operation,+ BTreeIterator *iterator,+ FSBufferDescriptor *btRecord,+ u_int16_t *recordLen );+++extern OSStatus BTIterateRecords(FCB *filePtr, BTreeIterationOperation operation, BTreeIterator *iterator,+ IterateCallBackProcPtr callBackProc, void * callBackState);++extern OSStatus BTInsertRecord (FCB *filePtr,+ BTreeIterator *iterator,+ FSBufferDescriptor *btrecord,+ u_int16_t recordLen );++extern OSStatus BTReplaceRecord (FCB *filePtr,+ BTreeIterator *iterator,+ FSBufferDescriptor *btRecord,+ u_int16_t recordLen );++extern OSStatus BTUpdateRecord (FCB *filePtr,+ BTreeIterator *iterator,+ IterateCallBackProcPtr callBackProc,+ void *callBackState );++extern OSStatus BTDeleteRecord (FCB *filePtr,+ BTreeIterator *iterator );++extern OSStatus BTGetInformation (FCB *filePtr,+ u_int16_t vers,+ BTreeInfoRec *info );++extern OSStatus BTIsDirty(FCB *filePtr);++extern OSStatus BTFlushPath (FCB *filePtr );++extern OSStatus BTReloadData (FCB *filePtr);++extern OSStatus BTInvalidateHint (BTreeIterator *iterator );++extern OSStatus BTGetLastSync (FCB *filePtr,+ u_int32_t *lastfsync );++extern OSStatus BTSetLastSync (FCB *filePtr,+ u_int32_t lastfsync );++extern OSStatus BTHasContiguousNodes(FCB *filePtr);++extern OSStatus BTGetUserData(FCB *filePtr, void * dataPtr, int dataSize);++extern OSStatus BTSetUserData(FCB *filePtr, void * dataPtr, int dataSize);++/* B-tree node reserve routines. */+extern void BTReserveSetup(void);++extern int BTReserveSpace(FCB *file, int operations, void * data);++extern int BTReleaseReserve(FCB *file, void * data);++extern int BTZeroUnusedNodes(FCB *file);++#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */+#endif // __BTREESINTERNAL__diff --git a/xnu/files/bsd/hfs/BTreesPrivate.h b/xnu/files/bsd/hfs/BTreesPrivate.hnew file mode 100644index 0000000..260de38--- /dev/null+++ b/xnu/files/bsd/hfs/BTreesPrivate.h@@ -0,0 +1,516 @@+/*+ * Copyright (c) 2000-2015 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@+ */+/*+ File: BTreesPrivate.h++ Contains: Private interface file for the BTree Module.++ Version: xxx put the technology version here xxx++ Written by: Gordon Sheridan and Bill Bruffey++ Copyright: (c) 1992-1999 by Apple Inc., all rights reserved.++ File Ownership:++ DRI: Don Brady++ Other Contact: Mark Day++ Technology: File Systems++ Writers:++ (msd) Mark Day+ (DSH) Deric Horn+ (djb) Don Brady+ (ser) Scott Roberts+ (dkh) Dave Heller++ Change History (most recent first):+ <MacOSX> 3/19/99 djb Disable MoveRecordsLeft/Right macros since bcopy is broken.++ <MacOSX> 8/10/98 djb Removed unused BTreeIterator from BTreeControlBlock, fixed alignment.++ <CS5> 9/4/97 djb Convert MoveRecordsLeft and GetLeftSiblingNode to macros.+ <CS4> 7/24/97 djb Add macro for GetRecordAddress (was a function before).+ <CS3> 7/21/97 msd GetRecordByIndex now returns an OSStatus.+ <CS2> 7/16/97 DSH FilesInternal.i renamed FileMgrInternal.i to avoid name+ collision+ <CS1> 4/23/97 djb first checked in++ <HFS6> 3/17/97 DSH Added a refCon field to BTreeControlBlock, for DFA use, to point+ to additional data. Fixed Panic macros for use with SC.+ <HFS5> 2/19/97 djb Add InsertKey struct. Moved on-disk definitions to+ HFSBTreesPriv.h+ <HFS4> 1/27/97 djb InsertTree and DeleteTree are now recursive and support variable+ sized index keys.+ <HFS3> 1/15/97 djb Move GetFileRefNumFromFCB macro to FilesInternal.h. Added+ kBTVariableIndexKeysMask.+ <HFS2> 1/3/97 djb Added support for large keys.+ <HFS1> 12/19/96 djb first checked in++ History applicable to original Scarecrow Design:++ <7> 10/25/96 ser Changing for new VFPI+ <6> 10/18/96 ser Converting over VFPI changes+ <5> 9/17/96 dkh More BTree statistics+ <4> 9/16/96 dkh Revised BTree statistics+ <3> 6/20/96 dkh Radar #1358740. Switch from using Pools to debug MemAllocators.+ <2> 12/7/95 dkh D10E2 build. Changed usage of Ref data type to LogicalAddress.+ <1> 10/18/95 rst Moved from Scarecrow project.++ <19> 11/22/94 djb Add prototype for GetMapNode+ <18> 11/16/94 prp Add IsItAHint routine prototype.+ <17> 9/30/94 prp Get in sync with D2 interface changes.+ <16> 7/25/94 wjk Eliminate usage of BytePtr in favor of UInt8 *.+ <15> 7/22/94 wjk Convert to the new set of header files.+ <14> 5/31/94 srs Moved Btree types to public interface+ <13> 12/9/93 wjk Add 68k alignment pragma's around persistent structures.+ <12> 11/30/93 wjk Move from Makefiles to BuildFiles. Fit into the ModernOS and+ NRCmds environments.+ <11> 11/23/93 wjk Changes required to compile on the RS6000.+ <10> 8/30/93 CH Removed the M_ExitOnError and M_ReturnErrorIf macros which were+ already defined in FileSystemPriv.h (included here).+ <9> 8/30/93 CH Added parens around the M_ReturnErrorIf macro.+ <8> 5/21/93 gs Add kBadClose flag. Add some prototypes for internal routines.+ <7> 5/10/93 gs Change Ptr to BytePtr. Move BTreeTypes to BTree.h. Add+ DeleteTree prototype.+ <6> 3/23/93 gs Remove mysterious "flags" field from HeaderRec structure. Move+ prototypes of private functions to top of respective source+ files.+ <5> 2/8/93 gs Update to use FSAgent.h Get/Release/SetEOF/SetBlockSize+ procPtrs. Add UpdateNode routine.+ <4> 12/10/92 gs Add Key Descriptor function declarations.+ <3> 12/8/92 gs Add HeaderRec structure and incorporate review feedback.+ <2> 12/2/92 gs Add GetNode and ReleaseNode callback procptrs to BTree CB, and+ add internal function declarations.+ <1> 11/15/92 gs first checked in++*/++#ifndef __BTREESPRIVATE__+#define __BTREESPRIVATE__++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE++#include "hfs_macos_defs.h"++#ifndef __FILEMGRINTERNAL__+#include "FileMgrInternal.h"+#endif++#ifndef __BTREESINTERNAL__+#include "BTreesInternal.h"+#endif+++/////////////////////////////////// Constants ///////////////////////////////////++#define kBTreeVersion 1+#define kMaxTreeDepth 16+++#define kHeaderNodeNum 0+#define kKeyDescRecord 1+++// Header Node Record Offsets+enum {+ kHeaderRecOffset = 0x000E,+ kKeyDescRecOffset = 0x0078,+ kHeaderMapRecOffset = 0x00F8+};++#define kMinNodeSize 512++#define kMinRecordSize 6+ // where is minimum record size enforced?++// miscellaneous BTree constants+enum {+ kOffsetSize = 2+};++// Insert Operations+typedef enum {+ kInsertRecord = 0,+ kReplaceRecord = 1+} InsertType;++// illegal string attribute bits set in mask+#define kBadStrAttribMask 0xCF++++//////////////////////////////////// Macros /////////////////////////////////////++#define M_NodesInMap(mapSize) ((mapSize) << 3)++#define M_ClearBitNum(integer,bitNumber) ((integer) &= (~(1<<(bitNumber))))+#define M_SetBitNum(integer,bitNumber) ((integer) |= (1<<(bitNumber)))+#define M_IsOdd(integer) (((integer) & 1) != 0)+#define M_IsEven(integer) (((integer) & 1) == 0)++#define M_MapRecordSize(nodeSize) (nodeSize - sizeof (BTNodeDescriptor) - 6)+#define M_HeaderMapRecordSize(nodeSize) (nodeSize - sizeof(BTNodeDescriptor) - sizeof(BTHeaderRec) - 128 - 8)++#define M_SWAP_BE16_ClearBitNum(integer,bitNumber) ((integer) &= SWAP_BE16(~(1<<(bitNumber))))+#define M_SWAP_BE16_SetBitNum(integer,bitNumber) ((integer) |= SWAP_BE16(1<<(bitNumber)))++///////////////////////////////////// Types /////////////////////////////////////++typedef struct BTreeControlBlock { // fields specific to BTree CBs++ u_int8_t keyCompareType; /* Key string Comparison Type */+ u_int8_t btreeType;+ u_int16_t treeDepth;+ FileReference fileRefNum; // refNum of btree file+ KeyCompareProcPtr keyCompareProc;+ u_int32_t rootNode;+ u_int32_t leafRecords;+ u_int32_t firstLeafNode;+ u_int32_t lastLeafNode;+ u_int16_t nodeSize;+ u_int16_t maxKeyLength;+ u_int32_t totalNodes;+ u_int32_t freeNodes;++ u_int16_t reserved3; // 4-byte alignment++ // new fields+ int16_t version;+ u_int32_t flags; // dynamic flags+ u_int32_t attributes; // persistent flags+ u_int32_t writeCount;+ u_int32_t lastfsync; /* Last time that this was fsynced */++ GetBlockProcPtr getBlockProc;+ ReleaseBlockProcPtr releaseBlockProc;+ SetEndOfForkProcPtr setEndOfForkProc;++ // statistical information+ u_int32_t numGetNodes;+ u_int32_t numGetNewNodes;+ u_int32_t numReleaseNodes;+ u_int32_t numUpdateNodes;+ u_int32_t numMapNodesRead; // map nodes beyond header node+ u_int32_t numHintChecks;+ u_int32_t numPossibleHints; // Looks like a formated hint+ u_int32_t numValidHints; // Hint used to find correct record.+ u_int32_t reservedNodes;+ BTreeIterator iterator; // useable when holding exclusive b-tree lock++#if DEBUG+ void *madeDirtyBy[2];+#endif+} BTreeControlBlock, *BTreeControlBlockPtr;++u_int32_t CalcKeySize(const BTreeControlBlock *btcb, const BTreeKey *key);+#define CalcKeySize(btcb, key) ( ((btcb)->attributes & kBTBigKeysMask) ? ((key)->length16 + 2) : ((key)->length8 + 1) )++u_int32_t KeyLength(const BTreeControlBlock *btcb, const BTreeKey *key);+#define KeyLength(btcb, key) ( ((btcb)->attributes & kBTBigKeysMask) ? (key)->length16 : (key)->length8 )++++typedef enum {+ kBTHeaderDirty = 0x00000001+} BTreeFlags;++static inline void M_BTreeHeaderDirty(BTreeControlBlock *bt) {+#if DEBUG+ bt->madeDirtyBy[0] = __builtin_return_address(0);+ bt->madeDirtyBy[1] = __builtin_return_address(1);+#endif+ bt->flags |= kBTHeaderDirty;+}++typedef int8_t *NodeBuffer;+typedef BlockDescriptor NodeRec, *NodePtr; //�� remove this someday...+++++//// Tree Path Table - constructed by SearchTree, used by InsertTree and DeleteTree++typedef struct {+ u_int32_t node; // node number+ u_int16_t index;+ u_int16_t reserved; // align size to a power of 2+} TreePathRecord, *TreePathRecordPtr;++typedef TreePathRecord TreePathTable [kMaxTreeDepth];+++//// InsertKey - used by InsertTree, InsertLevel and InsertNode++struct InsertKey {+ BTreeKeyPtr keyPtr;+ u_int8_t * recPtr;+ u_int16_t keyLength;+ u_int16_t recSize;+ Boolean replacingKey;+ Boolean skipRotate;+};++typedef struct InsertKey InsertKey;+++//// For Notational Convenience++typedef BTNodeDescriptor* NodeDescPtr;+typedef u_int8_t *RecordPtr;+typedef BTreeKeyPtr KeyPtr;+++//////////////////////////////////// Globals ////////////////////////////////////+++//////////////////////////////////// Macros /////////////////////////////////////++#if DEBUG+ #define Panic( message ) DebugStr( message )+ #define PanicIf( condition, message ) do { if ( (condition) != 0 ) DebugStr( message ); } while(0)+#else+ #define Panic( message ) do { } while(0)+ #define PanicIf( condition, message ) do { } while(0)+#endif++// Exit function on error+#define M_ExitOnError( result ) do { if ( ( result ) != noErr ) goto ErrorExit; } while(0)++// Test for passed condition and return if true+#define M_ReturnErrorIf( condition, error ) do { if ( condition ) return( error ); } while(0)++//////////////////////////////// Key Operations /////////////////////////////////++int32_t CompareKeys (BTreeControlBlockPtr btreePtr,+ KeyPtr searchKey,+ KeyPtr trialKey );++//////////////////////////////// Map Operations /////////////////////////////////++OSStatus AllocateNode (BTreeControlBlockPtr btreePtr,+ u_int32_t *nodeNum);++OSStatus FreeNode (BTreeControlBlockPtr btreePtr,+ u_int32_t nodeNum);++OSStatus ExtendBTree (BTreeControlBlockPtr btreePtr,+ u_int32_t nodes );++u_int32_t CalcMapBits (BTreeControlBlockPtr btreePtr);+++void BTUpdateReserve (BTreeControlBlockPtr btreePtr,+ int nodes);++//////////////////////////////// Misc Operations ////////////////////////////////++u_int16_t CalcKeyRecordSize (u_int16_t keySize,+ u_int16_t recSize );++OSStatus VerifyHeader (FCB *filePtr,+ BTHeaderRec *header );++OSStatus UpdateHeader (BTreeControlBlockPtr btreePtr,+ Boolean forceWrite );++OSStatus FindIteratorPosition (BTreeControlBlockPtr btreePtr,+ BTreeIteratorPtr iterator,+ BlockDescriptor *left,+ BlockDescriptor *middle,+ BlockDescriptor *right,+ u_int32_t *nodeNum,+ u_int16_t *index,+ Boolean *foundRecord );++OSStatus CheckInsertParams (FCB *filePtr,+ BTreeIterator *iterator,+ FSBufferDescriptor *record,+ u_int16_t recordLen );++OSStatus TrySimpleReplace (BTreeControlBlockPtr btreePtr,+ NodeDescPtr nodePtr,+ BTreeIterator *iterator,+ FSBufferDescriptor *record,+ u_int16_t recordLen,+ Boolean *recordInserted );++OSStatus IsItAHint (BTreeControlBlockPtr btreePtr,+ BTreeIterator *iterator,+ Boolean *answer );++extern OSStatus TreeIsDirty(BTreeControlBlockPtr btreePtr);++//////////////////////////////// Node Operations ////////////////////////////////++//// Node Operations++OSStatus GetNode (BTreeControlBlockPtr btreePtr,+ u_int32_t nodeNum,+ u_int32_t flags,+ NodeRec *returnNodePtr );++/* Flags for GetNode() */+#define kGetNodeHint 0x1 /* If set, the node is being looked up using a hint */++OSStatus GetLeftSiblingNode (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ NodeRec *left );++#define GetLeftSiblingNode(btree,node,left) GetNode ((btree), ((NodeDescPtr)(node))->bLink, 0, (left))++OSStatus GetRightSiblingNode (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ NodeRec *right );++#define GetRightSiblingNode(btree,node,right) GetNode ((btree), ((NodeDescPtr)(node))->fLink, 0, (right))+++OSStatus GetNewNode (BTreeControlBlockPtr btreePtr,+ u_int32_t nodeNum,+ NodeRec *returnNodePtr );++OSStatus ReleaseNode (BTreeControlBlockPtr btreePtr,+ NodePtr nodePtr );++OSStatus TrashNode (BTreeControlBlockPtr btreePtr,+ NodePtr nodePtr );++OSStatus UpdateNode (BTreeControlBlockPtr btreePtr,+ NodePtr nodePtr,+ u_int32_t transactionID,+ u_int32_t flags );++//// Node Buffer Operations++void ClearNode (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node );++u_int16_t GetNodeDataSize (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node );++u_int16_t GetNodeFreeSize (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node );+++//// Record Operations++Boolean InsertRecord (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ u_int16_t index,+ RecordPtr recPtr,+ u_int16_t recSize );++Boolean InsertKeyRecord (BTreeControlBlockPtr btreePtr,+ NodeDescPtr node,+ u_int16_t index,+ KeyPtr keyPtr,+ u_int16_t keyLength,+ RecordPtr recPtr,+ u_int16_t recSize );++void DeleteRecord (BTreeControlBlockPtr btree,+ NodeDescPtr node,+ u_int16_t index );+++Boolean SearchNode (BTreeControlBlockPtr btree,+ NodeDescPtr node,+ KeyPtr searchKey,+ u_int16_t *index );++OSStatus GetRecordByIndex (BTreeControlBlockPtr btree,+ NodeDescPtr node,+ u_int16_t index,+ KeyPtr *keyPtr,+ u_int8_t * *dataPtr,+ u_int16_t *dataSize );++u_int8_t * GetRecordAddress (BTreeControlBlockPtr btree,+ NodeDescPtr node,+ u_int16_t index );++#define GetRecordAddress(btreePtr,node,index) ((u_int8_t *)(node) + (*(short *) ((u_int8_t *)(node) + (btreePtr)->nodeSize - ((index) << 1) - kOffsetSize)))+++u_int16_t GetRecordSize (BTreeControlBlockPtr btree,+ NodeDescPtr node,+ u_int16_t index );++u_int32_t GetChildNodeNum (BTreeControlBlockPtr btreePtr,+ NodeDescPtr nodePtr,+ u_int16_t index );++void MoveRecordsLeft (u_int8_t * src,+ u_int8_t * dst,+ u_int16_t bytesToMove );++#define MoveRecordsLeft(src,dst,bytes) bcopy((src),(dst),(bytes))++void MoveRecordsRight (u_int8_t * src,+ u_int8_t * dst,+ u_int16_t bytesToMove );++#define MoveRecordsRight(src,dst,bytes) bcopy((src),(dst),(bytes))+++//////////////////////////////// Tree Operations ////////////////////////////////++OSStatus SearchTree (BTreeControlBlockPtr btreePtr,+ BTreeKeyPtr keyPtr,+ TreePathTable treePathTable,+ u_int32_t *nodeNum,+ BlockDescriptor *nodePtr,+ u_int16_t *index );++OSStatus InsertTree (BTreeControlBlockPtr btreePtr,+ TreePathTable treePathTable,+ KeyPtr keyPtr,+ u_int8_t * recPtr,+ u_int16_t recSize,+ BlockDescriptor *targetNode,+ u_int16_t index,+ u_int16_t level,+ Boolean replacingKey,+ u_int32_t *insertNode );++OSStatus DeleteTree (BTreeControlBlockPtr btreePtr,+ TreePathTable treePathTable,+ BlockDescriptor *targetNode,+ u_int16_t index,+ u_int16_t level );++#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */+#endif //__BTREESPRIVATE__diff --git a/xnu/files/bsd/hfs/CatalogPrivate.h b/xnu/files/bsd/hfs/CatalogPrivate.hnew file mode 100644index 0000000..72abbfe--- /dev/null+++ b/xnu/files/bsd/hfs/CatalogPrivate.h@@ -0,0 +1,129 @@+/*+ * Copyright (c) 2000-2005, 2015 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@+ */+/*+ File: CatalogPrivate.h++ Contains: Private Catalog Manager interfaces.++ Version: HFS Plus 1.0++ Copyright: (c) 1997-1998 by Apple Inc., all rights reserved.++ File Ownership:++ DRI: Don Brady++ Other Contact: xxx put other contact here xxx++ Technology: xxx put technology here xxx++ Writers:++ (JL) Jim Luther+ (msd) Mark Day+ (DSH) Deric Horn+ (djb) Don Brady++ Change History (most recent first):+ <MacOSX> 11/10/98 djb Remove obsolete PrepareInputName prototype;+ <MacOSX> 4/6/98 djb Added lock data stuctures and ReleaseCatalogIterator prototype;+ <MacOSX> 4/6/98 djb Removed CatalogDataCache since its no longer used.+ <MacOSX> 4/2/98 djb InvalidateCatalogNodeCache does nothing under MacOS X.+ <MacOSX> 3/31/98 djb Sync up with final HFSVolumes.h header file.++ <CS10> 11/20/97 djb Radar #2002357. Fixing retry mechanism.+ <CS9> 11/17/97 djb PrepareInputName routine now returns an error.+ <CS8> 11/13/97 djb Radar #1683572. Move CatalogIterator to this file from+ FileMgrInternal.i. Double size of short unicode name.+ <CS7> 10/31/97 JL #2000184 - Changed prototypes for CreateFileThreadID and+ ExchangeFiles.+ <CS6> 10/17/97 msd In CatalogCacheGlobals, add room for a single UniStr255 so+ catalog iterators can step over long Unicode names.+ <CS5> 10/17/97 djb Add ConvertInputNameToUnicode for Catalog Create/Rename.+ <CS4> 10/1/97 djb Change catalog iterator implementation.+ <CS3> 7/16/97 DSH FilesInternal.i renamed FileMgrInternal.i to avoid name+ collision+ <CS2> 6/24/97 djb Add LocateCatalogNodeByMangledName routine.+ <CS1> 6/24/97 djb first checked in+*/++#ifndef __CATALOGPRIVATE__+#define __CATALOGPRIVATE__++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE++#include "hfs_format.h"++#include "FileMgrInternal.h"+#include "BTreesInternal.h"++//+// Private Catalog Manager Routines (for use only by Catalog Manager, CatSearch and FileID Services)+//+++extern OSErr LocateCatalogNodeByKey ( const ExtendedVCB *volume, u_int32_t hint, CatalogKey *keyPtr,+ CatalogRecord *dataPtr, u_int32_t *newHint );++extern OSErr LocateCatalogRecord( const ExtendedVCB *volume, HFSCatalogNodeID folderID, const CatalogName *name,+ u_int32_t hint, CatalogKey *keyPtr, CatalogRecord *dataPtr, u_int32_t *newHint);++extern OSErr LocateCatalogNodeWithRetry ( const ExtendedVCB *volume, HFSCatalogNodeID folderID, ConstStr31Param pascalName,+ CatalogName *unicodeName, u_int32_t hint, CatalogKey *keyPtr, CatalogRecord *dataPtr,+ u_int32_t *newHint );+extern OSErr FlushCatalog( ExtendedVCB *volume);+++extern void ConvertInputNameToUnicode(ConstStr31Param name, TextEncoding encodingHint,+ TextEncoding *actualEncoding, CatalogName *catalogName);++extern void BuildCatalogKey( HFSCatalogNodeID parentID, const CatalogName *name, Boolean isHFSPlus,+ CatalogKey *key);++extern OSErr BuildCatalogKeyUTF8(ExtendedVCB *volume, HFSCatalogNodeID parentID, const unsigned char *name,+ u_int32_t length, CatalogKey *key);++extern void CopyCatalogName( const CatalogName *srcName, CatalogName *dstName, Boolean isHFSPLus);++extern OSErr ResolveFileID( ExtendedVCB *vcb, HFSCatalogNodeID fileID, HFSCatalogNodeID *parentID, Str31 name );++#if 0+extern OSErr CreateFileThreadID( FIDParam *filePB, WDCBRecPtr *wdcbPtr );++extern OSErr ExchangeFiles( FIDParam *filePB, WDCBRecPtr *wdcbPtr );+#endif++extern void UpdateCatalogName( ConstStr31Param srcName, Str31 destName );+++#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */+#endif //__CATALOGPRIVATE__diff --git a/xnu/files/bsd/hfs/CatalogUtilities.c b/xnu/files/bsd/hfs/CatalogUtilities.cnew file mode 100644index 0000000..4590323--- /dev/null+++ b/xnu/files/bsd/hfs/CatalogUtilities.c@@ -0,0 +1,296 @@+/*+ * Copyright (c) 2000-2002, 2004-2015 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@+ */+#include <sys/param.h>+#include <sys/utfconv.h>+#include <sys/stat.h>+#include <sys/kernel.h>+#include <sys/malloc.h>+#include <libkern/libkern.h>++#include "FileMgrInternal.h"+#include "BTreesInternal.h"+#include "CatalogPrivate.h"+#include "HFSUnicodeWrappers.h"+#include "BTreesPrivate.h"+#include <string.h>++//+// Routine: LocateCatalogNodeByKey+//+// Function: Locates the catalog record for an existing folder or file+// CNode and returns the key and data records.+//++OSErr+LocateCatalogNodeByKey(const ExtendedVCB *volume, u_int32_t hint, CatalogKey *keyPtr,+ CatalogRecord *dataPtr, u_int32_t *newHint)+{+ OSErr result;+ CatalogName *nodeName = NULL;+ HFSCatalogNodeID threadParentID;+ u_int16_t tempSize;+ FSBufferDescriptor btRecord;+ struct BTreeIterator *searchIterator;+ FCB *fcb;++ searchIterator = hfs_malloc_type(struct BTreeIterator);++ fcb = GetFileControlBlock(volume->catalogRefNum);++ btRecord.bufferAddress = dataPtr;+ btRecord.itemCount = 1;+ btRecord.itemSize = sizeof(CatalogRecord);++ searchIterator->hint.nodeNum = hint;++ bcopy(keyPtr, &searchIterator->key, sizeof(CatalogKey));++ result = BTSearchRecord( fcb, searchIterator, &btRecord, &tempSize, searchIterator );++ if (result == noErr)+ {+ *newHint = searchIterator->hint.nodeNum;++ BlockMoveData(&searchIterator->key, keyPtr, sizeof(CatalogKey));+ }++ if (result == btNotFound) {+ result = cmNotFound;+ }++ if (result) {+ hfs_free_type(searchIterator, struct BTreeIterator);+ return result;+ }++ // if we got a thread record, then go look up real record+ switch ( dataPtr->recordType )+ {+ case kHFSPlusFileThreadRecord:+ case kHFSPlusFolderThreadRecord:+ threadParentID = dataPtr->hfsPlusThread.parentID;+ nodeName = (CatalogName *) &dataPtr->hfsPlusThread.nodeName;+ break;++ default:+ threadParentID = 0;+ break;+ }++ if ( threadParentID ) // found a thread+ result = LocateCatalogRecord(volume, threadParentID, nodeName, kNoHint, keyPtr, dataPtr, newHint);++ hfs_free_type(searchIterator, struct BTreeIterator);+ return result;+}++++//*******************************************************************************+// Routine: LocateCatalogRecord+//+// Function: Locates the catalog record associated with folderID and name+//+//*******************************************************************************++OSErr+LocateCatalogRecord(const ExtendedVCB *volume, HFSCatalogNodeID folderID, const CatalogName *name,+ __unused u_int32_t hint, CatalogKey *keyPtr, CatalogRecord *dataPtr, u_int32_t *newHint)+{+ OSErr result;+ uint16_t tempSize;+ FSBufferDescriptor btRecord;+ struct BTreeIterator *searchIterator = NULL;+ FCB *fcb;+ BTreeControlBlock *btcb;++ searchIterator = hfs_malloc_type(struct BTreeIterator);++ fcb = GetFileControlBlock(volume->catalogRefNum);+ btcb = (BTreeControlBlock *)fcb->fcbBTCBPtr;++ btRecord.bufferAddress = dataPtr;+ btRecord.itemCount = 1;+ btRecord.itemSize = sizeof(CatalogRecord);++ BuildCatalogKey(folderID, name, (volume->vcbSigWord == kHFSPlusSigWord), (CatalogKey *)&searchIterator->key);++ result = BTSearchRecord(fcb, searchIterator, &btRecord, &tempSize, searchIterator);+ if (result == noErr) {+ *newHint = searchIterator->hint.nodeNum;+ BlockMoveData(&searchIterator->key, keyPtr, CalcKeySize(btcb, &searchIterator->key));+ }++ hfs_free_type(searchIterator, struct BTreeIterator);+ return (result == btNotFound ? cmNotFound : result);+}++++/*+ * Routine: BuildCatalogKey+ *+ * Function: Constructs a catalog key record (ckr) given the parent+ * folder ID and CName. Works for both classic and extended+ * HFS volumes.+ *+ */++void+BuildCatalogKey(HFSCatalogNodeID parentID, const CatalogName *cName, Boolean isHFSPlus, CatalogKey *key)+{+ if ( isHFSPlus )+ {+ key->hfsPlus.keyLength = kHFSPlusCatalogKeyMinimumLength; // initial key length (4 + 2)+ key->hfsPlus.parentID = parentID; // set parent ID+ key->hfsPlus.nodeName.length = 0; // null CName length+ if ( cName != NULL )+ {+ CopyCatalogName(cName, (CatalogName *) &key->hfsPlus.nodeName, isHFSPlus);+ key->hfsPlus.keyLength += sizeof(UniChar) * cName->ustr.length; // add CName size to key length+ }+ }++}++OSErr+BuildCatalogKeyUTF8(ExtendedVCB *volume, HFSCatalogNodeID parentID, const unsigned char *name, u_int32_t nameLength,+ CatalogKey *key)+{+ OSErr err = 0;++ if ( name == NULL)+ nameLength = 0;+ else if (nameLength == kUndefinedStrLen)+ nameLength = strlen((const char *)name);++ if ( volume->vcbSigWord == kHFSPlusSigWord ) {+ size_t unicodeBytes = 0;++ key->hfsPlus.keyLength = kHFSPlusCatalogKeyMinimumLength; // initial key length (4 + 2)+ key->hfsPlus.parentID = parentID; // set parent ID+ key->hfsPlus.nodeName.length = 0; // null CName length+ if ( nameLength > 0 ) {+ err = utf8_decodestr(name, nameLength, key->hfsPlus.nodeName.unicode,+ &unicodeBytes, sizeof(key->hfsPlus.nodeName.unicode), ':', UTF_DECOMPOSED);+ key->hfsPlus.nodeName.length = unicodeBytes / sizeof(UniChar);+ key->hfsPlus.keyLength += unicodeBytes;+ }+ }++ if (err) {+ if (err == ENAMETOOLONG)+ err = bdNamErr; /* name is too long */+ else+ err = paramErr; /* name has invalid characters */+ }++ return err;+}+++//*******************************************************************************+// Routine: FlushCatalog+//+// Function: Flushes the catalog for a specified volume.+//+//*******************************************************************************++OSErr+FlushCatalog(ExtendedVCB *volume)+{+ FCB * fcb;+ OSErr result;+ struct hfsmount *hfsmp = VCBTOHFS (volume);++ fcb = GetFileControlBlock(volume->catalogRefNum);+ result = BTFlushPath(fcb);++ if (result == noErr)+ {+ //--- check if catalog's fcb is dirty...++ if ( (0) /*fcb->fcbFlags & fcbModifiedMask*/ )+ {+ hfs_lock_mount (hfsmp);+ MarkVCBDirty(volume); // Mark the VCB dirty+ volume->vcbLsMod = GetTimeUTC(); // update last modified date+ hfs_unlock_mount (hfsmp);++ // result = FlushVolumeControlBlock(volume);+ }+ }++ return result;+}+++//�������������������������������������������������������������������������������+// Routine: UpdateCatalogName+//+// Function: Updates a CName.+//+//�������������������������������������������������������������������������������++void+UpdateCatalogName(ConstStr31Param srcName, Str31 destName)+{+ Size length = srcName[0];++ if (length > CMMaxCName)+ length = CMMaxCName; // truncate to max++ destName[0] = length; // set length byte++ BlockMoveData(&srcName[1], &destName[1], length);+}++//_______________________________________________________________________++void+CopyCatalogName(const CatalogName *srcName, CatalogName *dstName, Boolean isHFSPlus)+{+ u_int32_t length = 0;++ if ( srcName == NULL )+ {+ if ( dstName != NULL )+ dstName->ustr.length = 0; // set length byte to zero (works for both unicode and pascal)+ return;+ }++ if (isHFSPlus) {+ length = sizeof(UniChar) * (srcName->ustr.length + 1);+ }++ if ( length > 1 )+ BlockMoveData(srcName, dstName, length);+ else+ dstName->ustr.length = 0; // set length byte to zero (works for both unicode and pascal)+}+diff --git a/xnu/files/bsd/hfs/FileExtentMapping.c b/xnu/files/bsd/hfs/FileExtentMapping.cnew file mode 100644index 0000000..4401f14--- /dev/null+++ b/xnu/files/bsd/hfs/FileExtentMapping.c@@ -0,0 +1,1980 @@+/*+ * Copyright (c) 2000-2015 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@+ */+++#include "hfs.h"+#include "hfs_format.h"+#include "hfs_endian.h"++#include "FileMgrInternal.h"+#include "BTreesInternal.h"++#include <sys/malloc.h>++/*+============================================================+Public (Exported) Routines:+============================================================++ ExtendFileC Allocate more space to a given file.++ CompareExtentKeys+ Compare two extents file keys (a search key and a trial+ key). Used by the BTree manager when searching for,+ adding, or deleting keys in the extents file of an HFS+ volume.++ CompareExtentKeysPlus+ Compare two extents file keys (a search key and a trial+ key). Used by the BTree manager when searching for,+ adding, or deleting keys in the extents file of an HFS++ volume.++ MapFileBlockC Convert (map) an offset within a given file into a+ physical disk address.++ TruncateFileC Truncates the disk space allocated to a file. The file+ space is truncated to a specified new physical EOF, rounded+ up to the next allocation block boundry. There is an option+ to truncate to the end of the extent containing the new EOF.++ FlushExtentFile+ Flush the extents file for a given volume.++ SearchExtentFile+ Search the FCB and extents file for an extent record that+ contains a given file position (in bytes).+++============================================================+Internal Routines:+============================================================+ FindExtentRecord+ Search the extents BTree for a particular extent record.+ SearchExtentRecord+ Search a given extent record to see if it contains a given+ file position (in bytes). Used by SearchExtentFile.+ ReleaseExtents+ Deallocate all allocation blocks in all extents of an extent+ data record.+ TruncateExtents+ Deallocate blocks and delete extent records for all allocation+ blocks beyond a certain point in a file. The starting point+ must be the first file allocation block for some extent record+ for the file.+ DeallocateFork+ Deallocate all allocation blocks belonging to a given fork.+ UpdateExtentRecord+ If the extent record came from the extents file, write out+ the updated record; otherwise, copy the updated record into+ the FCB resident extent record. If the record has no extents,+ and was in the extents file, then delete the record instead.+*/++enum+{+ kDataForkType = 0,+ kResourceForkType = 0xFF,++ kPreviousRecord = -1+};++static OSErr FindExtentRecord(+ const ExtendedVCB *vcb,+ u_int8_t forkType,+ u_int32_t fileID,+ u_int32_t startBlock,+ Boolean allowPrevious,+ HFSPlusExtentKey *foundKey,+ HFSPlusExtentRecord foundData,+ u_int32_t *foundHint);++static OSErr DeleteExtentRecord(+ const ExtendedVCB *vcb,+ u_int8_t forkType,+ u_int32_t fileID,+ u_int32_t startBlock);++static OSErr CreateExtentRecord(+ ExtendedVCB *vcb,+ HFSPlusExtentKey *key,+ HFSPlusExtentRecord extents,+ u_int32_t *hint);+++static OSErr GetFCBExtentRecord(+ const FCB *fcb,+ HFSPlusExtentRecord extents);++static OSErr SearchExtentRecord(+ ExtendedVCB *vcb,+ u_int32_t searchFABN,+ const HFSPlusExtentRecord extentData,+ u_int32_t extentDataStartFABN,+ u_int32_t *foundExtentDataOffset,+ u_int32_t *endingFABNPlusOne,+ Boolean *noMoreExtents);++static OSErr ReleaseExtents(+ ExtendedVCB *vcb,+ const HFSPlusExtentRecord extentRecord,+ u_int32_t *numReleasedAllocationBlocks,+ Boolean *releasedLastExtent);++static OSErr DeallocateFork(+ ExtendedVCB *vcb,+ HFSCatalogNodeID fileID,+ u_int8_t forkType,+ HFSPlusExtentRecord catalogExtents,+ Boolean * recordDeleted);++static OSErr TruncateExtents(+ ExtendedVCB *vcb,+ u_int8_t forkType,+ u_int32_t fileID,+ u_int32_t startBlock,+ Boolean * recordDeleted);++static OSErr UpdateExtentRecord (+ ExtendedVCB *vcb,+ FCB *fcb,+ int deleted,+ const HFSPlusExtentKey *extentFileKey,+ const HFSPlusExtentRecord extentData,+ u_int32_t extentBTreeHint);++static Boolean ExtentsAreIntegral(+ const HFSPlusExtentRecord extentRecord,+ u_int32_t mask,+ u_int32_t *blocksChecked,+ Boolean *checkedLastExtent);++//_________________________________________________________________________________+//+// Routine: FindExtentRecord+//+// Purpose: Search the extents BTree for an extent record matching the given+// FileID, fork, and starting file allocation block number.+//+// Inputs:+// vcb Volume to search+// forkType 0 = data fork, -1 = resource fork+// fileID File's FileID (CatalogNodeID)+// startBlock Starting file allocation block number+// allowPrevious If the desired record isn't found and this flag is set,+// then see if the previous record belongs to the same fork.+// If so, then return it.+//+// Outputs:+// foundKey The key data for the record actually found+// foundData The extent record actually found (NOTE: on an HFS volume, the+// fourth entry will be zeroes.+// foundHint The BTree hint to find the node again+//_________________________________________________________________________________+static OSErr FindExtentRecord(+ const ExtendedVCB *vcb,+ u_int8_t forkType,+ u_int32_t fileID,+ u_int32_t startBlock,+ Boolean allowPrevious,+ HFSPlusExtentKey *foundKey,+ HFSPlusExtentRecord foundData,+ u_int32_t *foundHint)+{+ FCB * fcb;+ struct BTreeIterator *btIterator = NULL;+ FSBufferDescriptor btRecord;+ OSErr err;+ u_int16_t btRecordSize = 0;++ err = noErr;+ if (foundHint)+ *foundHint = 0;+ fcb = GetFileControlBlock(vcb->extentsRefNum);++ btIterator = hfs_malloc_type(struct BTreeIterator);++ /* HFS Plus / HFSX */+ if (vcb->vcbSigWord != kHFSSigWord) {+ HFSPlusExtentKey * extentKeyPtr;+ HFSPlusExtentRecord extentData;++ extentKeyPtr = (HFSPlusExtentKey*) &btIterator->key;+ extentKeyPtr->keyLength = kHFSPlusExtentKeyMaximumLength;+ extentKeyPtr->forkType = forkType;+ extentKeyPtr->pad = 0;+ extentKeyPtr->fileID = fileID;+ extentKeyPtr->startBlock = startBlock;++ btRecord.bufferAddress = &extentData;+ btRecord.itemSize = sizeof(HFSPlusExtentRecord);+ btRecord.itemCount = 1;++ err = BTSearchRecord(fcb, btIterator, &btRecord, &btRecordSize, btIterator);++ if (err == btNotFound && allowPrevious) {+ err = BTIterateRecord(fcb, kBTreePrevRecord, btIterator, &btRecord, &btRecordSize);++ // A previous record may not exist, so just return btNotFound (like we would if+ // it was for the wrong file/fork).+ if (err == (OSErr) fsBTStartOfIterationErr) //�� fsBTStartOfIterationErr is type unsigned long+ err = btNotFound;++ if (err == noErr) {+ // Found a previous record. Does it belong to the same fork of the same file?+ if (extentKeyPtr->fileID != fileID || extentKeyPtr->forkType != forkType)+ err = btNotFound;+ }+ }++ if (err == noErr) {+ // Copy the found key back for the caller+ if (foundKey)+ BlockMoveData(extentKeyPtr, foundKey, sizeof(HFSPlusExtentKey));+ // Copy the found data back for the caller+ BlockMoveData(&extentData, foundData, sizeof(HFSPlusExtentRecord));+ }+ }++ if (foundHint)+ *foundHint = btIterator->hint.nodeNum;++ hfs_free_type(btIterator, struct BTreeIterator);+ return err;+}++++static OSErr CreateExtentRecord(+ ExtendedVCB *vcb,+ HFSPlusExtentKey *key,+ HFSPlusExtentRecord extents,+ u_int32_t *hint)+{+ struct BTreeIterator *btIterator = NULL;+ FSBufferDescriptor btRecord;+ u_int16_t btRecordSize = 0;+ int lockflags;+ OSErr err;++ err = noErr;+ *hint = 0;++ btIterator = hfs_malloc_type(struct BTreeIterator);++ /*+ * The lock taken by callers of ExtendFileC is speculative and+ * only occurs when the file already has overflow extents. So+ * We need to make sure we have the lock here. The extents+ * btree lock can be nested (its recursive) so we always take+ * it here.+ */+ lockflags = hfs_systemfile_lock(vcb, SFL_EXTENTS, HFS_EXCLUSIVE_LOCK);++ /* HFS+/HFSX */+ if (vcb->vcbSigWord != kHFSSigWord) {+ btRecordSize = sizeof(HFSPlusExtentRecord);+ btRecord.bufferAddress = extents;+ btRecord.itemSize = btRecordSize;+ btRecord.itemCount = 1;++ BlockMoveData(key, &btIterator->key, sizeof(HFSPlusExtentKey));+ }++ if (err == noErr)+ err = BTInsertRecord(GetFileControlBlock(vcb->extentsRefNum), btIterator, &btRecord, btRecordSize);++ if (err == noErr)+ *hint = btIterator->hint.nodeNum;++ (void) BTFlushPath(GetFileControlBlock(vcb->extentsRefNum));++ hfs_systemfile_unlock(vcb, lockflags);++ hfs_free_type(btIterator, struct BTreeIterator);+ return err;+}+++static OSErr DeleteExtentRecord(+ const ExtendedVCB *vcb,+ u_int8_t forkType,+ u_int32_t fileID,+ u_int32_t startBlock)+{+ struct BTreeIterator *btIterator = NULL;+ OSErr err;++ err = noErr;++ btIterator = hfs_malloc_type(struct BTreeIterator);++ /* HFS+ / HFSX */+ if (vcb->vcbSigWord != kHFSSigWord) { // HFS Plus volume+ HFSPlusExtentKey * keyPtr;++ keyPtr = (HFSPlusExtentKey*) &btIterator->key;+ keyPtr->keyLength = kHFSPlusExtentKeyMaximumLength;+ keyPtr->forkType = forkType;+ keyPtr->pad = 0;+ keyPtr->fileID = fileID;+ keyPtr->startBlock = startBlock;+ }++ err = BTDeleteRecord(GetFileControlBlock(vcb->extentsRefNum), btIterator);+ (void) BTFlushPath(GetFileControlBlock(vcb->extentsRefNum));+++ hfs_free_type(btIterator, struct BTreeIterator);+ return err;+}++++//_________________________________________________________________________________+//+// Routine: MapFileBlock+//+// Function: Maps a file position into a physical disk address.+//+//_________________________________________________________________________________++OSErr MapFileBlockC (+ ExtendedVCB *vcb, // volume that file resides on+ FCB *fcb, // FCB of file+ size_t numberOfBytes, // number of contiguous bytes desired+ off_t offset, // starting offset within file (in bytes)+ daddr64_t *startSector, // first sector (NOT an allocation block)+ size_t *availableBytes) // number of contiguous bytes (up to numberOfBytes)+{+ OSErr err;+ u_int32_t allocBlockSize; // Size of the volume's allocation block+ u_int32_t sectorSize;+ HFSPlusExtentKey foundKey;+ HFSPlusExtentRecord foundData;+ u_int32_t foundIndex;+ u_int32_t hint;+ u_int32_t firstFABN = 0; // file allocation block of first block in found extent+ u_int32_t nextFABN; // file allocation block of block after end of found extent+ off_t dataEnd; // (offset) end of range that is contiguous+ u_int32_t sectorsPerBlock; // Number of sectors per allocation block+ u_int32_t startBlock = 0; // volume allocation block corresponding to firstFABN+ daddr64_t temp;+ off_t tmpOff;++ allocBlockSize = vcb->blockSize;+ sectorSize = VCBTOHFS(vcb)->hfs_logical_block_size;++ err = SearchExtentFile(vcb, fcb, offset, &foundKey, foundData, &foundIndex, &hint, &nextFABN);+ if (err == noErr) {+ startBlock = foundData[foundIndex].startBlock;+ firstFABN = nextFABN - foundData[foundIndex].blockCount;+ }++ if (err != noErr)+ {+ return err;+ }++ //+ // Determine the end of the available space. It will either be the end of the extent,+ // or the file's PEOF, whichever is smaller.+ //+ dataEnd = (off_t)((off_t)(nextFABN) * (off_t)(allocBlockSize)); // Assume valid data through end of this extent+ if (((off_t)fcb->ff_blocks * (off_t)allocBlockSize) < dataEnd) // Is PEOF shorter?+ dataEnd = (off_t)fcb->ff_blocks * (off_t)allocBlockSize; // Yes, so only map up to PEOF++ // Compute the number of sectors in an allocation block+ sectorsPerBlock = allocBlockSize / sectorSize; // sectors per allocation block++ //+ // Compute the absolute sector number that contains the offset of the given file+ // offset in sectors from start of the extent ++ // offset in sectors from start of allocation block space+ //+ temp = (daddr64_t)((offset - (off_t)((off_t)(firstFABN) * (off_t)(allocBlockSize)))/sectorSize);+ temp += (daddr64_t)startBlock * (daddr64_t)sectorsPerBlock;++ /* Add in any volume offsets */+ if (vcb->vcbSigWord == kHFSPlusSigWord)+ temp += vcb->hfsPlusIOPosOffset / sectorSize;+ else+ temp += vcb->vcbAlBlSt;++ // Return the desired sector for file position "offset"+ *startSector = temp;++ //+ // Determine the number of contiguous bytes until the end of the extent+ // (or the amount they asked for, whichever comes first).+ //+ if (availableBytes)+ {+ tmpOff = dataEnd - offset;+ /*+ * Disallow negative runs.+ */+ if (tmpOff <= 0) {+ /* This shouldn't happen unless something is corrupt */+ hfs_corruption_debug("MapFileBlockC: tmpOff <= 0 (%lld)\n", tmpOff);+ return EINVAL;+ }++ if (tmpOff > (off_t)(numberOfBytes)) {+ *availableBytes = numberOfBytes; // more there than they asked for, so pin the output+ }+ else {+ *availableBytes = tmpOff;+ }+ }++ return noErr;+}+++//�������������������������������������������������������������������������������+// Routine: ReleaseExtents+//+// Function: Release the extents of a single extent data record.+//�������������������������������������������������������������������������������++static OSErr ReleaseExtents(+ ExtendedVCB *vcb,+ const HFSPlusExtentRecord extentRecord,+ u_int32_t *numReleasedAllocationBlocks,+ Boolean *releasedLastExtent)+{+ u_int32_t extentIndex;+ u_int32_t numberOfExtents;+ OSErr err = noErr;++ *numReleasedAllocationBlocks = 0;+ *releasedLastExtent = false;++ if (vcb->vcbSigWord == kHFSPlusSigWord)+ numberOfExtents = kHFSPlusExtentDensity;+ else+ numberOfExtents = kHFSExtentDensity;++ for( extentIndex = 0; extentIndex < numberOfExtents; extentIndex++)+ {+ u_int32_t numAllocationBlocks;++ // Loop over the extent record and release the blocks associated with each extent.++ numAllocationBlocks = extentRecord[extentIndex].blockCount;+ if ( numAllocationBlocks == 0 )+ {+ *releasedLastExtent = true;+ break;+ }++ err = BlockDeallocate( vcb, extentRecord[extentIndex].startBlock, numAllocationBlocks , 0);+ if ( err != noErr )+ break;++ *numReleasedAllocationBlocks += numAllocationBlocks; // bump FABN to beg of next extent+ }++ return( err );+}++++//�������������������������������������������������������������������������������+// Routine: TruncateExtents+//+// Purpose: Delete extent records whose starting file allocation block number+// is greater than or equal to a given starting block number. The+// allocation blocks represented by the extents are deallocated.+//+// Inputs:+// vcb Volume to operate on+// fileID Which file to operate on+// startBlock Starting file allocation block number for first extent+// record to delete.+//�������������������������������������������������������������������������������++static OSErr TruncateExtents(+ ExtendedVCB *vcb,+ u_int8_t forkType,+ u_int32_t fileID,+ u_int32_t startBlock,+ Boolean * recordDeleted)+{+ OSErr err;+ u_int32_t numberExtentsReleased;+ Boolean releasedLastExtent;+ u_int32_t hint;+ HFSPlusExtentKey key;+ HFSPlusExtentRecord extents;+ int lockflags;++ /*+ * The lock taken by callers of TruncateFileC is speculative and+ * only occurs when the file already has overflow extents. So+ * We need to make sure we have the lock here. The extents+ * btree lock can be nested (its recursive) so we always take+ * it here.+ */+ lockflags = hfs_systemfile_lock(vcb, SFL_EXTENTS, HFS_EXCLUSIVE_LOCK);++ while (true) {+ err = FindExtentRecord(vcb, forkType, fileID, startBlock, false, &key, extents, &hint);+ if (err != noErr) {+ if (err == btNotFound)+ err = noErr;+ break;+ }++ err = ReleaseExtents( vcb, extents, &numberExtentsReleased, &releasedLastExtent );+ if (err != noErr) break;++ err = DeleteExtentRecord(vcb, forkType, fileID, startBlock);+ if (err != noErr) break;++ *recordDeleted = true;+ startBlock += numberExtentsReleased;+ }+ hfs_systemfile_unlock(vcb, lockflags);++ return err;+}++++//�������������������������������������������������������������������������������+// Routine: DeallocateFork+//+// Function: De-allocates all disk space allocated to a specified fork.+//�������������������������������������������������������������������������������++static OSErr DeallocateFork(+ ExtendedVCB *vcb,+ HFSCatalogNodeID fileID,+ u_int8_t forkType,+ HFSPlusExtentRecord catalogExtents,+ Boolean * recordDeleted) /* true if a record was deleted */+{+ OSErr err;+ u_int32_t numReleasedAllocationBlocks;+ Boolean releasedLastExtent;++ // Release the catalog extents+ err = ReleaseExtents( vcb, catalogExtents, &numReleasedAllocationBlocks, &releasedLastExtent );+ // Release the extra extents, if present+ if (err == noErr && !releasedLastExtent)+ err = TruncateExtents(vcb, forkType, fileID, numReleasedAllocationBlocks, recordDeleted);++ return( err );+}++//�������������������������������������������������������������������������������+// Routine: FlushExtentFile+//+// Function: Flushes the extent file for a specified volume+//�������������������������������������������������������������������������������++OSErr FlushExtentFile( ExtendedVCB *vcb )+{+ FCB * fcb;+ OSErr err;+ int lockflags;++ fcb = GetFileControlBlock(vcb->extentsRefNum);++ lockflags = hfs_systemfile_lock(vcb, SFL_EXTENTS, HFS_EXCLUSIVE_LOCK);+ err = BTFlushPath(fcb);+ hfs_systemfile_unlock(vcb, lockflags);++ if ( err == noErr )+ {+ // If the FCB for the extent "file" is dirty, mark the VCB as dirty.++ if (FTOC(fcb)->c_flag & C_MODIFIED)+ {+ MarkVCBDirty( vcb );+ // err = FlushVolumeControlBlock( vcb );+ }+ }++ return( err );+}+++//�������������������������������������������������������������������������������+// Routine: CompareExtentKeysPlus+//+// Function: Compares two extent file keys (a search key and a trial key) for+// an HFS volume.+//�������������������������������������������������������������������������������++int32_t CompareExtentKeysPlus( const HFSPlusExtentKey *searchKey, const HFSPlusExtentKey *trialKey )+{+ int32_t result; // � 1++ #if DEBUG+ if (searchKey->keyLength != kHFSPlusExtentKeyMaximumLength)+ DebugStr("HFS: search Key is wrong length");+ if (trialKey->keyLength != kHFSPlusExtentKeyMaximumLength)+ DebugStr("HFS: trial Key is wrong length");+ #endif++ result = -1; // assume searchKey < trialKey++ if (searchKey->fileID == trialKey->fileID) {+ //+ // FileNum's are equal; compare fork types+ //+ if (searchKey->forkType == trialKey->forkType) {+ //+ // Fork types are equal; compare allocation block number+ //+ if (searchKey->startBlock == trialKey->startBlock) {+ //+ // Everything is equal+ //+ result = 0;+ }+ else {+ //+ // Allocation block numbers differ; determine sign+ //+ if (searchKey->startBlock > trialKey->startBlock)+ result = 1;+ }+ }+ else {+ //+ // Fork types differ; determine sign+ //+ if (searchKey->forkType > trialKey->forkType)+ result = 1;+ }+ }+ else {+ //+ // FileNums differ; determine sign+ //+ if (searchKey->fileID > trialKey->fileID)+ result = 1;+ }++ return( result );+}++static int+should_pin_blocks(hfsmount_t *hfsmp, FCB *fcb)+{+ if (!ISSET(hfsmp->hfs_flags, HFS_CS_HOTFILE_PIN)+ || fcb->ff_cp == NULL || fcb->ff_cp->c_vp == NULL) {+ return 0;+ }++ int pin_blocks;++ //+ // File system metadata should get pinned+ //+ if (vnode_issystem(fcb->ff_cp->c_vp)) {+ return 1;+ }++ //+ // If a file is AutoCandidate, we should not pin its blocks because+ // it was an automatically added file and this function is intended+ // to pin new blocks being added to user-generated content.+ //+ if (fcb->ff_cp->c_attr.ca_recflags & kHFSAutoCandidateMask) {+ return 0;+ }++ //+ // If a file is marked FastDevPinned it is an existing pinned file+ // or a new file that should be pinned.+ //+ // If a file is marked FastDevCandidate it is a new file that is+ // being written to for the first time so we don't want to pin it+ // just yet as it may not meet the criteria (i.e. too large).+ //+ if ((fcb->ff_cp->c_attr.ca_recflags & (kHFSFastDevPinnedMask)) != 0) {+ pin_blocks = 1;+ } else {+ pin_blocks = 0;+ }++ return pin_blocks;+}++++static void+pin_blocks_if_needed(ExtendedVCB *vcb, FCB *fcb, u_int32_t startBlock, u_int32_t blockCount)+{+ if (!should_pin_blocks(vcb, fcb)) {+ return;+ }++ // ask CoreStorage to pin the new blocks being added to this file+ if (hfs_pin_block_range((struct hfsmount *)vcb, HFS_PIN_IT, startBlock, blockCount) == 0) {+ struct vnode *vp = fcb->ff_cp->c_vp;++ // and make sure to keep our accounting in order+ hfs_hotfile_adjust_blocks(vp, -blockCount);+ }+}++++/*+ * Add a file extent to a file.+ *+ * Used by hfs_extendfs to extend the volume allocation bitmap file.+ *+ */+int+AddFileExtent(ExtendedVCB *vcb, FCB *fcb, u_int32_t startBlock, u_int32_t blockCount)+{+ HFSPlusExtentKey foundKey;+ HFSPlusExtentRecord foundData;+ u_int32_t foundIndex;+ u_int32_t hint;+ u_int32_t nextBlock;+ int64_t peof;+ int i;+ int error;++ peof = (int64_t)(fcb->ff_blocks + blockCount) * (int64_t)vcb->blockSize;++ error = SearchExtentFile(vcb, fcb, peof-1, &foundKey, foundData, &foundIndex, &hint, &nextBlock);+ if (error != fxRangeErr)+ return (EBUSY);++ /*+ * Add new extent. See if there is room in the current record.+ */+ if (foundData[foundIndex].blockCount != 0)+ ++foundIndex;+ if (foundIndex == kHFSPlusExtentDensity) {+ /*+ * Existing record is full so create a new one.+ */+ foundKey.keyLength = kHFSPlusExtentKeyMaximumLength;+ foundKey.forkType = kDataForkType;+ foundKey.pad = 0;+ foundKey.fileID = FTOC(fcb)->c_fileid;+ foundKey.startBlock = nextBlock;++ foundData[0].startBlock = startBlock;+ foundData[0].blockCount = blockCount;++ /* zero out remaining extents. */+ for (i = 1; i < kHFSPlusExtentDensity; ++i) {+ foundData[i].startBlock = 0;+ foundData[i].blockCount = 0;+ }++ foundIndex = 0;++ error = CreateExtentRecord(vcb, &foundKey, foundData, &hint);+ if (error == fxOvFlErr) {+ error = dskFulErr;+ } else if (error == 0) {+ pin_blocks_if_needed(vcb, fcb, startBlock, blockCount);+ }++ } else {+ /*+ * Add a new extent into existing record.+ */+ foundData[foundIndex].startBlock = startBlock;+ foundData[foundIndex].blockCount = blockCount;+ error = UpdateExtentRecord(vcb, fcb, 0, &foundKey, foundData, hint);+ if (error == 0) {+ pin_blocks_if_needed(vcb, fcb, startBlock, blockCount);+ }+ }+ (void) FlushExtentFile(vcb);++ return (error);+}+++//_________________________________________________________________________________+//+// Routine: Extendfile+//+// Function: Extends the disk space allocated to a file.+//+//_________________________________________________________________________________++OSErr ExtendFileC (+ ExtendedVCB *vcb, // volume that file resides on+ FCB *fcb, // FCB of file to truncate+ int64_t bytesToAdd, // number of bytes to allocate+ u_int32_t blockHint, // desired starting allocation block+ u_int32_t flags, // EFContig and/or EFAll+ int64_t *actualBytesAdded) // number of bytes actually allocated+{+ OSErr err;+ u_int32_t volumeBlockSize;+ int64_t blocksToAdd;+ int64_t bytesThisExtent;+ HFSPlusExtentKey foundKey;+ HFSPlusExtentRecord foundData;+ u_int32_t foundIndex;+ u_int32_t hint;+ u_int32_t nextBlock;+ u_int32_t startBlock;+ Boolean allOrNothing;+ Boolean forceContig;+ Boolean wantContig;+ Boolean useMetaZone;+ Boolean needsFlush;+ int allowFlushTxns;+ u_int32_t actualStartBlock;+ u_int32_t actualNumBlocks;+ u_int32_t numExtentsPerRecord = 0;+ int64_t maximumBytes;+ int64_t availbytes;+ int64_t peof;+ u_int32_t prevblocks;+ uint32_t fastdev = 0;++ struct hfsmount *hfsmp = (struct hfsmount*)vcb;+ allowFlushTxns = 0;+ needsFlush = false;+ *actualBytesAdded = 0;+ volumeBlockSize = vcb->blockSize;+ allOrNothing = ((flags & kEFAllMask) != 0);+ forceContig = ((flags & kEFContigMask) != 0);+ prevblocks = fcb->ff_blocks;++ if (vcb->vcbSigWord != kHFSSigWord) {+ numExtentsPerRecord = kHFSPlusExtentDensity;+ }++ //+ // Determine how many blocks need to be allocated.+ // Round up the number of desired bytes to add.+ //+ blocksToAdd = howmany(bytesToAdd, volumeBlockSize);+ bytesToAdd = (int64_t)((int64_t)blocksToAdd * (int64_t)volumeBlockSize);++ /*+ * For deferred allocations just reserve the blocks.+ */+ if ((flags & kEFDeferMask)+ && (vcb->vcbSigWord == kHFSPlusSigWord)+ && (bytesToAdd < (int64_t)HFS_MAX_DEFERED_ALLOC)+ && (blocksToAdd < hfs_freeblks(VCBTOHFS(vcb), 1))) {+ hfs_lock_mount (hfsmp);+ vcb->loanedBlocks += blocksToAdd;+ hfs_unlock_mount(hfsmp);++ fcb->ff_unallocblocks += blocksToAdd;+ FTOC(fcb)->c_blocks += blocksToAdd;+ fcb->ff_blocks += blocksToAdd;++ /*+ * We haven't touched the disk here; no blocks have been+ * allocated and the volume will not be inconsistent if we+ * don't update the catalog record immediately.+ */+ FTOC(fcb)->c_flag |= C_MINOR_MOD;+ *actualBytesAdded = bytesToAdd;+ return (0);+ }+ /*+ * Give back any unallocated blocks before doing real allocations.+ */+ if (fcb->ff_unallocblocks > 0) {+ u_int32_t loanedBlocks;++ loanedBlocks = fcb->ff_unallocblocks;+ blocksToAdd += loanedBlocks;+ bytesToAdd = (int64_t)blocksToAdd * (int64_t)volumeBlockSize;+ FTOC(fcb)->c_blocks -= loanedBlocks;+ fcb->ff_blocks -= loanedBlocks;+ fcb->ff_unallocblocks = 0;++ hfs_lock_mount(hfsmp);+ vcb->loanedBlocks -= loanedBlocks;+ hfs_unlock_mount(hfsmp);+ }++ //+ // If the file's clump size is larger than the allocation block size,+ // then set the maximum number of bytes to the requested number of bytes+ // rounded up to a multiple of the clump size.+ //+ if ((vcb->vcbClpSiz > (int32_t)volumeBlockSize)+ && (bytesToAdd < (int64_t)HFS_MAX_DEFERED_ALLOC)+ && (flags & kEFNoClumpMask) == 0) {+ maximumBytes = (int64_t)howmany(bytesToAdd, vcb->vcbClpSiz);+ maximumBytes *= vcb->vcbClpSiz;+ } else {+ maximumBytes = bytesToAdd;+ }+++ //+ // If allocation is all-or-nothing, make sure there are+ // enough free blocks on the volume (quick test).+ //+ if (allOrNothing &&+ (blocksToAdd > hfs_freeblks(VCBTOHFS(vcb), flags & kEFReserveMask))) {+ err = dskFulErr;+ goto ErrorExit;+ }++ //+ // See if there are already enough blocks allocated to the file.+ //+ peof = ((int64_t)fcb->ff_blocks * (int64_t)volumeBlockSize) + bytesToAdd; // potential new PEOF+ err = SearchExtentFile(vcb, fcb, peof-1, &foundKey, foundData, &foundIndex, &hint, &nextBlock);+ if (err == noErr) {+ // Enough blocks are already allocated. Just update the FCB to reflect the new length.+ fcb->ff_blocks = peof / volumeBlockSize;+ FTOC(fcb)->c_blocks += (bytesToAdd / volumeBlockSize);+ FTOC(fcb)->c_flag |= C_MODIFIED;+ goto Exit;+ }+ if (err != fxRangeErr) // Any real error?+ goto ErrorExit; // Yes, so exit immediately++ //+ // Adjust the PEOF to the end of the last extent.+ //+ peof = (int64_t)((int64_t)nextBlock * (int64_t)volumeBlockSize); // currently allocated PEOF+ bytesThisExtent = (int64_t)(nextBlock - fcb->ff_blocks) * (int64_t)volumeBlockSize;+ if (bytesThisExtent != 0) {+ fcb->ff_blocks = nextBlock;+ FTOC(fcb)->c_blocks += (bytesThisExtent / volumeBlockSize);+ FTOC(fcb)->c_flag |= C_MODIFIED;+ bytesToAdd -= bytesThisExtent;+ }++ //+ // Allocate some more space.+ //+ // First try a contiguous allocation (of the whole amount).+ // If that fails, get whatever we can.+ // If forceContig, then take whatever we got+ // else, keep getting bits and pieces (non-contig)++ /*+ * Note that for sparse devices (like sparse bundle dmgs), we+ * should only be aggressive with re-using once-allocated pieces+ * if we're not dealing with system files. If we're trying to operate+ * on behalf of a system file, we need the maximum contiguous amount+ * possible. For non-system files we favor locality and fragmentation over+ * contiguity as it can result in fewer blocks being needed from the underlying+ * filesystem that the sparse image resides upon.+ */+ err = noErr;+ if ( (vcb->hfs_flags & HFS_HAS_SPARSE_DEVICE)+ && (fcb->ff_cp->c_fileid >= kHFSFirstUserCatalogNodeID)+ && (flags & kEFMetadataMask) == 0) {+ /*+ * We want locality over contiguity so by default we set wantContig to+ * false unless we hit one of the circumstances below.+ */+ wantContig = false;+ if (hfs_isrbtree_active(VCBTOHFS(vcb))) {+ /*+ * If the red-black tree is acive, we can always find a suitable contiguous+ * chunk. So if the user specifically requests contiguous files, we should+ * honor that no matter what kind of device it is.+ */+ if (forceContig) {+ wantContig = true;+ }+ }+ else {+ /*+ * If the red-black tree is not active, then only set wantContig to true+ * if we have never done a contig scan on the device, which would populate+ * the free extent cache. Note that the caller may explicitly unset the+ * DID_CONTIG_SCAN bit in order to force us to vend a contiguous extent here+ * if the caller wants to get a contiguous chunk.+ */+ if ((vcb->hfs_flags & HFS_DID_CONTIG_SCAN) == 0) {+ vcb->hfs_flags |= HFS_DID_CONTIG_SCAN;+ wantContig = true;+ }+ }+ }+ else {+ wantContig = true;+ }++ if (should_pin_blocks(hfsmp, fcb))+ fastdev = HFS_ALLOC_FAST_DEV;++ useMetaZone = flags & kEFMetadataMask;+ do {+ if (blockHint != 0)+ startBlock = blockHint;+ else+ startBlock = foundData[foundIndex].startBlock + foundData[foundIndex].blockCount;++ actualNumBlocks = 0;+ actualStartBlock = 0;++ /* Find number of free blocks based on reserved block flag option */+ availbytes = (int64_t)hfs_freeblks(VCBTOHFS(vcb), flags & kEFReserveMask) *+ (int64_t)volumeBlockSize;+ if (availbytes <= 0) {+ err = dskFulErr;+ } else {+ if (wantContig && (availbytes < bytesToAdd)) {+ err = dskFulErr;+ }+ else {+ uint32_t ba_flags = fastdev;++ if (wantContig) {+ ba_flags |= HFS_ALLOC_FORCECONTIG;+ }+ if (useMetaZone) {+ ba_flags |= HFS_ALLOC_METAZONE;+ }+ if (allowFlushTxns) {+ ba_flags |= HFS_ALLOC_FLUSHTXN;+ }++ err = BlockAllocate(+ vcb,+ startBlock,+ howmany(MIN(bytesToAdd, availbytes), volumeBlockSize),+ howmany(MIN(maximumBytes, availbytes), volumeBlockSize),+ ba_flags,+ &actualStartBlock,+ &actualNumBlocks);+ }+ }+ if (err == dskFulErr) {+ if (forceContig) {+ if (allowFlushTxns == 0) {+ /* If we're forcing contiguity, re-try but allow plucking from recently freed regions */+ allowFlushTxns = 1;+ wantContig = 1;+ err = noErr;+ continue;+ }+ else {+ break; // AllocContig failed because not enough contiguous space+ }+ }+ if (wantContig) {+ // Couldn't get one big chunk, so get whatever we can.+ err = noErr;+ wantContig = false;+ continue;+ }+ if (actualNumBlocks != 0)+ err = noErr;++ if (useMetaZone == 0) {+ /* Couldn't get anything so dip into metadat zone */+ err = noErr;+ useMetaZone = 1;+ continue;+ }++ /* If we couldn't find what we needed without flushing the journal, then go ahead and do it now */+ if (allowFlushTxns == 0) {+ allowFlushTxns = 1;+ err = noErr;+ continue;+ }++ }+ if (err == noErr) {+ // Add the new extent to the existing extent record, or create a new one.+ if ((actualStartBlock == startBlock) && (blockHint == 0)) {+ // We grew the file's last extent, so just adjust the number of blocks.+ foundData[foundIndex].blockCount += actualNumBlocks;+ err = UpdateExtentRecord(vcb, fcb, 0, &foundKey, foundData, hint);+ if (err != noErr) break;+ }+ else {+ u_int16_t i;++ // Need to add a new extent. See if there is room in the current record.+ if (foundData[foundIndex].blockCount != 0) // Is current extent free to use?+ ++foundIndex; // No, so use the next one.+ if (foundIndex == numExtentsPerRecord) {+ // This record is full. Need to create a new one.+ if (FTOC(fcb)->c_fileid == kHFSExtentsFileID) {+ (void) BlockDeallocate(vcb, actualStartBlock, actualNumBlocks, 0);+ err = dskFulErr; // Oops. Can't extend extents file past first record.+ break;+ }++ foundKey.keyLength = kHFSPlusExtentKeyMaximumLength;+ if (FORK_IS_RSRC(fcb))+ foundKey.forkType = kResourceForkType;+ else+ foundKey.forkType = kDataForkType;+ foundKey.pad = 0;+ foundKey.fileID = FTOC(fcb)->c_fileid;+ foundKey.startBlock = nextBlock;++ foundData[0].startBlock = actualStartBlock;+ foundData[0].blockCount = actualNumBlocks;++ // zero out remaining extents...+ for (i = 1; i < kHFSPlusExtentDensity; ++i)+ {+ foundData[i].startBlock = 0;+ foundData[i].blockCount = 0;+ }++ foundIndex = 0;++ err = CreateExtentRecord(vcb, &foundKey, foundData, &hint);+ if (err == fxOvFlErr) {+ // We couldn't create an extent record because extents B-tree+ // couldn't grow. Dellocate the extent just allocated and+ // return a disk full error.+ (void) BlockDeallocate(vcb, actualStartBlock, actualNumBlocks, 0);+ err = dskFulErr;+ }+ if (err != noErr) break;++ needsFlush = true; // We need to update the B-tree header+ }+ else {+ // Add a new extent into this record and update.+ foundData[foundIndex].startBlock = actualStartBlock;+ foundData[foundIndex].blockCount = actualNumBlocks;+ err = UpdateExtentRecord(vcb, fcb, 0, &foundKey, foundData, hint);+ if (err != noErr) break;+ }+ }++ // Figure out how many bytes were actually allocated.+ // NOTE: BlockAllocate could have allocated more than we asked for.+ // Don't set the PEOF beyond what our client asked for.+ nextBlock += actualNumBlocks;+ bytesThisExtent = (int64_t)((int64_t)actualNumBlocks * (int64_t)volumeBlockSize);+ if (bytesThisExtent > bytesToAdd) {+ bytesToAdd = 0;+ }+ else {+ bytesToAdd -= bytesThisExtent;+ maximumBytes -= bytesThisExtent;+ }+ fcb->ff_blocks += (bytesThisExtent / volumeBlockSize);+ FTOC(fcb)->c_blocks += (bytesThisExtent / volumeBlockSize);+ FTOC(fcb)->c_flag |= C_MODIFIED;++ // If contiguous allocation was requested, then we've already got one contiguous+ // chunk. If we didn't get all we wanted, then adjust the error to disk full.+ if (forceContig) {+ if (bytesToAdd != 0)+ err = dskFulErr;+ break; // We've already got everything that's contiguous+ }+ }+ } while (err == noErr && bytesToAdd);++ErrorExit:+Exit:+ if (VCBTOHFS(vcb)->hfs_flags & HFS_METADATA_ZONE) {+ /* Keep the roving allocator out of the metadata zone. */+ if (vcb->nextAllocation >= VCBTOHFS(vcb)->hfs_metazone_start &&+ vcb->nextAllocation <= VCBTOHFS(vcb)->hfs_metazone_end) {+ hfs_lock_mount (hfsmp);+ HFS_UPDATE_NEXT_ALLOCATION(vcb, VCBTOHFS(vcb)->hfs_metazone_end + 1);+ MarkVCBDirty(vcb);+ hfs_unlock_mount(hfsmp);+ }+ }+ if (prevblocks < fcb->ff_blocks) {+ *actualBytesAdded = (int64_t)(fcb->ff_blocks - prevblocks) * (int64_t)volumeBlockSize;+ } else {+ *actualBytesAdded = 0;+ }++ if (fastdev) {+ hfs_hotfile_adjust_blocks(fcb->ff_cp->c_vp,+ (int64_t)prevblocks - fcb->ff_blocks);+ }++ if (needsFlush)+ (void) FlushExtentFile(vcb);++ return err;+}++++//_________________________________________________________________________________+//+// Routine: TruncateFileC+//+// Function: Truncates the disk space allocated to a file. The file space is+// truncated to a specified new PEOF rounded up to the next allocation+// block boundry. If the 'TFTrunExt' option is specified, the file is+// truncated to the end of the extent containing the new PEOF.+//+//_________________________________________________________________________________++OSErr TruncateFileC (+ ExtendedVCB *vcb, // volume that file resides on+ FCB *fcb, // FCB of file to truncate+ int64_t peof, // new physical size for file+ int deleted, // if nonzero, the file's catalog record has already been deleted.+ int rsrc, // does this represent a resource fork or not?+ uint32_t fileid, // the fileid of the file we're manipulating.+ Boolean truncateToExtent) // if true, truncate to end of extent containing newPEOF++{+ OSErr err;+ u_int32_t nextBlock; // next file allocation block to consider+ u_int32_t startBlock; // Physical (volume) allocation block number of start of a range+ u_int32_t physNumBlocks; // Number of allocation blocks in file (according to PEOF)+ u_int32_t numBlocks;+ HFSPlusExtentKey key; // key for current extent record; key->keyLength == 0 if FCB's extent record+ u_int32_t hint; // BTree hint corresponding to key+ HFSPlusExtentRecord extentRecord;+ u_int32_t extentIndex;+ u_int32_t extentNextBlock;+ u_int32_t numExtentsPerRecord;+ int64_t temp64;+ u_int8_t forkType;+ Boolean extentChanged; // true if we actually changed an extent+ Boolean recordDeleted; // true if an extent record got deleted++ recordDeleted = false;++ if (vcb->vcbSigWord == kHFSPlusSigWord) {+ numExtentsPerRecord = kHFSPlusExtentDensity;+ }+ else {+ numExtentsPerRecord = kHFSExtentDensity;+ }++ if (rsrc) {+ forkType = kResourceForkType;+ }+ else {+ forkType = kDataForkType;+ }++ temp64 = fcb->ff_blocks;+ physNumBlocks = (u_int32_t)temp64;++ //+ // Round newPEOF up to a multiple of the allocation block size. If new size is+ // two gigabytes or more, then round down by one allocation block (??? really?+ // shouldn't that be an error?).+ //+ nextBlock = howmany(peof, vcb->blockSize); // number of allocation blocks to remain in file+ peof = (int64_t)((int64_t)nextBlock * (int64_t)vcb->blockSize); // number of bytes in those blocks++ //+ // Update FCB's length+ //+ /*+ * XXX Any errors could cause ff_blocks and c_blocks to get out of sync...+ */+ numBlocks = peof / vcb->blockSize;+ if (!deleted) {+ FTOC(fcb)->c_blocks -= (fcb->ff_blocks - numBlocks);+ }+ fcb->ff_blocks = numBlocks;++ // this catalog entry is modified and *must* get forced+ // to disk when hfs_update() is called+ if (!deleted) {+ /*+ * If the file is already C_NOEXISTS, then the catalog record+ * has been removed from disk already. We wouldn't need to force+ * another update+ */+ FTOC(fcb)->c_flag |= C_MODIFIED;+ }+ //+ // If the new PEOF is 0, then truncateToExtent has no meaning (we should always deallocate+ // all storage).+ //+ if (peof == 0) {+ int i;++ // Deallocate all the extents for this fork+ err = DeallocateFork(vcb, fileid, forkType, fcb->fcbExtents, &recordDeleted);+ if (err != noErr) goto ErrorExit; // got some error, so return it++ // Update the catalog extent record (making sure it's zeroed out)+ if (err == noErr) {+ for (i=0; i < kHFSPlusExtentDensity; i++) {+ fcb->fcbExtents[i].startBlock = 0;+ fcb->fcbExtents[i].blockCount = 0;+ }+ }+ goto Done;+ }++ //+ // Find the extent containing byte (peof-1). This is the last extent we'll keep.+ // (If truncateToExtent is true, we'll keep the whole extent; otherwise, we'll only+ // keep up through peof). The search will tell us how many allocation blocks exist+ // in the found extent plus all previous extents.+ //+ err = SearchExtentFile(vcb, fcb, peof-1, &key, extentRecord, &extentIndex, &hint, &extentNextBlock);+ if (err != noErr) goto ErrorExit;++ extentChanged = false; // haven't changed the extent yet++ if (!truncateToExtent) {+ //+ // Shorten this extent. It may be the case that the entire extent gets+ // freed here.+ //+ numBlocks = extentNextBlock - nextBlock; // How many blocks in this extent to free up+ if (numBlocks != 0) {+ // Compute first volume allocation block to free+ startBlock = extentRecord[extentIndex].startBlock + extentRecord[extentIndex].blockCount - numBlocks;+ // Free the blocks in bitmap+ err = BlockDeallocate(vcb, startBlock, numBlocks, 0);+ if (err != noErr) goto ErrorExit;+ // Adjust length of this extent+ extentRecord[extentIndex].blockCount -= numBlocks;+ // If extent is empty, set start block to 0+ if (extentRecord[extentIndex].blockCount == 0)+ extentRecord[extentIndex].startBlock = 0;+ // Remember that we changed the extent record+ extentChanged = true;+ }+ }++ //+ // Now move to the next extent in the record, and set up the file allocation block number+ //+ nextBlock = extentNextBlock; // Next file allocation block to free+ ++extentIndex; // Its index within the extent record++ //+ // Release all following extents in this extent record. Update the record.+ //+ while (extentIndex < numExtentsPerRecord && extentRecord[extentIndex].blockCount != 0) {+ numBlocks = extentRecord[extentIndex].blockCount;+ // Deallocate this extent+ err = BlockDeallocate(vcb, extentRecord[extentIndex].startBlock, numBlocks, 0);+ if (err != noErr) goto ErrorExit;+ // Update next file allocation block number+ nextBlock += numBlocks;+ // Zero out start and length of this extent to delete it from record+ extentRecord[extentIndex].startBlock = 0;+ extentRecord[extentIndex].blockCount = 0;+ // Remember that we changed an extent+ extentChanged = true;+ // Move to next extent in record+ ++extentIndex;+ }++ //+ // If any of the extents in the current record were changed, then update that+ // record (in the FCB, or extents file).+ //+ if (extentChanged) {+ err = UpdateExtentRecord(vcb, fcb, deleted, &key, extentRecord, hint);+ if (err != noErr) goto ErrorExit;+ }++ //+ // If there are any following allocation blocks, then we need+ // to seach for their extent records and delete those allocation+ // blocks.+ //+ if (nextBlock < physNumBlocks)+ err = TruncateExtents(vcb, forkType, fileid, nextBlock, &recordDeleted);++Done:+ErrorExit:+ if (recordDeleted)+ (void) FlushExtentFile(vcb);++ return err;+}+++/*+ * HFS Plus only+ *+ */+OSErr HeadTruncateFile (+ ExtendedVCB *vcb,+ FCB *fcb,+ u_int32_t headblks)+{+ HFSPlusExtentRecord extents;+ HFSPlusExtentRecord tailExtents;+ HFSCatalogNodeID fileID;+ u_int8_t forkType;+ u_int32_t blkcnt = 0;+ u_int32_t startblk;+ u_int32_t blksfreed;+ int i, j;+ int error = 0;+ int lockflags;+++ if (vcb->vcbSigWord != kHFSPlusSigWord)+ return (-1);++ forkType = FORK_IS_RSRC(fcb) ? kResourceForkType : kDataForkType;+ fileID = FTOC(fcb)->c_fileid;+ bzero(tailExtents, sizeof(tailExtents));++ blksfreed = 0;+ startblk = 0;++ /*+ * Process catalog resident extents+ */+ for (i = 0, j = 0; i < kHFSPlusExtentDensity; ++i) {+ blkcnt = fcb->fcbExtents[i].blockCount;+ if (blkcnt == 0)+ break; /* end of extents */++ if (blksfreed < headblks) {+ error = BlockDeallocate(vcb, fcb->fcbExtents[i].startBlock, blkcnt, 0);+ /*+ * Any errors after the first BlockDeallocate+ * must be ignored so we can put the file in+ * a known state.+ */+ if (error ) {+ if (i == 0)+ goto ErrorExit; /* uh oh */+ else {+ error = 0;+ printf("hfs: HeadTruncateFile: problems deallocating %s (%d)\n",+ FTOC(fcb)->c_desc.cd_nameptr ? (const char *)FTOC(fcb)->c_desc.cd_nameptr : "", error);+ }+ }++ blksfreed += blkcnt;+ fcb->fcbExtents[i].startBlock = 0;+ fcb->fcbExtents[i].blockCount = 0;+ } else {+ tailExtents[j].startBlock = fcb->fcbExtents[i].startBlock;+ tailExtents[j].blockCount = blkcnt;+ ++j;+ }+ startblk += blkcnt;+ }++ if (blkcnt == 0)+ goto CopyExtents;++ lockflags = hfs_systemfile_lock(vcb, SFL_EXTENTS, HFS_EXCLUSIVE_LOCK);++ /*+ * Process overflow extents+ */+ for (;;) {+ u_int32_t extblks;++ error = FindExtentRecord(vcb, forkType, fileID, startblk, false, NULL, extents, NULL);+ if (error) {+ /*+ * Any errors after the first BlockDeallocate+ * must be ignored so we can put the file in+ * a known state.+ */+ if (error != btNotFound)+ printf("hfs: HeadTruncateFile: problems finding extents %s (%d)\n",+ FTOC(fcb)->c_desc.cd_nameptr ? (const char *)FTOC(fcb)->c_desc.cd_nameptr : "", error);+ error = 0;+ break;+ }++ for(i = 0, extblks = 0; i < kHFSPlusExtentDensity; ++i) {+ blkcnt = extents[i].blockCount;+ if (blkcnt == 0)+ break; /* end of extents */++ if (blksfreed < headblks) {+ error = BlockDeallocate(vcb, extents[i].startBlock, blkcnt, 0);+ if (error) {+ printf("hfs: HeadTruncateFile: problems deallocating %s (%d)\n",+ FTOC(fcb)->c_desc.cd_nameptr ? (const char *)FTOC(fcb)->c_desc.cd_nameptr : "", error);+ error = 0;+ }+ blksfreed += blkcnt;+ } else {+ tailExtents[j].startBlock = extents[i].startBlock;+ tailExtents[j].blockCount = blkcnt;+ ++j;+ }+ extblks += blkcnt;+ }++ error = DeleteExtentRecord(vcb, forkType, fileID, startblk);+ if (error) {+ printf("hfs: HeadTruncateFile: problems deallocating %s (%d)\n",+ FTOC(fcb)->c_desc.cd_nameptr ? (const char *)FTOC(fcb)->c_desc.cd_nameptr : "", error);+ error = 0;+ }++ if (blkcnt == 0)+ break; /* all done */++ startblk += extblks;+ }+ hfs_systemfile_unlock(vcb, lockflags);++CopyExtents:+ if (blksfreed) {+ bcopy(tailExtents, fcb->fcbExtents, sizeof(tailExtents));+ blkcnt = fcb->ff_blocks - headblks;+ FTOC(fcb)->c_blocks -= headblks;+ fcb->ff_blocks = blkcnt;++ FTOC(fcb)->c_flag |= C_MODIFIED;+ FTOC(fcb)->c_touch_chgtime = TRUE;++ (void) FlushExtentFile(vcb);+ }++ErrorExit:+ return MacToVFSError(error);+}++++//�������������������������������������������������������������������������������+// Routine: SearchExtentRecord (was XRSearch)+//+// Function: Searches extent record for the extent mapping a given file+// allocation block number (FABN).+//+// Input: searchFABN - desired FABN+// extentData - pointer to extent data record (xdr)+// extentDataStartFABN - beginning FABN for extent record+//+// Output: foundExtentDataOffset - offset to extent entry within xdr+// result = noErr, offset to extent mapping desired FABN+// result = FXRangeErr, offset to last extent in record+// endingFABNPlusOne - ending FABN +1+// noMoreExtents - True if the extent was not found, and the+// extent record was not full (so don't bother+// looking in subsequent records); false otherwise.+//+// Result: noErr = ok+// FXRangeErr = desired FABN > last mapped FABN in record+//�������������������������������������������������������������������������������++static OSErr SearchExtentRecord(+ ExtendedVCB *vcb,+ u_int32_t searchFABN,+ const HFSPlusExtentRecord extentData,+ u_int32_t extentDataStartFABN,+ u_int32_t *foundExtentIndex,+ u_int32_t *endingFABNPlusOne,+ Boolean *noMoreExtents)+{+ OSErr err = noErr;+ u_int32_t extentIndex;+ /* Set it to the HFS std value */+ u_int32_t numberOfExtents = kHFSExtentDensity;+ u_int32_t numAllocationBlocks;+ Boolean foundExtent;++ *endingFABNPlusOne = extentDataStartFABN;+ *noMoreExtents = false;+ foundExtent = false;++ /* Override numberOfExtents for HFS+/HFSX */+ if (vcb->vcbSigWord != kHFSSigWord) {+ numberOfExtents = kHFSPlusExtentDensity;+ }++ for( extentIndex = 0; extentIndex < numberOfExtents; ++extentIndex )+ {++ // Loop over the extent record and find the search FABN.++ numAllocationBlocks = extentData[extentIndex].blockCount;+ if ( numAllocationBlocks == 0 )+ {+ break;+ }++ *endingFABNPlusOne += numAllocationBlocks;++ if( searchFABN < *endingFABNPlusOne )+ {+ // Found the extent.+ foundExtent = true;+ break;+ }+ }++ if( foundExtent )+ {+ // Found the extent. Note the extent offset+ *foundExtentIndex = extentIndex;+ }+ else+ {+ // Did not find the extent. Set foundExtentDataOffset accordingly+ if( extentIndex > 0 )+ {+ *foundExtentIndex = extentIndex - 1;+ }+ else+ {+ *foundExtentIndex = 0;+ }++ // If we found an empty extent, then set noMoreExtents.+ if (extentIndex < numberOfExtents)+ *noMoreExtents = true;++ // Finally, return an error to the caller+ err = fxRangeErr;+ }++ return( err );+}++//�������������������������������������������������������������������������������+// Routine: SearchExtentFile (was XFSearch)+//+// Function: Searches extent file (including the FCB resident extent record)+// for the extent mapping a given file position.+//+// Input: vcb - VCB pointer+// fcb - FCB pointer+// filePosition - file position (byte address)+//+// Output: foundExtentKey - extent key record (xkr)+// If extent was found in the FCB's resident extent record,+// then foundExtentKey->keyLength will be set to 0.+// foundExtentData - extent data record(xdr)+// foundExtentIndex - index to extent entry in xdr+// result = 0, offset to extent mapping desired FABN+// result = FXRangeErr, offset to last extent in record+// (i.e., kNumExtentsPerRecord-1)+// extentBTreeHint - BTree hint for extent record+// kNoHint = Resident extent record+// endingFABNPlusOne - ending FABN +1+//+// Result:+// noErr Found an extent that contains the given file position+// FXRangeErr Given position is beyond the last allocated extent+// (other) (some other internal I/O error)+//�������������������������������������������������������������������������������++OSErr SearchExtentFile(+ ExtendedVCB *vcb,+ const FCB *fcb,+ int64_t filePosition,+ HFSPlusExtentKey *foundExtentKey,+ HFSPlusExtentRecord foundExtentData,+ u_int32_t *foundExtentIndex,+ u_int32_t *extentBTreeHint,+ u_int32_t *endingFABNPlusOne )+{+ OSErr err;+ u_int32_t filePositionBlock;+ int64_t temp64;+ Boolean noMoreExtents;+ int lockflags;++ temp64 = filePosition / (int64_t)vcb->blockSize;+ filePositionBlock = (u_int32_t)temp64;++ bcopy ( fcb->fcbExtents, foundExtentData, sizeof(HFSPlusExtentRecord));++ // Search the resident FCB first.+ err = SearchExtentRecord( vcb, filePositionBlock, foundExtentData, 0,+ foundExtentIndex, endingFABNPlusOne, &noMoreExtents );++ if( err == noErr ) {+ // Found the extent. Set results accordingly+ *extentBTreeHint = kNoHint; // no hint, because not in the BTree+ foundExtentKey->keyLength = 0; // 0 = the FCB itself++ goto Exit;+ }++ // Didn't find extent in FCB. If FCB's extent record wasn't full, there's no point+ // in searching the extents file. Note that SearchExtentRecord left us pointing at+ // the last valid extent (or the first one, if none were valid). This means we need+ // to fill in the hint and key outputs, just like the "if" statement above.+ if ( noMoreExtents ) {+ *extentBTreeHint = kNoHint; // no hint, because not in the BTree+ foundExtentKey->keyLength = 0; // 0 = the FCB itself+ err = fxRangeErr; // There are no more extents, so must be beyond PEOF+ goto Exit;+ }++ //+ // Find the desired record, or the previous record if it is the same fork+ //+ lockflags = hfs_systemfile_lock(vcb, SFL_EXTENTS, HFS_EXCLUSIVE_LOCK);++ err = FindExtentRecord(vcb, FORK_IS_RSRC(fcb) ? kResourceForkType : kDataForkType,+ FTOC(fcb)->c_fileid, filePositionBlock, true, foundExtentKey, foundExtentData, extentBTreeHint);+ hfs_systemfile_unlock(vcb, lockflags);++ if (err == btNotFound) {+ //+ // If we get here, the desired position is beyond the extents in the FCB, and there are no extents+ // in the extents file. Return the FCB's extents and a range error.+ //+ *extentBTreeHint = kNoHint;+ foundExtentKey->keyLength = 0;+ err = GetFCBExtentRecord(fcb, foundExtentData);+ // Note: foundExtentIndex and endingFABNPlusOne have already been set as a result of the very+ // first SearchExtentRecord call in this function (when searching in the FCB's extents, and+ // we got a range error).++ return fxRangeErr;+ }++ //+ // If we get here, there was either a BTree error, or we found an appropriate record.+ // If we found a record, then search it for the correct index into the extents.+ //+ if (err == noErr) {+ // Find appropriate index into extent record+ err = SearchExtentRecord(vcb, filePositionBlock, foundExtentData, foundExtentKey->startBlock,+ foundExtentIndex, endingFABNPlusOne, &noMoreExtents);+ }++Exit:+ return err;+}++++//============================================================================+// Routine: UpdateExtentRecord+//+// Function: Write new extent data to an existing extent record with a given key.+// If all of the extents are empty, and the extent record is in the+// extents file, then the record is deleted.+//+// Input: vcb - the volume containing the extents+// fcb - the file that owns the extents+// deleted - whether or not the file is already deleted+// extentFileKey - pointer to extent key record (xkr)+// If the key length is 0, then the extents are actually part+// of the catalog record, stored in the FCB.+// extentData - pointer to extent data record (xdr)+// extentBTreeHint - hint for given key, or kNoHint+//+// Result: noErr = ok+// (other) = error from BTree+//============================================================================++static OSErr UpdateExtentRecord (ExtendedVCB *vcb, FCB *fcb, int deleted,+ const HFSPlusExtentKey *extentFileKey,+ const HFSPlusExtentRecord extentData,+ u_int32_t extentBTreeHint)+{+ OSErr err = noErr;++ if (extentFileKey->keyLength == 0) { // keyLength == 0 means the FCB's extent record+ BlockMoveData(extentData, fcb->fcbExtents, sizeof(HFSPlusExtentRecord));+ if (!deleted) {+ FTOC(fcb)->c_flag |= C_MODIFIED;+ }+ }+ else {+ struct BTreeIterator *btIterator = NULL;+ FSBufferDescriptor btRecord;+ u_int16_t btRecordSize;+ FCB * btFCB;+ int lockflags;++ //+ // Need to find and change a record in Extents BTree+ //+ btFCB = GetFileControlBlock(vcb->extentsRefNum);++ btIterator = hfs_malloc_type(struct BTreeIterator);++ /*+ * The lock taken by callers of ExtendFileC/TruncateFileC is+ * speculative and only occurs when the file already has+ * overflow extents. So we need to make sure we have the lock+ * here. The extents btree lock can be nested (its recursive)+ * so we always take it here.+ */+ lockflags = hfs_systemfile_lock(vcb, SFL_EXTENTS, HFS_EXCLUSIVE_LOCK);++ /* HFS+/HFSX */+ if (vcb->vcbSigWord != kHFSSigWord) { // HFS Plus volume+ HFSPlusExtentRecord foundData; // The extent data actually found++ BlockMoveData(extentFileKey, &btIterator->key, sizeof(HFSPlusExtentKey));++ btIterator->hint.index = 0;+ btIterator->hint.nodeNum = extentBTreeHint;++ btRecord.bufferAddress = &foundData;+ btRecord.itemSize = sizeof(HFSPlusExtentRecord);+ btRecord.itemCount = 1;++ err = BTSearchRecord(btFCB, btIterator, &btRecord, &btRecordSize, btIterator);++ if (err == noErr) {+ BlockMoveData(extentData, &foundData, sizeof(HFSPlusExtentRecord));+ err = BTReplaceRecord(btFCB, btIterator, &btRecord, btRecordSize);+ }+ (void) BTFlushPath(btFCB);+ }++ hfs_systemfile_unlock(vcb, lockflags);++ hfs_free_type(btIterator, struct BTreeIterator);+ }++ return err;+}+++static OSErr GetFCBExtentRecord(+ const FCB *fcb,+ HFSPlusExtentRecord extents)+{++ BlockMoveData(fcb->fcbExtents, extents, sizeof(HFSPlusExtentRecord));++ return noErr;+}+++//_________________________________________________________________________________+//+// Routine: ExtentsAreIntegral+//+// Purpose: Ensure that each extent can hold an integral number of nodes+// Called by the NodesAreContiguous function+//_________________________________________________________________________________++static Boolean ExtentsAreIntegral(+ const HFSPlusExtentRecord extentRecord,+ u_int32_t mask,+ u_int32_t *blocksChecked,+ Boolean *checkedLastExtent)+{+ u_int32_t blocks;+ u_int32_t extentIndex;++ *blocksChecked = 0;+ *checkedLastExtent = false;++ for(extentIndex = 0; extentIndex < kHFSPlusExtentDensity; extentIndex++)+ {+ blocks = extentRecord[extentIndex].blockCount;++ if ( blocks == 0 )+ {+ *checkedLastExtent = true;+ break;+ }++ *blocksChecked += blocks;++ if (blocks & mask)+ return false;+ }++ return true;+}+++//_________________________________________________________________________________+//+// Routine: NodesAreContiguous+//+// Purpose: Ensure that all b-tree nodes are contiguous on disk+// Called by BTOpenPath during volume mount+//_________________________________________________________________________________++Boolean NodesAreContiguous(+ ExtendedVCB *vcb,+ FCB *fcb,+ u_int32_t nodeSize)+{+ u_int32_t mask;+ u_int32_t startBlock;+ u_int32_t blocksChecked;+ u_int32_t hint;+ HFSPlusExtentKey key;+ HFSPlusExtentRecord extents;+ OSErr result;+ Boolean lastExtentReached;+ int lockflags;+++ if (vcb->blockSize >= nodeSize)+ return TRUE;++ mask = (nodeSize / vcb->blockSize) - 1;++ // check the local extents+ (void) GetFCBExtentRecord(fcb, extents);+ if ( !ExtentsAreIntegral(extents, mask, &blocksChecked, &lastExtentReached) )+ return FALSE;++ if ( lastExtentReached ||+ (int64_t)((int64_t)blocksChecked * (int64_t)vcb->blockSize) >= (int64_t)fcb->ff_size)+ return TRUE;++ startBlock = blocksChecked;++ lockflags = hfs_systemfile_lock(vcb, SFL_EXTENTS, HFS_EXCLUSIVE_LOCK);++ // check the overflow extents (if any)+ while ( !lastExtentReached )+ {+ result = FindExtentRecord(vcb, kDataForkType, fcb->ff_cp->c_fileid, startBlock, FALSE, &key, extents, &hint);+ if (result) break;++ if ( !ExtentsAreIntegral(extents, mask, &blocksChecked, &lastExtentReached) ) {+ hfs_systemfile_unlock(vcb, lockflags);+ return FALSE;+ }+ startBlock += blocksChecked;+ }+ hfs_systemfile_unlock(vcb, lockflags);+ return TRUE;+}+diff --git a/xnu/files/bsd/hfs/FileIDsServices.c b/xnu/files/bsd/hfs/FileIDsServices.cnew file mode 100644index 0000000..6c569fd--- /dev/null+++ b/xnu/files/bsd/hfs/FileIDsServices.c@@ -0,0 +1,578 @@+/*+ * Copyright (c) 2000-2015 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@+ */++#include "hfs_macos_defs.h"+#include "hfs_format.h"++#include "FileMgrInternal.h"+#include "HFSUnicodeWrappers.h"+#include "CatalogPrivate.h"+#include <sys/kernel.h>+#include <sys/malloc.h>+#include <libkern/libkern.h>++#include "hfs_dbg.h"++struct ExtentsRecBuffer {+ ExtentKey extentKey;+ ExtentRecord extentData;+};+typedef struct ExtentsRecBuffer ExtentsRecBuffer;+++static u_int32_t CheckExtents( void *extents, u_int32_t blocks, Boolean isHFSPlus );+static OSErr DeleteExtents( ExtendedVCB *vcb, u_int32_t fileNumber, int quitEarly, u_int8_t forkType, Boolean isHFSPlus );+static OSErr MoveExtents( ExtendedVCB *vcb, u_int32_t srcFileID, u_int32_t destFileID, int quitEarly, u_int8_t forkType, Boolean isHFSPlus );+static void CopyBigCatalogNodeInfo( CatalogRecord *src, CatalogRecord *dest );+static void CopyExtentInfo( ExtentKey *key, ExtentRecord *data, ExtentsRecBuffer *buffer, u_int16_t bufferCount );++/*+ * This function moves the overflow extents associated with srcID into the file associated with dstID.+ * We should have already verified that 'srcID' has overflow extents. So now we move all of the overflow+ * extent records.+ */+OSErr MoveData( ExtendedVCB *vcb, HFSCatalogNodeID srcID, HFSCatalogNodeID destID, int rsrc) {++ OSErr err;++ /*+ * Only the source file should have extents, so we just track those.+ * We operate on the fork represented by the open FD that was used to call into this+ * function+ */+ if (rsrc) {+ /* Copy the extent overflow blocks. */+ err = MoveExtents( vcb, srcID, destID, 1, (u_int8_t)0xff, 1);+ if ( err != noErr ) {+ if ( err != dskFulErr ) {+ return( err );+ }+ /*+ * In case of error, we would have probably run into problems+ * growing the extents b-tree. Since the move is actually a copy + delete+ * just delete the new entries. Same for below.+ */+ err = DeleteExtents( vcb, destID, 1, (u_int8_t)0xff, 1);+ ReturnIfError( err ); // we are doomed. Just QUIT!+ goto FlushAndReturn;+ }+ }+ else {+ /* Copy the extent overflow blocks. */+ err = MoveExtents( vcb, srcID, destID, 1, 0, 1);+ if ( err != noErr ) {+ if ( err != dskFulErr ) {+ return( err );+ }+ err = DeleteExtents( vcb, destID, 1, 0, 1);+ ReturnIfError( err ); // we are doomed. Just QUIT!+ goto FlushAndReturn;+ }+ }++FlushAndReturn:+ /* Write out the catalog and extent overflow B-Tree changes */+ err = FlushCatalog( vcb );+ err = FlushExtentFile( vcb );++ return( err );+}+++OSErr ExchangeFileIDs( ExtendedVCB *vcb, ConstUTF8Param srcName, ConstUTF8Param destName, HFSCatalogNodeID srcID, HFSCatalogNodeID destID, u_int32_t srcHint, u_int32_t destHint )+{+ CatalogKey srcKey; // 518 bytes+ CatalogKey destKey; // 518 bytes+ CatalogRecord srcData; // 520 bytes+ CatalogRecord destData; // 520 bytes+ CatalogRecord swapData; // 520 bytes+ int16_t numSrcExtentBlocks;+ int16_t numDestExtentBlocks;+ OSErr err;+ Boolean isHFSPlus = ( vcb->vcbSigWord == kHFSPlusSigWord );++ err = BuildCatalogKeyUTF8(vcb, srcID, srcName, kUndefinedStrLen, &srcKey);+ ReturnIfError(err);++ err = BuildCatalogKeyUTF8(vcb, destID, destName, kUndefinedStrLen, &destKey);+ ReturnIfError(err);++ if ( isHFSPlus )+ {+ //-- Step 1: Check the catalog nodes for extents++ //-- locate the source file, test for extents in extent file, and copy the cat record for later+ err = LocateCatalogNodeByKey( vcb, srcHint, &srcKey, &srcData, &srcHint );+ ReturnIfError( err );++ if ( srcData.recordType != kHFSPlusFileRecord )+ return( cmFThdDirErr ); // Error "cmFThdDirErr = it is a directory"++ //-- Check if there are any extents in the source file+ //�� I am only checling the extents in the low 32 bits, routine will fail if files extents after 2 gig are in overflow+ numSrcExtentBlocks = CheckExtents( srcData.hfsPlusFile.dataFork.extents, srcData.hfsPlusFile.dataFork.totalBlocks, isHFSPlus );+ if ( numSrcExtentBlocks == 0 ) // then check the resource fork extents+ numSrcExtentBlocks = CheckExtents( srcData.hfsPlusFile.resourceFork.extents, srcData.hfsPlusFile.resourceFork.totalBlocks, isHFSPlus );++ //-- Check if there are any extents in the destination file+ err = LocateCatalogNodeByKey( vcb, destHint, &destKey, &destData, &destHint );+ ReturnIfError( err );++ if ( destData.recordType != kHFSPlusFileRecord )+ return( cmFThdDirErr ); // Error "cmFThdDirErr = it is a directory"++ numDestExtentBlocks = CheckExtents( destData.hfsPlusFile.dataFork.extents, destData.hfsPlusFile.dataFork.totalBlocks, isHFSPlus );+ if ( numDestExtentBlocks == 0 ) // then check the resource fork extents+ numDestExtentBlocks = CheckExtents( destData.hfsPlusFile.resourceFork.extents, destData.hfsPlusFile.resourceFork.totalBlocks, isHFSPlus );++ //-- Step 2: Exchange the Extent key in the extent file++ //-- Exchange the extents key in the extent file+ err = DeleteExtents( vcb, kHFSBogusExtentFileID, 0, 0, isHFSPlus );+ ReturnIfError( err );++ if ( numSrcExtentBlocks && numDestExtentBlocks ) // if both files have extents+ {+ //-- Change the source extents file ids to our known bogus value+ err = MoveExtents( vcb, srcData.hfsPlusFile.fileID, kHFSBogusExtentFileID, 0,0, isHFSPlus );+ if ( err != noErr )+ {+ if ( err != dskFulErr ) {+ return( err );+ }+ else {+ err = DeleteExtents( vcb, kHFSBogusExtentFileID, 0, 0, isHFSPlus );+ ReturnIfError( err ); // we are doomed. Just QUIT!++ err = FlushCatalog( vcb ); // flush the catalog+ err = FlushExtentFile( vcb ); // flush the extent file (unneeded for common case, but it's cheap)+ return( dskFulErr );+ }+ }++ //-- Change the destination extents file id's to the source id's+ err = MoveExtents( vcb, destData.hfsPlusFile.fileID, srcData.hfsPlusFile.fileID, 0, 0, isHFSPlus );+ if ( err != noErr )+ {+ if ( err != dskFulErr )+ return( err );++ExUndo2aPlus: err = DeleteExtents( vcb, srcData.hfsPlusFile.fileID, 0, 0, isHFSPlus );+ ReturnIfError( err ); // we are doomed. Just QUIT!++ err = MoveExtents( vcb, kHFSBogusExtentFileID, srcData.hfsPlusFile.fileID, 0, 0, isHFSPlus ); // Move the extents back+ ReturnIfError( err ); // we are doomed. Just QUIT!++ err = DeleteExtents( vcb, kHFSBogusExtentFileID, 0, 0, isHFSPlus );+ ReturnIfError( err ); // we are doomed. Just QUIT!++ err = FlushCatalog( vcb ); // flush the catalog+ err = FlushExtentFile( vcb ); // flush the extent file (unneeded for common case, but it's cheap)+ return( dskFulErr );++ }++ //-- Change the bogus extents file id's to the dest id's+ err = MoveExtents( vcb, kHFSBogusExtentFileID, destData.hfsPlusFile.fileID, 0, 0, isHFSPlus );+ if ( err != noErr )+ {+ if ( err != dskFulErr )+ return( err );++ err = DeleteExtents( vcb, destData.hfsPlusFile.fileID, 0, 0, isHFSPlus );+ ReturnIfError( err ); // we are doomed. Just QUIT!++ err = MoveExtents( vcb, srcData.hfsPlusFile.fileID, destData.hfsPlusFile.fileID, 0, 0, isHFSPlus ); // Move the extents back+ ReturnIfError( err ); // we are doomed. Just QUIT!++ goto ExUndo2aPlus;+ }++ }+ else if ( numSrcExtentBlocks ) // just the source file has extents+ {+ err = MoveExtents( vcb, srcData.hfsPlusFile.fileID, destData.hfsPlusFile.fileID, 0, 0, isHFSPlus );+ if ( err != noErr )+ {+ if ( err != dskFulErr )+ return( err );++ err = DeleteExtents( vcb, srcData.hfsPlusFile.fileID, 0, 0, isHFSPlus );+ ReturnIfError( err ); // we are doomed. Just QUIT!++ goto FlushAndReturn;+ }+ }+ else if ( numDestExtentBlocks ) // just the destination file has extents+ {+ err = MoveExtents( vcb, destData.hfsPlusFile.fileID, srcData.hfsPlusFile.fileID, 0, 0, isHFSPlus );+ if ( err != noErr )+ {+ if ( err != dskFulErr )+ return( err );++ err = DeleteExtents( vcb, destData.hfsPlusFile.fileID, 0, 0, isHFSPlus );+ ReturnIfError( err ); // we are doomed. Just QUIT!++ goto FlushAndReturn;+ }+ }++ //-- Step 3: Change the data in the catalog nodes++ //-- find the source cnode and put dest info in it+ err = LocateCatalogNodeByKey( vcb, srcHint, &srcKey, &srcData, &srcHint );+ if ( err != noErr )+ return( cmBadNews );++ BlockMoveData( &srcData, &swapData, sizeof(CatalogRecord) );+ CopyBigCatalogNodeInfo( &destData, &srcData );++ err = ReplaceBTreeRecord( vcb->catalogRefNum, &srcKey, srcHint, &srcData, sizeof(HFSPlusCatalogFile), &srcHint );+ ReturnIfError( err );++ // find the destination cnode and put source info in it+ err = LocateCatalogNodeByKey( vcb, destHint, &destKey, &destData, &destHint );+ if ( err != noErr )+ return( cmBadNews );++ CopyBigCatalogNodeInfo( &swapData, &destData );+ err = ReplaceBTreeRecord( vcb->catalogRefNum, &destKey, destHint, &destData, sizeof(HFSPlusCatalogFile), &destHint );+ ReturnIfError( err );+ }++ err = noErr;++ //-- Step 4: Error Handling section+++FlushAndReturn:+ err = FlushCatalog( vcb ); // flush the catalog+ err = FlushExtentFile( vcb ); // flush the extent file (unneeded for common case, but it's cheap)+ return( err );+}++static void CopyBigCatalogNodeInfo( CatalogRecord *src, CatalogRecord *dest )+{+ BlockMoveData( &src->hfsPlusFile.dataFork, &dest->hfsPlusFile.dataFork, sizeof(HFSPlusForkData) );+ BlockMoveData( &src->hfsPlusFile.resourceFork, &dest->hfsPlusFile.resourceFork, sizeof(HFSPlusForkData) );+ dest->hfsPlusFile.contentModDate = src->hfsPlusFile.contentModDate;+}+++static OSErr MoveExtents( ExtendedVCB *vcb, u_int32_t srcFileID, u_int32_t destFileID, int quitEarly, u_int8_t forkType, Boolean isHFSPlus )+{+ FCB * fcb;+ ExtentsRecBuffer extentsBuffer[kNumExtentsToCache];+ ExtentKey * extentKeyPtr;+ ExtentRecord extentData;+ struct BTreeIterator *btIterator = NULL;+ struct BTreeIterator *tmpIterator = NULL;+ FSBufferDescriptor btRecord;+ u_int16_t btKeySize;+ u_int16_t btRecordSize;+ int16_t i, j;+ OSErr err;++ btIterator = hfs_malloc_type(struct BTreeIterator);+ tmpIterator = hfs_malloc_type(struct BTreeIterator);++ fcb = GetFileControlBlock(vcb->extentsRefNum);++ (void) BTInvalidateHint(btIterator);+ extentKeyPtr = (ExtentKey*) &btIterator->key;+ btRecord.bufferAddress = &extentData;+ btRecord.itemCount = 1;++ //-- Collect the extent records++ //+ // A search on the following key will cause the BTree to be positioned immediately+ // before the first extent record for file #srcFileID, but not actually positioned+ // on any record. This is because there cannot be an extent record with FABN = 0+ // (the first extent of the fork, which would be in the catalog entry, not an extent+ // record).+ //+ // Using BTIterateRecord with kBTreeNextRecord will then get that first extent record.+ //+ if (isHFSPlus) {+ btRecord.itemSize = sizeof(HFSPlusExtentRecord);+ btKeySize = sizeof(HFSPlusExtentKey);++ extentKeyPtr->hfsPlus.keyLength = kHFSPlusExtentKeyMaximumLength;+ extentKeyPtr->hfsPlus.forkType = forkType;+ extentKeyPtr->hfsPlus.pad = 0;+ extentKeyPtr->hfsPlus.fileID = srcFileID;+ extentKeyPtr->hfsPlus.startBlock = 0;+ } else {+ hfs_free_type(tmpIterator, struct BTreeIterator);+ hfs_free_type(btIterator, struct BTreeIterator);+ return cmBadNews;+ }+++ //+ // We do an initial BTSearchRecord to position the BTree's iterator just before any extent+ // records for srcFileID. We then do a few BTIterateRecord and BTInsertRecord of those found+ // records, but with destFileID as the file number in the key. Keep doing this sequence of+ // BTIterateRecord and BTInsertRecord until we find an extent for another file, or there are+ // no more extent records in the tree.+ //+ // Basically, we're copying records kNumExtentsToCache at a time. The copies have their file ID+ // set to destFileID.+ //+ // This depends on BTInsertRecord not effecting the iterator used by BTIterateRecord. If it+ // _did_ effect the iterator, then we would need to do a BTSearchRecord before each series+ // of BTIterateRecord. We'd need to set up the key for BTSearchRecord to find the last record+ // we found, so that BTIterateRecord would get the next one (the first we haven't processed).+ //++ err = BTSearchRecord(fcb, btIterator, &btRecord, &btRecordSize, btIterator);++ // We expect a btNotFound here, since there shouldn't be an extent record with FABN = 0.+ if (err != btNotFound)+ {+ hfs_debug("hfs: unexpected error from SearchBTreeRecord\n");++ if (err == noErr) // If we found such a bogus extent record, then the tree is really messed up+ err = cmBadNews; // so return an error that conveys the disk is hosed.++ hfs_free_type(tmpIterator, struct BTreeIterator);+ hfs_free_type(btIterator, struct BTreeIterator);+ return err;+ }++ do+ {+ btRecord.bufferAddress = &extentData;+ btRecord.itemCount = 1;++ for ( i=0 ; i<kNumExtentsToCache ; i++ )+ {+ HFSCatalogNodeID foundFileID = 0;++ err = BTIterateRecord(fcb, kBTreeNextRecord, btIterator, &btRecord, &btRecordSize);+ if ( err == btNotFound ) // Did we run out of extent records in the extents tree?+ break; // if xkrFNum(A0) is cleared on this error, then this test is bogus!+ else if ( err != noErr ) {+ hfs_free_type(tmpIterator, struct BTreeIterator);+ hfs_free_type(btIterator, struct BTreeIterator);+ return( err ); // must be ioError+ }+ if (isHFSPlus) {+ foundFileID = extentKeyPtr->hfsPlus.fileID;+ }++ if ( foundFileID == srcFileID ) {+ /* Check if we need to quit early. */+ if (quitEarly && isHFSPlus) {+ if (extentKeyPtr->hfsPlus.forkType != forkType) {+ break;+ }+ }+ CopyExtentInfo(extentKeyPtr, &extentData, extentsBuffer, i);+ }+ else{+ /* The fileID's are of a different file. We're done here. */+ break;+ }+ }++++ //-- edit each extent key, and reinsert each extent record in the extent file+ if (isHFSPlus)+ btRecordSize = sizeof(HFSPlusExtentRecord);++ for ( j=0 ; j<i ; j++ )+ {++ if (isHFSPlus)+ extentsBuffer[j].extentKey.hfsPlus.fileID = destFileID; // change only the id in the key to dest ID++ // get iterator and buffer descriptor ready...+ (void) BTInvalidateHint(tmpIterator);+ BlockMoveData(&(extentsBuffer[j].extentKey), &tmpIterator->key, btKeySize);+ btRecord.bufferAddress = &(extentsBuffer[j].extentData);++ err = BTInsertRecord(fcb, tmpIterator, &btRecord, btRecordSize);+ if ( err != noErr ) {+ /* Parse the error and free iterators */+ hfs_free_type(tmpIterator, struct BTreeIterator);+ hfs_free_type(btIterator, struct BTreeIterator);+ if ( err == btExists )+ {+ hfs_debug("hfs: can't insert record -- already exists\n");+ return( cmBadNews );+ }+ else {+ return( err );+ }+ }+ }++ //-- okay, done with this buffered batch, go get the next set of extent records+ // If our buffer is not full, we must be done, or recieved an error++ if ( i != kNumExtentsToCache ) // if the buffer is not full, we must be done+ {+ err = DeleteExtents( vcb, srcFileID, quitEarly, forkType, isHFSPlus ); // Now delete all the extent entries with the sourceID+ if (err != noErr )+ hfs_debug("hfs: error from DeleteExtents (%d)\n", err);+ break; // we're done!+ }+ } while ( true );++ hfs_free_type(tmpIterator, struct BTreeIterator);+ hfs_free_type(btIterator, struct BTreeIterator);++ return( err );+}+++static void CopyExtentInfo( ExtentKey *key, ExtentRecord *data, ExtentsRecBuffer *buffer, u_int16_t bufferCount )+{+ BlockMoveData( key, &(buffer[bufferCount].extentKey), sizeof( ExtentKey ) );+ BlockMoveData( data, &(buffer[bufferCount].extentData), sizeof( ExtentRecord ) );+}+++//-- Delete all extents in extent file that have the ID given.+static OSErr DeleteExtents( ExtendedVCB *vcb, u_int32_t fileID, int quitEarly, u_int8_t forkType, Boolean isHFSPlus )+{+ FCB * fcb;+ ExtentKey * extentKeyPtr;+ ExtentRecord extentData;+ struct BTreeIterator *btIterator = NULL;+ struct BTreeIterator *tmpIterator = NULL;+ FSBufferDescriptor btRecord;+ u_int16_t btRecordSize;+ OSErr err;++ btIterator = hfs_malloc_type(struct BTreeIterator);+ tmpIterator = hfs_malloc_type(struct BTreeIterator);++ fcb = GetFileControlBlock(vcb->extentsRefNum);++ (void) BTInvalidateHint(btIterator);+ extentKeyPtr = (ExtentKey*) &btIterator->key;+ btRecord.bufferAddress = &extentData;+ btRecord.itemCount = 1;++ // The algorithm is to position the BTree just before any extent records for fileID.+ // Then just keep getting successive records. If the record is still for fileID,+ // then delete it.++ if (isHFSPlus) {+ btRecord.itemSize = sizeof(HFSPlusExtentRecord);++ extentKeyPtr->hfsPlus.keyLength = kHFSPlusExtentKeyMaximumLength;+ extentKeyPtr->hfsPlus.forkType = forkType;+ extentKeyPtr->hfsPlus.pad = 0;+ extentKeyPtr->hfsPlus.fileID = fileID;+ extentKeyPtr->hfsPlus.startBlock = 0;+ } else {+ err = cmBadNews;+ goto exit;+ }++ err = BTSearchRecord(fcb, btIterator, &btRecord, &btRecordSize, btIterator);+ if ( err != btNotFound )+ {+ if (err == noErr) { // Did we find a bogus extent record?+ err = cmBadNews; // Yes, so indicate things are messed up.+ }++ goto exit;+ }++ do+ {+ HFSCatalogNodeID foundFileID = 0;++ err = BTIterateRecord(fcb, kBTreeNextRecord, btIterator, &btRecord, &btRecordSize);+ if ( err != noErr )+ {+ if (err == btNotFound) // If we hit the end of the BTree+ err = noErr; // then it's OK++ break; // We're done now.+ }+ if (isHFSPlus) {+ foundFileID = extentKeyPtr->hfsPlus.fileID;+ }++ if ( foundFileID != fileID ) {+ break; // numbers don't match, we must be done+ }+ if (quitEarly && isHFSPlus) {+ /* If we're only deleting one type of fork, then quit early if it doesn't match */+ if (extentKeyPtr->hfsPlus.forkType != forkType) {+ break;+ }+ }++ *tmpIterator = *btIterator;+ err = BTDeleteRecord( fcb, tmpIterator );+ if (err != noErr)+ break;+ } while ( true );++exit:++ hfs_free_type(tmpIterator, struct BTreeIterator);+ hfs_free_type(btIterator, struct BTreeIterator);++ return( err );+}+++// Check if there are extents represented in the extents overflow file.+static u_int32_t CheckExtents( void *extents, u_int32_t totalBlocks, Boolean isHFSPlus )+{+ u_int32_t extentAllocationBlocks;+ u_int16_t i;+++ if ( totalBlocks == 0 )+ return( 0 );++ extentAllocationBlocks = 0;++ if ( isHFSPlus )+ {+ for ( i = 0 ; i < kHFSPlusExtentDensity ; i++ )+ {+ extentAllocationBlocks += ((HFSPlusExtentDescriptor *)extents)[i].blockCount;+ if ( extentAllocationBlocks >= totalBlocks ) // greater than or equal (extents can add past eof if 'Close" crashes w/o truncating new clump)+ return( 0 );+ }+ }++ return( extentAllocationBlocks );+}diff --git a/xnu/files/bsd/hfs/FileMgrInternal.h b/xnu/files/bsd/hfs/FileMgrInternal.hnew file mode 100644index 0000000..4e598a9--- /dev/null+++ b/xnu/files/bsd/hfs/FileMgrInternal.h@@ -0,0 +1,391 @@+/*+ * Copyright (c) 2000-2015 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@+ */+/*+ File: FilesInternal.h++ Contains: IPI for File Manager (HFS Plus)++ Version: HFS Plus 1.0++ Copyright: (c) 1996-2001 by Apple Inc., all rights reserved.++*/+#ifndef __FILEMGRINTERNAL__+#define __FILEMGRINTERNAL__++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE++#include <sys/param.h>+#include <sys/vnode.h>++#if !HFS_ALLOC_TEST++#include "hfs.h"+#include "hfs_macos_defs.h"+#include "hfs_format.h"+#include "hfs_cnode.h"++#endif++#ifdef __cplusplus+extern "C" {+#endif++/* CatalogNodeID is used to track catalog objects */+typedef u_int32_t HFSCatalogNodeID;++/* internal error codes*/++#if TARGET_API_MACOS_X+ #define ERR_BASE -32767+#else+ #define ERR_BASE 0+#endif++enum {+ /* FXM errors*/+ fxRangeErr = ERR_BASE + 16, /* file position beyond mapped range*/+ fxOvFlErr = ERR_BASE + 17, /* extents file overflow*/+ /* Unicode errors*/+ uniTooLongErr = ERR_BASE + 24, /* Unicode string too long to convert to Str31*/+ uniBufferTooSmallErr = ERR_BASE + 25, /* Unicode output buffer too small*/+ uniNotMappableErr = ERR_BASE + 26, /* Unicode string can't be mapped to given script*/+ /* BTree Manager errors*/+ btNotFound = ERR_BASE + 32, /* record not found*/+ btExists = ERR_BASE + 33, /* record already exists*/+ btNoSpaceAvail = ERR_BASE + 34, /* no available space*/+ btNoFit = ERR_BASE + 35, /* record doesn't fit in node */+ btBadNode = ERR_BASE + 36, /* bad node detected*/+ btBadHdr = ERR_BASE + 37, /* bad BTree header record detected*/+ dsBadRotate = ERR_BASE + 64, /* bad BTree rotate*/+ /* Catalog Manager errors*/+ cmNotFound = ERR_BASE + 48, /* CNode not found*/+ cmExists = ERR_BASE + 49, /* CNode already exists*/+ cmNotEmpty = ERR_BASE + 50, /* directory CNode not empty (valence = 0)*/+ cmRootCN = ERR_BASE + 51, /* invalid reference to root CNode*/+ cmBadNews = ERR_BASE + 52, /* detected bad catalog structure*/+ cmFThdDirErr = ERR_BASE + 53, /* thread belongs to a directory not a file*/+ cmFThdGone = ERR_BASE + 54, /* file thread doesn't exist*/+ cmParentNotFound = ERR_BASE + 55, /* CNode for parent ID does not exist*/+ /* TFS internal errors*/+ fsDSIntErr = -127 /* Internal file system error*/+};+++/* internal flags*/++enum {+ kEFAllMask = 0x01, /* allocate all requested bytes or none */+ kEFContigMask = 0x02, /* force contiguous allocation */+ kEFReserveMask = 0x04, /* keep block reserve */+ kEFDeferMask = 0x08, /* defer file block allocations */+ kEFNoClumpMask = 0x10, /* don't round up to clump size */+ kEFMetadataMask = 0x20, /* metadata allocation */++ kTFTrunExtBit = 0, /* truncate to the extent containing new PEOF*/+ kTFTrunExtMask = 1+};++enum {+ kUndefinedStrLen = 0, /* Unknown string length */+ kNoHint = 0,++ /* FileIDs variables*/+ kNumExtentsToCache = 4 /* just guessing for ExchangeFiles*/+};+++/* Universal Extent Key */++union ExtentKey {+ HFSExtentKey hfs;+ HFSPlusExtentKey hfsPlus;+};+typedef union ExtentKey ExtentKey;+/* Universal extent descriptor */++union ExtentDescriptor {+ HFSExtentDescriptor hfs;+ HFSPlusExtentDescriptor hfsPlus;+};+typedef union ExtentDescriptor ExtentDescriptor;+/* Universal extent record */++union ExtentRecord {+ HFSExtentRecord hfs;+ HFSPlusExtentRecord hfsPlus;+};+typedef union ExtentRecord ExtentRecord;+++enum {+ CMMaxCName = kHFSMaxFileNameChars+};++++/* Universal catalog name*/++union CatalogName {+ Str31 pstr;+ HFSUniStr255 ustr;+};+typedef union CatalogName CatalogName;+++/*+ * MacOS accessor routines+ */+#define GetFileControlBlock(fref) VTOF((fref))+#define GetFileRefNumFromFCB(fcb) FTOV((fcb))++/* Test for error and return if error occurred*/+EXTERN_API_C( void )+ReturnIfError (OSErr result);++#define ReturnIfError(result) do { if ( (result) != noErr ) return (result); } while(0)++/* Exit function on error*/+EXTERN_API_C( void )+ExitOnError (OSErr result);++#define ExitOnError( result ) do { if ( ( result ) != noErr ) goto ErrorExit; } while(0)++++/* Catalog Manager Routines (IPI)*/++EXTERN_API_C( OSErr )+ExchangeFileIDs (ExtendedVCB * volume,+ ConstUTF8Param srcName,+ ConstUTF8Param destName,+ HFSCatalogNodeID srcID,+ HFSCatalogNodeID destID,+ u_int32_t srcHint,+ u_int32_t destHint );++EXTERN_API_C( OSErr )+MoveData( ExtendedVCB *vcb, HFSCatalogNodeID srcID, HFSCatalogNodeID destID, int rsrc);++/* BTree Manager Routines*/++typedef CALLBACK_API_C( int32_t , KeyCompareProcPtr )(void *a, void *b);+++EXTERN_API_C( OSErr )+ReplaceBTreeRecord (FileReference refNum,+ const void * key,+ u_int32_t hint,+ void * newData,+ u_int16_t dataSize,+ u_int32_t * newHint);+++/* Prototypes for exported routines in VolumeAllocation.c*/++/*+ * Flags for BlockAllocate(), BlockDeallocate() and hfs_block_alloc.+ * Some of these are for internal use only. See the comment at the+ * top of hfs_alloc_int for more details on the semantics of these+ * flags.+ */+#define HFS_ALLOC_FORCECONTIG 0x001 //force contiguous block allocation; minblocks must be allocated+#define HFS_ALLOC_METAZONE 0x002 //can use metazone blocks+#define HFS_ALLOC_SKIPFREEBLKS 0x004 //skip checking/updating freeblocks during alloc/dealloc+#define HFS_ALLOC_FLUSHTXN 0x008 //pick best fit for allocation, even if a jnl flush is req'd+#define HFS_ALLOC_TENTATIVE 0x010 //reserved allocation that can be claimed back+#define HFS_ALLOC_LOCKED 0x020 //reserved allocation that can't be claimed back+#define HFS_ALLOC_IGNORE_TENTATIVE 0x040 //Steal tentative blocks if necessary+#define HFS_ALLOC_IGNORE_RESERVED 0x080 //Ignore tentative/committed blocks+#define HFS_ALLOC_USE_TENTATIVE 0x100 //Use the supplied tentative range (if possible)+#define HFS_ALLOC_COMMIT 0x200 //Commit the supplied extent to disk+#define HFS_ALLOC_TRY_HARD 0x400 //Search hard to try and get maxBlocks; implies HFS_ALLOC_FLUSHTXN+#define HFS_ALLOC_ROLL_BACK 0x800 //Reallocate blocks that were just deallocated+#define HFS_ALLOC_FAST_DEV 0x1000 //Prefer fast device for allocation++typedef uint32_t hfs_block_alloc_flags_t;++struct rl_entry;+EXTERN_API_C( OSErr )+BlockAllocate (ExtendedVCB * vcb,+ u_int32_t startingBlock,+ u_int32_t minBlocks,+ u_int32_t maxBlocks,+ hfs_block_alloc_flags_t flags,+ u_int32_t * startBlock,+ u_int32_t * actualBlocks);++typedef struct hfs_alloc_extra_args {+ // Used with HFS_ALLOC_TRY_HARD and HFS_ALLOC_FORCECONTIG+ uint32_t max_blocks;++ // Used with with HFS_ALLOC_USE_TENTATIVE & HFS_ALLOC_COMMIT+ struct rl_entry **reservation_in;++ // Used with HFS_ALLOC_TENTATIVE & HFS_ALLOC_LOCKED+ struct rl_entry **reservation_out;++ /*+ * If the maximum cannot be returned, the allocation will be+ * trimmed to the specified alignment after taking+ * @alignment_offset into account. @alignment and+ * @alignment_offset are both in terms of blocks, *not* bytes.+ * The result will be such that:+ *+ * (block_count + @alignment_offset) % @alignment == 0+ *+ * Alignment is *not* guaranteed.+ *+ * One example where alignment might be useful is in the case+ * where the page size is greater than the allocation block size+ * and I/O is being performed in multiples of the page size.+ */+ int alignment;+ int alignment_offset;+} hfs_alloc_extra_args_t;++/*+ * Same as BlockAllocate but slightly different API.+ * @extent.startBlock is a hint for where to start searching and+ * @extent.blockCount is the minimum number of blocks acceptable.+ * Additional arguments can be passed in @extra_args and use will+ * depend on @flags. See comment at top of hfs_block_alloc_int for+ * more information.+ */+errno_t hfs_block_alloc(hfsmount_t *hfsmp,+ HFSPlusExtentDescriptor *extent,+ hfs_block_alloc_flags_t flags,+ hfs_alloc_extra_args_t *extra_args);++EXTERN_API_C( OSErr )+BlockDeallocate (ExtendedVCB * vcb,+ u_int32_t firstBlock,+ u_int32_t numBlocks,+ hfs_block_alloc_flags_t flags);++EXTERN_API_C ( void )+ResetVCBFreeExtCache(struct hfsmount *hfsmp);++EXTERN_API_C( OSErr )+BlockMarkAllocated(ExtendedVCB *vcb, u_int32_t startingBlock, u_int32_t numBlocks);++EXTERN_API_C( OSErr )+BlockMarkFree( ExtendedVCB *vcb, u_int32_t startingBlock, u_int32_t numBlocks);++EXTERN_API_C( OSErr )+BlockMarkFreeUnused( ExtendedVCB *vcb, u_int32_t startingBlock, u_int32_t numBlocks);++EXTERN_API_C( u_int32_t )+MetaZoneFreeBlocks(ExtendedVCB *vcb);++EXTERN_API_C( u_int32_t )+UpdateAllocLimit (struct hfsmount *hfsmp, u_int32_t new_end_block);++EXTERN_API_C( u_int32_t )+ScanUnmapBlocks(struct hfsmount *hfsmp);++EXTERN_API_C( int )+hfs_init_summary (struct hfsmount *hfsmp);++errno_t hfs_find_free_extents(struct hfsmount *hfsmp,+ void (*callback)(void *data, off_t), void *callback_arg);++void hfs_free_tentative(hfsmount_t *hfsmp, struct rl_entry **reservation);+void hfs_free_locked(hfsmount_t *hfsmp, struct rl_entry **reservation);++/* File Extent Mapping routines*/+EXTERN_API_C( OSErr )+FlushExtentFile (ExtendedVCB * vcb);++EXTERN_API_C( int32_t )+CompareExtentKeysPlus (const HFSPlusExtentKey *searchKey,+ const HFSPlusExtentKey *trialKey);++OSErr SearchExtentFile(ExtendedVCB *vcb,+ const FCB *fcb,+ int64_t filePosition,+ HFSPlusExtentKey *foundExtentKey,+ HFSPlusExtentRecord foundExtentData,+ u_int32_t *foundExtentDataIndex,+ u_int32_t *extentBTreeHint,+ u_int32_t *endingFABNPlusOne );++EXTERN_API_C( OSErr )+TruncateFileC (ExtendedVCB *vcb, FCB *fcb, int64_t peof, int deleted,+ int rsrc, uint32_t fileid, Boolean truncateToExtent);++EXTERN_API_C( OSErr )+ExtendFileC (ExtendedVCB * vcb,+ FCB * fcb,+ int64_t bytesToAdd,+ u_int32_t blockHint,+ u_int32_t flags,+ int64_t * actualBytesAdded);++EXTERN_API_C( OSErr )+MapFileBlockC (ExtendedVCB * vcb,+ FCB * fcb,+ size_t numberOfBytes,+ off_t offset,+ daddr64_t * startBlock,+ size_t * availableBytes);++OSErr HeadTruncateFile(ExtendedVCB *vcb, FCB *fcb, u_int32_t headblks);++EXTERN_API_C( int )+AddFileExtent (ExtendedVCB *vcb, FCB *fcb, u_int32_t startBlock, u_int32_t blockCount);++#if TARGET_API_MACOS_X+EXTERN_API_C( Boolean )+NodesAreContiguous (ExtendedVCB * vcb,+ FCB * fcb,+ u_int32_t nodeSize);+#endif++/* Get the current time in UTC (GMT)*/+EXTERN_API_C( u_int32_t )+GetTimeUTC (void);++EXTERN_API_C( u_int32_t )+LocalToUTC (u_int32_t localTime);++EXTERN_API_C( u_int32_t )+UTCToLocal (u_int32_t utcTime);+++#ifdef __cplusplus+}+#endif++#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */+#endif /* __FILEMGRINTERNAL__ */+diff --git a/xnu/files/bsd/hfs/HFSUnicodeWrappers.h b/xnu/files/bsd/hfs/HFSUnicodeWrappers.hnew file mode 100644index 0000000..35a394b--- /dev/null+++ b/xnu/files/bsd/hfs/HFSUnicodeWrappers.h@@ -0,0 +1,120 @@+/*+ * Copyright (c) 2000-2003, 2005-2015 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@+ */+/*+ File: HFSUnicodeWrappers.h++ Contains: IPI to Unicode routines used by File Manager.++ Version: HFS Plus 1.0++ Written by: Mark Day++ Copyright: (c) 1996-1997 by Apple Inc., all rights reserved.++ File Ownership:++ DRI: xxx put dri here xxx++ Other Contact: xxx put other contact here xxx++ Technology: xxx put technology here xxx++ Writers:++ (DSH) Deric Horn+ (msd) Mark Day+ (djb) Don Brady++ Change History (most recent first):++ <CS11> 11/16/97 djb Change Unicode.h to UnicodeConverter.h.+ <CS10> 11/7/97 msd Remove prototype for CompareUnicodeNames(). Add prototype for+ FastUnicodeCompare().+ <CS9> 10/13/97 djb Add encoding/index macros and add prototypes for new Get/Set+ encodding routines.+ <CS8> 9/15/97 djb InitUnicodeConverter now takes a boolean.+ <CS7> 9/10/97 msd Add prototype for InitializeEncodingContext.+ <CS6> 6/26/97 DSH Include "MockConverter" prototype for DFA usage.+ <CS5> 6/25/97 DSH Removed Prototype definitions, and checked in Unicode.h and+ TextCommon.h from Julio Gonzales into InternalInterfaces.+ <CS4> 6/25/97 msd Add prototypes for some new Unicode routines that haven't+ appeared in MasterInterfaces yet.+ <CS3> 6/18/97 djb Add more ConversionContexts routines.+ <CS2> 6/13/97 djb Switched to ConvertUnicodeToHFSName, ConvertHFSNameToUnicode, &+ CompareUnicodeNames.+ <CS1> 4/28/97 djb first checked in+ <HFS1> 12/12/96 msd first checked in++*/+#ifndef _HFSUNICODEWRAPPERS_+#define _HFSUNICODEWRAPPERS_++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE++#include "hfs_macos_defs.h"+#include "hfs_format.h"+++extern OSErr ConvertUnicodeToUTF8Mangled ( ByteCount srcLen,+ ConstUniCharArrayPtr srcStr,+ ByteCount maxDstLen,+ ByteCount *actualDstLen,+ unsigned char* dstStr ,+ HFSCatalogNodeID cnid);++/*+ This routine compares two Unicode names based on an ordering defined by the HFS Plus B-tree.+ This ordering must stay fixed for all time.++ Output:+ -n name1 < name2 (i.e. name 1 sorts before name 2)+ 0 name1 = name2+ +n name1 > name2++ NOTE: You should not depend on the magnitude of the result, just its sign. That is, when name1 < name2, then any+ negative number may be returned.+*/++extern int32_t FastUnicodeCompare(register ConstUniCharArrayPtr str1, register ItemCount length1,+ register ConstUniCharArrayPtr str2, register ItemCount length2);++extern int32_t UnicodeBinaryCompare (register ConstUniCharArrayPtr str1, register ItemCount length1,+ register ConstUniCharArrayPtr str2, register ItemCount length2);++extern int32_t FastRelString( ConstStr255Param str1, ConstStr255Param str2 );+++extern HFSCatalogNodeID GetEmbeddedFileID( ConstStr31Param filename, u_int32_t length, u_int32_t *prefixLength );+extern u_int32_t CountFilenameExtensionChars( const unsigned char * filename, u_int32_t length );++#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */+#endif /* _HFSUNICODEWRAPPERS_ */diff --git a/xnu/files/bsd/hfs/MacOSStubs.c b/xnu/files/bsd/hfs/MacOSStubs.cnew file mode 100644index 0000000..abfd208--- /dev/null+++ b/xnu/files/bsd/hfs/MacOSStubs.c@@ -0,0 +1,143 @@+/*+ * Copyright (c) 2000-2015 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@+ */+#include <sys/param.h>+#include <sys/systm.h>+#include <sys/kernel.h>+#include <sys/malloc.h>+#include <sys/types.h>+#include <pexpert/pexpert.h>+#include <IOKit/IOLib.h>++#include "hfs.h"+#include "hfs_dbg.h"+#include "FileMgrInternal.h"++/*+ * gTimeZone should only be used for HFS volumes!+ * It is initialized when an HFS volume is mounted.+ */+struct timezone gTimeZone = {8*60,1};++/*+ * GetTimeUTC - get the GMT Mac OS time (in seconds since 1/1/1904)+ *+ * called by the Catalog Manager when creating/updating HFS Plus records+ */+u_int32_t GetTimeUTC(void)+{+ struct timeval tv;++ microtime(&tv);++ return (tv.tv_sec + MAC_GMT_FACTOR);+}+++/*+ * LocalToUTC - convert from Mac OS local time to Mac OS GMT time.+ * This should only be called for HFS volumes (not for HFS Plus).+ */+u_int32_t LocalToUTC(u_int32_t localTime)+{+ u_int32_t gtime = localTime;++ if (gtime != 0) {+ gtime += (gTimeZone.tz_minuteswest * 60);+ /*+ * We no longer do DST adjustments here since we don't+ * know if time supplied needs adjustment!+ *+ * if (gTimeZone.tz_dsttime)+ * gtime -= 3600;+ */+ }+ return (gtime);+}++/*+ * UTCToLocal - convert from Mac OS GMT time to Mac OS local time.+ * This should only be called for HFS volumes (not for HFS Plus).+ */+u_int32_t UTCToLocal(u_int32_t utcTime)+{+ u_int32_t ltime = utcTime;++ if (ltime != 0) {+ ltime -= (gTimeZone.tz_minuteswest * 60);+ /*+ * We no longer do DST adjustments here since we don't+ * know if time supplied needs adjustment!+ *+ * if (gTimeZone.tz_dsttime)+ * ltime += 3600;+ */+ }+ return (ltime);+}++/*+ * to_bsd_time - convert from Mac OS time (seconds since 1/1/1904)+ * to BSD time (seconds since 1/1/1970)+ */+time_t to_bsd_time(u_int32_t hfs_time)+{+ u_int32_t gmt = hfs_time;++ if (gmt > MAC_GMT_FACTOR)+ gmt -= MAC_GMT_FACTOR;+ else+ gmt = 0; /* don't let date go negative! */++ return (time_t)gmt;+}++/*+ * to_hfs_time - convert from BSD time (seconds since 1/1/1970)+ * to Mac OS time (seconds since 1/1/1904)+ */+u_int32_t to_hfs_time(time_t bsd_time)+{+ u_int32_t hfs_time = (u_int32_t)bsd_time;++ /* don't adjust zero - treat as uninitialzed */+ if (hfs_time != 0)+ hfs_time += MAC_GMT_FACTOR;++ return (hfs_time);+}++void+DebugStr(+ const char * debuggerMsg+ )+{+ kprintf ("*** Mac OS Debugging Message: %s\n", debuggerMsg);+#if DEBUG+ Debugger(debuggerMsg);+#endif+}diff --git a/xnu/files/bsd/hfs/UCStringCompareData.h b/xnu/files/bsd/hfs/UCStringCompareData.hnew file mode 100644index 0000000..7322837--- /dev/null+++ b/xnu/files/bsd/hfs/UCStringCompareData.h@@ -0,0 +1,329 @@+/*+ * Copyright (c) 2000-2002, 2005 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@+ */+/*+ File: UCStringCompareData.h++ Contains: xxx put contents here xxx++ Version: HFS Plus 1.0++ Copyright: (c) 1997-1999 by Apple Inc., all rights reserved.++ File Ownership:++ DRI: Mark Day++ Other Contact: xxx put other contact here xxx++ Technology: xxx put technology here xxx++ Writers:++ (djb) Don Brady+ (msd) Mark Day++ Change History (most recent first):++ <CS4> 11/16/97 djb msd. Updated lower case table with ignorable mappings and less+ aggressive case folding. Added a trailing comma to make the+ StreamEdit script work right. Removed Unicode decomposition+ tables. Case folding tables convert u+0000 to 0xFFFF so that the+ NUL character can appear in names, while still allowing a zero+ value to be a sentinel. (From Andy Daniels, 11/10/97)+ <CS3> 8/26/97 djb Tweak gLowerCaseTable to make it faster.+ <CS2> 8/14/97 djb Add RelString compare table...+ <CS1> 4/24/97 djb first checked in+ <HFS1> 2/27/97 msd first checked in+*/++#ifndef _UCSTRINGCOMPAREDATA_+#define _UCSTRINGCOMPAREDATA_++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE+/*+ * For better performance, the case folding table for basic latin+ * is seperate from the others. This eliminates the extra lookup+ * to get the offset to this table.+ *+ * Note: 0x0000 now maps to 0 so that it will be ignored+ */+u_int16_t gLatinCaseFold[] = {+ /* 0 */ 0xFFFF, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,+ /* 1 */ 0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,+ /* 2 */ 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,+ /* 3 */ 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,+ /* 4 */ 0x0040, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,+ /* 5 */ 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,+ /* 6 */ 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,+ /* 7 */ 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,+ /* 8 */ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,+ /* 9 */ 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,+ /* A */ 0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,+ /* B */ 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,+ /* C */ 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00E6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,+ /* D */ 0x00F0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7, 0x00F8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00FE, 0x00DF,+ /* E */ 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,+ /* F */ 0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF,+};++/* The lower case table consists of a 256-entry high-byte table followed by some number of+ 256-entry subtables. The high-byte table contains either an offset to the subtable for+ characters with that high byte or zero, which means that there are no case mappings or+ ignored characters in that block. Ignored characters are mapped to zero.+ */++u_int16_t gLowerCaseTable[] = {++ /* High-byte indices ( == 0 iff no case mapping and no ignorables ) */++ /* 0 */ 0x0000, 0x0100, 0x0000, 0x0200, 0x0300, 0x0400, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 1 */ 0x0500, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 2 */ 0x0600, 0x0700, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 3 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 4 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 5 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 6 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 7 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 9 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* A */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* B */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* C */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* D */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* E */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* F */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0800, 0x0900,++ /* Table 1 (for high byte 0x01) */++ /* 0 */ 0x0100, 0x0101, 0x0102, 0x0103, 0x0104, 0x0105, 0x0106, 0x0107, 0x0108, 0x0109, 0x010A, 0x010B, 0x010C, 0x010D, 0x010E, 0x010F,+ /* 1 */ 0x0111, 0x0111, 0x0112, 0x0113, 0x0114, 0x0115, 0x0116, 0x0117, 0x0118, 0x0119, 0x011A, 0x011B, 0x011C, 0x011D, 0x011E, 0x011F,+ /* 2 */ 0x0120, 0x0121, 0x0122, 0x0123, 0x0124, 0x0125, 0x0127, 0x0127, 0x0128, 0x0129, 0x012A, 0x012B, 0x012C, 0x012D, 0x012E, 0x012F,+ /* 3 */ 0x0130, 0x0131, 0x0133, 0x0133, 0x0134, 0x0135, 0x0136, 0x0137, 0x0138, 0x0139, 0x013A, 0x013B, 0x013C, 0x013D, 0x013E, 0x0140,+ /* 4 */ 0x0140, 0x0142, 0x0142, 0x0143, 0x0144, 0x0145, 0x0146, 0x0147, 0x0148, 0x0149, 0x014B, 0x014B, 0x014C, 0x014D, 0x014E, 0x014F,+ /* 5 */ 0x0150, 0x0151, 0x0153, 0x0153, 0x0154, 0x0155, 0x0156, 0x0157, 0x0158, 0x0159, 0x015A, 0x015B, 0x015C, 0x015D, 0x015E, 0x015F,+ /* 6 */ 0x0160, 0x0161, 0x0162, 0x0163, 0x0164, 0x0165, 0x0167, 0x0167, 0x0168, 0x0169, 0x016A, 0x016B, 0x016C, 0x016D, 0x016E, 0x016F,+ /* 7 */ 0x0170, 0x0171, 0x0172, 0x0173, 0x0174, 0x0175, 0x0176, 0x0177, 0x0178, 0x0179, 0x017A, 0x017B, 0x017C, 0x017D, 0x017E, 0x017F,+ /* 8 */ 0x0180, 0x0253, 0x0183, 0x0183, 0x0185, 0x0185, 0x0254, 0x0188, 0x0188, 0x0256, 0x0257, 0x018C, 0x018C, 0x018D, 0x01DD, 0x0259,+ /* 9 */ 0x025B, 0x0192, 0x0192, 0x0260, 0x0263, 0x0195, 0x0269, 0x0268, 0x0199, 0x0199, 0x019A, 0x019B, 0x026F, 0x0272, 0x019E, 0x0275,+ /* A */ 0x01A0, 0x01A1, 0x01A3, 0x01A3, 0x01A5, 0x01A5, 0x01A6, 0x01A8, 0x01A8, 0x0283, 0x01AA, 0x01AB, 0x01AD, 0x01AD, 0x0288, 0x01AF,+ /* B */ 0x01B0, 0x028A, 0x028B, 0x01B4, 0x01B4, 0x01B6, 0x01B6, 0x0292, 0x01B9, 0x01B9, 0x01BA, 0x01BB, 0x01BD, 0x01BD, 0x01BE, 0x01BF,+ /* C */ 0x01C0, 0x01C1, 0x01C2, 0x01C3, 0x01C6, 0x01C6, 0x01C6, 0x01C9, 0x01C9, 0x01C9, 0x01CC, 0x01CC, 0x01CC, 0x01CD, 0x01CE, 0x01CF,+ /* D */ 0x01D0, 0x01D1, 0x01D2, 0x01D3, 0x01D4, 0x01D5, 0x01D6, 0x01D7, 0x01D8, 0x01D9, 0x01DA, 0x01DB, 0x01DC, 0x01DD, 0x01DE, 0x01DF,+ /* E */ 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E5, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF,+ /* F */ 0x01F0, 0x01F3, 0x01F3, 0x01F3, 0x01F4, 0x01F5, 0x01F6, 0x01F7, 0x01F8, 0x01F9, 0x01FA, 0x01FB, 0x01FC, 0x01FD, 0x01FE, 0x01FF,++ /* Table 2 (for high byte 0x03) */++ /* 0 */ 0x0300, 0x0301, 0x0302, 0x0303, 0x0304, 0x0305, 0x0306, 0x0307, 0x0308, 0x0309, 0x030A, 0x030B, 0x030C, 0x030D, 0x030E, 0x030F,+ /* 1 */ 0x0310, 0x0311, 0x0312, 0x0313, 0x0314, 0x0315, 0x0316, 0x0317, 0x0318, 0x0319, 0x031A, 0x031B, 0x031C, 0x031D, 0x031E, 0x031F,+ /* 2 */ 0x0320, 0x0321, 0x0322, 0x0323, 0x0324, 0x0325, 0x0326, 0x0327, 0x0328, 0x0329, 0x032A, 0x032B, 0x032C, 0x032D, 0x032E, 0x032F,+ /* 3 */ 0x0330, 0x0331, 0x0332, 0x0333, 0x0334, 0x0335, 0x0336, 0x0337, 0x0338, 0x0339, 0x033A, 0x033B, 0x033C, 0x033D, 0x033E, 0x033F,+ /* 4 */ 0x0340, 0x0341, 0x0342, 0x0343, 0x0344, 0x0345, 0x0346, 0x0347, 0x0348, 0x0349, 0x034A, 0x034B, 0x034C, 0x034D, 0x034E, 0x034F,+ /* 5 */ 0x0350, 0x0351, 0x0352, 0x0353, 0x0354, 0x0355, 0x0356, 0x0357, 0x0358, 0x0359, 0x035A, 0x035B, 0x035C, 0x035D, 0x035E, 0x035F,+ /* 6 */ 0x0360, 0x0361, 0x0362, 0x0363, 0x0364, 0x0365, 0x0366, 0x0367, 0x0368, 0x0369, 0x036A, 0x036B, 0x036C, 0x036D, 0x036E, 0x036F,+ /* 7 */ 0x0370, 0x0371, 0x0372, 0x0373, 0x0374, 0x0375, 0x0376, 0x0377, 0x0378, 0x0379, 0x037A, 0x037B, 0x037C, 0x037D, 0x037E, 0x037F,+ /* 8 */ 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386, 0x0387, 0x0388, 0x0389, 0x038A, 0x038B, 0x038C, 0x038D, 0x038E, 0x038F,+ /* 9 */ 0x0390, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,+ /* A */ 0x03C0, 0x03C1, 0x03A2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8, 0x03C9, 0x03AA, 0x03AB, 0x03AC, 0x03AD, 0x03AE, 0x03AF,+ /* B */ 0x03B0, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,+ /* C */ 0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE, 0x03CF,+ /* D */ 0x03D0, 0x03D1, 0x03D2, 0x03D3, 0x03D4, 0x03D5, 0x03D6, 0x03D7, 0x03D8, 0x03D9, 0x03DA, 0x03DB, 0x03DC, 0x03DD, 0x03DE, 0x03DF,+ /* E */ 0x03E0, 0x03E1, 0x03E3, 0x03E3, 0x03E5, 0x03E5, 0x03E7, 0x03E7, 0x03E9, 0x03E9, 0x03EB, 0x03EB, 0x03ED, 0x03ED, 0x03EF, 0x03EF,+ /* F */ 0x03F0, 0x03F1, 0x03F2, 0x03F3, 0x03F4, 0x03F5, 0x03F6, 0x03F7, 0x03F8, 0x03F9, 0x03FA, 0x03FB, 0x03FC, 0x03FD, 0x03FE, 0x03FF,++ /* Table 3 (for high byte 0x04) */++ /* 0 */ 0x0400, 0x0401, 0x0452, 0x0403, 0x0454, 0x0455, 0x0456, 0x0407, 0x0458, 0x0459, 0x045A, 0x045B, 0x040C, 0x040D, 0x040E, 0x045F,+ /* 1 */ 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0419, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,+ /* 2 */ 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,+ /* 3 */ 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,+ /* 4 */ 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,+ /* 5 */ 0x0450, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457, 0x0458, 0x0459, 0x045A, 0x045B, 0x045C, 0x045D, 0x045E, 0x045F,+ /* 6 */ 0x0461, 0x0461, 0x0463, 0x0463, 0x0465, 0x0465, 0x0467, 0x0467, 0x0469, 0x0469, 0x046B, 0x046B, 0x046D, 0x046D, 0x046F, 0x046F,+ /* 7 */ 0x0471, 0x0471, 0x0473, 0x0473, 0x0475, 0x0475, 0x0476, 0x0477, 0x0479, 0x0479, 0x047B, 0x047B, 0x047D, 0x047D, 0x047F, 0x047F,+ /* 8 */ 0x0481, 0x0481, 0x0482, 0x0483, 0x0484, 0x0485, 0x0486, 0x0487, 0x0488, 0x0489, 0x048A, 0x048B, 0x048C, 0x048D, 0x048E, 0x048F,+ /* 9 */ 0x0491, 0x0491, 0x0493, 0x0493, 0x0495, 0x0495, 0x0497, 0x0497, 0x0499, 0x0499, 0x049B, 0x049B, 0x049D, 0x049D, 0x049F, 0x049F,+ /* A */ 0x04A1, 0x04A1, 0x04A3, 0x04A3, 0x04A5, 0x04A5, 0x04A7, 0x04A7, 0x04A9, 0x04A9, 0x04AB, 0x04AB, 0x04AD, 0x04AD, 0x04AF, 0x04AF,+ /* B */ 0x04B1, 0x04B1, 0x04B3, 0x04B3, 0x04B5, 0x04B5, 0x04B7, 0x04B7, 0x04B9, 0x04B9, 0x04BB, 0x04BB, 0x04BD, 0x04BD, 0x04BF, 0x04BF,+ /* C */ 0x04C0, 0x04C1, 0x04C2, 0x04C4, 0x04C4, 0x04C5, 0x04C6, 0x04C8, 0x04C8, 0x04C9, 0x04CA, 0x04CC, 0x04CC, 0x04CD, 0x04CE, 0x04CF,+ /* D */ 0x04D0, 0x04D1, 0x04D2, 0x04D3, 0x04D4, 0x04D5, 0x04D6, 0x04D7, 0x04D8, 0x04D9, 0x04DA, 0x04DB, 0x04DC, 0x04DD, 0x04DE, 0x04DF,+ /* E */ 0x04E0, 0x04E1, 0x04E2, 0x04E3, 0x04E4, 0x04E5, 0x04E6, 0x04E7, 0x04E8, 0x04E9, 0x04EA, 0x04EB, 0x04EC, 0x04ED, 0x04EE, 0x04EF,+ /* F */ 0x04F0, 0x04F1, 0x04F2, 0x04F3, 0x04F4, 0x04F5, 0x04F6, 0x04F7, 0x04F8, 0x04F9, 0x04FA, 0x04FB, 0x04FC, 0x04FD, 0x04FE, 0x04FF,++ /* Table 4 (for high byte 0x05) */++ /* 0 */ 0x0500, 0x0501, 0x0502, 0x0503, 0x0504, 0x0505, 0x0506, 0x0507, 0x0508, 0x0509, 0x050A, 0x050B, 0x050C, 0x050D, 0x050E, 0x050F,+ /* 1 */ 0x0510, 0x0511, 0x0512, 0x0513, 0x0514, 0x0515, 0x0516, 0x0517, 0x0518, 0x0519, 0x051A, 0x051B, 0x051C, 0x051D, 0x051E, 0x051F,+ /* 2 */ 0x0520, 0x0521, 0x0522, 0x0523, 0x0524, 0x0525, 0x0526, 0x0527, 0x0528, 0x0529, 0x052A, 0x052B, 0x052C, 0x052D, 0x052E, 0x052F,+ /* 3 */ 0x0530, 0x0561, 0x0562, 0x0563, 0x0564, 0x0565, 0x0566, 0x0567, 0x0568, 0x0569, 0x056A, 0x056B, 0x056C, 0x056D, 0x056E, 0x056F,+ /* 4 */ 0x0570, 0x0571, 0x0572, 0x0573, 0x0574, 0x0575, 0x0576, 0x0577, 0x0578, 0x0579, 0x057A, 0x057B, 0x057C, 0x057D, 0x057E, 0x057F,+ /* 5 */ 0x0580, 0x0581, 0x0582, 0x0583, 0x0584, 0x0585, 0x0586, 0x0557, 0x0558, 0x0559, 0x055A, 0x055B, 0x055C, 0x055D, 0x055E, 0x055F,+ /* 6 */ 0x0560, 0x0561, 0x0562, 0x0563, 0x0564, 0x0565, 0x0566, 0x0567, 0x0568, 0x0569, 0x056A, 0x056B, 0x056C, 0x056D, 0x056E, 0x056F,+ /* 7 */ 0x0570, 0x0571, 0x0572, 0x0573, 0x0574, 0x0575, 0x0576, 0x0577, 0x0578, 0x0579, 0x057A, 0x057B, 0x057C, 0x057D, 0x057E, 0x057F,+ /* 8 */ 0x0580, 0x0581, 0x0582, 0x0583, 0x0584, 0x0585, 0x0586, 0x0587, 0x0588, 0x0589, 0x058A, 0x058B, 0x058C, 0x058D, 0x058E, 0x058F,+ /* 9 */ 0x0590, 0x0591, 0x0592, 0x0593, 0x0594, 0x0595, 0x0596, 0x0597, 0x0598, 0x0599, 0x059A, 0x059B, 0x059C, 0x059D, 0x059E, 0x059F,+ /* A */ 0x05A0, 0x05A1, 0x05A2, 0x05A3, 0x05A4, 0x05A5, 0x05A6, 0x05A7, 0x05A8, 0x05A9, 0x05AA, 0x05AB, 0x05AC, 0x05AD, 0x05AE, 0x05AF,+ /* B */ 0x05B0, 0x05B1, 0x05B2, 0x05B3, 0x05B4, 0x05B5, 0x05B6, 0x05B7, 0x05B8, 0x05B9, 0x05BA, 0x05BB, 0x05BC, 0x05BD, 0x05BE, 0x05BF,+ /* C */ 0x05C0, 0x05C1, 0x05C2, 0x05C3, 0x05C4, 0x05C5, 0x05C6, 0x05C7, 0x05C8, 0x05C9, 0x05CA, 0x05CB, 0x05CC, 0x05CD, 0x05CE, 0x05CF,+ /* D */ 0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7, 0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,+ /* E */ 0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7, 0x05E8, 0x05E9, 0x05EA, 0x05EB, 0x05EC, 0x05ED, 0x05EE, 0x05EF,+ /* F */ 0x05F0, 0x05F1, 0x05F2, 0x05F3, 0x05F4, 0x05F5, 0x05F6, 0x05F7, 0x05F8, 0x05F9, 0x05FA, 0x05FB, 0x05FC, 0x05FD, 0x05FE, 0x05FF,++ /* Table 5 (for high byte 0x10) */++ /* 0 */ 0x1000, 0x1001, 0x1002, 0x1003, 0x1004, 0x1005, 0x1006, 0x1007, 0x1008, 0x1009, 0x100A, 0x100B, 0x100C, 0x100D, 0x100E, 0x100F,+ /* 1 */ 0x1010, 0x1011, 0x1012, 0x1013, 0x1014, 0x1015, 0x1016, 0x1017, 0x1018, 0x1019, 0x101A, 0x101B, 0x101C, 0x101D, 0x101E, 0x101F,+ /* 2 */ 0x1020, 0x1021, 0x1022, 0x1023, 0x1024, 0x1025, 0x1026, 0x1027, 0x1028, 0x1029, 0x102A, 0x102B, 0x102C, 0x102D, 0x102E, 0x102F,+ /* 3 */ 0x1030, 0x1031, 0x1032, 0x1033, 0x1034, 0x1035, 0x1036, 0x1037, 0x1038, 0x1039, 0x103A, 0x103B, 0x103C, 0x103D, 0x103E, 0x103F,+ /* 4 */ 0x1040, 0x1041, 0x1042, 0x1043, 0x1044, 0x1045, 0x1046, 0x1047, 0x1048, 0x1049, 0x104A, 0x104B, 0x104C, 0x104D, 0x104E, 0x104F,+ /* 5 */ 0x1050, 0x1051, 0x1052, 0x1053, 0x1054, 0x1055, 0x1056, 0x1057, 0x1058, 0x1059, 0x105A, 0x105B, 0x105C, 0x105D, 0x105E, 0x105F,+ /* 6 */ 0x1060, 0x1061, 0x1062, 0x1063, 0x1064, 0x1065, 0x1066, 0x1067, 0x1068, 0x1069, 0x106A, 0x106B, 0x106C, 0x106D, 0x106E, 0x106F,+ /* 7 */ 0x1070, 0x1071, 0x1072, 0x1073, 0x1074, 0x1075, 0x1076, 0x1077, 0x1078, 0x1079, 0x107A, 0x107B, 0x107C, 0x107D, 0x107E, 0x107F,+ /* 8 */ 0x1080, 0x1081, 0x1082, 0x1083, 0x1084, 0x1085, 0x1086, 0x1087, 0x1088, 0x1089, 0x108A, 0x108B, 0x108C, 0x108D, 0x108E, 0x108F,+ /* 9 */ 0x1090, 0x1091, 0x1092, 0x1093, 0x1094, 0x1095, 0x1096, 0x1097, 0x1098, 0x1099, 0x109A, 0x109B, 0x109C, 0x109D, 0x109E, 0x109F,+ /* A */ 0x10D0, 0x10D1, 0x10D2, 0x10D3, 0x10D4, 0x10D5, 0x10D6, 0x10D7, 0x10D8, 0x10D9, 0x10DA, 0x10DB, 0x10DC, 0x10DD, 0x10DE, 0x10DF,+ /* B */ 0x10E0, 0x10E1, 0x10E2, 0x10E3, 0x10E4, 0x10E5, 0x10E6, 0x10E7, 0x10E8, 0x10E9, 0x10EA, 0x10EB, 0x10EC, 0x10ED, 0x10EE, 0x10EF,+ /* C */ 0x10F0, 0x10F1, 0x10F2, 0x10F3, 0x10F4, 0x10F5, 0x10C6, 0x10C7, 0x10C8, 0x10C9, 0x10CA, 0x10CB, 0x10CC, 0x10CD, 0x10CE, 0x10CF,+ /* D */ 0x10D0, 0x10D1, 0x10D2, 0x10D3, 0x10D4, 0x10D5, 0x10D6, 0x10D7, 0x10D8, 0x10D9, 0x10DA, 0x10DB, 0x10DC, 0x10DD, 0x10DE, 0x10DF,+ /* E */ 0x10E0, 0x10E1, 0x10E2, 0x10E3, 0x10E4, 0x10E5, 0x10E6, 0x10E7, 0x10E8, 0x10E9, 0x10EA, 0x10EB, 0x10EC, 0x10ED, 0x10EE, 0x10EF,+ /* F */ 0x10F0, 0x10F1, 0x10F2, 0x10F3, 0x10F4, 0x10F5, 0x10F6, 0x10F7, 0x10F8, 0x10F9, 0x10FA, 0x10FB, 0x10FC, 0x10FD, 0x10FE, 0x10FF,++ /* Table 6 (for high byte 0x20) */++ /* 0 */ 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x200B, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 1 */ 0x2010, 0x2011, 0x2012, 0x2013, 0x2014, 0x2015, 0x2016, 0x2017, 0x2018, 0x2019, 0x201A, 0x201B, 0x201C, 0x201D, 0x201E, 0x201F,+ /* 2 */ 0x2020, 0x2021, 0x2022, 0x2023, 0x2024, 0x2025, 0x2026, 0x2027, 0x2028, 0x2029, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x202F,+ /* 3 */ 0x2030, 0x2031, 0x2032, 0x2033, 0x2034, 0x2035, 0x2036, 0x2037, 0x2038, 0x2039, 0x203A, 0x203B, 0x203C, 0x203D, 0x203E, 0x203F,+ /* 4 */ 0x2040, 0x2041, 0x2042, 0x2043, 0x2044, 0x2045, 0x2046, 0x2047, 0x2048, 0x2049, 0x204A, 0x204B, 0x204C, 0x204D, 0x204E, 0x204F,+ /* 5 */ 0x2050, 0x2051, 0x2052, 0x2053, 0x2054, 0x2055, 0x2056, 0x2057, 0x2058, 0x2059, 0x205A, 0x205B, 0x205C, 0x205D, 0x205E, 0x205F,+ /* 6 */ 0x2060, 0x2061, 0x2062, 0x2063, 0x2064, 0x2065, 0x2066, 0x2067, 0x2068, 0x2069, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 7 */ 0x2070, 0x2071, 0x2072, 0x2073, 0x2074, 0x2075, 0x2076, 0x2077, 0x2078, 0x2079, 0x207A, 0x207B, 0x207C, 0x207D, 0x207E, 0x207F,+ /* 8 */ 0x2080, 0x2081, 0x2082, 0x2083, 0x2084, 0x2085, 0x2086, 0x2087, 0x2088, 0x2089, 0x208A, 0x208B, 0x208C, 0x208D, 0x208E, 0x208F,+ /* 9 */ 0x2090, 0x2091, 0x2092, 0x2093, 0x2094, 0x2095, 0x2096, 0x2097, 0x2098, 0x2099, 0x209A, 0x209B, 0x209C, 0x209D, 0x209E, 0x209F,+ /* A */ 0x20A0, 0x20A1, 0x20A2, 0x20A3, 0x20A4, 0x20A5, 0x20A6, 0x20A7, 0x20A8, 0x20A9, 0x20AA, 0x20AB, 0x20AC, 0x20AD, 0x20AE, 0x20AF,+ /* B */ 0x20B0, 0x20B1, 0x20B2, 0x20B3, 0x20B4, 0x20B5, 0x20B6, 0x20B7, 0x20B8, 0x20B9, 0x20BA, 0x20BB, 0x20BC, 0x20BD, 0x20BE, 0x20BF,+ /* C */ 0x20C0, 0x20C1, 0x20C2, 0x20C3, 0x20C4, 0x20C5, 0x20C6, 0x20C7, 0x20C8, 0x20C9, 0x20CA, 0x20CB, 0x20CC, 0x20CD, 0x20CE, 0x20CF,+ /* D */ 0x20D0, 0x20D1, 0x20D2, 0x20D3, 0x20D4, 0x20D5, 0x20D6, 0x20D7, 0x20D8, 0x20D9, 0x20DA, 0x20DB, 0x20DC, 0x20DD, 0x20DE, 0x20DF,+ /* E */ 0x20E0, 0x20E1, 0x20E2, 0x20E3, 0x20E4, 0x20E5, 0x20E6, 0x20E7, 0x20E8, 0x20E9, 0x20EA, 0x20EB, 0x20EC, 0x20ED, 0x20EE, 0x20EF,+ /* F */ 0x20F0, 0x20F1, 0x20F2, 0x20F3, 0x20F4, 0x20F5, 0x20F6, 0x20F7, 0x20F8, 0x20F9, 0x20FA, 0x20FB, 0x20FC, 0x20FD, 0x20FE, 0x20FF,++ /* Table 7 (for high byte 0x21) */++ /* 0 */ 0x2100, 0x2101, 0x2102, 0x2103, 0x2104, 0x2105, 0x2106, 0x2107, 0x2108, 0x2109, 0x210A, 0x210B, 0x210C, 0x210D, 0x210E, 0x210F,+ /* 1 */ 0x2110, 0x2111, 0x2112, 0x2113, 0x2114, 0x2115, 0x2116, 0x2117, 0x2118, 0x2119, 0x211A, 0x211B, 0x211C, 0x211D, 0x211E, 0x211F,+ /* 2 */ 0x2120, 0x2121, 0x2122, 0x2123, 0x2124, 0x2125, 0x2126, 0x2127, 0x2128, 0x2129, 0x212A, 0x212B, 0x212C, 0x212D, 0x212E, 0x212F,+ /* 3 */ 0x2130, 0x2131, 0x2132, 0x2133, 0x2134, 0x2135, 0x2136, 0x2137, 0x2138, 0x2139, 0x213A, 0x213B, 0x213C, 0x213D, 0x213E, 0x213F,+ /* 4 */ 0x2140, 0x2141, 0x2142, 0x2143, 0x2144, 0x2145, 0x2146, 0x2147, 0x2148, 0x2149, 0x214A, 0x214B, 0x214C, 0x214D, 0x214E, 0x214F,+ /* 5 */ 0x2150, 0x2151, 0x2152, 0x2153, 0x2154, 0x2155, 0x2156, 0x2157, 0x2158, 0x2159, 0x215A, 0x215B, 0x215C, 0x215D, 0x215E, 0x215F,+ /* 6 */ 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177, 0x2178, 0x2179, 0x217A, 0x217B, 0x217C, 0x217D, 0x217E, 0x217F,+ /* 7 */ 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177, 0x2178, 0x2179, 0x217A, 0x217B, 0x217C, 0x217D, 0x217E, 0x217F,+ /* 8 */ 0x2180, 0x2181, 0x2182, 0x2183, 0x2184, 0x2185, 0x2186, 0x2187, 0x2188, 0x2189, 0x218A, 0x218B, 0x218C, 0x218D, 0x218E, 0x218F,+ /* 9 */ 0x2190, 0x2191, 0x2192, 0x2193, 0x2194, 0x2195, 0x2196, 0x2197, 0x2198, 0x2199, 0x219A, 0x219B, 0x219C, 0x219D, 0x219E, 0x219F,+ /* A */ 0x21A0, 0x21A1, 0x21A2, 0x21A3, 0x21A4, 0x21A5, 0x21A6, 0x21A7, 0x21A8, 0x21A9, 0x21AA, 0x21AB, 0x21AC, 0x21AD, 0x21AE, 0x21AF,+ /* B */ 0x21B0, 0x21B1, 0x21B2, 0x21B3, 0x21B4, 0x21B5, 0x21B6, 0x21B7, 0x21B8, 0x21B9, 0x21BA, 0x21BB, 0x21BC, 0x21BD, 0x21BE, 0x21BF,+ /* C */ 0x21C0, 0x21C1, 0x21C2, 0x21C3, 0x21C4, 0x21C5, 0x21C6, 0x21C7, 0x21C8, 0x21C9, 0x21CA, 0x21CB, 0x21CC, 0x21CD, 0x21CE, 0x21CF,+ /* D */ 0x21D0, 0x21D1, 0x21D2, 0x21D3, 0x21D4, 0x21D5, 0x21D6, 0x21D7, 0x21D8, 0x21D9, 0x21DA, 0x21DB, 0x21DC, 0x21DD, 0x21DE, 0x21DF,+ /* E */ 0x21E0, 0x21E1, 0x21E2, 0x21E3, 0x21E4, 0x21E5, 0x21E6, 0x21E7, 0x21E8, 0x21E9, 0x21EA, 0x21EB, 0x21EC, 0x21ED, 0x21EE, 0x21EF,+ /* F */ 0x21F0, 0x21F1, 0x21F2, 0x21F3, 0x21F4, 0x21F5, 0x21F6, 0x21F7, 0x21F8, 0x21F9, 0x21FA, 0x21FB, 0x21FC, 0x21FD, 0x21FE, 0x21FF,++ /* Table 8 (for high byte 0xFE) */++ /* 0 */ 0xFE00, 0xFE01, 0xFE02, 0xFE03, 0xFE04, 0xFE05, 0xFE06, 0xFE07, 0xFE08, 0xFE09, 0xFE0A, 0xFE0B, 0xFE0C, 0xFE0D, 0xFE0E, 0xFE0F,+ /* 1 */ 0xFE10, 0xFE11, 0xFE12, 0xFE13, 0xFE14, 0xFE15, 0xFE16, 0xFE17, 0xFE18, 0xFE19, 0xFE1A, 0xFE1B, 0xFE1C, 0xFE1D, 0xFE1E, 0xFE1F,+ /* 2 */ 0xFE20, 0xFE21, 0xFE22, 0xFE23, 0xFE24, 0xFE25, 0xFE26, 0xFE27, 0xFE28, 0xFE29, 0xFE2A, 0xFE2B, 0xFE2C, 0xFE2D, 0xFE2E, 0xFE2F,+ /* 3 */ 0xFE30, 0xFE31, 0xFE32, 0xFE33, 0xFE34, 0xFE35, 0xFE36, 0xFE37, 0xFE38, 0xFE39, 0xFE3A, 0xFE3B, 0xFE3C, 0xFE3D, 0xFE3E, 0xFE3F,+ /* 4 */ 0xFE40, 0xFE41, 0xFE42, 0xFE43, 0xFE44, 0xFE45, 0xFE46, 0xFE47, 0xFE48, 0xFE49, 0xFE4A, 0xFE4B, 0xFE4C, 0xFE4D, 0xFE4E, 0xFE4F,+ /* 5 */ 0xFE50, 0xFE51, 0xFE52, 0xFE53, 0xFE54, 0xFE55, 0xFE56, 0xFE57, 0xFE58, 0xFE59, 0xFE5A, 0xFE5B, 0xFE5C, 0xFE5D, 0xFE5E, 0xFE5F,+ /* 6 */ 0xFE60, 0xFE61, 0xFE62, 0xFE63, 0xFE64, 0xFE65, 0xFE66, 0xFE67, 0xFE68, 0xFE69, 0xFE6A, 0xFE6B, 0xFE6C, 0xFE6D, 0xFE6E, 0xFE6F,+ /* 7 */ 0xFE70, 0xFE71, 0xFE72, 0xFE73, 0xFE74, 0xFE75, 0xFE76, 0xFE77, 0xFE78, 0xFE79, 0xFE7A, 0xFE7B, 0xFE7C, 0xFE7D, 0xFE7E, 0xFE7F,+ /* 8 */ 0xFE80, 0xFE81, 0xFE82, 0xFE83, 0xFE84, 0xFE85, 0xFE86, 0xFE87, 0xFE88, 0xFE89, 0xFE8A, 0xFE8B, 0xFE8C, 0xFE8D, 0xFE8E, 0xFE8F,+ /* 9 */ 0xFE90, 0xFE91, 0xFE92, 0xFE93, 0xFE94, 0xFE95, 0xFE96, 0xFE97, 0xFE98, 0xFE99, 0xFE9A, 0xFE9B, 0xFE9C, 0xFE9D, 0xFE9E, 0xFE9F,+ /* A */ 0xFEA0, 0xFEA1, 0xFEA2, 0xFEA3, 0xFEA4, 0xFEA5, 0xFEA6, 0xFEA7, 0xFEA8, 0xFEA9, 0xFEAA, 0xFEAB, 0xFEAC, 0xFEAD, 0xFEAE, 0xFEAF,+ /* B */ 0xFEB0, 0xFEB1, 0xFEB2, 0xFEB3, 0xFEB4, 0xFEB5, 0xFEB6, 0xFEB7, 0xFEB8, 0xFEB9, 0xFEBA, 0xFEBB, 0xFEBC, 0xFEBD, 0xFEBE, 0xFEBF,+ /* C */ 0xFEC0, 0xFEC1, 0xFEC2, 0xFEC3, 0xFEC4, 0xFEC5, 0xFEC6, 0xFEC7, 0xFEC8, 0xFEC9, 0xFECA, 0xFECB, 0xFECC, 0xFECD, 0xFECE, 0xFECF,+ /* D */ 0xFED0, 0xFED1, 0xFED2, 0xFED3, 0xFED4, 0xFED5, 0xFED6, 0xFED7, 0xFED8, 0xFED9, 0xFEDA, 0xFEDB, 0xFEDC, 0xFEDD, 0xFEDE, 0xFEDF,+ /* E */ 0xFEE0, 0xFEE1, 0xFEE2, 0xFEE3, 0xFEE4, 0xFEE5, 0xFEE6, 0xFEE7, 0xFEE8, 0xFEE9, 0xFEEA, 0xFEEB, 0xFEEC, 0xFEED, 0xFEEE, 0xFEEF,+ /* F */ 0xFEF0, 0xFEF1, 0xFEF2, 0xFEF3, 0xFEF4, 0xFEF5, 0xFEF6, 0xFEF7, 0xFEF8, 0xFEF9, 0xFEFA, 0xFEFB, 0xFEFC, 0xFEFD, 0xFEFE, 0x0000,++ /* Table 9 (for high byte 0xFF) */++ /* 0 */ 0xFF00, 0xFF01, 0xFF02, 0xFF03, 0xFF04, 0xFF05, 0xFF06, 0xFF07, 0xFF08, 0xFF09, 0xFF0A, 0xFF0B, 0xFF0C, 0xFF0D, 0xFF0E, 0xFF0F,+ /* 1 */ 0xFF10, 0xFF11, 0xFF12, 0xFF13, 0xFF14, 0xFF15, 0xFF16, 0xFF17, 0xFF18, 0xFF19, 0xFF1A, 0xFF1B, 0xFF1C, 0xFF1D, 0xFF1E, 0xFF1F,+ /* 2 */ 0xFF20, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F,+ /* 3 */ 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A, 0xFF3B, 0xFF3C, 0xFF3D, 0xFF3E, 0xFF3F,+ /* 4 */ 0xFF40, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F,+ /* 5 */ 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A, 0xFF5B, 0xFF5C, 0xFF5D, 0xFF5E, 0xFF5F,+ /* 6 */ 0xFF60, 0xFF61, 0xFF62, 0xFF63, 0xFF64, 0xFF65, 0xFF66, 0xFF67, 0xFF68, 0xFF69, 0xFF6A, 0xFF6B, 0xFF6C, 0xFF6D, 0xFF6E, 0xFF6F,+ /* 7 */ 0xFF70, 0xFF71, 0xFF72, 0xFF73, 0xFF74, 0xFF75, 0xFF76, 0xFF77, 0xFF78, 0xFF79, 0xFF7A, 0xFF7B, 0xFF7C, 0xFF7D, 0xFF7E, 0xFF7F,+ /* 8 */ 0xFF80, 0xFF81, 0xFF82, 0xFF83, 0xFF84, 0xFF85, 0xFF86, 0xFF87, 0xFF88, 0xFF89, 0xFF8A, 0xFF8B, 0xFF8C, 0xFF8D, 0xFF8E, 0xFF8F,+ /* 9 */ 0xFF90, 0xFF91, 0xFF92, 0xFF93, 0xFF94, 0xFF95, 0xFF96, 0xFF97, 0xFF98, 0xFF99, 0xFF9A, 0xFF9B, 0xFF9C, 0xFF9D, 0xFF9E, 0xFF9F,+ /* A */ 0xFFA0, 0xFFA1, 0xFFA2, 0xFFA3, 0xFFA4, 0xFFA5, 0xFFA6, 0xFFA7, 0xFFA8, 0xFFA9, 0xFFAA, 0xFFAB, 0xFFAC, 0xFFAD, 0xFFAE, 0xFFAF,+ /* B */ 0xFFB0, 0xFFB1, 0xFFB2, 0xFFB3, 0xFFB4, 0xFFB5, 0xFFB6, 0xFFB7, 0xFFB8, 0xFFB9, 0xFFBA, 0xFFBB, 0xFFBC, 0xFFBD, 0xFFBE, 0xFFBF,+ /* C */ 0xFFC0, 0xFFC1, 0xFFC2, 0xFFC3, 0xFFC4, 0xFFC5, 0xFFC6, 0xFFC7, 0xFFC8, 0xFFC9, 0xFFCA, 0xFFCB, 0xFFCC, 0xFFCD, 0xFFCE, 0xFFCF,+ /* D */ 0xFFD0, 0xFFD1, 0xFFD2, 0xFFD3, 0xFFD4, 0xFFD5, 0xFFD6, 0xFFD7, 0xFFD8, 0xFFD9, 0xFFDA, 0xFFDB, 0xFFDC, 0xFFDD, 0xFFDE, 0xFFDF,+ /* E */ 0xFFE0, 0xFFE1, 0xFFE2, 0xFFE3, 0xFFE4, 0xFFE5, 0xFFE6, 0xFFE7, 0xFFE8, 0xFFE9, 0xFFEA, 0xFFEB, 0xFFEC, 0xFFED, 0xFFEE, 0xFFEF,+ /* F */ 0xFFF0, 0xFFF1, 0xFFF2, 0xFFF3, 0xFFF4, 0xFFF5, 0xFFF6, 0xFFF7, 0xFFF8, 0xFFF9, 0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE, 0xFFFF,+};+++/* RelString case folding table */++unsigned short gCompareTable[] = {++ /* 0 */ 0x0000, 0x0100, 0x0200, 0x0300, 0x0400, 0x0500, 0x0600, 0x0700, 0x0800, 0x0900, 0x0A00, 0x0B00, 0x0C00, 0x0D00, 0x0E00, 0x0F00,+ /* 1 */ 0x1000, 0x1100, 0x1200, 0x1300, 0x1400, 0x1500, 0x1600, 0x1700, 0x1800, 0x1900, 0x1A00, 0x1B00, 0x1C00, 0x1D00, 0x1E00, 0x1F00,+ /* 2 */ 0x2000, 0x2100, 0x2200, 0x2300, 0x2400, 0x2500, 0x2600, 0x2700, 0x2800, 0x2900, 0x2A00, 0x2B00, 0x2C00, 0x2D00, 0x2E00, 0x2F00,+ /* 3 */ 0x3000, 0x3100, 0x3200, 0x3300, 0x3400, 0x3500, 0x3600, 0x3700, 0x3800, 0x3900, 0x3A00, 0x3B00, 0x3C00, 0x3D00, 0x3E00, 0x3F00,+ /* 4 */ 0x4000, 0x4100, 0x4200, 0x4300, 0x4400, 0x4500, 0x4600, 0x4700, 0x4800, 0x4900, 0x4A00, 0x4B00, 0x4C00, 0x4D00, 0x4E00, 0x4F00,+ /* 5 */ 0x5000, 0x5100, 0x5200, 0x5300, 0x5400, 0x5500, 0x5600, 0x5700, 0x5800, 0x5900, 0x5A00, 0x5B00, 0x5C00, 0x5D00, 0x5E00, 0x5F00,++ // 0x60 maps to 'a'+ // range 0x61 to 0x7a ('a' to 'z') map to upper case++ /* 6 */ 0x4180, 0x4100, 0x4200, 0x4300, 0x4400, 0x4500, 0x4600, 0x4700, 0x4800, 0x4900, 0x4A00, 0x4B00, 0x4C00, 0x4D00, 0x4E00, 0x4F00,+ /* 7 */ 0x5000, 0x5100, 0x5200, 0x5300, 0x5400, 0x5500, 0x5600, 0x5700, 0x5800, 0x5900, 0x5A00, 0x7B00, 0x7C00, 0x7D00, 0x7E00, 0x7F00,++ // range 0x80 to 0xd8 gets mapped...++ /* 8 */ 0x4108, 0x410C, 0x4310, 0x4502, 0x4E0A, 0x4F08, 0x5508, 0x4182, 0x4104, 0x4186, 0x4108, 0x410A, 0x410C, 0x4310, 0x4502, 0x4584,+ /* 9 */ 0x4586, 0x4588, 0x4982, 0x4984, 0x4986, 0x4988, 0x4E0A, 0x4F82, 0x4F84, 0x4F86, 0x4F08, 0x4F0A, 0x5582, 0x5584, 0x5586, 0x5508,+ /* A */ 0xA000, 0xA100, 0xA200, 0xA300, 0xA400, 0xA500, 0xA600, 0x5382, 0xA800, 0xA900, 0xAA00, 0xAB00, 0xAC00, 0xAD00, 0x4114, 0x4F0E,+ /* B */ 0xB000, 0xB100, 0xB200, 0xB300, 0xB400, 0xB500, 0xB600, 0xB700, 0xB800, 0xB900, 0xBA00, 0x4192, 0x4F92, 0xBD00, 0x4114, 0x4F0E,+ /* C */ 0xC000, 0xC100, 0xC200, 0xC300, 0xC400, 0xC500, 0xC600, 0x2206, 0x2208, 0xC900, 0x2000, 0x4104, 0x410A, 0x4F0A, 0x4F14, 0x4F14,+ /* D */ 0xD000, 0xD100, 0x2202, 0x2204, 0x2702, 0x2704, 0xD600, 0xD700, 0x5988, 0xD900, 0xDA00, 0xDB00, 0xDC00, 0xDD00, 0xDE00, 0xDF00,++ /* E */ 0xE000, 0xE100, 0xE200, 0xE300, 0xE400, 0xE500, 0xE600, 0xE700, 0xE800, 0xE900, 0xEA00, 0xEB00, 0xEC00, 0xED00, 0xEE00, 0xEF00,+ /* F */ 0xF000, 0xF100, 0xF200, 0xF300, 0xF400, 0xF500, 0xF600, 0xF700, 0xF800, 0xF900, 0xFA00, 0xFB00, 0xFC00, 0xFD00, 0xFE00, 0xFF00,++};+#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */+#endif /* _UCSTRINGCOMPAREDATA_ */diff --git a/xnu/files/bsd/hfs/UnicodeWrappers.c b/xnu/files/bsd/hfs/UnicodeWrappers.cnew file mode 100644index 0000000..8e5b6e6--- /dev/null+++ b/xnu/files/bsd/hfs/UnicodeWrappers.c@@ -0,0 +1,508 @@+/*+ * Copyright (c) 2000-2015 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@+ */+/*+ File: UnicodeWrappers.c++ Contains: Wrapper routines for Unicode conversion and comparison.++*/++#include <sys/param.h>+#include <sys/utfconv.h>++#include "hfs_macos_defs.h"+#include "UCStringCompareData.h"++#include "FileMgrInternal.h"+#include "HFSUnicodeWrappers.h"++enum {+ kMinFileExtensionChars = 1, /* does not include dot */+ kMaxFileExtensionChars = 5 /* does not include dot */+};+++#define EXTENSIONCHAR(c) (((c) >= 0x61 && (c) <= 0x7A) || \+ ((c) >= 0x41 && (c) <= 0x5A) || \+ ((c) >= 0x30 && (c) <= 0x39))+++#define IsHexDigit(c) (((c) >= (u_int8_t) '0' && (c) <= (u_int8_t) '9') || \+ ((c) >= (u_int8_t) 'A' && (c) <= (u_int8_t) 'F'))+++static void GetFilenameExtension( ItemCount length, ConstUniCharArrayPtr unicodeStr, char* extStr );+++static u_int32_t HexStringToInteger( u_int32_t length, const u_int8_t *hexStr );+++/*+ * Get filename extension (if any) as a C string+ */+static void+GetFilenameExtension(ItemCount length, ConstUniCharArrayPtr unicodeStr, char * extStr)+{+ u_int32_t i;+ UniChar c;+ u_int16_t extChars; /* number of extension chars (excluding dot) */+ u_int16_t maxExtChars;+ Boolean foundExtension;++ extStr[0] = '\0'; /* assume there's no extension */++ if ( length < 3 )+ return; /* "x.y" is smallest possible extension */++ if ( length < (kMaxFileExtensionChars + 2) )+ maxExtChars = length - 2; /* save room for prefix + dot */+ else+ maxExtChars = kMaxFileExtensionChars;++ i = length;+ extChars = 0;+ foundExtension = false;++ while ( extChars <= maxExtChars ) {+ c = unicodeStr[--i];++ /* look for leading dot */+ if ( c == (UniChar) '.' ) {+ if ( extChars > 0 ) /* cannot end with a dot */+ foundExtension = true;+ break;+ }++ if ( EXTENSIONCHAR(c) )+ ++extChars;+ else+ break;+ }++ /* if we found one then copy it */+ if ( foundExtension ) {+ u_int8_t *extStrPtr = (u_int8_t *)extStr;+ const UniChar *unicodeStrPtr = &unicodeStr[i];++ for ( i = 0; i <= extChars; ++i )+ *(extStrPtr++) = (u_int8_t) *(unicodeStrPtr++);+ extStr[extChars + 1] = '\0'; /* terminate extension + dot */+ }+}++++/*+ * Count filename extension characters (if any)+ */+u_int32_t+CountFilenameExtensionChars( const unsigned char * filename, u_int32_t length )+{+ u_int32_t i;+ UniChar c;+ u_int32_t extChars; /* number of extension chars (excluding dot) */+ u_int16_t maxExtChars;+ Boolean foundExtension;++ if ( length < 3 )+ return 0; /* "x.y" is smallest possible extension */++ if ( length < (kMaxFileExtensionChars + 2) )+ maxExtChars = length - 2; /* save room for prefix + dot */+ else+ maxExtChars = kMaxFileExtensionChars;++ extChars = 0; /* assume there's no extension */+ i = length - 1; /* index to last ascii character */+ foundExtension = false;++ while ( extChars <= maxExtChars ) {+ c = filename[i--];++ /* look for leading dot */+ if ( c == (u_int8_t) '.' ) {+ if ( extChars > 0 ) /* cannot end with a dot */+ return (extChars);++ break;+ }++ if ( EXTENSIONCHAR(c) )+ ++extChars;+ else+ break;+ }++ return 0;+}+++/*+ * extract the file id from a mangled name+ */+HFSCatalogNodeID+GetEmbeddedFileID(const unsigned char * filename, u_int32_t length, u_int32_t *prefixLength)+{+ short extChars;+ short i;+ u_int8_t c;++ *prefixLength = 0;++ if ( filename == NULL )+ return 0;++ if ( length < 28 )+ return 0; /* too small to have been mangled */++ /* big enough for a file ID (#10) and an extension (.x) ? */+ if ( length > 5 )+ extChars = CountFilenameExtensionChars(filename, length);+ else+ extChars = 0;++ /* skip over dot plus extension characters */+ if ( extChars > 0 )+ length -= (extChars + 1);++ /* scan for file id digits */+ for ( i = length - 1; i >= 0; --i) {+ c = filename[i];++ /* look for file ID marker */+ if ( c == '#' ) {+ if ( (length - i) < 3 )+ break; /* too small to be a file ID */++ *prefixLength = i;+ return HexStringToInteger(length - i - 1, &filename[i+1]);+ }++ if ( !IsHexDigit(c) )+ break; /* file ID string must have hex digits */+ }++ return 0;+}++++static u_int32_t+HexStringToInteger(u_int32_t length, const u_int8_t *hexStr)+{+ u_int32_t value;+ u_int32_t i;+ u_int8_t c;+ const u_int8_t *p;++ value = 0;+ p = hexStr;++ for ( i = 0; i < length; ++i ) {+ c = *p++;++ if (c >= '0' && c <= '9') {+ value = value << 4;+ value += (u_int32_t) c - (u_int32_t) '0';+ } else if (c >= 'A' && c <= 'F') {+ value = value << 4;+ value += 10 + ((unsigned int) c - (unsigned int) 'A');+ } else {+ return 0; /* bad character */+ }+ }++ return value;+}+++/*+ * Routine: FastRelString+ *+ * Output: returns -1 if str1 < str2+ * returns 1 if str1 > str2+ * return 0 if equal+ *+ */+int32_t FastRelString( ConstStr255Param str1, ConstStr255Param str2 )+{+ u_int16_t* compareTable;+ int32_t bestGuess;+ u_int8_t length, length2;+ u_int8_t delta;++ delta = 0;+ length = *(str1++);+ length2 = *(str2++);++ if (length == length2)+ bestGuess = 0;+ else if (length < length2)+ {+ bestGuess = -1;+ delta = length2 - length;+ }+ else+ {+ bestGuess = 1;+ length = length2;+ }++ compareTable = (u_int16_t*) gCompareTable;++ while (length--)+ {+ u_int8_t aChar, bChar;++ aChar = *(str1++);+ bChar = *(str2++);++ if (aChar != bChar) // If they don't match exacly, do case conversion+ {+ u_int16_t aSortWord, bSortWord;++ aSortWord = compareTable[aChar];+ bSortWord = compareTable[bChar];++ if (aSortWord > bSortWord)+ return 1;++ if (aSortWord < bSortWord)+ return -1;+ }++ // If characters match exactly, then go on to next character immediately without+ // doing any extra work.+ }++ // if you got to here, then return bestGuess+ return bestGuess;+}++++//+// FastUnicodeCompare - Compare two Unicode strings; produce a relative ordering+//+// IF RESULT+// --------------------------+// str1 < str2 => -1+// str1 = str2 => 0+// str1 > str2 => +1+//+// The lower case table starts with 256 entries (one for each of the upper bytes+// of the original Unicode char). If that entry is zero, then all characters with+// that upper byte are already case folded. If the entry is non-zero, then it is+// the _index_ (not byte offset) of the start of the sub-table for the characters+// with that upper byte. All ignorable characters are folded to the value zero.+//+// In pseudocode:+//+// Let c = source Unicode character+// Let table[] = lower case table+//+// lower = table[highbyte(c)]+// if (lower == 0)+// lower = c+// else+// lower = table[lower+lowbyte(c)]+//+// if (lower == 0)+// ignore this character+//+// To handle ignorable characters, we now need a loop to find the next valid character.+// Also, we can't pre-compute the number of characters to compare; the string length might+// be larger than the number of non-ignorable characters. Further, we must be able to handle+// ignorable characters at any point in the string, including as the first or last characters.+// We use a zero value as a sentinel to detect both end-of-string and ignorable characters.+// Since the File Manager doesn't prevent the NUL character (value zero) as part of a filename,+// the case mapping table is assumed to map u+0000 to some non-zero value (like 0xFFFF, which is+// an invalid Unicode character).+//+// Pseudocode:+//+// while (1) {+// c1 = GetNextValidChar(str1) // returns zero if at end of string+// c2 = GetNextValidChar(str2)+//+// if (c1 != c2) break // found a difference+//+// if (c1 == 0) // reached end of string on both strings at once?+// return 0; // yes, so strings are equal+// }+//+// // When we get here, c1 != c2. So, we just need to determine which one is less.+// if (c1 < c2)+// return -1;+// else+// return 1;+//++int32_t FastUnicodeCompare ( register ConstUniCharArrayPtr str1, register ItemCount length1,+ register ConstUniCharArrayPtr str2, register ItemCount length2)+{+ register u_int16_t c1,c2;+ register u_int16_t temp;+ register u_int16_t* lowerCaseTable;++ lowerCaseTable = (u_int16_t*) gLowerCaseTable;++ while (1) {+ /* Set default values for c1, c2 in case there are no more valid chars */+ c1 = 0;+ c2 = 0;++ /* Find next non-ignorable char from str1, or zero if no more */+ while (length1 && c1 == 0) {+ c1 = *(str1++);+ --length1;+ /* check for basic latin first */+ if (c1 < 0x0100) {+ c1 = gLatinCaseFold[c1];+ break;+ }+ /* case fold if neccessary */+ if ((temp = lowerCaseTable[c1>>8]) != 0)+ c1 = lowerCaseTable[temp + (c1 & 0x00FF)];+ }+++ /* Find next non-ignorable char from str2, or zero if no more */+ while (length2 && c2 == 0) {+ c2 = *(str2++);+ --length2;+ /* check for basic latin first */+ if (c2 < 0x0100) {+ c2 = gLatinCaseFold[c2];+ break;+ }+ /* case fold if neccessary */+ if ((temp = lowerCaseTable[c2>>8]) != 0)+ c2 = lowerCaseTable[temp + (c2 & 0x00FF)];+ }++ if (c1 != c2) // found a difference, so stop looping+ break;++ if (c1 == 0) // did we reach the end of both strings at the same time?+ return 0; // yes, so strings are equal+ }++ if (c1 < c2)+ return -1;+ else+ return 1;+}++/*+ * UnicodeBinaryCompare+ * Compare two UTF-16 strings and perform case-sensitive (binary) matching against them.+ *+ * Results are emitted like FastUnicodeCompare:+ *+ *+ * IF RESULT+ * --------------------------+ * str1 < str2 => -1+ * str1 = str2 => 0+ * str1 > str2 => +1+ *+ * The case matching source code is greatly simplified due to the lack of case-folding+ * in this comparison routine. We compare, in order: the lengths, then do character-by-+ * character comparisons.+ *+ */+int32_t UnicodeBinaryCompare (register ConstUniCharArrayPtr str1, register ItemCount len1,+ register ConstUniCharArrayPtr str2, register ItemCount len2) {+ uint16_t c1;+ uint16_t c2;+ int string_length;+ int32_t result = 0;++ /* Set default values for the two character pointers */+ c1 = 0;+ c2 = 0;++ /* First generate the string length (for comparison purposes) */+ if (len1 < len2) {+ string_length = len1;+ --result;+ }+ else if (len1 > len2) {+ string_length = len2;+ ++result;+ }+ else {+ string_length = len1;+ }++ /* now compare the two string pointers */+ while (string_length--) {+ c1 = *(str1++);+ c2 = *(str2++);++ if (c1 > c2) {+ result = 1;+ break;+ }++ if (c1 < c2) {+ result = -1;+ break;+ }+ /* If equal, iterate to the next two respective chars */+ }++ return result;+}+++OSErr+ConvertUnicodeToUTF8Mangled(ByteCount srcLen, ConstUniCharArrayPtr srcStr, ByteCount maxDstLen,+ ByteCount *actualDstLen, unsigned char* dstStr, HFSCatalogNodeID cnid)+{+ ByteCount subMaxLen;+ size_t utf8len;+ char fileIDStr[15];+ char extStr[15];++ snprintf(fileIDStr, sizeof(fileIDStr), "#%X", cnid);+ GetFilenameExtension(srcLen/sizeof(UniChar), srcStr, extStr);++ /* remove extension chars from source */+ srcLen -= strlen(extStr) * sizeof(UniChar);+ subMaxLen = maxDstLen - (strlen(extStr) + strlen(fileIDStr));++ (void) utf8_encodestr(srcStr, srcLen, dstStr, &utf8len, subMaxLen, ':', 0);++ strlcat((char *)dstStr, fileIDStr, maxDstLen);+ strlcat((char *)dstStr, extStr, maxDstLen);+ *actualDstLen = utf8len + (strlen(extStr) + strlen(fileIDStr));++ return noErr;+}diff --git a/xnu/files/bsd/hfs/VolumeAllocation.c b/xnu/files/bsd/hfs/VolumeAllocation.cnew file mode 100644index 0000000..f050c72--- /dev/null+++ b/xnu/files/bsd/hfs/VolumeAllocation.c@@ -0,0 +1,6204 @@+/*+ * Copyright (c) 2000-2021 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@+ */+/*+ File: VolumeAllocation.c++ Contains: Routines for accessing and modifying the volume bitmap.++ Version: HFS Plus 1.0++ Copyright: (c) 1996-2009 by Apple Inc., all rights reserved.++*/++/*+Public routines:+ BlockAllocate / hfs_block_alloc+ Allocate space on a volume. Can allocate space contiguously.+ If not contiguous, then allocation may be less than what was+ asked for. Returns the starting block number, and number of+ blocks. It will only return a single extent.++ BlockDeallocate+ Deallocate a contiguous run of allocation blocks.++ BlockMarkAllocated+ Exported wrapper to mark blocks as in-use. This will correctly determine+ whether or not the red-black tree is enabled and call the appropriate function+ if applicable.+ BlockMarkFree+ Exported wrapper to mark blocks as freed. This will correctly determine whether or+ not the red-black tree is enabled and call the appropriate function if applicable.+++ ResetVCBFreeExtCache+ Since the red-black tree obviates the need to maintain the free extent cache, we do+ not update it if the tree is also live. As a result, if we ever need to destroy the trees+ we should reset the free extent cache so it doesn't confuse us when we need to fall back to the+ bitmap scanning allocator.+ We also reset and disable the free extent cache when volume resizing is+ in flight.++ UpdateAllocLimit+ Adjusts the AllocLimit field in the hfs mount point. This is used when we need to prevent+ allocations from occupying space in the region we are modifying during a filesystem resize.+ At other times, it should be consistent with the total number of allocation blocks in the+ filesystem. It is also used to shrink or grow the number of blocks that the red-black tree should+ know about. If growing, scan the new range of bitmap, and if shrinking, reduce the+ number of items in the tree that we can allocate from.++ ScanUnmapBlocks+ Traverse the entire allocation bitmap. Potentially issue DKIOCUNMAPs to the device as it+ tracks unallocated ranges when iterating the volume bitmap. Additionally, build up the in-core+ summary table of the allocation bitmap.++Internal routines:+ BlockMarkFreeInternal+ Mark a contiguous range of blocks as free. The corresponding+ bits in the volume bitmap will be cleared. This will actually do the work+ of modifying the bitmap for us.++ BlockMarkAllocatedInternal+ Mark a contiguous range of blocks as allocated. The cor-+ responding bits in the volume bitmap are set. Also tests to see+ if any of the blocks were previously unallocated.+ BlockFindContiguous+ Find a contiguous range of blocks of a given size. The caller+ specifies where to begin the search (by block number). The+ block number of the first block in the range is returned. This is only+ called by the bitmap scanning logic as the red-black tree should be able+ to do this internally by searching its tree.+ BlockFindAny+ Find and allocate a contiguous range of blocks up to a given size. The+ first range of contiguous free blocks found are allocated, even if there+ are fewer blocks than requested (and even if a contiguous range of blocks+ of the given size exists elsewhere).+ BlockFindAnyBitmap+ Finds a range of blocks per the above requirements without using the+ Allocation RB Tree. This relies on the bitmap-scanning logic in order to find+ any valid range of free space needed.+ BlockFindContig+ Find a contiguous range of blocks of a given size.+ If the minimum cannot be satisfied, nothing is+ returned.+ BlockFindKnown+ Try to allocate space from known free space in the volume's+ free extent cache.+ ReadBitmapBlock+ Given an allocation block number, read the bitmap block that+ contains that allocation block into a caller-supplied buffer.++ ReleaseBitmapBlock+ Release a bitmap block back into the buffer cache.++ ReadBitmapRange+ Given an allocation block number, read a range of bitmap that+ must begin at that allocation block into a caller supplied buffer.++ ReleaseBitmapRange+ Release and invalidate a buf_t corresponding to the bitmap+ back into the UBC in order to prevent coherency issues.++ remove_free_extent_cache+ Remove an extent from the free extent cache. Handles overlaps+ with multiple extents in the cache, and handles splitting an+ extent in the cache if the extent to be removed is in the middle+ of a cached extent.++ add_free_extent_cache+ Add an extent to the free extent cache. It will merge the+ input extent with extents already in the cache.+ CheckUnmappedBytes+ Check whether or not the current transaction+ has allocated blocks that were recently freed. This may have data safety implications.++++Debug/Test Routines+ hfs_isallocated+ Test to see if any blocks in a range are allocated. Journal or+ allocation file lock must be held.++ hfs_isallocated_scan+ Test to see if any blocks in a range are allocated. Releases and+ invalidates the block used when finished.++Optimization Routines+ hfs_alloc_scan_block+ Given a starting allocation block number, figures out which physical block contains that+ allocation block's bit, and scans it from the starting bit until either the ending bit or+ the end of the block. Free space extents are inserted into the appropriate red-black tree.++*/+++#include <sys/types.h>+#include <sys/buf.h>++#if HFS_ALLOC_TEST+#define KERNEL_DEBUG_CONSTANT(x, a, b, c, d, e) do {} while (0)+#else // !HFS_ALLOC_TEST++#include "hfs_macos_defs.h"+#include <sys/systm.h>+#include <sys/ubc.h>+/* For VM Page size */+#include <libkern/libkern.h>+#include "hfs_journal.h"+#include "hfs.h"+#include "hfs_endian.h"+#include "FileMgrInternal.h"++#endif // !HFS_ALLOC_TEST++#include <sys/sysctl.h>+#include <sys/disk.h>+#include <sys/uio.h>+#include <sys/malloc.h>++#include "hfs_dbg.h"+#include "hfs_format.h"+#include "hfs_kdebug.h"+#include "rangelist.h"+#include "hfs_extents.h"++/* Headers for unmap-on-mount support */+#include <sys/disk.h>++/*+ * Use sysctl vfs.generic.hfs.kdebug.allocation to control which+ * KERNEL_DEBUG_CONSTANT events are enabled at runtime. (They're+ * disabled by default because there can be a lot of these events,+ * and we don't want to overwhelm the kernel debug buffer. If you+ * want to watch these events in particular, just set the sysctl.)+ */+static int hfs_kdebug_allocation = 0;+SYSCTL_DECL(_vfs_generic);+HFS_SYSCTL(NODE, _vfs_generic, OID_AUTO, hfs, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "HFS file system")+HFS_SYSCTL(NODE, _vfs_generic_hfs, OID_AUTO, kdebug, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "HFS kdebug")+HFS_SYSCTL(INT, _vfs_generic_hfs_kdebug, OID_AUTO, allocation, CTLFLAG_RW|CTLFLAG_LOCKED, &hfs_kdebug_allocation, 0, "Enable kdebug logging for HFS allocations")+enum {+ /*+ * HFSDBG_ALLOC_ENABLED: Log calls to BlockAllocate and+ * BlockDeallocate, including the internal BlockAllocateXxx+ * routines so we can see how an allocation was satisfied.+ *+ * HFSDBG_EXT_CACHE_ENABLED: Log routines that read or write the+ * free extent cache.+ *+ * HFSDBG_UNMAP_ENABLED: Log events involving the trim list.+ *+ * HFSDBG_BITMAP_ENABLED: Log accesses to the volume bitmap (setting+ * or clearing bits, scanning the bitmap).+ */+ HFSDBG_ALLOC_ENABLED = 1,+ HFSDBG_EXT_CACHE_ENABLED = 2,+ HFSDBG_UNMAP_ENABLED = 4,+ HFSDBG_BITMAP_ENABLED = 8+};++enum {+ kBytesPerWord = 4,+ kBitsPerByte = 8,+ kBitsPerWord = 32,++ kBitsWithinWordMask = kBitsPerWord-1+};++#define kLowBitInWordMask 0x00000001ul+#define kHighBitInWordMask 0x80000000ul+#define kAllBitsSetInWord 0xFFFFFFFFul++#define HFS_MIN_SUMMARY_BLOCKSIZE 4096++#define ALLOC_DEBUG 0++static OSErr ReadBitmapBlock(+ ExtendedVCB *vcb,+ u_int32_t bit,+ u_int32_t **buffer,+ uintptr_t *blockRef,+ hfs_block_alloc_flags_t flags);++static OSErr ReleaseBitmapBlock(+ ExtendedVCB *vcb,+ uintptr_t blockRef,+ Boolean dirty);++static OSErr hfs_block_alloc_int(hfsmount_t *hfsmp,+ HFSPlusExtentDescriptor *extent,+ hfs_block_alloc_flags_t flags,+ hfs_alloc_extra_args_t *ap);++static OSErr BlockFindAny(+ ExtendedVCB *vcb,+ u_int32_t startingBlock,+ u_int32_t endingBlock,+ u_int32_t maxBlocks,+ hfs_block_alloc_flags_t flags,+ Boolean trustSummary,+ u_int32_t *actualStartBlock,+ u_int32_t *actualNumBlocks);++static OSErr BlockFindAnyBitmap(+ ExtendedVCB *vcb,+ u_int32_t startingBlock,+ u_int32_t endingBlock,+ u_int32_t maxBlocks,+ hfs_block_alloc_flags_t flags,+ u_int32_t *actualStartBlock,+ u_int32_t *actualNumBlocks);++static OSErr BlockFindContig(+ ExtendedVCB *vcb,+ u_int32_t startingBlock,+ u_int32_t minBlocks,+ u_int32_t maxBlocks,+ hfs_block_alloc_flags_t flags,+ u_int32_t *actualStartBlock,+ u_int32_t *actualNumBlocks);++static OSErr BlockFindContiguous(+ ExtendedVCB *vcb,+ u_int32_t startingBlock,+ u_int32_t endingBlock,+ u_int32_t minBlocks,+ u_int32_t maxBlocks,+ Boolean useMetaZone,+ Boolean trustSummary,+ u_int32_t *actualStartBlock,+ u_int32_t *actualNumBlocks,+ hfs_block_alloc_flags_t flags);++static OSErr BlockFindKnown(+ ExtendedVCB *vcb,+ u_int32_t maxBlocks,+ u_int32_t *actualStartBlock,+ u_int32_t *actualNumBlocks);++static OSErr hfs_alloc_try_hard(hfsmount_t *hfsmp,+ HFSPlusExtentDescriptor *extent,+ uint32_t max_blocks,+ hfs_block_alloc_flags_t flags);++static OSErr BlockMarkAllocatedInternal (+ ExtendedVCB *vcb,+ u_int32_t startingBlock,+ u_int32_t numBlocks,+ hfs_block_alloc_flags_t flags);++static OSErr BlockMarkFreeInternal(+ ExtendedVCB *vcb,+ u_int32_t startingBlock,+ u_int32_t numBlocks,+ Boolean do_validate);+++static OSErr ReadBitmapRange (struct hfsmount *hfsmp, uint32_t offset, uint32_t iosize,+ uint32_t **buffer, struct buf **blockRef);++static OSErr ReleaseScanBitmapRange( struct buf *bp );++static int hfs_track_unmap_blocks (struct hfsmount *hfsmp, u_int32_t offset,+ u_int32_t numBlocks, struct jnl_trim_list *list);++static int hfs_issue_unmap (struct hfsmount *hfsmp, struct jnl_trim_list *list);++static int hfs_alloc_scan_range(struct hfsmount *hfsmp,+ u_int32_t startbit,+ u_int32_t *bitToScan,+ struct jnl_trim_list *list);++static int hfs_scan_range_size (struct hfsmount* hfsmp, uint32_t start, uint32_t *iosize);+static uint32_t CheckUnmappedBytes (struct hfsmount *hfsmp, uint64_t blockno, uint64_t numblocks, int *recent, uint32_t *next);++/* Bitmap Re-use Detection */+static inline int extents_overlap (uint32_t start1, uint32_t len1,+ uint32_t start2, uint32_t len2) {+ return !( ((start1 + len1) <= start2) || ((start2 + len2) <= start1) );+}+++int hfs_isallocated_scan (struct hfsmount *hfsmp,+ u_int32_t startingBlock,+ u_int32_t *bp_buf);++/* Summary Table Functions */+static int hfs_set_summary (struct hfsmount *hfsmp, uint32_t summarybit, uint32_t inuse);+static int hfs_get_summary_index (struct hfsmount *hfsmp, uint32_t block, uint32_t *index);+static int hfs_find_summary_free (struct hfsmount *hfsmp, uint32_t block, uint32_t *newblock);+static int hfs_get_summary_allocblock (struct hfsmount *hfsmp, uint32_t summarybit, uint32_t *alloc);+static int hfs_release_summary (struct hfsmount *hfsmp, uint32_t start, uint32_t length);+static int hfs_check_summary (struct hfsmount *hfsmp, uint32_t start, uint32_t *freeblocks);+static int hfs_rebuild_summary (struct hfsmount *hfsmp);++#if 0+static int hfs_get_next_summary (struct hfsmount *hfsmp, uint32_t block, uint32_t *newblock);+#endif++/* Used in external mount code to initialize the summary table */+int hfs_init_summary (struct hfsmount *hfsmp);++#if ALLOC_DEBUG+void hfs_validate_summary (struct hfsmount *hfsmp);+#endif+++/* Functions for manipulating free extent cache */+static void remove_free_extent_cache(struct hfsmount *hfsmp, u_int32_t startBlock, u_int32_t blockCount);+static Boolean add_free_extent_cache(struct hfsmount *hfsmp, u_int32_t startBlock, u_int32_t blockCount);+static void sanity_check_free_ext(struct hfsmount *hfsmp, int check_allocated);++static void hfs_release_reserved(hfsmount_t *hfsmp, struct rl_entry *range, int list);++/* Functions for getting free exents */++typedef struct bitmap_context {+ void *bitmap; // current bitmap chunk+ uint32_t run_offset; // offset (in bits) from start of bitmap to start of current run+ uint32_t chunk_current; // next bit to scan in the chunk+ uint32_t chunk_end; // number of valid bits in this chunk+ struct hfsmount *hfsmp;+ struct buf *bp;+ uint32_t last_free_summary_bit; // last marked free summary bit+ int lockflags;+ uint64_t lock_start;+} bitmap_context_t;+++static errno_t get_more_bits(bitmap_context_t *bitmap_ctx);+static int bit_count_set(void *bitmap, int start, int end);+static int bit_count_clr(void *bitmap, int start, int end);+static errno_t hfs_bit_count(bitmap_context_t *bitmap_ctx, int (*fn)(void *, int ,int), uint32_t *bit_count);+static errno_t hfs_bit_count_set(bitmap_context_t *bitmap_ctx, uint32_t *count);+static errno_t hfs_bit_count_clr(bitmap_context_t *bitmap_ctx, uint32_t *count);+static errno_t update_summary_table(bitmap_context_t *bitmap_ctx, uint32_t start, uint32_t count, bool set);+static int clzll(uint64_t x);++#if ALLOC_DEBUG+/*+ * Validation Routine to verify that the TRIM list maintained by the journal+ * is in good shape relative to what we think the bitmap should have. We should+ * never encounter allocated blocks in the TRIM list, so if we ever encounter them,+ * we panic.+ */+int trim_validate_bitmap (struct hfsmount *hfsmp);+int trim_validate_bitmap (struct hfsmount *hfsmp) {+ u_int64_t blockno_offset;+ u_int64_t numblocks;+ int i;+ int count;+ u_int32_t startblk;+ u_int32_t blks;+ int err = 0;+ uint32_t alloccount = 0;++ if (hfsmp->jnl) {+ struct journal *jnl = (struct journal*)hfsmp->jnl;+ if (jnl->active_tr) {+ struct jnl_trim_list *trim = &(jnl->active_tr->trim);+ count = trim->extent_count;+ for (i = 0; i < count; i++) {+ blockno_offset = trim->extents[i].offset;+ blockno_offset = blockno_offset - (uint64_t)hfsmp->hfsPlusIOPosOffset;+ blockno_offset = blockno_offset / hfsmp->blockSize;+ numblocks = trim->extents[i].length / hfsmp->blockSize;++ startblk = (u_int32_t)blockno_offset;+ blks = (u_int32_t) numblocks;+ err = hfs_count_allocated (hfsmp, startblk, blks, &alloccount);++ if (err == 0 && alloccount != 0) {+ panic ("trim_validate_bitmap: %d blocks @ ABN %d are allocated!", alloccount, startblk);+ }+ }+ }+ }+ return 0;+}++#endif+++/*+ ;________________________________________________________________________________+ ;+ ; Routine: hfs_unmap_free_extent+ ;+ ; Function: Make note of a range of allocation blocks that should be+ ; unmapped (trimmed). That is, the given range of blocks no+ ; longer have useful content, and the device can unmap the+ ; previous contents. For example, a solid state disk may reuse+ ; the underlying storage for other blocks.+ ;+ ; This routine is only supported for journaled volumes. The extent+ ; being freed is passed to the journal code, and the extent will+ ; be unmapped after the current transaction is written to disk.+ ;+ ; Input Arguments:+ ; hfsmp - The volume containing the allocation blocks.+ ; startingBlock - The first allocation block of the extent being freed.+ ; numBlocks - The number of allocation blocks of the extent being freed.+ ;________________________________________________________________________________+ */+static void hfs_unmap_free_extent(struct hfsmount *hfsmp, u_int32_t startingBlock, u_int32_t numBlocks)+{+ u_int64_t offset;+ u_int64_t length;+ u_int64_t device_sz;+ int err = 0;++ if (hfs_kdebug_allocation & HFSDBG_UNMAP_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_UNMAP_FREE | DBG_FUNC_START, startingBlock, numBlocks, 0, 0, 0);++ if (ALLOC_DEBUG) {+ if (hfs_isallocated(hfsmp, startingBlock, numBlocks)) {+ panic("hfs: %p: (%u,%u) unmapping allocated blocks", hfsmp, startingBlock, numBlocks);+ }+ }++ if (hfsmp->jnl != NULL) {+ device_sz = hfsmp->hfs_logical_bytes;+ offset = (u_int64_t) startingBlock * hfsmp->blockSize + (u_int64_t) hfsmp->hfsPlusIOPosOffset;+ length = (u_int64_t) numBlocks * hfsmp->blockSize;++ /* Validate that the trim is in a valid range of bytes */+ if ((offset >= device_sz) || ((offset + length) > device_sz)) {+ printf("hfs_unmap_free_ext: ignoring trim vol=%s @ off %lld len %lld \n", hfsmp->vcbVN, offset, length);+ err = EINVAL;+ }++ if (err == 0) {+ err = journal_trim_add_extent(hfsmp->jnl, offset, length);+ if (err) {+ printf("hfs_unmap_free_extent: error %d from journal_trim_add_extent for vol=%s", err, hfsmp->vcbVN);+ }+ }+ }++ if (hfs_kdebug_allocation & HFSDBG_UNMAP_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_UNMAP_FREE | DBG_FUNC_END, err, 0, 0, 0, 0);+}++/*+ ;________________________________________________________________________________+ ;+ ; Routine: hfs_track_unmap_blocks+ ;+ ; Function: Make note of a range of allocation blocks that should be+ ; unmapped (trimmed). That is, the given range of blocks no+ ; longer have useful content, and the device can unmap the+ ; previous contents. For example, a solid state disk may reuse+ ; the underlying storage for other blocks.+ ;+ ; This routine is only supported for journaled volumes.+ ;+ ; *****NOTE*****:+ ; This function should *NOT* be used when the volume is fully+ ; mounted. This function is intended to support a bitmap iteration+ ; at mount time to fully inform the SSD driver of the state of all blocks+ ; at mount time, and assumes that there is no allocation/deallocation+ ; interference during its iteration.,+ ;+ ; Input Arguments:+ ; hfsmp - The volume containing the allocation blocks.+ ; offset - The first allocation block of the extent being freed.+ ; numBlocks - The number of allocation blocks of the extent being freed.+ ; list - The list of currently tracked trim ranges.+ ;________________________________________________________________________________+ */+static int hfs_track_unmap_blocks (struct hfsmount *hfsmp, u_int32_t start,+ u_int32_t numBlocks, struct jnl_trim_list *list) {++ u_int64_t offset;+ u_int64_t length;+ int error = 0;++ if ((hfsmp->hfs_flags & HFS_UNMAP) && (hfsmp->jnl != NULL) && list->allocated_count && list->extents != NULL) {+ int extent_no = list->extent_count;+ offset = (u_int64_t) start * hfsmp->blockSize + (u_int64_t) hfsmp->hfsPlusIOPosOffset;+ length = (u_int64_t) numBlocks * hfsmp->blockSize;+++ list->extents[extent_no].offset = offset;+ list->extents[extent_no].length = length;+ list->extent_count++;+ if (list->extent_count == list->allocated_count) {+ error = hfs_issue_unmap (hfsmp, list);+ }+ }++ return error;+}++/*+ ;________________________________________________________________________________+ ;+ ; Routine: hfs_issue_unmap+ ;+ ; Function: Issue a DKIOCUNMAP for all blocks currently tracked by the jnl_trim_list+ ;+ ; Input Arguments:+ ; hfsmp - The volume containing the allocation blocks.+ ; list - The list of currently tracked trim ranges.+ ;________________________________________________________________________________+ */++static int hfs_issue_unmap (struct hfsmount *hfsmp, struct jnl_trim_list *list)+{+ dk_unmap_t unmap;+ int error = 0;++ if (hfs_kdebug_allocation & HFSDBG_UNMAP_ENABLED) {+ KERNEL_DEBUG_CONSTANT(HFSDBG_UNMAP_SCAN_TRIM | DBG_FUNC_START, hfsmp->hfs_raw_dev, 0, 0, 0, 0);+ }++ if (list->extent_count > 0 && list->extents != NULL) {+ bzero(&unmap, sizeof(unmap));+ unmap.extents = list->extents;+ unmap.extentsCount = list->extent_count;++ if (hfs_kdebug_allocation & HFSDBG_UNMAP_ENABLED) {+ KERNEL_DEBUG_CONSTANT(HFSDBG_UNMAP_SCAN_TRIM | DBG_FUNC_NONE, hfsmp->hfs_raw_dev, unmap.extentsCount, 0, 0, 0);+ }++#if CONFIG_PROTECT+ /*+ * If we have not yet completed the first scan through the bitmap, then+ * optionally inform the block driver below us that this is an initialization+ * TRIM scan, if it can deal with this information.+ */+ if ((hfsmp->scan_var & HFS_ALLOCATOR_SCAN_COMPLETED) == 0) {+ unmap.options |= _DK_UNMAP_INITIALIZE;+ }+#endif+ /* Issue a TRIM and flush them out */+ error = VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCUNMAP, (caddr_t)&unmap, 0, vfs_context_kernel());++ bzero (list->extents, (list->allocated_count * sizeof(dk_extent_t)));+ bzero (&unmap, sizeof(unmap));+ list->extent_count = 0;+ }++ if (hfs_kdebug_allocation & HFSDBG_UNMAP_ENABLED) {+ KERNEL_DEBUG_CONSTANT(HFSDBG_UNMAP_SCAN_TRIM | DBG_FUNC_END, error, hfsmp->hfs_raw_dev, 0, 0, 0);+ }++ return error;+}++/*+ ;________________________________________________________________________________+ ;+ ; Routine: hfs_unmap_alloc_extent+ ;+ ; Function: Make note of a range of allocation blocks, some of+ ; which may have previously been passed to hfs_unmap_free_extent,+ ; is now in use on the volume. The given blocks will be removed+ ; from any pending DKIOCUNMAP.+ ;+ ; Input Arguments:+ ; hfsmp - The volume containing the allocation blocks.+ ; startingBlock - The first allocation block of the extent being allocated.+ ; numBlocks - The number of allocation blocks being allocated.+ ;________________________________________________________________________________+ */++static void hfs_unmap_alloc_extent(struct hfsmount *hfsmp, u_int32_t startingBlock, u_int32_t numBlocks)+{+ u_int64_t offset;+ u_int64_t length;+ int err = 0;++ if (hfs_kdebug_allocation & HFSDBG_UNMAP_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_UNMAP_ALLOC | DBG_FUNC_START, startingBlock, numBlocks, 0, 0, 0);++ if (hfsmp->jnl != NULL) {+ offset = (u_int64_t) startingBlock * hfsmp->blockSize + (u_int64_t) hfsmp->hfsPlusIOPosOffset;+ length = (u_int64_t) numBlocks * hfsmp->blockSize;++ err = journal_trim_remove_extent(hfsmp->jnl, offset, length);+ if (err) {+ printf("hfs_unmap_alloc_extent: error %d from journal_trim_remove_extent for vol=%s", err, hfsmp->vcbVN);+ }+ }++ if (hfs_kdebug_allocation & HFSDBG_UNMAP_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_UNMAP_ALLOC | DBG_FUNC_END, err, 0, 0, 0, 0);+}+++/*+;________________________________________________________________________________+;+; Routine: hfs_trim_callback+;+; Function: This function is called when a transaction that freed extents+; (via hfs_unmap_free_extent/journal_trim_add_extent) has been+; written to the on-disk journal. This routine will add those+; extents to the free extent cache so that they can be reused.+;+; CAUTION: This routine is called while the journal's trim lock+; is held shared, so that no other thread can reuse any portion+; of those extents. We must be very careful about which locks+; we take from within this callback, to avoid deadlock. The+; call to add_free_extent_cache will end up taking the cache's+; lock (just long enough to add these extents to the cache).+;+; CAUTION: If the journal becomes invalid (eg., due to an I/O+; error when trying to write to the journal), this callback+; will stop getting called, even if extents got freed before+; the journal became invalid!+;+; Input Arguments:+; arg - The hfsmount of the volume containing the extents.+; extent_count - The number of extents freed in the transaction.+; extents - An array of extents (byte ranges) that were freed.+;________________________________________________________________________________+*/++void+hfs_trim_callback(void *arg, uint32_t extent_count, const dk_extent_t *extents)+{+ uint32_t i;+ uint32_t startBlock, numBlocks;+ struct hfsmount *hfsmp = arg;++ if (hfs_kdebug_allocation & HFSDBG_UNMAP_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_UNMAP_CALLBACK | DBG_FUNC_START, 0, extent_count, 0, 0, 0);++ for (i=0; i<extent_count; ++i) {+ /* Convert the byte range in *extents back to a range of allocation blocks. */+ startBlock = (extents[i].offset - hfsmp->hfsPlusIOPosOffset) / hfsmp->blockSize;+ numBlocks = extents[i].length / hfsmp->blockSize;+ (void) add_free_extent_cache(hfsmp, startBlock, numBlocks);+ }++ if (hfs_kdebug_allocation & HFSDBG_UNMAP_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_UNMAP_CALLBACK | DBG_FUNC_END, 0, 0, 0, 0, 0);+}+++/*+ ;________________________________________________________________________________+ ;+ ; Routine: CheckUnmappedBytes+ ;+ ; Function: From the specified inputs, determine if the extent in question overlaps+ ; space that was recently freed, where the recently freed space may still be+ ; lingering in an uncommitted journal transaction. This may have data safety+ ; implications. The intended use is to decide whether or not to force a journal flush+ ; before allowing file data I/O to be issued. If we did not do this+ ; then it would be possible to issue the file I/O ahead of the+ ; journal, resulting in data being overwritten if the transaction either+ ; is not committed or cannot be replayed.+ ;+ ; NOTE: This function assumes that the journal and catalog/extent locks are held.+ ;+ ; Input Arguments:+ ; hfsmp - The volume containing the allocation blocks.+ ; foffset - start of the extent in question (in allocation blocks)+ ; numbytes - number of blocks in the extent.+ ; recently_freed: - output pointer containing whether or not the blocks were freed recently+ ; overlap_end - end of the overlap between the argument extent and the trim list (in allocation blocks)+ ;+ ; Output:+ ;+ ; Returns 0 if we could determine extent validity for this (or a previous transaction)+ ; Returns errno if there was an error+ ;+ ; If returned 0, then recently freed will contain a boolean that indicates+ ; that it was recently freed.+ ;________________________________________________________________________________+ */++u_int32_t+CheckUnmappedBytes (struct hfsmount *hfsmp, uint64_t blockno, uint64_t numblocks, int *recently_freed, uint32_t *overlap_end) {+ uint64_t device_offset;+ uint64_t numbytes;+ uint32_t err = 0;+ uint64_t lba_overlap_end;++ if (hfsmp->jnl != NULL) {+ /*+ * Convert the allocation block # and the number of blocks into device-relative+ * offsets so that they can be compared using the TRIM list.+ */+ uint64_t device_sz = hfsmp->hfs_logical_bytes;+ device_offset = blockno * ((uint64_t)hfsmp->blockSize);+ device_offset += hfsmp->hfsPlusIOPosOffset;+ numbytes = (((uint64_t)hfsmp->blockSize) * numblocks);++ /*+ * Since we check that the device_offset isn't too large, it's safe to subtract it+ * from the size in the second check.+ */+ if ((device_offset >= device_sz) || (numbytes > (device_sz - device_offset))) {+ return EINVAL;+ }++ /* Ask the journal if this extent overlaps with any pending TRIMs */+ if (journal_trim_extent_overlap (hfsmp->jnl, device_offset, numbytes, &lba_overlap_end)) {+ *recently_freed = 1;++ /* Convert lba_overlap_end back into allocation blocks */+ uint64_t end_offset = lba_overlap_end - hfsmp->hfsPlusIOPosOffset;+ end_offset = end_offset / ((uint64_t) hfsmp->blockSize);+ *overlap_end = (uint32_t) end_offset;+ }+ else {+ *recently_freed = 0;+ }+ err = 0;+ }+ else {+ /* There may not be a journal. In that case, always return success. */+ *recently_freed = 0;+ }+ return err;++}+++/*+ ;________________________________________________________________________________+ ;+ ; Routine: ScanUnmapBlocks+ ;+ ; Function: Traverse the bitmap, and potentially issue DKIOCUNMAPs to the underlying+ ; device as needed so that the underlying disk device is as+ ; up-to-date as possible with which blocks are unmapped.+ ; Additionally build up the summary table as needed.+ ;+ ; This function reads the bitmap in large block size+ ; (up to 1MB) unlike the runtime which reads the bitmap+ ; in 4K block size. So if this function is being called+ ; after the volume is mounted and actively modified, the+ ; caller needs to invalidate all of the existing buffers+ ; associated with the bitmap vnode before calling this+ ; function. If the buffers are not invalidated, it can+ ; cause buf_t collision and potential data corruption.+ ;+ ; Input Arguments:+ ; hfsmp - The volume containing the allocation blocks.+ ;________________________________________________________________________________+ */++u_int32_t ScanUnmapBlocks (struct hfsmount *hfsmp)+{+ u_int32_t blocks_scanned = 0;+ int error = 0;+ struct jnl_trim_list trimlist;++ if (hfs_kdebug_allocation & HFSDBG_UNMAP_ENABLED) {+ KERNEL_DEBUG_CONSTANT(HFSDBG_UNMAP_SCAN | DBG_FUNC_START, hfsmp->hfs_raw_dev, 0, 0, 0, 0);+ }++ /*+ *struct jnl_trim_list {+ uint32_t allocated_count;+ uint32_t extent_count;+ dk_extent_t *extents;+ };+ */+ bzero (&trimlist, sizeof(trimlist));++ /*+ * Any trim related work should be tied to whether the underlying+ * storage media supports UNMAP, as any solid state device would+ * on desktop or embedded.+ *+ * We do this because we may want to scan the full bitmap on+ * desktop for spinning media for the purposes of building up the+ * summary table.+ *+ * We also avoid sending TRIMs down to the underlying media if the+ * mount is read-only.+ */++ if ((hfsmp->hfs_flags & HFS_UNMAP) &&+ ((hfsmp->hfs_flags & HFS_READ_ONLY) == 0)) {+ /* If the underlying device supports unmap and the mount is read-write, initialize */+ int alloc_count = PAGE_SIZE / sizeof(dk_extent_t);+ void *extents = hfs_new_data(dk_extent_t, alloc_count);+ trimlist.extents = (dk_extent_t*)extents;+ trimlist.allocated_count = alloc_count;+ trimlist.extent_count = 0;+ }++ while ((blocks_scanned < hfsmp->totalBlocks) && (error == 0)){++ error = hfs_alloc_scan_range (hfsmp, blocks_scanned, &blocks_scanned, &trimlist);++ if (error) {+ printf("HFS: bitmap scan range error: %d on vol=%s\n", error, hfsmp->vcbVN);+ break;+ }+ }++ if ((hfsmp->hfs_flags & HFS_UNMAP) &&+ ((hfsmp->hfs_flags & HFS_READ_ONLY) == 0)) {+ if (error == 0) {+ hfs_issue_unmap(hfsmp, &trimlist);+ }+ if (trimlist.extents) {+ hfs_delete_data(trimlist.extents, dk_extent_t, trimlist.allocated_count);+ }+ }++ /*+ * This is in an #if block because hfs_validate_summary prototype and function body+ * will only show up if ALLOC_DEBUG is on, to save wired memory ever so slightly.+ */+#if ALLOC_DEBUG+ sanity_check_free_ext(hfsmp, 1);+ if (hfsmp->hfs_flags & HFS_SUMMARY_TABLE) {+ /* Validate the summary table too! */+ hfs_validate_summary(hfsmp);+ printf("HFS: Summary validation complete on %s\n", hfsmp->vcbVN);+ }+#endif++ if (hfs_kdebug_allocation & HFSDBG_UNMAP_ENABLED) {+ KERNEL_DEBUG_CONSTANT(HFSDBG_UNMAP_SCAN | DBG_FUNC_END, error, hfsmp->hfs_raw_dev, 0, 0, 0);+ }++ return error;+}++static void add_to_reserved_list(hfsmount_t *hfsmp, uint32_t start,+ uint32_t count, int list,+ struct rl_entry **reservation)+{+ struct rl_entry *range, *next_range;++ if (list == HFS_TENTATIVE_BLOCKS) {+ int nranges = 0;+ // Don't allow more than 4 tentative reservations+ TAILQ_FOREACH_SAFE(range, &hfsmp->hfs_reserved_ranges[HFS_TENTATIVE_BLOCKS],+ rl_link, next_range) {+ if (++nranges > 3)+ hfs_release_reserved(hfsmp, range, HFS_TENTATIVE_BLOCKS);+ }+ }++ range = hfs_malloc_type(struct rl_entry);+ range->rl_start = start;+ range->rl_end = start + count - 1;+ TAILQ_INSERT_HEAD(&hfsmp->hfs_reserved_ranges[list], range, rl_link);+ *reservation = range;+}++static void hfs_release_reserved(hfsmount_t *hfsmp,+ struct rl_entry *range,+ int list)+{+ if (range->rl_start == -1)+ return;++ TAILQ_REMOVE(&hfsmp->hfs_reserved_ranges[list], range, rl_link);++ if (rl_len(range) > 0) {+ if (list == HFS_TENTATIVE_BLOCKS)+ hfsmp->tentativeBlocks -= rl_len(range);+ else {+ /*+ * We don't need to unmap tentative blocks because we won't have+ * written to them, but we might have written to reserved blocks.+ * Nothing can refer to those blocks so this doesn't have to be+ * via the journal. If this proves to be too expensive, we could+ * consider not sending down the unmap or we could require this+ * to always be called within a transaction and then we can use+ * the journal.+ */+ dk_extent_t extent = {+ .offset = (hfs_blk_to_bytes(range->rl_start, hfsmp->blockSize)+ + hfsmp->hfsPlusIOPosOffset),+ .length = hfs_blk_to_bytes(rl_len(range), hfsmp->blockSize)+ };+ dk_unmap_t unmap = {+ .extents = &extent,+ .extentsCount = 1,+ };+ VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCUNMAP, (caddr_t)&unmap,+ 0, vfs_context_kernel());+ hfs_assert(hfsmp->lockedBlocks >= rl_len(range));+ hfsmp->lockedBlocks -= rl_len(range);+ }+ hfs_release_summary(hfsmp, range->rl_start, rl_len(range));+ add_free_extent_cache(hfsmp, range->rl_start, rl_len(range));+ }++ range->rl_start = -1;+ range->rl_end = -2;+}++static void hfs_free_locked_internal(hfsmount_t *hfsmp,+ struct rl_entry **reservation,+ int list)+{+ if (*reservation) {+ hfs_release_reserved(hfsmp, *reservation, list);+ hfs_free_type(*reservation, struct rl_entry);+ *reservation = NULL;+ }+}++void hfs_free_tentative(hfsmount_t *hfsmp, struct rl_entry **reservation)+{+ hfs_free_locked_internal(hfsmp, reservation, HFS_TENTATIVE_BLOCKS);+}++void hfs_free_locked(hfsmount_t *hfsmp, struct rl_entry **reservation)+{+ hfs_free_locked_internal(hfsmp, reservation, HFS_LOCKED_BLOCKS);+}++OSErr BlockAllocate (+ hfsmount_t *hfsmp, /* which volume to allocate space on */+ u_int32_t startingBlock, /* preferred starting block, or 0 for no preference */+ u_int32_t minBlocks, /* desired number of blocks to allocate */+ u_int32_t maxBlocks, /* maximum number of blocks to allocate */+ hfs_block_alloc_flags_t flags, /* option flags */+ u_int32_t *actualStartBlock, /* actual first block of allocation */+ u_int32_t *actualNumBlocks)+{+ hfs_alloc_extra_args_t extra_args = {+ .max_blocks = maxBlocks+ };++ HFSPlusExtentDescriptor extent = { startingBlock, minBlocks };++ OSErr err = hfs_block_alloc_int(hfsmp, &extent, flags, &extra_args);++ *actualStartBlock = extent.startBlock;+ *actualNumBlocks = extent.blockCount;++ return err;+}++errno_t hfs_block_alloc(hfsmount_t *hfsmp,+ HFSPlusExtentDescriptor *extent,+ hfs_block_alloc_flags_t flags,+ hfs_alloc_extra_args_t *ap)+{+ return MacToVFSError(hfs_block_alloc_int(hfsmp, extent, flags, ap));+}++/*+ ;________________________________________________________________________________+ ;+ ; Routine: hfs_block_alloc_int+ ;+ ; Function: Allocate space on a volume. If contiguous allocation is requested,+ ; at least the requested number of bytes will be allocated or an+ ; error will be returned. If contiguous allocation is not forced,+ ; the space will be allocated with the first largest extent available+ ; at the requested starting allocation block. If there is not enough+ ; room there, a block allocation of less than the requested size will be+ ; allocated.+ ;+ ; If the requested starting block is 0 (for new file allocations),+ ; the volume's allocation block pointer will be used as a starting+ ; point.+ ;+ ; Input Arguments:+ ; hfsmp - Pointer to the HFS mount structure.+ ; extent - startBlock indicates the block to start+ ; searching from and blockCount is the number of+ ; blocks required. Depending on the flags used,+ ; more or less blocks may be returned. The+ ; allocated extent is returned via this+ ; parameter.+ ; flags - Flags to specify options like contiguous, use+ ; metadata zone, skip free block check, etc.+ ; ap - Additional arguments used depending on flags.+ ; See hfs_alloc_extra_args_t and below.+ ;+ ; Output:+ ; (result) - Error code, zero for successful allocation+ ; extent - If successful, the allocated extent.+ ;+ ; Side effects:+ ; The volume bitmap is read and updated; the volume bitmap cache may be changed.+ ;+ ; HFS_ALLOC_TENTATIVE+ ; Blocks will be reserved but not marked allocated. They can be+ ; stolen if free space is limited. Tentative blocks can be used by+ ; passing HFS_ALLOC_USE_TENTATIVE and passing in the resevation.+ ; @ap->reservation_out is used to store the reservation.+ ;+ ; HFS_ALLOC_USE_TENTATIVE+ ; Use blocks previously returned with HFS_ALLOC_TENTATIVE.+ ; @ap->reservation_in should be set to whatever @ap->reservation_out+ ; was set to when HFS_ALLOC_TENTATIVE was used. If the tentative+ ; reservation was stolen, a normal allocation will take place.+ ;+ ; HFS_ALLOC_LOCKED+ ; Blocks will be reserved but not marked allocated. Unlike tentative+ ; reservations they cannot be stolen. It is safe to write to these+ ; blocks. @ap->reservation_out is used to store the reservation.+ ;+ ; HFS_ALLOC_COMMIT+ ; This will take blocks previously returned with HFS_ALLOC_LOCKED and+ ; mark them allocated on disk. @ap->reservation_in is used.+ ;+ ; HFS_ALLOC_ROLL_BACK+ ; Take blocks that were just recently deallocated and mark them+ ; allocated. This is for roll back situations. Blocks got+ ; deallocated and then something went wrong and we need to roll back+ ; by marking the blocks allocated.+ ;+ ; HFS_ALLOC_FORCECONTIG+ ; It will not return fewer than @min_blocks.+ ;+ ; HFS_ALLOC_TRY_HARD+ ; We will perform an exhaustive search to try and find @max_blocks.+ ; It will not return fewer than @min_blocks.+ ;+ ;________________________________________________________________________________+ */+OSErr hfs_block_alloc_int(hfsmount_t *hfsmp,+ HFSPlusExtentDescriptor *extent,+ hfs_block_alloc_flags_t flags,+ hfs_alloc_extra_args_t *ap)+{+ u_int32_t freeBlocks;+ OSErr err = 0;+ Boolean updateAllocPtr = false; // true if nextAllocation needs to be updated+ Boolean forceContiguous = false;+ Boolean forceFlush;++ uint32_t startingBlock = extent->startBlock;+ uint32_t minBlocks = extent->blockCount;+ uint32_t maxBlocks = (ap && ap->max_blocks) ? ap->max_blocks : minBlocks;++ if (hfs_kdebug_allocation & HFSDBG_ALLOC_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_BLOCK_ALLOCATE | DBG_FUNC_START, startingBlock, minBlocks, maxBlocks, flags, 0);++ if (ISSET(flags, HFS_ALLOC_COMMIT)) {+ extent->startBlock = (*ap->reservation_in)->rl_start;+ extent->blockCount = rl_len(*ap->reservation_in);+ goto mark_allocated;+ }++ if (ISSET(flags, HFS_ALLOC_ROLL_BACK))+ goto mark_allocated;++ freeBlocks = hfs_freeblks(hfsmp, 0);++ if (ISSET(flags, HFS_ALLOC_USE_TENTATIVE)) {+ struct rl_entry *range = *ap->reservation_in;++ if (range && range->rl_start != -1) {+ /*+ * It's possible that we have a tentative reservation+ * but there aren't enough free blocks due to loaned blocks+ * or insufficient space in the backing store.+ */+ uint32_t count = min(min(maxBlocks, rl_len(range)), freeBlocks);++ if (count >= minBlocks) {+ extent->startBlock = range->rl_start;+ extent->blockCount = count;++ // Should we go straight to commit?+ if (!ISSET(flags, HFS_ALLOC_LOCKED))+ SET(flags, HFS_ALLOC_COMMIT);++ goto mark_allocated;+ }+ }++ /*+ * We can't use the tentative reservation so free it and allocate+ * normally.+ */+ hfs_free_tentative(hfsmp, ap->reservation_in);+ CLR(flags, HFS_ALLOC_USE_TENTATIVE);+ }++ if (ISSET(flags, HFS_ALLOC_FORCECONTIG | HFS_ALLOC_TRY_HARD))+ forceContiguous = true;++ if (flags & HFS_ALLOC_FLUSHTXN) {+ forceFlush = true;+ }+ else {+ forceFlush = false;+ }++ hfs_assert(hfsmp->freeBlocks >= hfsmp->tentativeBlocks);++ // See if we have to steal tentative blocks+ if (freeBlocks < hfsmp->tentativeBlocks + minBlocks)+ SET(flags, HFS_ALLOC_IGNORE_TENTATIVE);++ /* Skip free block check if blocks are being allocated for relocating+ * data during truncating a volume.+ *+ * During hfs_truncatefs(), the volume free block count is updated+ * before relocating data to reflect the total number of free blocks+ * that will exist on the volume after resize is successful. This+ * means that we have reserved allocation blocks required for relocating+ * the data and hence there is no need to check the free blocks.+ * It will also prevent resize failure when the number of blocks in+ * an extent being relocated is more than the free blocks that will+ * exist after the volume is resized.+ */+ if ((flags & HFS_ALLOC_SKIPFREEBLKS) == 0) {+ // If the disk is already full, don't bother.+ if (freeBlocks == 0) {+ err = dskFulErr;+ goto exit;+ }+ if (forceContiguous && freeBlocks < minBlocks) {+ err = dskFulErr;+ goto exit;+ }++ /*+ * Clip if necessary so we don't over-subscribe the free blocks.+ */+ if (minBlocks > freeBlocks) {+ minBlocks = freeBlocks;+ }+ if (maxBlocks > freeBlocks) {+ maxBlocks = freeBlocks;+ }+ }++ if (ISSET(flags, HFS_ALLOC_TRY_HARD)) {+ err = hfs_alloc_try_hard(hfsmp, extent, maxBlocks, flags);+ if (err)+ goto exit;++ goto mark_allocated;+ }++ //+ // If caller didn't specify a starting block number, then use the volume's+ // next block to allocate from.+ //+ if (startingBlock == 0) {+ hfs_lock_mount (hfsmp);++ /* Sparse Allocation and nextAllocation are both used even if the R/B Tree is on */+ if (hfsmp->hfs_flags & HFS_HAS_SPARSE_DEVICE) {+ startingBlock = hfsmp->sparseAllocation;+ }+ else {+ startingBlock = hfsmp->nextAllocation;+ }+ hfs_unlock_mount(hfsmp);+ updateAllocPtr = true;+ }+++ if (startingBlock >= hfsmp->allocLimit) {+ startingBlock = 0; /* overflow so start at beginning */+ }++ //+ // If the request must be contiguous, then find a sequence of free blocks+ // that is long enough. Otherwise, find the first free block.+ //+ if (forceContiguous) {+ err = BlockFindContig(hfsmp, startingBlock, minBlocks, maxBlocks,+ flags, &extent->startBlock, &extent->blockCount);+ /*+ * If we allocated from a new position then also update the roving allocator.+ * This will keep the roving allocation pointer up-to-date even+ * if we are using the new R/B tree allocator, since+ * it doesn't matter to us here, how the underlying allocator found+ * the block to vend out.+ */+ if ((err == noErr) &&+ (extent->startBlock > startingBlock) &&+ ((extent->startBlock < hfsmp->hfs_metazone_start) ||+ (extent->startBlock > hfsmp->hfs_metazone_end))) {+ updateAllocPtr = true;+ }+ } else {+ /*+ * Scan the bitmap once, gather the N largest free extents, then+ * allocate from these largest extents. Repeat as needed until+ * we get all the space we needed. We could probably build up+ * that list when the higher level caller tried (and failed) a+ * contiguous allocation first.+ *+ * Note that the free-extent cache will be cease to be updated if+ * we are using the red-black tree for allocations. If we jettison+ * the tree, then we will reset the free-extent cache and start over.+ */++ /* Disable HFS_ALLOC_FLUSHTXN if needed */+ if (forceFlush) {+ flags &= ~HFS_ALLOC_FLUSHTXN;+ }++ /*+ * BlockFindKnown only examines the free extent cache; anything in there will+ * have been committed to stable storage already.+ */+ err = BlockFindKnown(hfsmp, maxBlocks, &extent->startBlock,+ &extent->blockCount);++ /* dskFulErr out of BlockFindKnown indicates an empty Free Extent Cache */++ if (err == dskFulErr) {+ /*+ * Now we have to do a bigger scan. Start at startingBlock and go up until the+ * allocation limit. We 'trust' the summary bitmap in this call, if it tells us+ * that it could not find any free space.+ */+ err = BlockFindAny(hfsmp, startingBlock, hfsmp->allocLimit,+ maxBlocks, flags, true,+ &extent->startBlock, &extent->blockCount);+ }+ if (err == dskFulErr) {+ /*+ * Vary the behavior here if the summary table is on or off.+ * If it is on, then we don't trust it it if we get into this case and+ * basically do a full scan for maximum coverage.+ * If it is off, then we trust the above and go up until the startingBlock.+ */+ if (hfsmp->hfs_flags & HFS_SUMMARY_TABLE) {+ err = BlockFindAny(hfsmp, 1, hfsmp->allocLimit, maxBlocks,+ flags, false,+ &extent->startBlock, &extent->blockCount);+ }+ else {+ err = BlockFindAny(hfsmp, 1, startingBlock, maxBlocks,+ flags, false,+ &extent->startBlock, &extent->blockCount);+ }++ /*+ * Last Resort: Find/use blocks that may require a journal flush.+ */+ if (err == dskFulErr && forceFlush) {+ flags |= HFS_ALLOC_FLUSHTXN;+ err = BlockFindAny(hfsmp, 1, hfsmp->allocLimit, maxBlocks,+ flags, false,+ &extent->startBlock, &extent->blockCount);+ }+ }+ }++ if (err)+ goto exit;++mark_allocated:++ // Handle alignment+ if (ap && ap->alignment && extent->blockCount < ap->max_blocks) {+ /*+ * See the comment in FileMgrInternal.h for alignment+ * semantics.+ */+ uint32_t rounding = ((extent->blockCount + ap->alignment_offset)+ % ap->alignment);++ // @minBlocks is still the minimum+ if (extent->blockCount >= minBlocks + rounding)+ extent->blockCount -= rounding;+ }++ err = BlockMarkAllocatedInternal(hfsmp, extent->startBlock,+ extent->blockCount, flags);++ if (err)+ goto exit;++ if (ISSET(hfsmp->hfs_flags, HFS_CS) && extent->blockCount != 0+ && !ISSET(flags, HFS_ALLOC_TENTATIVE)) {+ if (ISSET(flags, HFS_ALLOC_FAST_DEV)) {+#if !HFS_ALLOC_TEST /* need this guard because this file is compiled outside of the kernel */+ hfs_pin_block_range(hfsmp, HFS_PIN_IT,+ extent->startBlock, extent->blockCount);+#endif+ } else {+ _dk_cs_map_t cm = {+ .cm_extent = {+ (hfs_blk_to_bytes(extent->startBlock, hfsmp->blockSize)+ + hfsmp->hfsPlusIOPosOffset),+ hfs_blk_to_bytes(extent->blockCount, hfsmp->blockSize)+ }+ };++ errno_t err2 = VNOP_IOCTL(hfsmp->hfs_devvp, _DKIOCCSMAP,+ (caddr_t)&cm, 0, vfs_context_current());++ /*+ * Ignore errors for now; we are fully provisioned so in+ * theory CoreStorage should be able to handle this+ * allocation. Should we want to change this in future, then+ * we should think carefully how we handle errors. Allowing+ * CoreStorage to truncate our allocation is problematic+ * because we might have minimum and alignment requirements+ * and backing out changes we have already made is+ * non-trivial.+ */++ if (err2 || cm.cm_bytes_mapped < cm.cm_extent.length) {+ printf("hfs: _DKIOCCSMAP error: %d, bytes_mapped: %llu\n",+ err2, cm.cm_bytes_mapped);+ }+ }+ }++ // if we actually allocated something then go update the+ // various bits of state that we maintain regardless of+ // whether there was an error (i.e. partial allocations+ // still need to update things like the free block count).+ //+ if (extent->blockCount != 0) {+ //+ // If we used the volume's roving allocation pointer, then we need to update it.+ // Adding in the length of the current allocation might reduce the next allocate+ // call by avoiding a re-scan of the already allocated space. However, the clump+ // just allocated can quite conceivably end up being truncated or released when+ // the file is closed or its EOF changed. Leaving the allocation pointer at the+ // start of the last allocation will avoid unnecessary fragmentation in this case.+ //+ hfs_lock_mount (hfsmp);++ if (!ISSET(flags, HFS_ALLOC_USE_TENTATIVE | HFS_ALLOC_COMMIT)) {+ lck_spin_lock(&hfsmp->vcbFreeExtLock);+ if (hfsmp->vcbFreeExtCnt == 0 && hfsmp->hfs_freed_block_count == 0) {+ hfsmp->sparseAllocation = extent->startBlock;+ }+ lck_spin_unlock(&hfsmp->vcbFreeExtLock);+ if (extent->blockCount < hfsmp->hfs_freed_block_count) {+ hfsmp->hfs_freed_block_count -= extent->blockCount;+ } else {+ hfsmp->hfs_freed_block_count = 0;+ }++ if (updateAllocPtr &&+ ((extent->startBlock < hfsmp->hfs_metazone_start) ||+ (extent->startBlock > hfsmp->hfs_metazone_end))) {+ HFS_UPDATE_NEXT_ALLOCATION(hfsmp, extent->startBlock);+ }++ (void) remove_free_extent_cache(hfsmp, extent->startBlock, extent->blockCount);+ }++ if (ISSET(flags, HFS_ALLOC_USE_TENTATIVE)) {+ (*ap->reservation_in)->rl_start += extent->blockCount;+ hfsmp->tentativeBlocks -= extent->blockCount;+ if (rl_len(*ap->reservation_in) <= 0)+ hfs_free_tentative(hfsmp, ap->reservation_in);+ } else if (ISSET(flags, HFS_ALLOC_COMMIT)) {+ // Handle committing locked extents+ hfs_assert(hfsmp->lockedBlocks >= extent->blockCount);+ (*ap->reservation_in)->rl_start += extent->blockCount;+ hfsmp->lockedBlocks -= extent->blockCount;+ hfs_free_locked(hfsmp, ap->reservation_in);+ }++ /*+ * Update the number of free blocks on the volume+ *+ * Skip updating the free blocks count if the block are+ * being allocated to relocate data as part of hfs_truncatefs()+ */++ if (ISSET(flags, HFS_ALLOC_TENTATIVE)) {+ hfsmp->tentativeBlocks += extent->blockCount;+ } else if (ISSET(flags, HFS_ALLOC_LOCKED)) {+ hfsmp->lockedBlocks += extent->blockCount;+ } else if ((flags & HFS_ALLOC_SKIPFREEBLKS) == 0) {+ hfsmp->freeBlocks -= extent->blockCount;+ }+ MarkVCBDirty(hfsmp);+ hfs_unlock_mount(hfsmp);++ hfs_generate_volume_notifications(hfsmp);++ if (ISSET(flags, HFS_ALLOC_TENTATIVE)) {+ hfs_assert(ap);+ add_to_reserved_list(hfsmp, extent->startBlock, extent->blockCount,+ 0, ap->reservation_out);+ } else if (ISSET(flags, HFS_ALLOC_LOCKED)) {+ hfs_assert(ap);+ add_to_reserved_list(hfsmp, extent->startBlock, extent->blockCount,+ 1, ap->reservation_out);+ }++ if (ISSET(flags, HFS_ALLOC_IGNORE_TENTATIVE)) {+ /*+ * See if we used tentative blocks. Note that we cannot+ * free the reservations here because we don't have access+ * to the external pointers. All we can do is update the+ * reservations and they'll be cleaned up when whatever is+ * holding the pointers calls us back.+ *+ * We use the rangelist code to detect overlaps and+ * constrain the tentative block allocation. Note that+ * @end is inclusive so that our rangelist code will+ * resolve the various cases for us. As a result, we need+ * to ensure that we account for it properly when removing+ * the blocks from the tentative count in the mount point+ * and re-inserting the remainder (either head or tail)+ */+ struct rl_entry *range, *next_range;+ struct rl_head *ranges = &hfsmp->hfs_reserved_ranges[HFS_TENTATIVE_BLOCKS];+ const uint32_t start = extent->startBlock;+ const uint32_t end = start + extent->blockCount - 1;+ TAILQ_FOREACH_SAFE(range, ranges, rl_link, next_range) {+ switch (rl_overlap(range, start, end)) {+ case RL_OVERLAPCONTAINSRANGE:+ // Keep the bigger part+ if (start - range->rl_start > range->rl_end - end) {+ // Discard the tail+ hfsmp->tentativeBlocks -= range->rl_end + 1 - start;+ hfs_release_summary(hfsmp, end + 1, range->rl_end - end);+ const uint32_t old_end = range->rl_end;+ range->rl_end = start - 1;+ add_free_extent_cache(hfsmp, end + 1, old_end - end);+ } else {+ // Discard the head+ hfsmp->tentativeBlocks -= end + 1 - range->rl_start;+ hfs_release_summary(hfsmp, range->rl_start,+ start - range->rl_start);+ const uint32_t old_start = range->rl_start;+ range->rl_start = end + 1;+ add_free_extent_cache(hfsmp, old_start,+ start - old_start);+ }+ hfs_assert(range->rl_end >= range->rl_start);+ break;+ case RL_MATCHINGOVERLAP:+ case RL_OVERLAPISCONTAINED:+ hfsmp->tentativeBlocks -= rl_len(range);+ range->rl_end = range->rl_start - 1;+ hfs_release_reserved(hfsmp, range, HFS_TENTATIVE_BLOCKS);+ break;+ case RL_OVERLAPSTARTSBEFORE:+ hfsmp->tentativeBlocks -= range->rl_end + 1 - start;+ range->rl_end = start - 1;+ hfs_assert(range->rl_end >= range->rl_start);+ break;+ case RL_OVERLAPENDSAFTER:+ hfsmp->tentativeBlocks -= end + 1 - range->rl_start;+ range->rl_start = end + 1;+ hfs_assert(range->rl_end >= range->rl_start);+ break;+ case RL_NOOVERLAP:+ break;+ }+ }+ }+ }++exit:++ if (ALLOC_DEBUG) {+ if (err == noErr) {+ if (extent->startBlock >= hfsmp->totalBlocks) {+ panic ("BlockAllocate: vending invalid blocks!");+ }+ if (extent->startBlock >= hfsmp->allocLimit) {+ panic ("BlockAllocate: vending block past allocLimit!");+ }++ if ((extent->startBlock + extent->blockCount) >= hfsmp->totalBlocks) {+ panic ("BlockAllocate: vending too many invalid blocks!");+ }++ if ((extent->startBlock + extent->blockCount) >= hfsmp->allocLimit) {+ panic ("BlockAllocate: vending too many invalid blocks past allocLimit!");+ }+ }+ }++ if (err) {+ // Just to be safe...+ extent->startBlock = 0;+ extent->blockCount = 0;+ }++ if (hfs_kdebug_allocation & HFSDBG_ALLOC_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_BLOCK_ALLOCATE | DBG_FUNC_END, err, extent->startBlock, extent->blockCount, 0, 0);++ return err;+}+++/*+;________________________________________________________________________________+;+; Routine: BlockDeallocate+;+; Function: Update the bitmap to deallocate a run of disk allocation blocks+;+; Input Arguments:+; vcb - Pointer to ExtendedVCB for the volume to free space on+; firstBlock - First allocation block to be freed+; numBlocks - Number of allocation blocks to free up (must be > 0!)+;+; Output:+; (result) - Result code+;+; Side effects:+; The volume bitmap is read and updated; the volume bitmap cache may be changed.+; The Allocator's red-black trees may also be modified as a result.+;+;________________________________________________________________________________+*/++OSErr BlockDeallocate (+ ExtendedVCB *vcb, // Which volume to deallocate space on+ u_int32_t firstBlock, // First block in range to deallocate+ u_int32_t numBlocks, // Number of contiguous blocks to deallocate+ hfs_block_alloc_flags_t flags)+{+ if (ISSET(flags, HFS_ALLOC_TENTATIVE | HFS_ALLOC_LOCKED))+ return 0;++ OSErr err;+ struct hfsmount *hfsmp;+ hfsmp = VCBTOHFS(vcb);++ if (hfs_kdebug_allocation & HFSDBG_ALLOC_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_BLOCK_DEALLOCATE | DBG_FUNC_START, firstBlock, numBlocks, flags, 0, 0);++ //+ // If no blocks to deallocate, then exit early+ //+ if (numBlocks == 0) {+ err = noErr;+ goto Exit;+ }+++ if (ALLOC_DEBUG) {+ if (firstBlock >= hfsmp->totalBlocks) {+ panic ("BlockDeallocate: freeing invalid blocks!");+ }++ if ((firstBlock + numBlocks) >= hfsmp->totalBlocks) {+ panic ("BlockDeallocate: freeing too many invalid blocks!");+ }+ }++ /*+ * If we're using the summary bitmap, then try to mark the bits+ * as potentially usable/free before actually deallocating them.+ * It is better to be slightly speculative here for correctness.+ */++ (void) hfs_release_summary (hfsmp, firstBlock, numBlocks);++ err = BlockMarkFreeInternal(vcb, firstBlock, numBlocks, true);++ if (err) {+ goto Exit;+ }++ //+ // Update the volume's free block count, and mark the VCB as dirty.+ //+ hfs_lock_mount(hfsmp);+ /*+ * Do not update the free block count. This flags is specified+ * when a volume is being truncated.+ */+ if ((flags & HFS_ALLOC_SKIPFREEBLKS) == 0) {+ vcb->freeBlocks += numBlocks;+ }++ vcb->hfs_freed_block_count += numBlocks;++ if (vcb->nextAllocation == (firstBlock + numBlocks)) {+ HFS_UPDATE_NEXT_ALLOCATION(vcb, (vcb->nextAllocation - numBlocks));+ }++ if (hfsmp->jnl == NULL) {+ /*+ * In the journal case, we'll add the free extent once the journal+ * calls us back to tell us it wrote the transaction to disk.+ */+ (void) add_free_extent_cache(vcb, firstBlock, numBlocks);++ /*+ * If the journal case, we'll only update sparseAllocation once the+ * free extent cache becomes empty (when we remove the last entry+ * from the cache). Skipping it here means we're less likely to+ * find a recently freed extent via the bitmap before it gets added+ * to the free extent cache.+ */+ if (firstBlock < vcb->sparseAllocation) {+ vcb->sparseAllocation = firstBlock;+ }+ }++ MarkVCBDirty(vcb);+ hfs_unlock_mount(hfsmp);++ hfs_generate_volume_notifications(VCBTOHFS(vcb));+Exit:++ if (hfs_kdebug_allocation & HFSDBG_ALLOC_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_BLOCK_DEALLOCATE | DBG_FUNC_END, err, 0, 0, 0, 0);++ return err;+}+++u_int8_t freebitcount[16] = {+ 4, 3, 3, 2, 3, 2, 2, 1, /* 0 1 2 3 4 5 6 7 */+ 3, 2, 2, 1, 2, 1, 1, 0, /* 8 9 A B C D E F */+};++u_int32_t+MetaZoneFreeBlocks(ExtendedVCB *vcb)+{+ u_int32_t freeblocks;+ u_int32_t *currCache;+ uintptr_t blockRef;+ u_int32_t bit;+ u_int32_t lastbit;+ int bytesleft;+ int bytesperblock;+ u_int8_t byte;+ u_int8_t *buffer;++ blockRef = 0;+ bytesleft = freeblocks = 0;+ buffer = NULL;+ bit = VCBTOHFS(vcb)->hfs_metazone_start;+ if (bit == 1)+ bit = 0;++ lastbit = VCBTOHFS(vcb)->hfs_metazone_end;+ bytesperblock = vcb->vcbVBMIOSize;++ /*+ * Count all the bits from bit to lastbit.+ */+ while (bit < lastbit) {+ /*+ * Get next bitmap block.+ */+ if (bytesleft == 0) {+ if (blockRef) {+ (void) ReleaseBitmapBlock(vcb, blockRef, false);+ blockRef = 0;+ }+ if (ReadBitmapBlock(vcb, bit, &currCache, &blockRef,+ HFS_ALLOC_IGNORE_TENTATIVE) != 0) {+ return (0);+ }+ buffer = (u_int8_t *)currCache;+ bytesleft = bytesperblock;+ }+ byte = *buffer++;+ freeblocks += freebitcount[byte & 0x0F];+ freeblocks += freebitcount[(byte >> 4) & 0x0F];+ bit += kBitsPerByte;+ --bytesleft;+ }+ if (blockRef)+ (void) ReleaseBitmapBlock(vcb, blockRef, false);++ return (freeblocks);+}+++/*+ * Obtain the next allocation block (bit) that's+ * outside the metadata allocation zone.+ */+static u_int32_t NextBitmapBlock(+ ExtendedVCB *vcb,+ u_int32_t bit)+{+ struct hfsmount *hfsmp = VCBTOHFS(vcb);++ if ((hfsmp->hfs_flags & HFS_METADATA_ZONE) == 0)+ return (bit);+ /*+ * Skip over metadata allocation zone.+ */+ if ((bit >= hfsmp->hfs_metazone_start) &&+ (bit <= hfsmp->hfs_metazone_end)) {+ bit = hfsmp->hfs_metazone_end + 1;+ }+ return (bit);+}+++// Assumes @bitmap is aligned to 8 bytes and multiple of 8 bytes.+static void bits_set(void *bitmap, int start, int end)+{+ const int start_bit = start & 63;+ const int end_bit = end & 63;++#define LEFT_MASK(bit) OSSwapHostToBigInt64(0xffffffffffffffffull << (64 - bit))+#define RIGHT_MASK(bit) OSSwapHostToBigInt64(0xffffffffffffffffull >> bit)++ uint64_t *p = (uint64_t *)bitmap + start / 64;++ if ((start & ~63) == (end & ~63)) {+ // Start and end in same 64 bits+ *p |= RIGHT_MASK(start_bit) & LEFT_MASK(end_bit);+ } else {+ *p++ |= RIGHT_MASK(start_bit);++ int nquads = (end - end_bit - start - 1) / 64;++ while (nquads--)+ *p++ = 0xffffffffffffffffull;++ if (end_bit)+ *p |= LEFT_MASK(end_bit);+ }+}++// Modifies the buffer and applies any reservations that we might have+static buf_t process_reservations(hfsmount_t *hfsmp, buf_t bp, off_t offset,+ hfs_block_alloc_flags_t flags,+ bool always_copy)+{+ bool taken_copy = false;+ void *buffer = (void *)buf_dataptr(bp);+ const uint32_t nbytes = buf_count(bp);+ const off_t end = offset + nbytes * 8 - 1;++ for (int i = (ISSET(flags, HFS_ALLOC_IGNORE_TENTATIVE)+ ? HFS_LOCKED_BLOCKS : HFS_TENTATIVE_BLOCKS); i < 2; ++i) {+ struct rl_entry *entry;+ TAILQ_FOREACH(entry, &hfsmp->hfs_reserved_ranges[i], rl_link) {+ uint32_t a, b;++ enum rl_overlaptype overlap_type = rl_overlap(entry, offset, end);++ if (overlap_type == RL_NOOVERLAP)+ continue;++ /*+ * If always_copy is false, we only take a copy if B_LOCKED is+ * set because ReleaseScanBitmapRange doesn't invalidate the+ * buffer in that case.+ */+ if (!taken_copy && (always_copy || ISSET(buf_flags(bp), B_LOCKED))) {+ buf_t new_bp = buf_create_shadow(bp, true, 0, NULL, NULL);+ buf_brelse(bp);+ bp = new_bp;+ buf_setflags(bp, B_NOCACHE);+ buffer = (void *)buf_dataptr(bp);+ taken_copy = true;+ }++ switch (overlap_type) {+ case RL_OVERLAPCONTAINSRANGE:+ case RL_MATCHINGOVERLAP:+ memset(buffer, 0xff, nbytes);+ return bp;+ case RL_OVERLAPISCONTAINED:+ a = entry->rl_start;+ b = entry->rl_end;+ break;+ case RL_OVERLAPSTARTSBEFORE:+ a = offset;+ b = entry->rl_end;+ break;+ case RL_OVERLAPENDSAFTER:+ a = entry->rl_start;+ b = end;+ break;+ case RL_NOOVERLAP:+ __builtin_unreachable();+ }++ a -= offset;+ b -= offset;++ hfs_assert(a < buf_count(bp) * 8);+ hfs_assert(b < buf_count(bp) * 8);+ hfs_assert(b >= a);++ // b is inclusive+ bits_set(buffer, a, b + 1);+ }+ } // for (;;)++ return bp;+}++/*+;_______________________________________________________________________+;+; Routine: ReadBitmapBlock+;+; Function: Read in a bitmap block corresponding to a given allocation+; block (bit). Return a pointer to the bitmap block.+;+; Inputs:+; vcb -- Pointer to ExtendedVCB+; bit -- Allocation block whose bitmap block is desired+;+; Outputs:+; buffer -- Pointer to bitmap block corresonding to "block"+; blockRef+;_______________________________________________________________________+*/+static OSErr ReadBitmapBlock(ExtendedVCB *vcb,+ u_int32_t bit,+ u_int32_t **buffer,+ uintptr_t *blockRef,+ hfs_block_alloc_flags_t flags)+{+ OSErr err;+ struct buf *bp = NULL;+ struct vnode *vp = NULL;+ daddr64_t block;+ u_int32_t blockSize;++ if (hfs_kdebug_allocation & HFSDBG_BITMAP_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_READ_BITMAP_BLOCK | DBG_FUNC_START, bit, 0, 0, 0, 0);++ /*+ * volume bitmap blocks are protected by the allocation file lock+ */+ REQUIRE_FILE_LOCK(vcb->hfs_allocation_vp, false);++ blockSize = (u_int32_t)vcb->vcbVBMIOSize;+ block = (daddr64_t)(bit / (blockSize * kBitsPerByte));++ /* HFS+ / HFSX */+ if (vcb->vcbSigWord != kHFSSigWord) {+ vp = vcb->hfs_allocation_vp; /* use allocation file vnode */+ }++ err = (int)buf_meta_bread(vp, block, blockSize, NOCRED, &bp);++ if (bp) {+ if (err) {+ buf_brelse(bp);+ *blockRef = 0;+ *buffer = NULL;+ } else {+ if (!ISSET(flags, HFS_ALLOC_IGNORE_RESERVED)) {+ bp = process_reservations(vcb, bp, block * blockSize * 8,+ flags, /* always_copy: */ true);+ }++ buf_setfsprivate(bp, (void *)(uintptr_t)flags);++ *blockRef = (uintptr_t)bp;+ *buffer = (u_int32_t *)buf_dataptr(bp);+ }+ } else+ hfs_assert(err);++ if (hfs_kdebug_allocation & HFSDBG_BITMAP_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_READ_BITMAP_BLOCK | DBG_FUNC_END, err, 0, 0, 0, 0);++ return err;+}+++/*+;_______________________________________________________________________+;+; Routine: ReadBitmapRange+;+; Function: Read in a range of the bitmap starting at the given offset.+; Use the supplied size to determine the amount of I/O to generate+; against the bitmap file. Return a pointer to the bitmap block.+;+; Inputs:+; hfsmp -- Pointer to hfs mount+; offset -- byte offset into the bitmap file+; size -- How much I/O to generate against the bitmap file.+;+; Outputs:+; buffer -- Pointer to bitmap block data corresonding to "block"+; blockRef -- struct 'buf' pointer which MUST be released in a subsequent call.+;_______________________________________________________________________+*/+static OSErr ReadBitmapRange(struct hfsmount *hfsmp, uint32_t offset,+ uint32_t iosize, uint32_t **buffer, struct buf **blockRef)+{++ OSErr err;+ struct buf *bp = NULL;+ struct vnode *vp = NULL;+ daddr64_t block;++ /* This function isn't supported for HFS standard */+ if (hfsmp->vcbSigWord != kHFSPlusSigWord) {+ return EINVAL;+ }++ if (hfs_kdebug_allocation & HFSDBG_BITMAP_ENABLED) {+ KERNEL_DEBUG_CONSTANT(HFSDBG_READ_BITMAP_RANGE | DBG_FUNC_START, offset, iosize, 0, 0, 0);+ }++ /*+ * volume bitmap blocks are protected by the allocation file lock+ */+ REQUIRE_FILE_LOCK(hfsmp->hfs_allocation_vp, false);++ vp = hfsmp->hfs_allocation_vp; /* use allocation file vnode */++ /*+ * The byte offset argument must be converted into bitmap-relative logical+ * block numbers before using it in buf_meta_bread.+ *+ * buf_meta_bread (and the things it calls) will eventually try to+ * reconstruct the byte offset into the file by multiplying the logical+ * block number passed in below by the vcbVBMIOSize field in the mount+ * point. So we prepare for that by converting the byte offset back into+ * logical blocks in terms of VBMIOSize units.+ *+ * The amount of I/O requested and the byte offset should be computed+ * based on the helper function in the frame that called us, so we can+ * get away with just doing a simple divide here.+ */+ block = (daddr64_t)(offset / hfsmp->vcbVBMIOSize);++ err = (int) buf_meta_bread(vp, block, iosize, NOCRED, &bp);++ if (bp) {+ if (err) {+ buf_brelse(bp);+ *blockRef = 0;+ *buffer = NULL;+ } else {+ bp = process_reservations(hfsmp, bp, (offset * 8), 0,+ /* always_copy: */ false);++ *blockRef = bp;+ *buffer = (u_int32_t *)buf_dataptr(bp);+ }+ }++ if (hfs_kdebug_allocation & HFSDBG_BITMAP_ENABLED) {+ KERNEL_DEBUG_CONSTANT(HFSDBG_READ_BITMAP_RANGE | DBG_FUNC_END, err, 0, 0, 0, 0);+ }++ return err;+}+++/*+;_______________________________________________________________________+;+; Routine: ReleaseBitmapBlock+;+; Function: Relase a bitmap block.+;+; Inputs:+; vcb+; blockRef+; dirty+;_______________________________________________________________________+*/+static OSErr ReleaseBitmapBlock(+ ExtendedVCB *vcb,+ uintptr_t blockRef,+ Boolean dirty)+{+ struct buf *bp = (struct buf *)blockRef;++ if (hfs_kdebug_allocation & HFSDBG_BITMAP_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_RELEASE_BITMAP_BLOCK | DBG_FUNC_START, dirty, 0, 0, 0, 0);++ if (blockRef == 0) {+ if (dirty)+ panic("hfs: ReleaseBitmapBlock: missing bp");+ return (0);+ }++ if (bp) {+ if (dirty) {+ hfs_block_alloc_flags_t flags = (uintptr_t)buf_fsprivate(bp);++ if (!ISSET(flags, HFS_ALLOC_IGNORE_RESERVED))+ panic("Modified read-only bitmap buffer!");++ struct hfsmount *hfsmp = VCBTOHFS(vcb);++ if (hfsmp->jnl) {+ journal_modify_block_end(hfsmp->jnl, bp, NULL, NULL);+ } else {+ buf_bdwrite(bp);+ }+ } else {+ buf_brelse(bp);+ }+ }++ if (hfs_kdebug_allocation & HFSDBG_BITMAP_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_RELEASE_BITMAP_BLOCK | DBG_FUNC_END, 0, 0, 0, 0, 0);++ return (0);+}++/*+ * ReleaseScanBitmapRange+ *+ * This is used to release struct bufs that were created for use by+ * bitmap scanning code. Because they may be of sizes different than the+ * typical runtime manipulation code, we want to force them to be purged out+ * of the buffer cache ASAP, so we'll release them differently than in the+ * ReleaseBitmapBlock case.+ *+ * Additionally, because we know that we're only reading the blocks and that they+ * should have been clean prior to reading them, we will never+ * issue a write to them (thus dirtying them).+ */++static OSErr ReleaseScanBitmapRange(struct buf *bp ) {++ if (hfs_kdebug_allocation & HFSDBG_BITMAP_ENABLED) {+ KERNEL_DEBUG_CONSTANT(HFSDBG_RELEASE_BITMAP_BLOCK | DBG_FUNC_START, 0, 0, 0, 0, 0);+ }++ if (bp) {+ /* Mark the buffer invalid if it isn't locked, then release it */+ if ((buf_flags(bp) & B_LOCKED) == 0) {+ buf_markinvalid(bp);+ }+ buf_brelse(bp);+ }++ if (hfs_kdebug_allocation & HFSDBG_BITMAP_ENABLED) {+ KERNEL_DEBUG_CONSTANT(HFSDBG_RELEASE_SCAN_BITMAP | DBG_FUNC_END, 0, 0, 0, 0, 0);+ }++ return (0);+}++/*+ * @extent.startBlock, on input, contains a preferred block for the+ * allocation. @extent.blockCount, on input, contains the minimum+ * number of blocks acceptable. Upon success, the result is conveyed+ * in @extent.+ */+static OSErr hfs_alloc_try_hard(hfsmount_t *hfsmp,+ HFSPlusExtentDescriptor *extent,+ uint32_t max_blocks,+ hfs_block_alloc_flags_t flags)+{+ OSErr err = dskFulErr;++ const uint32_t min_blocks = extent->blockCount;++ // It's > rather than >= because the last block is always reserved+ if (extent->startBlock > 0 && extent->startBlock < hfsmp->allocLimit+ && hfsmp->allocLimit - extent->startBlock > max_blocks) {+ /*+ * This is just checking to see if there's an extent starting+ * at extent->startBlock that will suit. We only check for+ * @max_blocks here; @min_blocks is ignored.+ */++ err = BlockFindContiguous(hfsmp, extent->startBlock, extent->startBlock + max_blocks,+ max_blocks, max_blocks, true, true,+ &extent->startBlock, &extent->blockCount, flags);++ if (err != dskFulErr)+ return err;+ }++ err = BlockFindKnown(hfsmp, max_blocks, &extent->startBlock,+ &extent->blockCount);++ if (!err) {+ if (extent->blockCount >= max_blocks)+ return 0;+ } else if (err != dskFulErr)+ return err;++ // Try a more exhaustive search+ return BlockFindContiguous(hfsmp, 1, hfsmp->allocLimit,+ min_blocks, max_blocks,+ /* useMetaZone: */ true,+ /* trustSummary: */ true,+ &extent->startBlock, &extent->blockCount, flags);+}++/*+_______________________________________________________________________++Routine: BlockFindContig++Function: Find a contiguous group of allocation blocks. If the+ minimum cannot be satisfied, nothing is returned. The+ caller guarantees that there are enough free blocks+ (though they may not be contiguous, in which case this+ call will fail).++Inputs:+ vcb Pointer to volume where space is to be allocated+ startingBlock Preferred first block for allocation+ minBlocks Minimum number of contiguous blocks to allocate+ maxBlocks Maximum number of contiguous blocks to allocate+ flags++Outputs:+ actualStartBlock First block of range allocated, or 0 if error+ actualNumBlocks Number of blocks allocated, or 0 if error+_______________________________________________________________________+*/+static OSErr BlockFindContig(+ ExtendedVCB *vcb,+ u_int32_t startingBlock,+ u_int32_t minBlocks,+ u_int32_t maxBlocks,+ hfs_block_alloc_flags_t flags,+ u_int32_t *actualStartBlock,+ u_int32_t *actualNumBlocks)+{+ OSErr retval = noErr;+ uint32_t currentStart = startingBlock;++ uint32_t foundStart = 0; // values to emit to caller+ uint32_t foundCount = 0;++ uint32_t collision_start = 0; // if we have to re-allocate a recently deleted extent, use this+ uint32_t collision_count = 0;++ int err;+ int allowReuse = (flags & HFS_ALLOC_FLUSHTXN);+ Boolean useMetaZone = (flags & HFS_ALLOC_METAZONE);++ int recently_deleted = 0;+ struct hfsmount *hfsmp = VCBTOHFS(vcb);++ if (hfs_kdebug_allocation & HFSDBG_ALLOC_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_FIND_CONTIG_BITMAP | DBG_FUNC_START, startingBlock, minBlocks, maxBlocks, useMetaZone, 0);++ while ((retval == noErr) && (foundStart == 0) && (foundCount == 0)) {++ /* Try and find something that works. */++ /*+ * NOTE: If the only contiguous free extent of at least minBlocks+ * crosses startingBlock (i.e. starts before, ends after), then we+ * won't find it. Earlier versions *did* find this case by letting+ * the second search look past startingBlock by minBlocks. But+ * with the free extent cache, this can lead to duplicate entries+ * in the cache, causing the same blocks to be allocated twice.+ */+ retval = BlockFindContiguous(vcb, currentStart, vcb->allocLimit, minBlocks,+ maxBlocks, useMetaZone, true, &foundStart, &foundCount, flags);++ if (retval == dskFulErr && currentStart != 0) {+ /*+ * We constrain the endingBlock so we don't bother looking for ranges+ * that would overlap those found in the previous call, if the summary bitmap+ * is not on for this volume. If it is, then we assume that it was not trust+ * -worthy and do a full scan.+ */+ if (hfsmp->hfs_flags & HFS_SUMMARY_TABLE) {+ retval = BlockFindContiguous(vcb, 1, vcb->allocLimit, minBlocks,+ maxBlocks, useMetaZone, false, &foundStart, &foundCount, flags);+ }+ else {+ retval = BlockFindContiguous(vcb, 1, currentStart, minBlocks,+ maxBlocks, useMetaZone, false, &foundStart, &foundCount, flags);+ }+ }++ if (retval != noErr) {+ goto bailout;+ }++ /* Do we overlap with the recently found collision extent? */+ if (collision_start) {+ if (extents_overlap (foundStart, foundCount, collision_start, collision_count)) {+ /*+ * We've looped around, and the only thing we could use was the collision extent.+ * Since we are allowed to use it, go ahead and do so now.+ */+ if(allowReuse) {+ /*+ * then we couldn't find anything except values which might have been+ * recently deallocated. just return our cached value if we are allowed to.+ */+ foundStart = collision_start;+ foundCount = collision_count;+ goto bailout;+ }+ else {+ /* Otherwise, we looped around and couldn't find anything that wouldn't require a journal flush. */+ retval = dskFulErr;+ goto bailout;+ }+ }+ }++ /* OK, we know we must not have collided . See if this one is recently deleted */+ if (hfsmp->jnl) {+ recently_deleted = 0;+ uint32_t nextStart;+ err = CheckUnmappedBytes (hfsmp, (uint64_t)foundStart,+ (uint64_t) foundCount, &recently_deleted, &nextStart);+ if (err == 0) {+ if(recently_deleted != 0) {+ /*+ * these blocks were recently deleted/deallocated. Cache the extent, but+ * but keep searching to see if we can find one that won't collide here.+ */+ if (collision_start == 0) {+ collision_start = foundStart;+ collision_count = foundCount;+ }+ recently_deleted = 0;++ /*+ * advance currentStart to the point just past the overlap we just found. Note that+ * we will automatically loop around to start of the bitmap as needed.+ */+ currentStart = nextStart;+ /* Unset foundStart/Count to allow it to loop around again. */+ foundStart = 0;+ foundCount = 0;+ }+ }+ } // end jnl/deleted case++ /*+ * If we found something good, we'd break out of the loop at the top; foundCount+ * and foundStart should be set.+ */++ } // end while loop.++bailout:++ if (retval == noErr) {+ *actualStartBlock = foundStart;+ *actualNumBlocks = foundCount;+ }++ if (hfs_kdebug_allocation & HFSDBG_ALLOC_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_FIND_CONTIG_BITMAP | DBG_FUNC_END, foundStart, foundCount, retval, 0, 0);++ return retval;++}+++/*+_______________________________________________________________________++Routine: BlockFindAny++Function: Find one or more allocation blocks and may return fewer than+ requested. The caller guarantees that there is at least one+ free block.++Inputs:+ vcb Pointer to volume where space is to be allocated+ startingBlock Preferred first block for allocation+ endingBlock Last block to check + 1+ maxBlocks Maximum number of contiguous blocks to allocate+ useMetaZone++Outputs:+ actualStartBlock First block of range allocated, or 0 if error+ actualNumBlocks Number of blocks allocated, or 0 if error+_______________________________________________________________________+*/++static OSErr BlockFindAny(+ ExtendedVCB *vcb,+ u_int32_t startingBlock,+ register u_int32_t endingBlock,+ u_int32_t maxBlocks,+ hfs_block_alloc_flags_t flags,+ Boolean trustSummary,+ u_int32_t *actualStartBlock,+ u_int32_t *actualNumBlocks)+{++ /*+ * If it is enabled, scan through the summary table to find the first free block.+ *+ * If it reports that there are not any free blocks, we could have a false+ * positive, so in that case, use the input arguments as a pass through.+ */+ uint32_t start_blk = startingBlock;+ uint32_t end_blk = endingBlock;+ struct hfsmount *hfsmp;+ OSErr err;++ hfsmp = (struct hfsmount*)vcb;+ if (hfsmp->hfs_flags & HFS_SUMMARY_TABLE) {+ uint32_t suggested_start;++ /*+ * If the summary table is enabled, scan through it to find the first free+ * block. If there was an error, or we couldn't find anything free in the+ * summary table, then just leave the start_blk fields unmodified. We wouldn't+ * have gotten to this point if the mount point made it look like there was possibly+ * free space in the FS.+ */+ err = hfs_find_summary_free (hfsmp, startingBlock, &suggested_start);+ if (err == 0) {+ start_blk = suggested_start;+ }+ else {+ /* Differentiate between ENOSPC and a more esoteric error in the above call. */+ if ((err == ENOSPC) && (trustSummary)) {+ /*+ * The 'trustSummary' argument is for doing a full scan if we really+ * really, need the space and we think it's somewhere but can't find it in the+ * summary table. If it's true, then we trust the summary table and return+ * dskFulErr if we couldn't find it above.+ */+ return dskFulErr;+ }+ /*+ * If either trustSummary was false or we got a different errno, then we+ * want to fall through to the real bitmap single i/o code...+ */+ }+ }++ err = BlockFindAnyBitmap(vcb, start_blk, end_blk, maxBlocks,+ flags, actualStartBlock, actualNumBlocks);++ return err;+}+++/*+ * BlockFindAnyBitmap finds free ranges by scanning the bitmap to+ * figure out where the free allocation blocks are. Inputs and+ * outputs are the same as for BlockFindAny.+ */++static OSErr BlockFindAnyBitmap(+ ExtendedVCB *vcb,+ u_int32_t startingBlock,+ register u_int32_t endingBlock,+ u_int32_t maxBlocks,+ hfs_block_alloc_flags_t flags,+ u_int32_t *actualStartBlock,+ u_int32_t *actualNumBlocks)+{+ OSErr err;+ register u_int32_t block = 0; // current block number+ register u_int32_t currentWord; // Pointer to current word within bitmap block+ register u_int32_t bitMask; // Word with given bits already set (ready to OR in)+ register u_int32_t wordsLeft; // Number of words left in this bitmap block+ u_int32_t *buffer = NULL;+ u_int32_t *currCache = NULL;+ uintptr_t blockRef = 0;+ u_int32_t bitsPerBlock;+ u_int32_t wordsPerBlock;+ struct hfsmount *hfsmp = VCBTOHFS(vcb);+ Boolean useMetaZone = (flags & HFS_ALLOC_METAZONE);+ Boolean forceFlush = (flags & HFS_ALLOC_FLUSHTXN);++ if (hfs_kdebug_allocation & HFSDBG_ALLOC_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_ALLOC_ANY_BITMAP | DBG_FUNC_START, startingBlock, endingBlock, maxBlocks, useMetaZone, 0);++restartSearchAny:++ /*+ * When we're skipping the metadata zone and the start/end+ * range overlaps with the metadata zone then adjust the+ * start to be outside of the metadata zone. If the range+ * is entirely inside the metadata zone then we can deny the+ * request (dskFulErr).+ */+ if (!useMetaZone && (vcb->hfs_flags & HFS_METADATA_ZONE)) {+ if (startingBlock <= vcb->hfs_metazone_end) {+ if (endingBlock > (vcb->hfs_metazone_end + 2))+ startingBlock = vcb->hfs_metazone_end + 1;+ else {+ err = dskFulErr;+ goto Exit;+ }+ }+ }++ // Since this routine doesn't wrap around+ if (maxBlocks > (endingBlock - startingBlock)) {+ maxBlocks = endingBlock - startingBlock;+ }++ //+ // Pre-read the first bitmap block+ //+ err = ReadBitmapBlock(vcb, startingBlock, &currCache, &blockRef, flags);+ if (err != noErr) goto Exit;+ buffer = currCache;++ //+ // Set up the current position within the block+ //+ {+ u_int32_t wordIndexInBlock;++ bitsPerBlock = vcb->vcbVBMIOSize * kBitsPerByte;+ wordsPerBlock = vcb->vcbVBMIOSize / kBytesPerWord;++ wordIndexInBlock = (startingBlock & (bitsPerBlock-1)) / kBitsPerWord;+ buffer += wordIndexInBlock;+ wordsLeft = wordsPerBlock - wordIndexInBlock;+ currentWord = SWAP_BE32 (*buffer);+ bitMask = kHighBitInWordMask >> (startingBlock & kBitsWithinWordMask);+ }++ /*+ * While loop 1:+ * Find the first unallocated block starting at 'block'+ */+ uint32_t summary_block_scan = 0;++ block=startingBlock;+ while (block < endingBlock) {+ if ((currentWord & bitMask) == 0)+ break;++ // Next bit+ ++block;+ bitMask >>= 1;+ if (bitMask == 0) {+ // Next word+ bitMask = kHighBitInWordMask;+ ++buffer;++ if (--wordsLeft == 0) {+ // Next block+ buffer = currCache = NULL;+ if (hfsmp->hfs_flags & HFS_SUMMARY_TABLE) {+ /*+ * If summary_block_scan is non-zero, then we must have+ * pulled a bitmap file block into core, and scanned through+ * the entire thing. Because we're in this loop, we are+ * implicitly trusting that the bitmap didn't have any knowledge+ * about this particular block. As a result, update the bitmap+ * (lazily, now that we've scanned it) with our findings that+ * this particular block is completely used up.+ */+ if (summary_block_scan != 0) {+ uint32_t summary_bit;+ (void) hfs_get_summary_index (hfsmp, summary_block_scan, &summary_bit);+ hfs_set_summary (hfsmp, summary_bit, 1);+ }+ }++ err = ReleaseBitmapBlock(vcb, blockRef, false);+ if (err != noErr) goto Exit;++ /*+ * Skip over metadata blocks.+ */+ if (!useMetaZone) {+ block = NextBitmapBlock(vcb, block);+ }+ if (block >= endingBlock) {+ err = dskFulErr;+ goto Exit;+ }++ err = ReadBitmapBlock(vcb, block, &currCache, &blockRef, flags);+ if (err != noErr) goto Exit;+ buffer = currCache;+ summary_block_scan = block;+ wordsLeft = wordsPerBlock;+ }+ currentWord = SWAP_BE32 (*buffer);+ }+ }++ // Did we get to the end of the bitmap before finding a free block?+ // If so, then couldn't allocate anything.+ if (block >= endingBlock) {+ err = dskFulErr;+ goto Exit;+ }+++ /*+ * Don't move forward just yet. Verify that either one of the following+ * two conditions is true:+ * 1) journaling is not enabled+ * 2) block is not currently on any pending TRIM list.+ */+ if (hfsmp->jnl != NULL && (forceFlush == false)) {+ int recently_deleted = 0;+ uint32_t nextblk;+ err = CheckUnmappedBytes (hfsmp, (uint64_t) block, 1, &recently_deleted, &nextblk);+ if ((err == 0) && (recently_deleted)) {++ /* release the bitmap block & unset currCache. we may jump past it. */+ err = ReleaseBitmapBlock(vcb, blockRef, false);+ currCache = NULL;+ if (err != noErr) {+ goto Exit;+ }+ /* set our start to nextblk, and re-do the search. */+ startingBlock = nextblk;+ goto restartSearchAny;+ }+ }+++ // Return the first block in the allocated range+ *actualStartBlock = block;++ // If we could get the desired number of blocks before hitting endingBlock,+ // then adjust endingBlock so we won't keep looking. Ideally, the comparison+ // would be (block + maxBlocks) < endingBlock, but that could overflow. The+ // comparison below yields identical results, but without overflow.+ if (block < (endingBlock-maxBlocks)) {+ endingBlock = block + maxBlocks; // if we get this far, we've found enough+ }++ /*+ * While loop 2:+ * Scan the bitmap, starting at 'currentWord' in the current+ * bitmap block. Continue iterating through the bitmap until+ * either we hit an allocated block, or until we have accumuluated+ * maxBlocks worth of bitmap.+ */++ /* Continue until we see an allocated block */+ while ((currentWord & bitMask) == 0) {+ // Move to the next block. If no more, then exit.+ ++block;+ if (block == endingBlock) {+ break;+ }++ // Next bit+ bitMask >>= 1;+ if (bitMask == 0) {+ // Next word+ bitMask = kHighBitInWordMask;+ ++buffer;++ if (--wordsLeft == 0) {+ // Next block+ buffer = currCache = NULL;++ /* We're only reading the bitmap here, so mark it as clean */+ err = ReleaseBitmapBlock(vcb, blockRef, false);+ if (err != noErr) {+ goto Exit;+ }++ /*+ * Skip over metadata blocks.+ */+ if (!useMetaZone) {+ u_int32_t nextBlock;+ nextBlock = NextBitmapBlock(vcb, block);+ if (nextBlock != block) {+ goto Exit; /* allocation gap, so stop */+ }+ }++ if (block >= endingBlock) {+ goto Exit;+ }++ err = ReadBitmapBlock(vcb, block, &currCache, &blockRef, flags);+ if (err != noErr) {+ goto Exit;+ }+ buffer = currCache;+ wordsLeft = wordsPerBlock;+ }+ currentWord = SWAP_BE32 (*buffer);+ }+ }++Exit:+ if (currCache) {+ /* Release the bitmap reference prior to marking bits in-use */+ (void) ReleaseBitmapBlock(vcb, blockRef, false);+ currCache = NULL;+ }++ if (err == noErr) {+ *actualNumBlocks = block - *actualStartBlock;++ // sanity check+ if ((*actualStartBlock + *actualNumBlocks) > vcb->allocLimit) {+ panic("hfs: BlockFindAnyBitmap: allocation overflow on \"%s\"", vcb->vcbVN);+ }+ }+ else {+ *actualStartBlock = 0;+ *actualNumBlocks = 0;+ }++ if (hfs_kdebug_allocation & HFSDBG_ALLOC_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_ALLOC_ANY_BITMAP | DBG_FUNC_END, err, *actualStartBlock, *actualNumBlocks, 0, 0);++ return err;+}+++/*+_______________________________________________________________________++Routine: BlockFindKnown++Function: Return a potential extent from the free extent cache. The+ returned extent *must* be marked allocated and removed+ from the cache by the *caller*.++Inputs:+ vcb Pointer to volume where space is to be allocated+ maxBlocks Maximum number of contiguous blocks to allocate++Outputs:+ actualStartBlock First block of range allocated, or 0 if error+ actualNumBlocks Number of blocks allocated, or 0 if error++Returns:+ dskFulErr Free extent cache is empty+_______________________________________________________________________+*/++static OSErr BlockFindKnown(+ ExtendedVCB *vcb,+ u_int32_t maxBlocks,+ u_int32_t *actualStartBlock,+ u_int32_t *actualNumBlocks)+{+ OSErr err;+ u_int32_t foundBlocks;+ struct hfsmount *hfsmp = VCBTOHFS(vcb);++ if (hfs_kdebug_allocation & HFSDBG_ALLOC_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_ALLOC_FIND_KNOWN | DBG_FUNC_START, 0, 0, maxBlocks, 0, 0);++ hfs_lock_mount (hfsmp);+ lck_spin_lock(&vcb->vcbFreeExtLock);+ if ( vcb->vcbFreeExtCnt == 0 ||+ vcb->vcbFreeExt[0].blockCount == 0) {+ lck_spin_unlock(&vcb->vcbFreeExtLock);+ hfs_unlock_mount(hfsmp);+ if (hfs_kdebug_allocation & HFSDBG_ALLOC_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_ALLOC_FIND_KNOWN | DBG_FUNC_END, dskFulErr, *actualStartBlock, *actualNumBlocks, 0, 0);+ return dskFulErr;+ }+ lck_spin_unlock(&vcb->vcbFreeExtLock);+ hfs_unlock_mount(hfsmp);++ lck_spin_lock(&vcb->vcbFreeExtLock);++ // Just grab up to maxBlocks of the first (largest) free exent.+ *actualStartBlock = vcb->vcbFreeExt[0].startBlock;+ foundBlocks = vcb->vcbFreeExt[0].blockCount;+ if (foundBlocks > maxBlocks)+ foundBlocks = maxBlocks;+ *actualNumBlocks = foundBlocks;++ lck_spin_unlock(&vcb->vcbFreeExtLock);++ // sanity check+ if ((*actualStartBlock + *actualNumBlocks) > vcb->allocLimit)+ {+ printf ("hfs: BlockAllocateKnown() found allocation overflow on \"%s\"", vcb->vcbVN);+ hfs_mark_inconsistent(vcb, HFS_INCONSISTENCY_DETECTED);+ err = EIO;+ } else+ err = 0;++ if (hfs_kdebug_allocation & HFSDBG_ALLOC_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_ALLOC_FIND_KNOWN | DBG_FUNC_END, err, *actualStartBlock, *actualNumBlocks, 0, 0);++ return err;+}++/*+ * BlockMarkAllocated+ *+ * This is a wrapper function around the internal calls which will actually mark the blocks+ * as in-use. It will mark the blocks in the red-black tree if appropriate. We need to do+ * this logic here to avoid callers having to deal with whether or not the red-black tree+ * is enabled.+ */++OSErr BlockMarkAllocated(+ ExtendedVCB *vcb,+ u_int32_t startingBlock,+ register u_int32_t numBlocks)+{+ return BlockMarkAllocatedInternal(vcb, startingBlock, numBlocks, 0);+}+++/*+_______________________________________________________________________++Routine: BlockMarkAllocatedInternal++Function: Mark a contiguous group of blocks as allocated (set in the+ bitmap). It assumes those bits are currently marked+ deallocated (clear in the bitmap). Note that this function+ must be called regardless of whether or not the bitmap or+ tree-based allocator is used, as all allocations must correctly+ be marked on-disk. If the tree-based approach is running, then+ this will be done before the node is removed from the tree.++Inputs:+ vcb Pointer to volume where space is to be allocated+ startingBlock First block number to mark as allocated+ numBlocks Number of blocks to mark as allocated+_______________________________________________________________________+*/+static+OSErr BlockMarkAllocatedInternal (+ ExtendedVCB *vcb,+ u_int32_t startingBlock,+ u_int32_t numBlocks,+ hfs_block_alloc_flags_t flags)+{+ OSErr err;+ register u_int32_t *currentWord; // Pointer to current word within bitmap block+ register u_int32_t wordsLeft; // Number of words left in this bitmap block+ register u_int32_t bitMask; // Word with given bits already set (ready to OR in)+ u_int32_t firstBit; // Bit index within word of first bit to allocate+ u_int32_t numBits; // Number of bits in word to allocate+ u_int32_t *buffer = NULL;+ uintptr_t blockRef = 0;+ u_int32_t bitsPerBlock;+ u_int32_t wordsPerBlock;+ // XXXdbg+ struct hfsmount *hfsmp = VCBTOHFS(vcb);++ if (hfs_kdebug_allocation & HFSDBG_BITMAP_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_MARK_ALLOC_BITMAP | DBG_FUNC_START, startingBlock, numBlocks, flags, 0, 0);++#if DEBUG++ if (!ISSET(flags, HFS_ALLOC_COMMIT)+ || ISSET(flags, HFS_ALLOC_USE_TENTATIVE)) {+ struct rl_entry *range;+ TAILQ_FOREACH(range, &hfsmp->hfs_reserved_ranges[HFS_LOCKED_BLOCKS], rl_link) {+ hfs_assert(rl_overlap(range, startingBlock,+ startingBlock + numBlocks - 1) == RL_NOOVERLAP);+ }+ }++#endif++ int force_flush = 0;+ /*+ * Since we are about to mark these bits as in-use+ * in the bitmap, decide if we need to alert the caller+ * that a journal flush might be appropriate. It's safe to+ * poke at the journal pointer here since we MUST have+ * called start_transaction by the time this function is invoked.+ * If the journal is enabled, then it will have taken the requisite+ * journal locks. If it is not enabled, then we have taken+ * a shared lock on the global lock.+ */+ if (hfsmp->jnl) {+ uint32_t ignore;+ err = CheckUnmappedBytes (hfsmp, (uint64_t) startingBlock, (uint64_t)numBlocks, &force_flush, &ignore);+ if ((err == 0) && (force_flush)) {+ journal_request_immediate_flush (hfsmp->jnl);+ }+ }++ hfs_unmap_alloc_extent(vcb, startingBlock, numBlocks);++ /*+ * Don't make changes to the disk if we're just reserving. Note that+ * we could do better in the tentative case because we could, in theory,+ * avoid the journal flush above. However, that would mean that we would+ * need to catch the callback to stop it incorrectly addding the extent+ * to our free cache.+ */+ if (ISSET(flags, HFS_ALLOC_LOCKED | HFS_ALLOC_TENTATIVE)) {+ err = 0;+ goto Exit;+ }++ //+ // Pre-read the bitmap block containing the first word of allocation+ //++ err = ReadBitmapBlock(vcb, startingBlock, &buffer, &blockRef,+ HFS_ALLOC_IGNORE_RESERVED);+ if (err != noErr) goto Exit;+ //+ // Initialize currentWord, and wordsLeft.+ //+ {+ u_int32_t wordIndexInBlock;++ bitsPerBlock = vcb->vcbVBMIOSize * kBitsPerByte;+ wordsPerBlock = vcb->vcbVBMIOSize / kBytesPerWord;++ wordIndexInBlock = (startingBlock & (bitsPerBlock-1)) / kBitsPerWord;+ currentWord = buffer + wordIndexInBlock;+ wordsLeft = wordsPerBlock - wordIndexInBlock;+ }++ // XXXdbg+ if (hfsmp->jnl) {+ journal_modify_block_start(hfsmp->jnl, (struct buf *)blockRef);+ }++ //+ // If the first block to allocate doesn't start on a word+ // boundary in the bitmap, then treat that first word+ // specially.+ //++ firstBit = startingBlock % kBitsPerWord;+ if (firstBit != 0) {+ bitMask = kAllBitsSetInWord >> firstBit; // turn off all bits before firstBit+ numBits = kBitsPerWord - firstBit; // number of remaining bits in this word+ if (numBits > numBlocks) {+ numBits = numBlocks; // entire allocation is inside this one word+ bitMask &= ~(kAllBitsSetInWord >> (firstBit + numBits)); // turn off bits after last+ }+#if DEBUG+ if ((*currentWord & SWAP_BE32 (bitMask)) != 0) {+ panic("hfs: BlockMarkAllocatedInternal: blocks already allocated!");+ }+#endif+ *currentWord |= SWAP_BE32 (bitMask); // set the bits in the bitmap+ numBlocks -= numBits; // adjust number of blocks left to allocate++ ++currentWord; // move to next word+ --wordsLeft; // one less word left in this block+ }++ //+ // Allocate whole words (32 blocks) at a time.+ //++ bitMask = kAllBitsSetInWord; // put this in a register for 68K+ while (numBlocks >= kBitsPerWord) {+ if (wordsLeft == 0) {+ // Read in the next bitmap block+ startingBlock += bitsPerBlock; // generate a block number in the next bitmap block++ buffer = NULL;+ err = ReleaseBitmapBlock(vcb, blockRef, true);+ if (err != noErr) goto Exit;++ err = ReadBitmapBlock(vcb, startingBlock, &buffer, &blockRef,+ HFS_ALLOC_IGNORE_RESERVED);+ if (err != noErr) goto Exit;++ // XXXdbg+ if (hfsmp->jnl) {+ journal_modify_block_start(hfsmp->jnl, (struct buf *)blockRef);+ }++ // Readjust currentWord and wordsLeft+ currentWord = buffer;+ wordsLeft = wordsPerBlock;+ }+#if DEBUG+ if (*currentWord != 0) {+ panic("hfs: BlockMarkAllocatedInternal: blocks already allocated!");+ }+#endif+ *currentWord = SWAP_BE32 (bitMask);+ numBlocks -= kBitsPerWord;++ ++currentWord; // move to next word+ --wordsLeft; // one less word left in this block+ }++ //+ // Allocate any remaining blocks.+ //++ if (numBlocks != 0) {+ bitMask = ~(kAllBitsSetInWord >> numBlocks); // set first numBlocks bits+ if (wordsLeft == 0) {+ // Read in the next bitmap block+ startingBlock += bitsPerBlock; // generate a block number in the next bitmap block++ buffer = NULL;+ err = ReleaseBitmapBlock(vcb, blockRef, true);+ if (err != noErr) goto Exit;++ err = ReadBitmapBlock(vcb, startingBlock, &buffer, &blockRef,+ HFS_ALLOC_IGNORE_RESERVED);+ if (err != noErr) goto Exit;++ // XXXdbg+ if (hfsmp->jnl) {+ journal_modify_block_start(hfsmp->jnl, (struct buf *)blockRef);+ }++ currentWord = buffer;+ }+#if DEBUG+ if ((*currentWord & SWAP_BE32 (bitMask)) != 0) {+ panic("hfs: BlockMarkAllocatedInternal: blocks already allocated!");+ }+#endif+ *currentWord |= SWAP_BE32 (bitMask); // set the bits in the bitmap++ // No need to update currentWord or wordsLeft+ }++Exit:++ if (buffer)+ (void)ReleaseBitmapBlock(vcb, blockRef, true);++ if (hfs_kdebug_allocation & HFSDBG_BITMAP_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_MARK_ALLOC_BITMAP | DBG_FUNC_END, err, 0, 0, 0, 0);++ return err;+}+++/*+ * BlockMarkFree+ *+ * This is a wrapper function around the internal calls which will actually mark the blocks+ * as freed. It will mark the blocks in the red-black tree if appropriate. We need to do+ * this logic here to avoid callers having to deal with whether or not the red-black tree+ * is enabled.+ *+ */+OSErr BlockMarkFree(+ ExtendedVCB *vcb,+ u_int32_t startingBlock,+ register u_int32_t numBlocks)+{+ return BlockMarkFreeInternal(vcb, startingBlock, numBlocks, true);+}+++/*+ * BlockMarkFreeUnused+ *+ * Scan the bitmap block beyond end of current file system for bits+ * that are marked as used. If any of the bits are marked as used,+ * this function marks them free.+ *+ * Note: This was specifically written to mark all bits beyond+ * end of current file system during hfs_extendfs(), which makes+ * sure that all the new blocks added to the file system are+ * marked as free. We expect that all the blocks beyond end of+ * current file system are always marked as free, but there might+ * be cases where are marked as used. This function assumes that+ * the number of blocks marked as used incorrectly are relatively+ * small, otherwise this can overflow journal transaction size+ * on certain file system configurations (example, large unused+ * bitmap with relatively small journal).+ *+ * Input:+ * startingBlock: First block of the range to mark unused+ * numBlocks: Number of blocks in the range to mark unused+ *+ * Returns: zero on success, non-zero on error.+ */+OSErr BlockMarkFreeUnused(ExtendedVCB *vcb, u_int32_t startingBlock, register u_int32_t numBlocks)+{+ int error = 0;+ struct hfsmount *hfsmp = VCBTOHFS(vcb);+ u_int32_t curNumBlocks;+ u_int32_t bitsPerBlock;+ u_int32_t lastBit;++ /* Use the optimal bitmap I/O size instead of bitmap block size */+ bitsPerBlock = hfsmp->vcbVBMIOSize * kBitsPerByte;++ /*+ * First clear any non bitmap allocation block aligned bits+ *+ * Calculate the first bit in the bitmap block next to+ * the bitmap block containing the bit for startingBlock.+ * Using this value, we calculate the total number of+ * bits to be marked unused from startingBlock to the+ * end of bitmap block containing startingBlock.+ */+ lastBit = ((startingBlock + (bitsPerBlock - 1))/bitsPerBlock) * bitsPerBlock;+ curNumBlocks = lastBit - startingBlock;+ if (curNumBlocks > numBlocks) {+ curNumBlocks = numBlocks;+ }+ error = BlockMarkFreeInternal(vcb, startingBlock, curNumBlocks, false);+ if (error) {+ return error;+ }+ startingBlock += curNumBlocks;+ numBlocks -= curNumBlocks;++ /*+ * Check a full bitmap block for any 'used' bit. If any bit is used,+ * mark all the bits only in that bitmap block as free. This ensures+ * that we do not write unmodified bitmap blocks and do not+ * overwhelm the journal.+ *+ * The code starts by checking full bitmap block at a time, and+ * marks entire bitmap block as free only if any bit in that bitmap+ * block is marked as used. In the end, it handles the last bitmap+ * block which might be partially full by only checking till the+ * caller-specified last bit and if any bit is set, only mark that+ * range as free.+ */+ while (numBlocks) {+ if (numBlocks >= bitsPerBlock) {+ curNumBlocks = bitsPerBlock;+ } else {+ curNumBlocks = numBlocks;+ }+ if (hfs_isallocated(hfsmp, startingBlock, curNumBlocks) == true) {+ error = BlockMarkFreeInternal(vcb, startingBlock, curNumBlocks, false);+ if (error) {+ return error;+ }+ }+ startingBlock += curNumBlocks;+ numBlocks -= curNumBlocks;+ }++ return error;+}++/*+_______________________________________________________________________++Routine: BlockMarkFreeInternal++Function: Mark a contiguous group of blocks as free (clear in the+ bitmap). It assumes those bits are currently marked+ allocated (set in the bitmap).++Inputs:+ vcb Pointer to volume where space is to be freed+ startingBlock First block number to mark as freed+ numBlocks Number of blocks to mark as freed+ do_validate If true, validate that the blocks being+ deallocated to check if they are within totalBlocks+ for current volume and whether they were allocated+ before they are marked free.+_______________________________________________________________________+*/+static+OSErr BlockMarkFreeInternal(+ ExtendedVCB *vcb,+ u_int32_t startingBlock_in,+ register u_int32_t numBlocks_in,+ Boolean do_validate)+{+ OSErr err;+ u_int32_t startingBlock = startingBlock_in;+ u_int32_t numBlocks = numBlocks_in;+ uint32_t unmapStart = startingBlock_in;+ uint32_t unmapCount = numBlocks_in;+ uint32_t wordIndexInBlock;+ u_int32_t *currentWord; // Pointer to current word within bitmap block+ u_int32_t wordsLeft; // Number of words left in this bitmap block+ u_int32_t bitMask; // Word with given bits already set (ready to OR in)+ u_int32_t currentBit; // Bit index within word of current bit to allocate+ u_int32_t numBits; // Number of bits in word to allocate+ u_int32_t *buffer = NULL;+ uintptr_t blockRef = 0;+ u_int32_t bitsPerBlock;+ u_int32_t wordsPerBlock;+ // XXXdbg+ struct hfsmount *hfsmp = VCBTOHFS(vcb);++ if (hfs_kdebug_allocation & HFSDBG_BITMAP_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_MARK_FREE_BITMAP | DBG_FUNC_START, startingBlock_in, numBlocks_in, do_validate, 0, 0);++ /*+ * NOTE: We use vcb->totalBlocks instead of vcb->allocLimit because we+ * need to be able to free blocks being relocated during hfs_truncatefs.+ */+ if ((do_validate == true) &&+ (startingBlock + numBlocks > vcb->totalBlocks)) {+#if ALLOC_DEBUG || DEBUG+ panic ("BlockMarkFreeInternal() free non-existent blocks at %u (numBlock=%u) on vol %s\n", startingBlock, numBlocks, vcb->vcbVN);+ __builtin_unreachable();+#else+ printf ("hfs: BlockMarkFreeInternal() trying to free non-existent blocks starting at %u (numBlock=%u) on volume %s\n", startingBlock, numBlocks, vcb->vcbVN);+ hfs_mark_inconsistent(vcb, HFS_INCONSISTENCY_DETECTED);+ err = EIO;+ goto Exit;+#endif+ }++ //+ // Pre-read the bitmap block containing the first word of allocation+ //++ err = ReadBitmapBlock(vcb, startingBlock, &buffer, &blockRef,+ HFS_ALLOC_IGNORE_RESERVED);+ if (err != noErr) goto Exit;+ // XXXdbg+ if (hfsmp->jnl) {+ journal_modify_block_start(hfsmp->jnl, (struct buf *)blockRef);+ }++ uint32_t min_unmap = 0, max_unmap = UINT32_MAX;++ // Work out the bounds of any unmap we can send down+ struct rl_entry *range;+ for (int i = 0; i < 2; ++i) {+ TAILQ_FOREACH(range, &hfsmp->hfs_reserved_ranges[i], rl_link) {+ if (range->rl_start < startingBlock+ && range->rl_end >= min_unmap) {+ min_unmap = range->rl_end + 1;+ }+ if (range->rl_end >= startingBlock + numBlocks+ && range->rl_start < max_unmap) {+ max_unmap = range->rl_start;+ }+ }+ }++ //+ // Figure out how many bits and words per bitmap block.+ //+ bitsPerBlock = vcb->vcbVBMIOSize * kBitsPerByte;+ wordsPerBlock = vcb->vcbVBMIOSize / kBytesPerWord;+ wordIndexInBlock = (startingBlock & (bitsPerBlock-1)) / kBitsPerWord;++ //+ // Look for a range of free blocks immediately before startingBlock+ // (up to the start of the current bitmap block). Set unmapStart to+ // the first free block.+ //+ currentWord = buffer + wordIndexInBlock;+ currentBit = startingBlock % kBitsPerWord;+ bitMask = kHighBitInWordMask >> currentBit;+ while (unmapStart > min_unmap) {+ // Move currentWord/bitMask back by one bit+ bitMask <<= 1;+ if (bitMask == 0) {+ if (--currentWord < buffer)+ break;+ bitMask = kLowBitInWordMask;+ }++ if (*currentWord & SWAP_BE32(bitMask))+ break; // Found an allocated block. Stop searching.+ --unmapStart;+ ++unmapCount;+ }++ //+ // If the first block to free doesn't start on a word+ // boundary in the bitmap, then treat that first word+ // specially.+ //++ currentWord = buffer + wordIndexInBlock;+ wordsLeft = wordsPerBlock - wordIndexInBlock;+ currentBit = startingBlock % kBitsPerWord;+ if (currentBit != 0) {+ bitMask = kAllBitsSetInWord >> currentBit; // turn off all bits before currentBit+ numBits = kBitsPerWord - currentBit; // number of remaining bits in this word+ if (numBits > numBlocks) {+ numBits = numBlocks; // entire allocation is inside this one word+ bitMask &= ~(kAllBitsSetInWord >> (currentBit + numBits)); // turn off bits after last+ }+ if ((do_validate == true) &&+ (*currentWord & SWAP_BE32 (bitMask)) != SWAP_BE32 (bitMask)) {+ goto Corruption;+ }+ *currentWord &= SWAP_BE32 (~bitMask); // clear the bits in the bitmap+ numBlocks -= numBits; // adjust number of blocks left to free++ ++currentWord; // move to next word+ --wordsLeft; // one less word left in this block+ }++ //+ // Free whole words (32 blocks) at a time.+ //++ while (numBlocks >= kBitsPerWord) {+ if (wordsLeft == 0) {+ // Read in the next bitmap block+ startingBlock += bitsPerBlock; // generate a block number in the next bitmap block++ buffer = NULL;+ err = ReleaseBitmapBlock(vcb, blockRef, true);+ if (err != noErr) goto Exit;++ err = ReadBitmapBlock(vcb, startingBlock, &buffer, &blockRef,+ HFS_ALLOC_IGNORE_RESERVED);+ if (err != noErr) goto Exit;++ // XXXdbg+ if (hfsmp->jnl) {+ journal_modify_block_start(hfsmp->jnl, (struct buf *)blockRef);+ }++ // Readjust currentWord and wordsLeft+ currentWord = buffer;+ wordsLeft = wordsPerBlock;+ }+ if ((do_validate == true) &&+ (*currentWord != SWAP_BE32 (kAllBitsSetInWord))) {+ goto Corruption;+ }+ *currentWord = 0; // clear the entire word+ numBlocks -= kBitsPerWord;++ ++currentWord; // move to next word+ --wordsLeft; // one less word left in this block+ }++ //+ // Free any remaining blocks.+ //++ if (numBlocks != 0) {+ bitMask = ~(kAllBitsSetInWord >> numBlocks); // set first numBlocks bits+ if (wordsLeft == 0) {+ // Read in the next bitmap block+ startingBlock += bitsPerBlock; // generate a block number in the next bitmap block++ buffer = NULL;+ err = ReleaseBitmapBlock(vcb, blockRef, true);+ if (err != noErr) goto Exit;++ err = ReadBitmapBlock(vcb, startingBlock, &buffer, &blockRef,+ HFS_ALLOC_IGNORE_RESERVED);+ if (err != noErr) goto Exit;++ // XXXdbg+ if (hfsmp->jnl) {+ journal_modify_block_start(hfsmp->jnl, (struct buf *)blockRef);+ }++ currentWord = buffer;+ }+ if ((do_validate == true) &&+ (*currentWord & SWAP_BE32 (bitMask)) != SWAP_BE32 (bitMask)) {+ goto Corruption;+ }+ *currentWord &= SWAP_BE32 (~bitMask); // clear the bits in the bitmap++ // No need to update currentWord or wordsLeft+ }++ //+ // Look for a range of free blocks immediately after the range we just freed+ // (up to the end of the current bitmap block).+ //+ wordIndexInBlock = ((startingBlock_in + numBlocks_in - 1) & (bitsPerBlock-1)) / kBitsPerWord;+ wordsLeft = wordsPerBlock - wordIndexInBlock;+ currentWord = buffer + wordIndexInBlock;+ currentBit = (startingBlock_in + numBlocks_in - 1) % kBitsPerWord;+ bitMask = kHighBitInWordMask >> currentBit;+ while (unmapStart + unmapCount < max_unmap) {+ // Move currentWord/bitMask/wordsLeft forward one bit+ bitMask >>= 1;+ if (bitMask == 0) {+ if (--wordsLeft == 0)+ break;+ ++currentWord;+ bitMask = kHighBitInWordMask;+ }++ if (*currentWord & SWAP_BE32(bitMask))+ break; // Found an allocated block. Stop searching.+ ++unmapCount;+ }++Exit:++ if (buffer)+ (void)ReleaseBitmapBlock(vcb, blockRef, true);++ if (err == noErr) {+ hfs_unmap_free_extent(vcb, unmapStart, unmapCount);+ }++ if (hfs_kdebug_allocation & HFSDBG_BITMAP_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_MARK_FREE_BITMAP | DBG_FUNC_END, err, 0, 0, 0, 0);++ return err;++Corruption:+#if DEBUG+ panic("hfs: BlockMarkFreeInternal: blocks not allocated!");+ __builtin_unreachable();+#else+ printf ("hfs: BlockMarkFreeInternal() trying to free unallocated blocks on volume %s <%u, %u>\n",+ vcb->vcbVN, startingBlock_in, numBlocks_in);+ hfs_mark_inconsistent(vcb, HFS_INCONSISTENCY_DETECTED);+ err = EIO;+ goto Exit;+#endif+}+++/*+_______________________________________________________________________++Routine: BlockFindContiguous++Function: Find a contiguous range of blocks that are free (bits+ clear in the bitmap). If a contiguous range of the+ minimum size can't be found, an error will be returned.+ This is only needed to support the bitmap-scanning logic,+ as the red-black tree should be able to do this by internally+ searching its tree.++Inputs:+ vcb Pointer to volume where space is to be allocated+ startingBlock Preferred first block of range+ endingBlock Last possible block in range + 1+ minBlocks Minimum number of blocks needed. Must be > 0.+ maxBlocks Maximum (ideal) number of blocks desired+ useMetaZone OK to dip into metadata allocation zone++Outputs:+ actualStartBlock First block of range found, or 0 if error+ actualNumBlocks Number of blocks found, or 0 if error++Returns:+ noErr Found at least minBlocks contiguous+ dskFulErr No contiguous space found, or all less than minBlocks+_______________________________________________________________________+*/++static OSErr BlockFindContiguous(+ ExtendedVCB *vcb,+ u_int32_t startingBlock,+ u_int32_t endingBlock,+ u_int32_t minBlocks,+ u_int32_t maxBlocks,+ Boolean useMetaZone,+ Boolean trustSummary,+ u_int32_t *actualStartBlock,+ u_int32_t *actualNumBlocks,+ hfs_block_alloc_flags_t flags)+{+ OSErr err;+ register u_int32_t currentBlock; // Block we're currently looking at.+ u_int32_t firstBlock; // First free block in current extent.+ u_int32_t stopBlock; // If we get to this block, stop searching for first free block.+ u_int32_t foundBlocks; // Number of contiguous free blocks in current extent.+ u_int32_t *buffer = NULL;+ register u_int32_t *currentWord;+ register u_int32_t bitMask;+ register u_int32_t wordsLeft;+ register u_int32_t tempWord;+ uintptr_t blockRef = 0;+ u_int32_t wordsPerBlock;+ u_int32_t updated_free_extent = 0;+ struct hfsmount *hfsmp = (struct hfsmount*) vcb;+ HFSPlusExtentDescriptor best = { 0, 0 };++ if (hfs_kdebug_allocation & HFSDBG_ALLOC_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_BLOCK_FIND_CONTIG | DBG_FUNC_START, startingBlock, endingBlock, minBlocks, maxBlocks, 0);++ /*+ * When we're skipping the metadata zone and the start/end+ * range overlaps with the metadata zone then adjust the+ * start to be outside of the metadata zone. If the range+ * is entirely inside the metadata zone then we can deny the+ * request (dskFulErr).+ */+ if (!useMetaZone && (vcb->hfs_flags & HFS_METADATA_ZONE)) {+ if (startingBlock <= vcb->hfs_metazone_end) {+ if (endingBlock > (vcb->hfs_metazone_end + 2))+ startingBlock = vcb->hfs_metazone_end + 1;+ else+ goto DiskFull;+ }+ }++ if ((endingBlock - startingBlock) < minBlocks)+ {+ // The set of blocks we're checking is smaller than the minimum number+ // of blocks, so we couldn't possibly find a good range.+ goto DiskFull;+ }++ stopBlock = endingBlock - minBlocks + 1;+ currentBlock = startingBlock;+ firstBlock = 0;++ /*+ * Skip over metadata blocks.+ */+ if (!useMetaZone)+ currentBlock = NextBitmapBlock(vcb, currentBlock);++ /*+ * Use the summary table if we can. Skip over any totally+ * allocated blocks. currentBlock should now point to the first+ * block beyond the metadata zone if the metazone allocations are not+ * allowed in this invocation.+ */+ if ((trustSummary) && (hfsmp->hfs_flags & HFS_SUMMARY_TABLE)) {+ uint32_t suggestion;+ err = hfs_find_summary_free (hfsmp, currentBlock, &suggestion);+ if (err && err != ENOSPC)+ goto ErrorExit;+ if (err == ENOSPC || suggestion >= stopBlock)+ goto DiskFull;+ currentBlock = suggestion;+ }+++ //+ // Pre-read the first bitmap block.+ //+ err = ReadBitmapBlock(vcb, currentBlock, &buffer, &blockRef, flags);+ if ( err != noErr ) goto ErrorExit;++ //+ // Figure out where currentBlock is within the buffer.+ //+ wordsPerBlock = vcb->vcbVBMIOSize / kBytesPerWord;++ wordsLeft = (currentBlock / kBitsPerWord) & (wordsPerBlock-1); // Current index into buffer+ currentWord = buffer + wordsLeft;+ wordsLeft = wordsPerBlock - wordsLeft;++ uint32_t remaining = (hfsmp->freeBlocks - hfsmp->lockedBlocks+ - (ISSET(flags, HFS_ALLOC_IGNORE_TENTATIVE)+ ? 0 : hfsmp->tentativeBlocks));++ /*+ * This outer do-while loop is the main body of this function. Its job is+ * to search through the blocks (until we hit 'stopBlock'), and iterate+ * through swaths of allocated bitmap until it finds free regions.+ */++ do+ {+ foundBlocks = 0;+ /*+ * We will try and update the summary table as we search+ * below. Note that we will never update the summary table+ * for the first and last blocks that the summary table+ * covers. Ideally, we should, but the benefits probably+ * aren't that significant so we leave things alone for now.+ */+ uint32_t summary_block_scan = 0;+ /*+ * Inner while loop 1:+ * Look for free blocks, skipping over allocated ones.+ *+ * Initialization starts with checking the initial partial word+ * if applicable.+ */+ bitMask = currentBlock & kBitsWithinWordMask;+ if (bitMask)+ {+ tempWord = SWAP_BE32(*currentWord); // Fetch the current word only once+ bitMask = kHighBitInWordMask >> bitMask;+ while (tempWord & bitMask)+ {+ bitMask >>= 1;+ ++currentBlock;+ }++ // Did we find an unused bit (bitMask != 0), or run out of bits (bitMask == 0)?+ if (bitMask)+ goto FoundUnused;++ // Didn't find any unused bits, so we're done with this word.+ ++currentWord;+ --wordsLeft;+ }++ //+ // Check whole words+ //+ while (currentBlock < stopBlock)+ {+ // See if it's time to read another block.+ if (wordsLeft == 0)+ {+ buffer = NULL;+ if (hfsmp->hfs_flags & HFS_SUMMARY_TABLE) {+ /*+ * If summary_block_scan is non-zero, then we must have+ * pulled a bitmap file block into core, and scanned through+ * the entire thing. Because we're in this loop, we are+ * implicitly trusting that the bitmap didn't have any knowledge+ * about this particular block. As a result, update the bitmap+ * (lazily, now that we've scanned it) with our findings that+ * this particular block is completely used up.+ */+ if (summary_block_scan != 0) {+ uint32_t summary_bit;+ (void) hfs_get_summary_index (hfsmp, summary_block_scan, &summary_bit);+ hfs_set_summary (hfsmp, summary_bit, 1);+ }+ }+ err = ReleaseBitmapBlock(vcb, blockRef, false);+ if (err != noErr) goto ErrorExit;++ /*+ * Skip over metadata blocks.+ */+ if (!useMetaZone) {+ currentBlock = NextBitmapBlock(vcb, currentBlock);+ if (currentBlock >= stopBlock) {+ goto LoopExit;+ }+ }++ /* Skip over fully allocated bitmap blocks if we can */+ if ((trustSummary) && (hfsmp->hfs_flags & HFS_SUMMARY_TABLE)) {+ uint32_t suggestion;+ err = hfs_find_summary_free (hfsmp, currentBlock, &suggestion);+ if (err && err != ENOSPC)+ goto ErrorExit;+ if (err == ENOSPC || suggestion >= stopBlock)+ goto LoopExit;+ currentBlock = suggestion;+ }++ err = ReadBitmapBlock(vcb, currentBlock, &buffer, &blockRef, flags);+ if ( err != noErr ) goto ErrorExit;++ /*+ * Set summary_block_scan to be the block we just read into the block cache.+ *+ * At this point, we've just read an allocation block worth of bitmap file+ * into the buffer above, but we don't know if it is completely allocated or not.+ * If we find that it is completely allocated/full then we will jump+ * through this loop again and set the appropriate summary bit as fully allocated.+ */+ summary_block_scan = currentBlock;+ currentWord = buffer;+ wordsLeft = wordsPerBlock;+ }++ // See if any of the bits are clear+ if ((tempWord = SWAP_BE32(*currentWord)) + 1) // non-zero if any bits were clear+ {+ // Figure out which bit is clear+ bitMask = kHighBitInWordMask;+ while (tempWord & bitMask)+ {+ bitMask >>= 1;+ ++currentBlock;+ }++ break; // Found the free bit; break out to FoundUnused.+ }++ // Keep looking at the next word+ currentBlock += kBitsPerWord;+ ++currentWord;+ --wordsLeft;+ }++FoundUnused:+ // Make sure the unused bit is early enough to use+ if (currentBlock >= stopBlock)+ {+ break;+ }++ // Remember the start of the extent+ firstBlock = currentBlock;+++ /*+ * Inner while loop 2:+ * We get here if we find a free block. Count the number+ * of contiguous free blocks observed.+ *+ * Initialization starts with checking the initial partial word+ * if applicable.+ */+ bitMask = currentBlock & kBitsWithinWordMask;+ if (bitMask)+ {+ tempWord = SWAP_BE32(*currentWord); // Fetch the current word only once+ bitMask = kHighBitInWordMask >> bitMask;+ while (bitMask && !(tempWord & bitMask))+ {+ bitMask >>= 1;+ ++currentBlock;+ }++ // Did we find a used bit (bitMask != 0), or run out of bits (bitMask == 0)?+ if (bitMask)+ goto FoundUsed;++ // Didn't find any used bits, so we're done with this word.+ ++currentWord;+ --wordsLeft;+ }++ //+ // Check whole words+ //+ while (currentBlock < endingBlock)+ {+ // See if it's time to read another block.+ if (wordsLeft == 0)+ {+ buffer = NULL;+ err = ReleaseBitmapBlock(vcb, blockRef, false);+ if (err != noErr) goto ErrorExit;++ /*+ * Skip over metadata blocks.+ */+ if (!useMetaZone) {+ u_int32_t nextBlock;++ nextBlock = NextBitmapBlock(vcb, currentBlock);+ if (nextBlock != currentBlock) {+ goto LoopExit; /* allocation gap, so stop */+ }+ }++ err = ReadBitmapBlock(vcb, currentBlock, &buffer, &blockRef, flags);+ if ( err != noErr ) goto ErrorExit;++ currentWord = buffer;+ wordsLeft = wordsPerBlock;+ }++ // See if any of the bits are set+ if ((tempWord = SWAP_BE32(*currentWord)) != 0)+ {+ // Figure out which bit is set+ bitMask = kHighBitInWordMask;+ while (!(tempWord & bitMask))+ {+ bitMask >>= 1;+ ++currentBlock;+ }++ break; // Found the used bit; break out to FoundUsed.+ }++ // Keep looking at the next word+ currentBlock += kBitsPerWord;+ ++currentWord;+ --wordsLeft;++ // If we found at least maxBlocks, we can quit early.+ if ((currentBlock - firstBlock) >= maxBlocks)+ break;+ }++FoundUsed:+ // Make sure we didn't run out of bitmap looking for a used block.+ // If so, pin to the end of the bitmap.+ if (currentBlock > endingBlock)+ currentBlock = endingBlock;++ // Figure out how many contiguous free blocks there were.+ // Pin the answer to maxBlocks.+ foundBlocks = currentBlock - firstBlock;+ if (foundBlocks > maxBlocks)+ foundBlocks = maxBlocks;++ if (remaining) {+ if (foundBlocks > remaining) {+ hfs_debug("hfs: found more blocks than are indicated free!\n");+ remaining = UINT32_MAX;+ } else+ remaining -= foundBlocks;+ }++ if (ISSET(flags, HFS_ALLOC_TRY_HARD)) {+ if (foundBlocks > best.blockCount) {+ best.startBlock = firstBlock;+ best.blockCount = foundBlocks;+ }++ if (foundBlocks >= maxBlocks || best.blockCount >= remaining)+ break;++ /*+ * Note that we will go ahead and add this free extent to our+ * cache below but that's OK because we'll remove it again if we+ * decide to use this extent.+ */+ } else if (foundBlocks >= minBlocks)+ break; // Found what we needed!++ /*+ * We did not find the total blocks we were looking for, but+ * add this free block run to our free extent cache list, if possible.+ */++ // If we're ignoring tentative ranges, we need to account for them here+ if (ISSET(flags, HFS_ALLOC_IGNORE_TENTATIVE)) {+ struct rl_entry free_extent = rl_make(firstBlock, firstBlock + foundBlocks - 1);+ struct rl_entry *range;;+ TAILQ_FOREACH(range, &hfsmp->hfs_reserved_ranges[HFS_TENTATIVE_BLOCKS], rl_link) {+ rl_subtract(&free_extent, range);+ if (rl_len(range) == 0)+ break;+ }+ firstBlock = free_extent.rl_start;+ foundBlocks = rl_len(&free_extent);+ }++ if (foundBlocks) {+ if (hfsmp->jnl == NULL) {+ /* If there is no journal, go ahead and add to the free ext cache. */+ updated_free_extent = add_free_extent_cache(vcb, firstBlock, foundBlocks);+ }+ else {+ /*+ * If journaled, only add to the free extent cache if this block is not+ * waiting for a TRIM to complete; that implies that the transaction that freed it+ * has not yet been committed to stable storage.+ */+ int recently_deleted = 0;+ uint32_t nextblock;+ err = CheckUnmappedBytes(hfsmp, (uint64_t)firstBlock,+ (uint64_t)foundBlocks, &recently_deleted, &nextblock);+ if ((err) || (recently_deleted == 0)) {+ /* if we hit an error, or the blocks not recently freed, go ahead and insert it */+ updated_free_extent = add_free_extent_cache(vcb, firstBlock, foundBlocks);+ }+ }+ }+ } while (currentBlock < stopBlock);+LoopExit:++ if (ISSET(flags, HFS_ALLOC_TRY_HARD)) {+ firstBlock = best.startBlock;+ foundBlocks = best.blockCount;+ }++ // Return the outputs.+ if (foundBlocks < minBlocks)+ {+DiskFull:+ err = dskFulErr;+ErrorExit:+ *actualStartBlock = 0;+ *actualNumBlocks = 0;+ }+ else+ {+ err = noErr;+ *actualStartBlock = firstBlock;+ *actualNumBlocks = foundBlocks;+ /*+ * Sanity check for overflow+ */+ if ((firstBlock + foundBlocks) > vcb->allocLimit) {+ panic("hfs: blk allocation overflow on \"%s\" sb:0x%08x eb:0x%08x cb:0x%08x fb:0x%08x stop:0x%08x min:0x%08x found:0x%08x",+ vcb->vcbVN, startingBlock, endingBlock, currentBlock,+ firstBlock, stopBlock, minBlocks, foundBlocks);+ }+ }++ if (updated_free_extent && (vcb->hfs_flags & HFS_HAS_SPARSE_DEVICE)) {+ int i;+ u_int32_t min_start = vcb->totalBlocks;++ // set the nextAllocation pointer to the smallest free block number+ // we've seen so on the next mount we won't rescan unnecessarily+ lck_spin_lock(&vcb->vcbFreeExtLock);+ for(i=0; i < (int)vcb->vcbFreeExtCnt; i++) {+ if (vcb->vcbFreeExt[i].startBlock < min_start) {+ min_start = vcb->vcbFreeExt[i].startBlock;+ }+ }+ lck_spin_unlock(&vcb->vcbFreeExtLock);+ if (min_start != vcb->totalBlocks) {+ if (min_start < vcb->nextAllocation) {+ vcb->nextAllocation = min_start;+ }+ if (min_start < vcb->sparseAllocation) {+ vcb->sparseAllocation = min_start;+ }+ }+ }++ if (buffer)+ (void) ReleaseBitmapBlock(vcb, blockRef, false);++ if (hfs_kdebug_allocation & HFSDBG_ALLOC_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_BLOCK_FIND_CONTIG | DBG_FUNC_END, err, *actualStartBlock, *actualNumBlocks, 0, 0);++ return err;+}+++/*+ * Count number of bits set in the given 32-bit unsigned number+ *+ * Returns:+ * Number of bits set+ */+static int num_bits_set(u_int32_t num)+{+ int count;++ for (count = 0; num; count++) {+ num &= num - 1;+ }++ return count;+}++/*+ * For a given range of blocks, find the total number of blocks+ * allocated. If 'stop_on_first' is true, it stops as soon as it+ * encounters the first allocated block. This option is useful+ * to determine if any block is allocated or not.+ *+ * Inputs:+ * startingBlock First allocation block number of the range to be scanned.+ * numBlocks Total number of blocks that need to be scanned.+ * stop_on_first Stop the search after the first allocated block is found.+ *+ * Output:+ * allocCount Total number of allocation blocks allocated in the given range.+ *+ * On error, it is the number of allocated blocks found+ * before the function got an error.+ *+ * If 'stop_on_first' is set,+ * allocCount = 1 if any allocated block was found.+ * allocCount = 0 if no allocated block was found.+ *+ * Returns:+ * 0 on success, non-zero on failure.+ */+static int+hfs_isallocated_internal(struct hfsmount *hfsmp, u_int32_t startingBlock,+ u_int32_t numBlocks, Boolean stop_on_first, u_int32_t *allocCount)+{+ u_int32_t *currentWord; // Pointer to current word within bitmap block+ u_int32_t wordsLeft; // Number of words left in this bitmap block+ u_int32_t bitMask; // Word with given bits already set (ready to test)+ u_int32_t firstBit; // Bit index within word of first bit to allocate+ u_int32_t numBits; // Number of bits in word to allocate+ u_int32_t *buffer = NULL;+ uintptr_t blockRef;+ u_int32_t bitsPerBlock;+ u_int32_t wordsPerBlock;+ u_int32_t blockCount = 0;+ int error;++ if (hfs_kdebug_allocation & HFSDBG_BITMAP_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_IS_ALLOCATED | DBG_FUNC_START, startingBlock, numBlocks, stop_on_first, 0, 0);++ /*+ * Pre-read the bitmap block containing the first word of allocation+ */+ error = ReadBitmapBlock(hfsmp, startingBlock, &buffer, &blockRef,+ HFS_ALLOC_IGNORE_TENTATIVE);+ if (error)+ goto JustReturn;++ /*+ * Initialize currentWord, and wordsLeft.+ */+ {+ u_int32_t wordIndexInBlock;++ bitsPerBlock = hfsmp->vcbVBMIOSize * kBitsPerByte;+ wordsPerBlock = hfsmp->vcbVBMIOSize / kBytesPerWord;++ wordIndexInBlock = (startingBlock & (bitsPerBlock-1)) / kBitsPerWord;+ currentWord = buffer + wordIndexInBlock;+ wordsLeft = wordsPerBlock - wordIndexInBlock;+ }++ /*+ * First test any non word aligned bits.+ */+ firstBit = startingBlock % kBitsPerWord;+ if (firstBit != 0) {+ bitMask = kAllBitsSetInWord >> firstBit;+ numBits = kBitsPerWord - firstBit;+ if (numBits > numBlocks) {+ numBits = numBlocks;+ bitMask &= ~(kAllBitsSetInWord >> (firstBit + numBits));+ }+ if ((*currentWord & SWAP_BE32 (bitMask)) != 0) {+ if (stop_on_first) {+ blockCount = 1;+ goto Exit;+ }+ blockCount += num_bits_set(*currentWord & SWAP_BE32 (bitMask));+ }+ numBlocks -= numBits;+ ++currentWord;+ --wordsLeft;+ }++ /*+ * Test whole words (32 blocks) at a time.+ */+ while (numBlocks >= kBitsPerWord) {+ if (wordsLeft == 0) {+ /* Read in the next bitmap block. */+ startingBlock += bitsPerBlock;++ buffer = NULL;+ error = ReleaseBitmapBlock(hfsmp, blockRef, false);+ if (error) goto Exit;++ error = ReadBitmapBlock(hfsmp, startingBlock, &buffer, &blockRef,+ HFS_ALLOC_IGNORE_TENTATIVE);+ if (error) goto Exit;++ /* Readjust currentWord and wordsLeft. */+ currentWord = buffer;+ wordsLeft = wordsPerBlock;+ }+ if (*currentWord != 0) {+ if (stop_on_first) {+ blockCount = 1;+ goto Exit;+ }+ blockCount += num_bits_set(*currentWord);+ }+ numBlocks -= kBitsPerWord;+ ++currentWord;+ --wordsLeft;+ }++ /*+ * Test any remaining blocks.+ */+ if (numBlocks != 0) {+ bitMask = ~(kAllBitsSetInWord >> numBlocks);+ if (wordsLeft == 0) {+ /* Read in the next bitmap block */+ startingBlock += bitsPerBlock;++ buffer = NULL;+ error = ReleaseBitmapBlock(hfsmp, blockRef, false);+ if (error) goto Exit;++ error = ReadBitmapBlock(hfsmp, startingBlock, &buffer, &blockRef,+ HFS_ALLOC_IGNORE_TENTATIVE);+ if (error) goto Exit;++ currentWord = buffer;+ }+ if ((*currentWord & SWAP_BE32 (bitMask)) != 0) {+ if (stop_on_first) {+ blockCount = 1;+ goto Exit;+ }+ blockCount += num_bits_set(*currentWord & SWAP_BE32 (bitMask));+ }+ }+Exit:+ if (buffer) {+ (void)ReleaseBitmapBlock(hfsmp, blockRef, false);+ }+ if (allocCount) {+ *allocCount = blockCount;+ }++JustReturn:+ if (hfs_kdebug_allocation & HFSDBG_BITMAP_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_IS_ALLOCATED | DBG_FUNC_END, error, 0, blockCount, 0, 0);++ return (error);+}++/*+ * Count total number of blocks that are allocated in the given+ * range from the bitmap. This is used to preflight total blocks+ * that need to be relocated during volume resize.+ *+ * The journal or allocation file lock must be held.+ *+ * Returns:+ * 0 on success, non-zero on failure.+ * On failure, allocCount is zero.+ */+ int+hfs_count_allocated(struct hfsmount *hfsmp, u_int32_t startBlock,+ u_int32_t numBlocks, u_int32_t *allocCount)+{+ return hfs_isallocated_internal(hfsmp, startBlock, numBlocks, false, allocCount);+}++/*+ * Test to see if any blocks in a range are allocated.+ *+ * Note: On error, this function returns 1, which means that+ * one or more blocks in the range are allocated. This function+ * is primarily used for volume resize and we do not want+ * to report to the caller that the blocks are free when we+ * were not able to deterministically find it out. So on error,+ * we always report that the blocks are allocated.+ *+ * The journal or allocation file lock must be held.+ *+ * Returns+ * 0 if all blocks in the range are free.+ * 1 if blocks in the range are allocated, or there was an error.+ */+ int+hfs_isallocated(struct hfsmount *hfsmp, u_int32_t startingBlock, u_int32_t numBlocks)+{+ int error;+ u_int32_t allocCount;++ error = hfs_isallocated_internal(hfsmp, startingBlock, numBlocks, true, &allocCount);+ if (error) {+ /* On error, we always say that the blocks are allocated+ * so that volume resize does not return false success.+ */+ return 1;+ } else {+ /* The function was deterministically able to find out+ * if there was any block allocated or not. In that case,+ * the value in allocCount is good enough to be returned+ * back to the caller.+ */+ return allocCount;+ }+}++/*+ * CONFIG_HFS_RBTREE+ * Check to see if the red-black tree is live. Allocation file lock must be held+ * shared or exclusive to call this function. Note that we may call this even if+ * HFS is built without activating the red-black tree code.+ */+int+hfs_isrbtree_active(struct hfsmount *hfsmp){++#pragma unused (hfsmp)++ /* Just return 0 for now */+ return 0;+}++++/* Summary Table Functions */+/*+ * hfs_check_summary:+ *+ * This function should be used to query the summary table to see if we can+ * bypass a bitmap block or not when we're trying to find a free allocation block.+ *+ *+ * Inputs:+ * allocblock - allocation block number. Will be used to infer the correct summary bit.+ * hfsmp -- filesystem in question.+ *+ * Output Arg:+ * *freeblocks - set to 1 if we believe at least one free blocks in this vcbVBMIOSize+ * page of bitmap file.+ *+ *+ * Returns:+ * 0 on success+ * EINVAL on error+ *+ */++static int hfs_check_summary (struct hfsmount *hfsmp, uint32_t allocblock, uint32_t *freeblocks) {++ int err = EINVAL;+ if (hfsmp->vcbVBMIOSize) {+ if (hfsmp->hfs_flags & HFS_SUMMARY_TABLE) {+ uint32_t index;+ if (hfs_get_summary_index (hfsmp, allocblock, &index)) {+ *freeblocks = 0;+ return EINVAL;+ }++ /* Ok, now that we have the bit index into the array, what byte is it in ? */+ uint32_t byteindex = index / kBitsPerByte;+ uint8_t current_byte = hfsmp->hfs_summary_table[byteindex];+ uint8_t bit_in_byte = index % kBitsPerByte;++ if (current_byte & (1 << bit_in_byte)) {+ /*+ * We do not believe there is anything free in the+ * entire vcbVBMIOSize'd block.+ */+ *freeblocks = 0;+ }+ else {+ /* Looks like there might be a free block here... */+ *freeblocks = 1;+ }+ }+ err = 0;+ }++ return err;+}+++#if 0+/*+ * hfs_get_next_summary+ *+ * From a given allocation block, jump to the allocation block at the start of the+ * next vcbVBMIOSize boundary. This is useful when trying to quickly skip over+ * large swaths of bitmap once we have determined that the bitmap is relatively full.+ *+ * Inputs: hfsmount, starting allocation block number+ * Output Arg: *newblock will contain the allocation block number to start+ * querying.+ *+ * Returns:+ * 0 on success+ * EINVAL if the block argument is too large to be used, or the summary table not live.+ * EFBIG if there are no more summary bits to be queried+ */+static int+hfs_get_next_summary (struct hfsmount *hfsmp, uint32_t block, uint32_t *newblock) {++ u_int32_t bits_per_iosize = hfsmp->vcbVBMIOSize * kBitsPerByte;+ u_int32_t start_offset;+ u_int32_t next_offset;+ int err = EINVAL;++ if (hfsmp->hfs_flags & HFS_SUMMARY_TABLE) {+ if ((err = hfs_get_summary_index(hfsmp, block, &start_offset))) {+ return err;+ }++ next_offset = start_offset++;++ if ((start_offset >= hfsmp->hfs_summary_size) || (next_offset >= hfsmp->hfs_summary_size)) {+ /* Can't jump to the next summary bit. */+ return EINVAL;+ }++ /* Otherwise, compute and return */+ *newblock = next_offset * bits_per_iosize;+ if (*newblock >= hfsmp->totalBlocks) {+ return EINVAL;+ }+ err = 0;+ }++ return err;+}++#endif++/*+ * hfs_release_summary+ *+ * Given an extent that is about to be de-allocated on-disk, determine the number+ * of summary bitmap bits that need to be marked as 'potentially available'.+ * Then go ahead and mark them as free.+ *+ * Inputs:+ * hfsmp - hfs mount+ * block - starting allocation block.+ * length - length of the extent.+ *+ * Returns:+ * EINVAL upon any errors.+ */+static int hfs_release_summary(struct hfsmount *hfsmp, uint32_t start_blk, uint32_t length) {+ int err = EINVAL;+ uint32_t end_blk = (start_blk + length) - 1;++ if (hfsmp->hfs_flags & HFS_SUMMARY_TABLE) {+ /* Figure out what the starting / ending block's summary bits are */+ uint32_t start_bit;+ uint32_t end_bit;+ uint32_t current_bit;++ err = hfs_get_summary_index (hfsmp, start_blk, &start_bit);+ if (err) {+ goto release_err;+ }+ err = hfs_get_summary_index (hfsmp, end_blk, &end_bit);+ if (err) {+ goto release_err;+ }++ if (ALLOC_DEBUG) {+ if (start_bit > end_bit) {+ panic ("HFS: start > end!, %d %d ", start_bit, end_bit);+ }+ }+ current_bit = start_bit;+ while (current_bit <= end_bit) {+ err = hfs_set_summary (hfsmp, current_bit, 0);+ current_bit++;+ }+ }++release_err:+ return err;+}++/*+ * hfs_find_summary_free+ *+ * Given a allocation block as input, returns an allocation block number as output as a+ * suggestion for where to start scanning the bitmap in order to find free blocks. It will+ * determine the vcbVBMIOsize of the input allocation block, convert that into a summary+ * bit, then keep iterating over the summary bits in order to find the first free one.+ *+ * Inputs:+ * hfsmp - hfs mount+ * block - starting allocation block+ * newblock - output block as suggestion+ *+ * Returns:+ * 0 on success+ * ENOSPC if we could not find a free block+ */++int hfs_find_summary_free (struct hfsmount *hfsmp, uint32_t block, uint32_t *newblock) {++ int err = ENOSPC;+ uint32_t bit_index = 0;+ uint32_t maybe_has_blocks = 0;++ if (hfsmp->hfs_flags & HFS_SUMMARY_TABLE) {+ uint32_t byte_index;+ uint8_t curbyte;+ uint8_t bit_in_byte;+ uint32_t summary_cap;++ /*+ * We generate a cap for the summary search because the summary table+ * always represents a full summary of the bitmap FILE, which may+ * be way more bits than are necessary for the actual filesystem+ * whose allocations are mapped by the bitmap.+ *+ * Compute how much of hfs_summary_size is useable for the given number+ * of allocation blocks eligible on this FS.+ */+ err = hfs_get_summary_index (hfsmp, hfsmp->allocLimit - 1, &summary_cap);+ if (err) {+ goto summary_exit;+ }++ /* Check the starting block first */+ err = hfs_check_summary (hfsmp, block, &maybe_has_blocks);+ if (err) {+ goto summary_exit;+ }++ if (maybe_has_blocks) {+ /*+ * It looks like the initial start block could have something.+ * Short-circuit and just use that.+ */+ *newblock = block;+ goto summary_exit;+ }++ /*+ * OK, now we know that the first block was useless.+ * Get the starting summary bit, and find it in the array+ */+ maybe_has_blocks = 0;+ err = hfs_get_summary_index (hfsmp, block, &bit_index);+ if (err) {+ goto summary_exit;+ }++ /* Iterate until we find something. */+ while (bit_index <= summary_cap) {+ byte_index = bit_index / kBitsPerByte;+ curbyte = hfsmp->hfs_summary_table[byte_index];+ bit_in_byte = bit_index % kBitsPerByte;++ if (curbyte & (1 << bit_in_byte)) {+ /* nothing here. increment and move on */+ bit_index++;+ }+ else {+ /*+ * found something! convert bit_index back into+ * an allocation block for use. 'newblock' will now+ * contain the proper allocation block # based on the bit+ * index.+ */+ err = hfs_get_summary_allocblock (hfsmp, bit_index, newblock);+ if (err) {+ goto summary_exit;+ }+ maybe_has_blocks = 1;+ break;+ }+ }++ /* If our loop didn't find anything, set err to ENOSPC */+ if (maybe_has_blocks == 0) {+ err = ENOSPC;+ }+ }++ /* If the summary table is not active for this mount, we'll just return ENOSPC */+summary_exit:+ if (maybe_has_blocks) {+ err = 0;+ }++ return err;+}++/*+ * hfs_get_summary_allocblock+ *+ * Convert a summary bit into an allocation block number to use to start searching for free blocks.+ *+ * Inputs:+ * hfsmp - hfs mount+ * summarybit - summmary bit index+ * *alloc - allocation block number in the bitmap file.+ *+ * Output:+ * 0 on success+ * EINVAL on failure+ */+int hfs_get_summary_allocblock (struct hfsmount *hfsmp, uint32_t+ summarybit, uint32_t *alloc) {+ uint32_t bits_per_iosize = hfsmp->vcbVBMIOSize * kBitsPerByte;+ uint32_t allocblk;++ allocblk = summarybit * bits_per_iosize;++ if (allocblk >= hfsmp->totalBlocks) {+ return EINVAL;+ }+ else {+ *alloc = allocblk;+ }++ return 0;+}+++/*+ * hfs_set_summary:+ *+ * This function should be used to manipulate the summary table+ *+ * The argument 'inuse' will set the value of the bit in question to one or zero+ * depending on its value.+ *+ * Inputs:+ * hfsmp - hfs mount+ * summarybit - the bit index into the summary table to set/unset.+ * inuse - the value to assign to the bit.+ *+ * Returns:+ * 0 on success+ * EINVAL on error+ *+ */++static int hfs_set_summary (struct hfsmount *hfsmp, uint32_t summarybit, uint32_t inuse) {++ int err = EINVAL;+ if (hfsmp->vcbVBMIOSize) {+ if (hfsmp->hfs_flags & HFS_SUMMARY_TABLE) {++ if (ALLOC_DEBUG) {+ if (hfsmp->hfs_summary_table == NULL) {+ panic ("hfs_set_summary: no table for %p ", hfsmp);+ }+ }++ /* Ok, now that we have the bit index into the array, what byte is it in ? */+ uint32_t byte_index = summarybit / kBitsPerByte;+ uint8_t current_byte = hfsmp->hfs_summary_table[byte_index];+ uint8_t bit_in_byte = summarybit % kBitsPerByte;++ if (inuse) {+ current_byte = (current_byte | (1 << bit_in_byte));+ }+ else {+ current_byte = (current_byte & ~(1 << bit_in_byte));+ }++ hfsmp->hfs_summary_table[byte_index] = current_byte;+ }+ err = 0;+ }++ return err;+}+++/*+ * hfs_get_summary_index:+ *+ * This is a helper function which determines what summary bit represents the vcbVBMIOSize worth+ * of IO against the bitmap file.+ *+ * Returns:+ * 0 on success+ * EINVAL on failure+ */+static int hfs_get_summary_index (struct hfsmount *hfsmp, uint32_t block, uint32_t* index) {+ uint32_t summary_bit;+ uint32_t bits_per_iosize;+ int err = EINVAL;++ if (hfsmp->hfs_flags & HFS_SUMMARY_TABLE) {+ /* Is the input block bigger than the total number of blocks? */+ if (block >= hfsmp->totalBlocks) {+ return EINVAL;+ }++ /* Is there even a vbmIOSize set? */+ if (hfsmp->vcbVBMIOSize == 0) {+ return EINVAL;+ }++ bits_per_iosize = hfsmp->vcbVBMIOSize * kBitsPerByte;++ summary_bit = block / bits_per_iosize;++ *index = summary_bit;+ err = 0;+ }++ return err;+}++/*+ * hfs_init_summary+ *+ * From a given mount structure, compute how big the summary table should be for the given+ * filesystem, then allocate and bzero the memory.+ *+ * Returns:+ * 0 on success+ * EINVAL on failure+ */+int+hfs_init_summary (struct hfsmount *hfsmp) {++ uint32_t summary_size;+ uint32_t summary_size_bytes;+ uint8_t *summary_table;++ if (hfsmp->hfs_allocation_cp == NULL) {+ if (ALLOC_DEBUG) {+ printf("hfs: summary table cannot progress without a bitmap cnode! \n");+ }+ return EINVAL;+ }+ /*+ * The practical maximum size of the summary table is 16KB:+ *+ * (512MB maximum bitmap size / (4k -- min alloc block size)) / 8 bits/byte.+ *+ * HFS+ will allow filesystems with allocation block sizes smaller than 4k, but+ * the end result is that we'll start to issue I/O in 2k or 1k sized chunks, which makes+ * supporting this much worse. The math would instead look like this:+ * (512MB / 2k) / 8 == 32k.+ *+ * So, we will disallow the summary table if the allocation block size is < 4k.+ */++ if (hfsmp->blockSize < HFS_MIN_SUMMARY_BLOCKSIZE) {+ printf("hfs: summary table not allowed on FS with block size of %d\n", hfsmp->blockSize);+ return EINVAL;+ }++ summary_size = hfsmp->hfs_allocation_cp->c_blocks;++ if (ALLOC_DEBUG) {+ printf("HFS Summary Table Initialization: Bitmap %u blocks\n",+ hfsmp->hfs_allocation_cp->c_blocks);+ }++ /*+ * If the bitmap IO size is not the same as the allocation block size then+ * then re-compute the number of summary bits necessary. Note that above, the+ * the default size is the number of allocation blocks in the bitmap *FILE*+ * (not the number of bits in the bitmap itself). If the allocation block size+ * is large enough though, we may need to increase this.+ */+ if (hfsmp->blockSize != hfsmp->vcbVBMIOSize) {+ uint64_t lrg_size = (uint64_t) hfsmp->hfs_allocation_cp->c_blocks * (uint64_t) hfsmp->blockSize;+ lrg_size = lrg_size / (uint64_t)hfsmp->vcbVBMIOSize;++ /* With a full bitmap and 64k-capped iosize chunks, this would be 64k */+ summary_size = (uint32_t) lrg_size;+ }++ /*+ * If the block size is the same as the IO Size, then the total number of blocks+ * is already equal to the number of IO units, which is our number of summary bits.+ */++ summary_size_bytes = summary_size / kBitsPerByte;+ /* Always add one byte, just in case we have a dangling number of bits */+ summary_size_bytes++;++ if (ALLOC_DEBUG) {+ printf("HFS Summary Table: vcbVBMIOSize %d summary bits %d \n", hfsmp->vcbVBMIOSize, summary_size);+ printf("HFS Summary Table Size (in bytes) %d \n", summary_size_bytes);+ }++ /* Store the field in the mount point */+ hfsmp->hfs_summary_size = summary_size;+ hfsmp->hfs_summary_bytes = summary_size_bytes;++ summary_table = hfs_malloc_zero_data(summary_size_bytes);++ /* enable the summary table */+ hfsmp->hfs_flags |= HFS_SUMMARY_TABLE;+ hfsmp->hfs_summary_table = summary_table;++ if (ALLOC_DEBUG) {+ if (hfsmp->hfs_summary_table == NULL) {+ panic ("HFS Summary Init: no table for %p\n", hfsmp);+ }+ }+ return 0;+}++/*+ * hfs_rebuild_summary+ *+ * This function should be used to allocate a new hunk of memory for use as a summary+ * table, then copy the existing data into it. We use it whenever the filesystem's size+ * changes. When a resize is in progress, you can still use the extant summary+ * table if it is active.+ *+ * Inputs:+ * hfsmp -- FS in question+ * newlength -- new length of the FS in allocation blocks.+ *+ * Outputs:+ * 0 on success, EINVAL on failure. If this function fails, the summary table+ * will be disabled for future use.+ *+ */+static int hfs_rebuild_summary (struct hfsmount *hfsmp) {++ uint32_t new_summary_size;++ new_summary_size = hfsmp->hfs_allocation_cp->c_blocks;+++ if (ALLOC_DEBUG) {+ printf("HFS Summary Table Re-init: bitmap %u blocks\n", new_summary_size);+ }++ /*+ * If the bitmap IO size is not the same as the allocation block size, then re-compute+ * the number of summary bits necessary. Note that above, the default size is the number+ * of allocation blocks in the bitmap *FILE* (not the number of bits that the bitmap manages).+ * If the allocation block size is large enough though, we may need to increase this, as+ * bitmap IO is capped at 64k per IO+ */+ if (hfsmp->blockSize != hfsmp->vcbVBMIOSize) {+ uint64_t lrg_size = (uint64_t) hfsmp->hfs_allocation_cp->c_blocks * (uint64_t) hfsmp->blockSize;+ lrg_size = lrg_size / (uint64_t)hfsmp->vcbVBMIOSize;++ /* With a full bitmap and 64k-capped iosize chunks, this would be 64k */+ new_summary_size = (uint32_t) lrg_size;+ }++ /*+ * Ok, we have the new summary bitmap theoretical max size. See if it's the same as+ * what we've got already...+ */+ if (new_summary_size != hfsmp->hfs_summary_size) {+ uint32_t summarybytes = new_summary_size / kBitsPerByte;+ uint32_t copysize;+ uint8_t *newtable;+ /* Add one byte for slop */+ summarybytes++;++ if (ALLOC_DEBUG) {+ printf("HFS Summary Table: vcbVBMIOSize %d summary bits %d \n", hfsmp->vcbVBMIOSize, new_summary_size);+ printf("HFS Summary Table Size (in bytes) %d \n", summarybytes);+ }++ newtable = hfs_malloc_zero_data(summarybytes);++ /*+ * The new table may be smaller than the old one. If this is true, then+ * we can't copy the full size of the existing summary table into the new+ * one.+ *+ * The converse is not an issue since we bzeroed the table above.+ */+ copysize = hfsmp->hfs_summary_bytes;+ if (summarybytes < hfsmp->hfs_summary_bytes) {+ copysize = summarybytes;+ }+ memcpy (newtable, hfsmp->hfs_summary_table, copysize);++ /* We're all good. Destroy the old copy and update ptrs */+ hfs_free_data(hfsmp->hfs_summary_table, hfsmp->hfs_summary_bytes);++ hfsmp->hfs_summary_table = newtable;+ hfsmp->hfs_summary_size = new_summary_size;+ hfsmp->hfs_summary_bytes = summarybytes;+ }++ return 0;+}+++#if ALLOC_DEBUG+/*+ * hfs_validate_summary+ *+ * Validation routine for the summary table. Debug-only function.+ *+ * Bitmap lock must be held.+ *+ */+void hfs_validate_summary (struct hfsmount *hfsmp) {+ uint32_t i;+ int err;++ /*+ * Iterate over all of the bits in the summary table, and verify if+ * there really are free blocks in the pages that we believe may+ * may contain free blocks.+ */++ if (hfsmp->hfs_summary_table == NULL) {+ panic ("HFS Summary: No HFS summary table!");+ }++ /* 131072 bits == 16384 bytes. This is the theoretical max size of the summary table. we add 1 byte for slop */+ if (hfsmp->hfs_summary_size == 0 || hfsmp->hfs_summary_size > 131080) {+ panic("HFS Summary: Size is bad! %d", hfsmp->hfs_summary_size);+ }++ if (hfsmp->vcbVBMIOSize == 0) {+ panic("HFS Summary: no VCB VBM IO Size !");+ }++ printf("hfs: summary validation beginning on %s\n", hfsmp->vcbVN);+ printf("hfs: summary validation %d summary bits, %d summary blocks\n", hfsmp->hfs_summary_size, hfsmp->totalBlocks);+++ /* iterate through all possible summary bits */+ for (i = 0; i < hfsmp->hfs_summary_size ; i++) {++ uint32_t bits_per_iosize = hfsmp->vcbVBMIOSize * kBitsPerByte;+ uint32_t byte_offset = hfsmp->vcbVBMIOSize * i;++ /* Compute the corresponding allocation block for the summary bit. */+ uint32_t alloc_block = i * bits_per_iosize;++ /*+ * We use a uint32_t pointer here because it will speed up+ * access to the real bitmap data on disk.+ */+ uint32_t *block_data;+ struct buf *bp;+ int counter;+ int counter_max;+ int saw_free_bits = 0;++ /* Get the block */+ if ((err = ReadBitmapRange (hfsmp, byte_offset, hfsmp->vcbVBMIOSize, &block_data, &bp))) {+ panic ("HFS Summary: error (%d) in ReadBitmapRange!", err);+ }++ /* Query the status of the bit and then make sure we match */+ uint32_t maybe_has_free_blocks;+ err = hfs_check_summary (hfsmp, alloc_block, &maybe_has_free_blocks);+ if (err) {+ panic ("HFS Summary: hfs_check_summary returned error (%d) ", err);+ }+ counter_max = hfsmp->vcbVBMIOSize / kBytesPerWord;++ for (counter = 0; counter < counter_max; counter++) {+ uint32_t word = block_data[counter];++ /* We assume that we'll not find any free bits here. */+ if (word != kAllBitsSetInWord) {+ if (maybe_has_free_blocks) {+ /* All done */+ saw_free_bits = 1;+ break;+ }+ else {+ panic ("HFS Summary: hfs_check_summary saw free bits!");+ }+ }+ }++ if (maybe_has_free_blocks && (saw_free_bits == 0)) {+ panic ("HFS Summary: did not see free bits !");+ }++ /* Release the block. */+ if ((err = ReleaseScanBitmapRange (bp))) {+ panic ("HFS Summary: Error (%d) in ReleaseScanBitmapRange", err);+ }+ }++ printf("hfs: summary validation completed successfully on %s\n", hfsmp->vcbVN);++ return;+}+#endif++/*+ * hfs_alloc_scan_range:+ *+ * This function should be used to scan large ranges of the allocation bitmap+ * at one time. It makes two key assumptions:+ *+ * 1) Bitmap lock is held during the duration of the call (exclusive)+ * 2) There are no pages in the buffer cache for any of the bitmap+ * blocks that we may encounter. It *MUST* be completely empty.+ *+ * The expected use case is when we are scanning the bitmap in full while we are+ * still mounting the filesystem in order to issue TRIMs or build up the summary+ * table for the mount point. It should be done after any potential journal replays+ * are completed and their I/Os fully issued.+ *+ * The key reason for assumption (2) above is that this function will try to issue+ * I/O against the bitmap file in chunks as large a possible -- essentially as+ * much as the buffer layer will handle (1MB). Because the size of these I/Os+ * is larger than what would be expected during normal runtime we must invalidate+ * the buffers as soon as we are done with them so that they do not persist in+ * the buffer cache for other threads to find, as they'll typically be doing+ * allocation-block size I/Os instead.+ *+ * Input Args:+ * hfsmp - hfs mount data structure+ * startbit - allocation block # to start our scan. It must be aligned+ * on a vcbVBMIOsize boundary.+ * list - journal trim list data structure for issuing TRIMs+ *+ * Output Args:+ * bitToScan - Return the next bit to scan if this function is called again.+ * Caller will supply this into the next invocation+ * of this call as 'startbit'.+ */++static int hfs_alloc_scan_range(struct hfsmount *hfsmp, u_int32_t startbit,+ u_int32_t *bitToScan, struct jnl_trim_list *list) {++ int error;+ int readwrite = 1;+ u_int32_t curAllocBlock;+ struct buf *blockRef = NULL;+ u_int32_t *buffer = NULL;+ u_int32_t free_offset = 0; //tracks the start of the current free range+ u_int32_t size = 0; // tracks the length of the current free range.+ u_int32_t iosize = 0; //how much io we should generate against the bitmap+ u_int32_t byte_off; // byte offset into the bitmap file.+ u_int32_t completed_size; // how much io was actually completed+ u_int32_t last_bitmap_block;+ u_int32_t current_word;+ u_int32_t word_index = 0;++ /* summary table building */+ uint32_t summary_bit = 0;+ uint32_t saw_free_blocks = 0;+ uint32_t last_marked = 0;++ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ readwrite = 0;+ }++ /*+ * Compute how much I/O we should generate here.+ * hfs_scan_range_size will validate that the start bit+ * converted into a byte offset into the bitmap file,+ * is aligned on a VBMIOSize boundary.+ */+ error = hfs_scan_range_size (hfsmp, startbit, &iosize);+ if (error) {+ if (ALLOC_DEBUG) {+ panic ("hfs_alloc_scan_range: hfs_scan_range_size error %d\n", error);+ }+ return error;+ }++ if (iosize < hfsmp->vcbVBMIOSize) {+ if (ALLOC_DEBUG) {+ panic ("hfs_alloc_scan_range: iosize too small! (iosize %d)\n", iosize);+ }+ return EINVAL;+ }++ /* hfs_scan_range_size should have verified startbit. Convert it to bytes */+ byte_off = startbit / kBitsPerByte;++ /*+ * When the journal replays blocks, it does so by writing directly to the disk+ * device (bypassing any filesystem vnodes and such). When it finishes its I/Os+ * it also immediately re-reads and invalidates the range covered by the bp so+ * it does not leave anything lingering in the cache (for iosize reasons).+ *+ * As such, it is safe to do large I/Os here with ReadBitmapRange.+ *+ * NOTE: It is not recommended, but it is possible to call the function below+ * on sections of the bitmap that may be in core already as long as the pages are not+ * dirty. In that case, we'd notice that something starting at that+ * logical block of the bitmap exists in the metadata cache, and we'd check+ * if the iosize requested is the same as what was already allocated for it.+ * Odds are pretty good we're going to request something larger. In that case,+ * we just free the existing memory associated with the buf and reallocate a+ * larger range. This function should immediately invalidate it as soon as we're+ * done scanning, so this shouldn't cause any coherency issues.+ */++ error = ReadBitmapRange(hfsmp, byte_off, iosize, &buffer, &blockRef);+ if (error) {+ if (ALLOC_DEBUG) {+ panic ("hfs_alloc_scan_range: start %d iosize %d ReadBitmapRange error %d\n", startbit, iosize, error);+ }+ return error;+ }++ /*+ * At this point, we have a giant wired buffer that represents some portion of+ * the bitmap file that we want to analyze. We may not have gotten all 'iosize'+ * bytes though, so clip our ending bit to what we actually read in.+ */+ completed_size = buf_count(blockRef);+ last_bitmap_block = completed_size * kBitsPerByte;+ last_bitmap_block = last_bitmap_block + startbit;++ /* Cap the last block to the total number of blocks if required */+ if (last_bitmap_block > hfsmp->totalBlocks) {+ last_bitmap_block = hfsmp->totalBlocks;+ }++ /* curAllocBlock represents the logical block we're analyzing. */+ curAllocBlock = startbit;+ word_index = 0;+ size = 0;++ if (hfsmp->hfs_flags & HFS_SUMMARY_TABLE) {+ if (hfs_get_summary_index (hfsmp, startbit, &summary_bit)) {+ error = EINVAL;+ if (ALLOC_DEBUG) {+ panic ("hfs_alloc_scan_range: Could not acquire summary index for %u", startbit);+ }+ return error;+ }+ /*+ * summary_bit should now be set to the summary bit corresponding to+ * the allocation block of the first bit that we're supposed to scan+ */+ }+ saw_free_blocks = 0;++ while (curAllocBlock < last_bitmap_block) {+ u_int32_t bit;++ /* Update the summary table as needed */+ if (hfsmp->hfs_flags & HFS_SUMMARY_TABLE) {+ if (ALLOC_DEBUG) {+ if (hfsmp->hfs_summary_table == NULL) {+ panic ("hfs_alloc_scan_range: no summary table!");+ }+ }++ uint32_t temp_summary;+ error = hfs_get_summary_index (hfsmp, curAllocBlock, &temp_summary);+ if (error) {+ if (ALLOC_DEBUG) {+ panic ("hfs_alloc_scan_range: could not get summary index for %u", curAllocBlock);+ }+ return EINVAL;+ }++ if (ALLOC_DEBUG) {+ if (temp_summary < summary_bit) {+ panic ("hfs_alloc_scan_range: backwards summary bit?\n");+ }+ }++ /*+ * If temp_summary is greater than summary_bit, then this+ * means that the next allocation block crosses a vcbVBMIOSize boundary+ * and we should treat this range of on-disk data as part of a new summary+ * bit.+ */+ if (temp_summary > summary_bit) {+ if (saw_free_blocks == 0) {+ /* Mark the bit as totally consumed in the summary table */+ hfs_set_summary (hfsmp, summary_bit, 1);+ }+ else {+ /* Mark the bit as potentially free in summary table */+ hfs_set_summary (hfsmp, summary_bit, 0);+ }+ last_marked = summary_bit;+ /*+ * Any time we set the summary table, update our counter which tracks+ * what the last bit that was fully marked in the summary table.+ *+ * Then reset our marker which says we haven't seen a free bit yet.+ */+ saw_free_blocks = 0;+ summary_bit = temp_summary;+ }+ } /* End summary table conditions */++ current_word = SWAP_BE32(buffer[word_index]);+ /* Iterate through the word 1 bit at a time... */+ for (bit = 0 ; bit < kBitsPerWord ; bit++, curAllocBlock++) {+ if (curAllocBlock >= last_bitmap_block) {+ break;+ }+ u_int32_t allocated = (current_word & (kHighBitInWordMask >> bit));++ if (allocated) {+ if (size != 0) {+ if (readwrite) {+ /* Insert the previously tracked range of free blocks to the trim list */+ hfs_track_unmap_blocks (hfsmp, free_offset, size, list);+ }+ add_free_extent_cache (hfsmp, free_offset, size);+ size = 0;+ free_offset = 0;+ }+ }+ else {+ /* Not allocated */+ size++;+ if (free_offset == 0) {+ /* Start a new run of free spcae at curAllocBlock */+ free_offset = curAllocBlock;+ }+ if (saw_free_blocks == 0) {+ saw_free_blocks = 1;+ }+ }+ } /* end for loop iterating through the word */++ if (curAllocBlock < last_bitmap_block) {+ word_index++;+ }++ } /* End while loop (iterates through last_bitmap_block) */+++ /*+ * We've (potentially) completed our pass through this region of bitmap,+ * but one thing we may not have done is updated that last summary bit for+ * the last page we scanned, because we would have never transitioned across+ * a vcbVBMIOSize boundary again. Check for that and update the last bit+ * as needed.+ *+ * Note that 'last_bitmap_block' is *not* inclusive WRT the very last bit in the bitmap+ * for the region of bitmap on-disk that we were scanning. (it is one greater).+ */+ if ((curAllocBlock >= last_bitmap_block) &&+ (hfsmp->hfs_flags & HFS_SUMMARY_TABLE)) {+ uint32_t temp_summary;+ /* temp_block should be INSIDE the region we just scanned, so subtract 1 */+ uint32_t temp_block = last_bitmap_block - 1;+ error = hfs_get_summary_index (hfsmp, temp_block, &temp_summary);+ if (error) {+ if (ALLOC_DEBUG) {+ panic ("hfs_alloc_scan_range: end bit curAllocBlock %u, last_bitmap_block %u", curAllocBlock, last_bitmap_block);+ }+ return EINVAL;+ }++ /* Did we already update this in the table? */+ if (temp_summary > last_marked) {+ if (saw_free_blocks == 0) {+ hfs_set_summary (hfsmp, temp_summary, 1);+ }+ else {+ hfs_set_summary (hfsmp, temp_summary, 0);+ }+ }+ }++ /*+ * We may have been tracking a range of free blocks that hasn't been inserted yet.+ * Keep the logic for the TRIM and free extent separate from that of the summary+ * table management even though they are closely linked.+ */+ if (size != 0) {+ if (readwrite) {+ hfs_track_unmap_blocks (hfsmp, free_offset, size, list);+ }+ add_free_extent_cache (hfsmp, free_offset, size);+ }++ /*+ * curAllocBlock represents the next block we need to scan when we return+ * to this function.+ */+ *bitToScan = curAllocBlock;+ ReleaseScanBitmapRange(blockRef);++ return 0;++}++++/*+ * Compute the maximum I/O size to generate against the bitmap file+ * Will attempt to generate at LEAST VBMIOsize I/Os for interior ranges of the bitmap.+ *+ * Inputs:+ * hfsmp -- hfsmount to look at+ * bitmap_off -- bit offset into the bitmap file+ *+ * Outputs:+ * iosize -- iosize to generate.+ *+ * Returns:+ * 0 on success; EINVAL otherwise+ */+static int hfs_scan_range_size (struct hfsmount *hfsmp, uint32_t bitmap_st, uint32_t *iosize) {++ uint32_t bitmap_len;+ uint64_t bitmap64;+ uint32_t remaining_bitmap;+ uint32_t target_iosize;+ uint32_t bitmap_off;++ /* Is this bit index not word aligned? If so, immediately fail. */+ if (bitmap_st % kBitsPerWord) {+ if (ALLOC_DEBUG) {+ panic ("hfs_scan_range_size unaligned start bit! bitmap_st %d \n", bitmap_st);+ }+ return EINVAL;+ }++ /* bitmap_off is in bytes, not allocation blocks/bits */+ bitmap_off = bitmap_st / kBitsPerByte;++ if ((hfsmp->totalBlocks <= bitmap_st) || (bitmap_off > (512 * 1024 * 1024))) {+ if (ALLOC_DEBUG) {+ panic ("hfs_scan_range_size: invalid start! bitmap_st %d, bitmap_off %d\n", bitmap_st, bitmap_off);+ }+ return EINVAL;+ }++ /*+ * Also invalid if it's not at least aligned to HFS bitmap logical+ * block boundaries. We don't have to emit an iosize that's an+ * exact multiple of the VBMIOSize, but it must start on such+ * a boundary.+ *+ * The vcbVBMIOSize may be SMALLER than the allocation block size+ * on a FS with giant allocation blocks, but it will never be+ * greater than it, so it should be safe to start I/O+ * aligned on a VBMIOsize boundary.+ */+ if (bitmap_off & (hfsmp->vcbVBMIOSize - 1)) {+ if (ALLOC_DEBUG) {+ panic ("hfs_scan_range_size: unaligned start! bitmap_off %d\n", bitmap_off);+ }+ return EINVAL;+ }++ /*+ * Round the total useable bitmap to the nearest allocation block+ * boundary (in bits). Then convert that value to bytes. Normally,+ * the bitmap file will be less than its maximum (512MB), and so we+ * want to ensure that the end is rounded to an even allocation block+ * boundary, so that I/Os are in neat block-aligned units.+ * We won't scan past the last actual allocation block in the bitmap.+ *+ * Unless we're completing the bitmap scan (or bitmap < 1MB), we+ * have to complete the I/O on VBMIOSize boundaries, but we can+ * only read up until the end of the bitmap file.+ *+ * NOTE: We upcast to a 64-bit type temporarily to avoid integer+ * overflow with the roundup on large blocksize HFS.+ */+ bitmap64 = roundup((uint64_t)hfsmp->totalBlocks, (uint64_t)hfsmp->blockSize * 8);+ bitmap64 = bitmap64 / 8; // convert to bytes.++ if (bitmap64 >= (512 * 1024 * 1024)){+ /*+ * cap it -- the bitmap file should never have more than 512Mb+ * of content, which represents 2^32-1 bits+ */+ bitmap64 = (512 * 1024 * 1024);+ }+ bitmap_len = (uint32_t)bitmap64;+ remaining_bitmap = bitmap_len - bitmap_off;++ /*+ * io size is the MIN of the maximum I/O we can generate or the+ * remaining amount of bitmap. Note that due to rounding, we expect+ * that the bitmap will likely be rounded to at least the next 4K.+ */+ target_iosize = MIN((MAXBSIZE), remaining_bitmap);+ *iosize = target_iosize;++ return 0;+}+++++/*+ * This function is basically the same as hfs_isallocated, except it's designed for+ * use with the red-black tree validation code. It assumes we're only checking whether+ * one bit is active, and that we're going to pass in the buf to use, since GenerateTree+ * calls ReadBitmapBlock and will have that buf locked down for the duration of its operation.+ *+ * This should not be called in general purpose scanning code.+ */+int hfs_isallocated_scan(struct hfsmount *hfsmp, u_int32_t startingBlock, u_int32_t *bp_buf) {++ u_int32_t *currentWord; // Pointer to current word within bitmap block+ u_int32_t bitMask; // Word with given bits already set (ready to test)+ u_int32_t firstBit; // Bit index within word of first bit to allocate+ u_int32_t numBits; // Number of bits in word to allocate+ u_int32_t bitsPerBlock;+ uintptr_t blockRef = 0;+ u_int32_t numBlocks = 1;+ u_int32_t *buffer = NULL;++ int inuse = 0;+ int error;+++ if (bp_buf) {+ /* just use passed-in buffer if avail. */+ buffer = bp_buf;+ }+ else {+ /*+ * Pre-read the bitmap block containing the first word of allocation+ */+ error = ReadBitmapBlock(hfsmp, startingBlock, &buffer, &blockRef,+ HFS_ALLOC_IGNORE_TENTATIVE);+ if (error)+ return (error);+ }++ /*+ * Initialize currentWord, and wordsLeft.+ */+ u_int32_t wordIndexInBlock;++ bitsPerBlock = hfsmp->vcbVBMIOSize * kBitsPerByte;++ wordIndexInBlock = (startingBlock & (bitsPerBlock-1)) / kBitsPerWord;+ currentWord = buffer + wordIndexInBlock;++ /*+ * First test any non word aligned bits.+ */+ firstBit = startingBlock % kBitsPerWord;+ bitMask = kAllBitsSetInWord >> firstBit;+ numBits = kBitsPerWord - firstBit;+ if (numBits > numBlocks) {+ numBits = numBlocks;+ bitMask &= ~(kAllBitsSetInWord >> (firstBit + numBits));+ }+ if ((*currentWord & SWAP_BE32 (bitMask)) != 0) {+ inuse = 1;+ goto Exit;+ }+ ++currentWord;++Exit:+ if(bp_buf == NULL) {+ if (buffer) {+ (void)ReleaseBitmapBlock(hfsmp, blockRef, false);+ }+ }+ return (inuse);++++}++/*+ * This function resets all of the data structures relevant to the+ * free extent cache stored in the hfsmount struct.+ *+ * If we are using the red-black tree code then we need to account for the fact that+ * we may encounter situations where we need to jettison the tree. If that is the+ * case, then we fail-over to the bitmap scanning logic, but we need to ensure that+ * the free ext cache is zeroed before we start using it.+ *+ * We also reset and disable the cache when allocLimit is updated... which+ * is when a volume is being resized (via hfs_truncatefs() or hfs_extendfs()).+ * It is independent of the type of allocator being used currently.+ */+void ResetVCBFreeExtCache(struct hfsmount *hfsmp)+{+ int bytes;+ void *freeExt;++ if (hfs_kdebug_allocation & HFSDBG_EXT_CACHE_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_RESET_EXTENT_CACHE | DBG_FUNC_START, 0, 0, 0, 0, 0);++ lck_spin_lock(&hfsmp->vcbFreeExtLock);++ /* reset Free Extent Count */+ hfsmp->vcbFreeExtCnt = 0;++ /* reset the actual array */+ bytes = kMaxFreeExtents * sizeof(HFSPlusExtentDescriptor);+ freeExt = (void*)(hfsmp->vcbFreeExt);++ bzero (freeExt, bytes);++ lck_spin_unlock(&hfsmp->vcbFreeExtLock);++ if (hfs_kdebug_allocation & HFSDBG_EXT_CACHE_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_RESET_EXTENT_CACHE | DBG_FUNC_END, 0, 0, 0, 0, 0);++ return;+}++/*+ * This function is used to inform the allocator if we have to effectively shrink+ * or grow the total number of allocation blocks via hfs_truncatefs or hfs_extendfs.+ *+ * The bitmap lock must be held when calling this function. This function also modifies the+ * allocLimit field in the hfs mount point structure in the general case.+ *+ * In the shrinking case, we'll have to remove all free extents from the red-black+ * tree past the specified offset new_end_block. In the growth case, we'll have to force+ * a re-scan of the new allocation blocks from our current allocLimit to the new end block.+ *+ * new_end_block represents the total number of blocks available for allocation in the resized+ * filesystem. Block #new_end_block should not be allocatable in the resized filesystem since it+ * will be out of the (0, n-1) range that are indexable in the bitmap.+ *+ * Returns 0 on success+ * errno on failure+ */+u_int32_t UpdateAllocLimit (struct hfsmount *hfsmp, u_int32_t new_end_block) {++ /*+ * Update allocLimit to the argument specified+ */+ hfsmp->allocLimit = new_end_block;++ /* Invalidate the free extent cache completely so that+ * it does not have any extents beyond end of current+ * volume.+ */+ ResetVCBFreeExtCache(hfsmp);++ /* Force a rebuild of the summary table. */+ (void) hfs_rebuild_summary (hfsmp);++ // Delete any tentative ranges that are in the area we're shrinking+ struct rl_entry *range, *next_range;+ TAILQ_FOREACH_SAFE(range, &hfsmp->hfs_reserved_ranges[HFS_TENTATIVE_BLOCKS],+ rl_link, next_range) {+ if (rl_overlap(range, new_end_block, RL_INFINITY) != RL_NOOVERLAP)+ hfs_release_reserved(hfsmp, range, HFS_TENTATIVE_BLOCKS);+ }++ return 0;+}++/*+ * Remove an extent from the list of free extents.+ *+ * This is a low-level routine. It does not handle overlaps or splitting;+ * that is the responsibility of the caller. The input extent must exactly+ * match an extent already in the list; it will be removed, and any following+ * extents in the list will be shifted up.+ *+ * Inputs:+ * startBlock - Start of extent to remove+ * blockCount - Number of blocks in extent to remove+ *+ * Result:+ * The index of the extent that was removed.+ */+static void remove_free_extent_list(struct hfsmount *hfsmp, int index)+{+ if (index < 0 || (uint32_t)index >= hfsmp->vcbFreeExtCnt) {+ if (ALLOC_DEBUG)+ panic("hfs: remove_free_extent_list: %p: index (%d) out of range (0, %u)", hfsmp, index, hfsmp->vcbFreeExtCnt);+ else+ printf("hfs: remove_free_extent_list: %p: index (%d) out of range (0, %u)", hfsmp, index, hfsmp->vcbFreeExtCnt);+ return;+ }+ int shift_count = hfsmp->vcbFreeExtCnt - index - 1;+ if (shift_count > 0) {+ memmove(&hfsmp->vcbFreeExt[index], &hfsmp->vcbFreeExt[index+1], shift_count * sizeof(hfsmp->vcbFreeExt[0]));+ }+ hfsmp->vcbFreeExtCnt--;+}+++/*+ * Add an extent to the list of free extents.+ *+ * This is a low-level routine. It does not handle overlaps or coalescing;+ * that is the responsibility of the caller. This routine *does* make+ * sure that the extent it is adding is inserted in the correct location.+ * If the list is full, this routine will handle either removing the last+ * extent in the list to make room for the new extent, or ignoring the+ * new extent if it is "worse" than the last extent in the list.+ *+ * Inputs:+ * startBlock - Start of extent to add+ * blockCount - Number of blocks in extent to add+ *+ * Result:+ * The index where the extent that was inserted, or kMaxFreeExtents+ * if the extent was not inserted (the list was full, and the extent+ * being added was "worse" than everything in the list).+ */+static int add_free_extent_list(struct hfsmount *hfsmp, u_int32_t startBlock, u_int32_t blockCount)+{+ uint32_t i;++ /* ALLOC_DEBUG: Make sure no extents in the list overlap or are contiguous with the input extent. */+ if (ALLOC_DEBUG) {+ uint32_t endBlock = startBlock + blockCount;+ for (i = 0; i < hfsmp->vcbFreeExtCnt; ++i) {+ if (endBlock < hfsmp->vcbFreeExt[i].startBlock ||+ startBlock > (hfsmp->vcbFreeExt[i].startBlock + hfsmp->vcbFreeExt[i].blockCount)) {+ continue;+ }+ panic("hfs: add_free_extent_list: %p: extent(%u %u) overlaps existing extent (%u %u) at index %d",+ hfsmp, startBlock, blockCount, hfsmp->vcbFreeExt[i].startBlock, hfsmp->vcbFreeExt[i].blockCount, i);+ }+ }++ /* Figure out what index the new extent should be inserted at. */+ for (i = 0; i < hfsmp->vcbFreeExtCnt; ++i) {+ if (hfsmp->hfs_flags & HFS_HAS_SPARSE_DEVICE) {+ /* The list is sorted by increasing offset. */+ if (startBlock < hfsmp->vcbFreeExt[i].startBlock) {+ break;+ }+ } else {+ /* The list is sorted by decreasing size. */+ if (blockCount > hfsmp->vcbFreeExt[i].blockCount) {+ break;+ }+ }+ }++ /* When we get here, i is the index where the extent should be inserted. */+ if (i == kMaxFreeExtents) {+ /*+ * The new extent is worse than anything already in the list,+ * and the list is full, so just ignore the extent to be added.+ */+ return i;+ }++ /*+ * Grow the list (if possible) to make room for an insert.+ */+ if (hfsmp->vcbFreeExtCnt < kMaxFreeExtents)+ hfsmp->vcbFreeExtCnt++;++ /*+ * If we'll be keeping any extents after the insert position, then shift them.+ */+ int shift_count = hfsmp->vcbFreeExtCnt - i - 1;+ if (shift_count > 0) {+ memmove(&hfsmp->vcbFreeExt[i+1], &hfsmp->vcbFreeExt[i], shift_count * sizeof(hfsmp->vcbFreeExt[0]));+ }++ /* Finally, store the new extent at its correct position. */+ hfsmp->vcbFreeExt[i].startBlock = startBlock;+ hfsmp->vcbFreeExt[i].blockCount = blockCount;+ return i;+}+++/*+ * Remove an entry from free extent cache after it has been allocated.+ *+ * This is a high-level routine. It handles removing a portion of a+ * cached extent, potentially splitting it into two (if the cache was+ * already full, throwing away the extent that would sort last). It+ * also handles removing an extent that overlaps multiple extents in+ * the cache.+ *+ * Inputs:+ * hfsmp - mount point structure+ * startBlock - starting block of the extent to be removed.+ * blockCount - number of blocks of the extent to be removed.+ */+static void remove_free_extent_cache(struct hfsmount *hfsmp, u_int32_t startBlock, u_int32_t blockCount)+{+ u_int32_t i, insertedIndex;+ u_int32_t currentStart, currentEnd, endBlock;+ int extentsRemoved = 0;++ if (hfs_kdebug_allocation & HFSDBG_EXT_CACHE_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_REMOVE_EXTENT_CACHE | DBG_FUNC_START, startBlock, blockCount, 0, 0, 0);++ endBlock = startBlock + blockCount;++ lck_spin_lock(&hfsmp->vcbFreeExtLock);++ /*+ * Iterate over all of the extents in the free extent cache, removing or+ * updating any entries that overlap with the input extent.+ */+ for (i = 0; i < hfsmp->vcbFreeExtCnt; ++i) {+ currentStart = hfsmp->vcbFreeExt[i].startBlock;+ currentEnd = currentStart + hfsmp->vcbFreeExt[i].blockCount;++ /*+ * If the current extent is entirely before or entirely after the+ * the extent to be removed, then we keep it as-is.+ */+ if (currentEnd <= startBlock || currentStart >= endBlock) {+ continue;+ }++ /*+ * If the extent being removed entirely contains the current extent,+ * then remove the current extent.+ */+ if (startBlock <= currentStart && endBlock >= currentEnd) {+ remove_free_extent_list(hfsmp, i);++ /*+ * We just removed the extent at index i. The extent at+ * index i+1 just got shifted to index i. So decrement i+ * to undo the loop's "++i", and the next iteration will+ * examine index i again, which contains the next extent+ * in the list.+ */+ --i;+ ++extentsRemoved;+ continue;+ }++ /*+ * If the extent being removed is strictly "in the middle" of the+ * current extent, then we need to split the current extent into+ * two discontiguous extents (the "head" and "tail"). The good+ * news is that we don't need to examine any other extents in+ * the list.+ */+ if (startBlock > currentStart && endBlock < currentEnd) {+ remove_free_extent_list(hfsmp, i);+ add_free_extent_list(hfsmp, currentStart, startBlock - currentStart);+ add_free_extent_list(hfsmp, endBlock, currentEnd - endBlock);+ break;+ }++ /*+ * The only remaining possibility is that the extent to be removed+ * overlaps the start or end (but not both!) of the current extent.+ * So we need to replace the current extent with a shorter one.+ *+ * The only tricky part is that the updated extent might be at a+ * different index than the original extent. If the updated extent+ * was inserted after the current extent, then we need to re-examine+ * the entry at index i, since it now contains the extent that was+ * previously at index i+1. If the updated extent was inserted+ * before or at the same index as the removed extent, then the+ * following extents haven't changed position.+ */+ remove_free_extent_list(hfsmp, i);+ if (startBlock > currentStart) {+ /* Remove the tail of the current extent. */+ insertedIndex = add_free_extent_list(hfsmp, currentStart, startBlock - currentStart);+ } else {+ /* Remove the head of the current extent. */+ insertedIndex = add_free_extent_list(hfsmp, endBlock, currentEnd - endBlock);+ }+ if (insertedIndex > i) {+ --i; /* Undo the "++i" in the loop, so we examine the entry at index i again. */+ }+ }++ lck_spin_unlock(&hfsmp->vcbFreeExtLock);++ sanity_check_free_ext(hfsmp, 0);++ if (hfs_kdebug_allocation & HFSDBG_EXT_CACHE_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_REMOVE_EXTENT_CACHE | DBG_FUNC_END, 0, 0, 0, extentsRemoved, 0);++ return;+}+++/*+ * Add an entry to free extent cache after it has been deallocated.+ *+ * This is a high-level routine. It will merge overlapping or contiguous+ * extents into a single, larger extent.+ *+ * If the extent provided has blocks beyond current allocLimit, it is+ * clipped to allocLimit (so that we won't accidentally find and allocate+ * space beyond allocLimit).+ *+ * Inputs:+ * hfsmp - mount point structure+ * startBlock - starting block of the extent to be removed.+ * blockCount - number of blocks of the extent to be removed.+ *+ * Returns:+ * true - if the extent was added successfully to the list+ * false - if the extent was not added to the list, maybe because+ * the extent was beyond allocLimit, or is not best+ * candidate to be put in the cache.+ */+static Boolean add_free_extent_cache(struct hfsmount *hfsmp, u_int32_t startBlock, u_int32_t blockCount)+{+ Boolean retval = false;+ uint32_t endBlock;+ uint32_t currentEnd;+ uint32_t i;++ if (hfs_kdebug_allocation & HFSDBG_EXT_CACHE_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_ADD_EXTENT_CACHE | DBG_FUNC_START, startBlock, blockCount, 0, 0, 0);++#if DEBUG+ for (i = 0; i < 2; ++i) {+ struct rl_entry *range;+ TAILQ_FOREACH(range, &hfsmp->hfs_reserved_ranges[i], rl_link) {+ hfs_assert(rl_overlap(range, startBlock,+ startBlock + blockCount - 1) == RL_NOOVERLAP);+ }+ }+#endif++ /* No need to add extent that is beyond current allocLimit */+ if (startBlock >= hfsmp->allocLimit) {+ goto out_not_locked;+ }++ /* If end of the free extent is beyond current allocLimit, clip the extent */+ if ((startBlock + blockCount) > hfsmp->allocLimit) {+ blockCount = hfsmp->allocLimit - startBlock;+ }++ lck_spin_lock(&hfsmp->vcbFreeExtLock);++ /*+ * Make a pass through the free extent cache, looking for known extents that+ * overlap or are contiguous with the extent to be added. We'll remove those+ * extents from the cache, and incorporate them into the new extent to be added.+ */+ endBlock = startBlock + blockCount;+ for (i=0; i < hfsmp->vcbFreeExtCnt; ++i) {+ currentEnd = hfsmp->vcbFreeExt[i].startBlock + hfsmp->vcbFreeExt[i].blockCount;+ if (hfsmp->vcbFreeExt[i].startBlock > endBlock || currentEnd < startBlock) {+ /* Extent i does not overlap and is not contiguous, so keep it. */+ continue;+ } else {+ /* We need to remove extent i and combine it with the input extent. */+ if (hfsmp->vcbFreeExt[i].startBlock < startBlock)+ startBlock = hfsmp->vcbFreeExt[i].startBlock;+ if (currentEnd > endBlock)+ endBlock = currentEnd;++ remove_free_extent_list(hfsmp, i);+ /*+ * We just removed the extent at index i. The extent at+ * index i+1 just got shifted to index i. So decrement i+ * to undo the loop's "++i", and the next iteration will+ * examine index i again, which contains the next extent+ * in the list.+ */+ --i;+ }+ }+ add_free_extent_list(hfsmp, startBlock, endBlock - startBlock);++ lck_spin_unlock(&hfsmp->vcbFreeExtLock);++out_not_locked:+ sanity_check_free_ext(hfsmp, 0);++ if (hfs_kdebug_allocation & HFSDBG_EXT_CACHE_ENABLED)+ KERNEL_DEBUG_CONSTANT(HFSDBG_ADD_EXTENT_CACHE | DBG_FUNC_END, 0, 0, 0, retval, 0);++ return retval;+}++/* Debug function to check if the free extent cache is good or not */+static void sanity_check_free_ext(struct hfsmount *hfsmp, int check_allocated)+{+ u_int32_t i, j;++ /* Do not do anything if debug is not on */+ if (ALLOC_DEBUG == 0) {+ return;+ }++ lck_spin_lock(&hfsmp->vcbFreeExtLock);++ if (hfsmp->vcbFreeExtCnt > kMaxFreeExtents)+ panic("hfs: %p: free extent count (%u) is too large", hfsmp, hfsmp->vcbFreeExtCnt);++ /*+ * Iterate the Free extent cache and ensure no entries are bogus or refer to+ * allocated blocks.+ */+ for(i=0; i < hfsmp->vcbFreeExtCnt; i++) {+ u_int32_t start, nblocks;++ start = hfsmp->vcbFreeExt[i].startBlock;+ nblocks = hfsmp->vcbFreeExt[i].blockCount;++ /* Check if any of the blocks in free extent cache are allocated.+ * This should not be enabled always because it might take+ * very long for large extents that get added to the list.+ *+ * We have to drop vcbFreeExtLock while we call hfs_isallocated+ * because it is going to do I/O. Note that the free extent+ * cache could change. That's a risk we take when using this+ * debugging code. (Another alternative would be to try to+ * detect when the free extent cache changed, and perhaps+ * restart if the list changed while we dropped the lock.)+ */+ if (check_allocated) {+ lck_spin_unlock(&hfsmp->vcbFreeExtLock);+ if (hfs_isallocated(hfsmp, start, nblocks)) {+ panic("hfs: %p: slot %d:(%u,%u) in the free extent array is allocated\n",+ hfsmp, i, start, nblocks);+ }+ lck_spin_lock(&hfsmp->vcbFreeExtLock);+ }++ /* Check if any part of the extent is beyond allocLimit */+ if ((start > hfsmp->allocLimit) || ((start + nblocks) > hfsmp->allocLimit)) {+ panic ("hfs: %p: slot %d:(%u,%u) in the free extent array is beyond allocLimit=%u\n",+ hfsmp, i, start, nblocks, hfsmp->allocLimit);+ }++ /* Check if there are any duplicate start blocks */+ for(j=i+1; j < hfsmp->vcbFreeExtCnt; j++) {+ if (start == hfsmp->vcbFreeExt[j].startBlock) {+ panic("hfs: %p: slot %d:(%u,%u) and %d:(%u,%u) are duplicate\n",+ hfsmp, i, start, nblocks, j, hfsmp->vcbFreeExt[j].startBlock,+ hfsmp->vcbFreeExt[j].blockCount);+ }+ }++ /* Check if the entries are out of order */+ if ((i+1) != hfsmp->vcbFreeExtCnt) {+ if (hfsmp->hfs_flags & HFS_HAS_SPARSE_DEVICE) {+ /* sparse devices are sorted by starting block number (ascending) */+ if (hfsmp->vcbFreeExt[i].startBlock > hfsmp->vcbFreeExt[i+1].startBlock) {+ panic ("hfs: %p: SPARSE %d:(%u,%u) and %d:(%u,%u) are out of order\n",+ hfsmp, i, start, nblocks, i+1, hfsmp->vcbFreeExt[i+1].startBlock,+ hfsmp->vcbFreeExt[i+1].blockCount);+ }+ } else {+ /* normally sorted by block count (descending) */+ if (hfsmp->vcbFreeExt[i].blockCount < hfsmp->vcbFreeExt[i+1].blockCount) {+ panic ("hfs: %p: %d:(%u,%u) and %d:(%u,%u) are out of order\n",+ hfsmp, i, start, nblocks, i+1, hfsmp->vcbFreeExt[i+1].startBlock,+ hfsmp->vcbFreeExt[i+1].blockCount);+ }+ }+ }+ }+ lck_spin_unlock(&hfsmp->vcbFreeExtLock);+}++#define BIT_RIGHT_MASK(bit) (0xffffffffffffffffull >> (bit))++static int clzll(uint64_t x)+{+ if (x == 0)+ return 64;+ else+ return __builtin_clzll(x);+}++#if !HFS_ALLOC_TEST++static errno_t get_more_bits(bitmap_context_t *bitmap_ctx)+{+ uint32_t start_bit;+ uint32_t iosize = 0;+ uint32_t byte_offset;+ uint32_t last_bitmap_block;+ int error;+ struct hfsmount *hfsmp = bitmap_ctx->hfsmp;+#if !HFS_ALLOC_TEST+ uint64_t lock_elapsed;+#endif+++ if (bitmap_ctx->bp)+ ReleaseScanBitmapRange(bitmap_ctx->bp);++ if (msleep(NULL, NULL, PINOD | PCATCH,+ "hfs_fsinfo", NULL) == EINTR) {+ return EINTR;+ }++#if !HFS_ALLOC_TEST+ /*+ * Let someone else use the allocation map after we've processed over HFS_FSINFO_MAX_LOCKHELD_TIME .+ * lock_start is initialized in hfs_find_free_extents().+ */+ absolutetime_to_nanoseconds(mach_absolute_time() - bitmap_ctx->lock_start, &lock_elapsed);++ if (lock_elapsed >= HFS_FSINFO_MAX_LOCKHELD_TIME) {++ hfs_systemfile_unlock(hfsmp, bitmap_ctx->lockflags);++ /* add tsleep here to force context switch and fairness */+ tsleep((caddr_t)get_more_bits, PRIBIO, "hfs_fsinfo", 1);++ hfs_journal_lock(hfsmp);++ /* Flush the journal and wait for all I/Os to finish up */+ error = hfs_flush(hfsmp, HFS_FLUSH_JOURNAL_META);+ if (error) {+ hfs_journal_unlock(hfsmp);+ return error;+ }++ /*+ * Take bitmap lock to ensure it is not being modified while journal is still held.+ * Since we are reading larger than normal blocks from the bitmap, which+ * might confuse other parts of the bitmap code using normal blocks, we+ * take exclusive lock here.+ */+ bitmap_ctx->lockflags = hfs_systemfile_lock(hfsmp, SFL_BITMAP, HFS_EXCLUSIVE_LOCK);++ bitmap_ctx->lock_start = mach_absolute_time();++ /* Release the journal lock */+ hfs_journal_unlock(hfsmp);++ /*+ * Bitmap is read in large block size (up to 1MB),+ * unlike the runtime which reads the bitmap in the+ * 4K block size. If the bitmap is read by both ways+ * at the same time, it can result in multiple buf_t with+ * different sizes and potentially case data corruption.+ * To avoid this, we invalidate all the existing buffers+ * associated with the bitmap vnode.+ */+ error = buf_invalidateblks(hfsmp->hfs_allocation_vp, 0, 0, 0);+ if (error) {+ /* hfs_systemfile_unlock will be called in the caller */+ return error;+ }+ }+#endif++ start_bit = bitmap_ctx->run_offset;++ if (start_bit >= bitmap_ctx->hfsmp->totalBlocks) {+ bitmap_ctx->chunk_end = 0;+ bitmap_ctx->bp = NULL;+ bitmap_ctx->bitmap = NULL;+ return 0;+ }++ hfs_assert(start_bit % 8 == 0);++ /*+ * Compute how much I/O we should generate here.+ * hfs_scan_range_size will validate that the start bit+ * converted into a byte offset into the bitmap file,+ * is aligned on a VBMIOSize boundary.+ */+ error = hfs_scan_range_size (bitmap_ctx->hfsmp, start_bit, &iosize);+ if (error)+ return error;++ hfs_assert(iosize != 0);++ /* hfs_scan_range_size should have verified startbit. Convert it to bytes */+ byte_offset = start_bit / kBitsPerByte;++ /*+ * When the journal replays blocks, it does so by writing directly to the disk+ * device (bypassing any filesystem vnodes and such). When it finishes its I/Os+ * it also immediately re-reads and invalidates the range covered by the bp so+ * it does not leave anything lingering in the cache (for iosize reasons).+ *+ * As such, it is safe to do large I/Os here with ReadBitmapRange.+ *+ * NOTE: It is not recommended, but it is possible to call the function below+ * on sections of the bitmap that may be in core already as long as the pages are not+ * dirty. In that case, we'd notice that something starting at that+ * logical block of the bitmap exists in the metadata cache, and we'd check+ * if the iosize requested is the same as what was already allocated for it.+ * Odds are pretty good we're going to request something larger. In that case,+ * we just free the existing memory associated with the buf and reallocate a+ * larger range. This function should immediately invalidate it as soon as we're+ * done scanning, so this shouldn't cause any coherency issues.+ */+ error = ReadBitmapRange(bitmap_ctx->hfsmp, byte_offset, iosize, (uint32_t **)&bitmap_ctx->bitmap, &bitmap_ctx->bp);+ if (error)+ return error;++ /*+ * At this point, we have a giant wired buffer that represents some portion of+ * the bitmap file that we want to analyze. We may not have gotten all 'iosize'+ * bytes though, so clip our ending bit to what we actually read in.+ */+ last_bitmap_block = start_bit + buf_count(bitmap_ctx->bp) * kBitsPerByte;++ /* Cap the last block to the total number of blocks if required */+ if (last_bitmap_block > bitmap_ctx->hfsmp->totalBlocks)+ last_bitmap_block = bitmap_ctx->hfsmp->totalBlocks;++ bitmap_ctx->chunk_current = 0; // new chunk of bitmap+ bitmap_ctx->chunk_end = last_bitmap_block - start_bit;++ return 0;+}++#endif // !HFS_ALLOC_TEST++// Returns number of contiguous bits set at start+static int bit_count_set(void *bitmap, int start, int end)+{+ if (start == end)+ return 0;++ hfs_assert(end > start);++ const int start_bit = start & 63;+ const int end_bit = end & 63;++ uint64_t *p = (uint64_t *)bitmap + start / 64;+ uint64_t x = ~OSSwapBigToHostInt64(*p);++ if ((start & ~63) == (end & ~63)) {+ // Start and end in same 64 bits+ x = (x & BIT_RIGHT_MASK(start_bit)) | BIT_RIGHT_MASK(end_bit);+ return clzll(x) - start_bit;+ }++ // Deal with initial unaligned bit+ x &= BIT_RIGHT_MASK(start_bit);++ if (x)+ return clzll(x) - start_bit;++ // Go fast+ ++p;+ int count = 64 - start_bit;+ int nquads = (end - end_bit - start - 1) / 64;++ while (nquads--) {+ if (*p != 0xffffffffffffffffull) {+ x = ~OSSwapBigToHostInt64(*p);+ return count + clzll(x);+ }+ ++p;+ count += 64;+ }++ if (end_bit) {+ x = ~OSSwapBigToHostInt64(*p) | BIT_RIGHT_MASK(end_bit);+ count += clzll(x);+ }++ return count;+}++/* Returns the number of a run of cleared bits:+ * bitmap is a single chunk of memory being examined+ * start: the start bit relative to the current buffer to be examined; start is inclusive.+ * end: the end bit relative to the current buffer to be examined; end is not inclusive.+ */+static int bit_count_clr(void *bitmap, int start, int end)+{+ if (start == end)+ return 0;++ hfs_assert(end > start);++ const int start_bit = start & 63;+ const int end_bit = end & 63;++ uint64_t *p = (uint64_t *)bitmap + start / 64;+ uint64_t x = OSSwapBigToHostInt64(*p);++ if ((start & ~63) == (end & ~63)) {+ // Start and end in same 64 bits+ x = (x & BIT_RIGHT_MASK(start_bit)) | BIT_RIGHT_MASK(end_bit);++ return clzll(x) - start_bit;+ }++ // Deal with initial unaligned bit+ x &= BIT_RIGHT_MASK(start_bit);++ if (x)+ return clzll(x) - start_bit;++ // Go fast+ ++p;+ int count = 64 - start_bit;+ int nquads = (end - end_bit - start - 1) / 64;++ while (nquads--) {+ if (*p) {+ x = OSSwapBigToHostInt64(*p);+ return count + clzll(x);+ }+ ++p;+ count += 64;+ }++ if (end_bit) {+ x = OSSwapBigToHostInt64(*p) | BIT_RIGHT_MASK(end_bit);++ count += clzll(x);+ }++ return count;+}++#if !HFS_ALLOC_TEST+static errno_t update_summary_table(bitmap_context_t *bitmap_ctx, uint32_t start, uint32_t count, bool set)+{+ uint32_t end, start_summary_bit, end_summary_bit;+ errno_t error = 0;++ if (count == 0)+ goto out;++ if (!ISSET(bitmap_ctx->hfsmp->hfs_flags, HFS_SUMMARY_TABLE))+ return 0;++ if (hfs_get_summary_index (bitmap_ctx->hfsmp, start, &start_summary_bit)) {+ error = EINVAL;+ goto out;+ }++ end = start + count - 1;+ if (hfs_get_summary_index (bitmap_ctx->hfsmp, end, &end_summary_bit)) {+ error = EINVAL;+ goto out;+ }++ // if summary table bit has been updated with free block previously, leave it.+ if ((start_summary_bit == bitmap_ctx->last_free_summary_bit) && set)+ start_summary_bit++;++ for (uint32_t summary_bit = start_summary_bit; summary_bit <= end_summary_bit; summary_bit++)+ hfs_set_summary (bitmap_ctx->hfsmp, summary_bit, set);++ if (!set)+ bitmap_ctx->last_free_summary_bit = end_summary_bit;++out:+ return error;++}+#endif //!HFS_ALLOC_TEST++/*+ * Read in chunks of the bitmap into memory, and find a run of cleared/set bits;+ * the run can extend across chunk boundaries.+ * bit_count_clr can be passed to get a run of cleared bits.+ * bit_count_set can be passed to get a run of set bits.+ */+static errno_t hfs_bit_count(bitmap_context_t *bitmap_ctx, int (*fn)(void *, int ,int), uint32_t *bit_count)+{+ int count;+ errno_t error = 0;++ *bit_count = 0;++ do {+ if (bitmap_ctx->run_offset == 0 || bitmap_ctx->chunk_current == bitmap_ctx->chunk_end) {+ if ((error = get_more_bits(bitmap_ctx)) != 0)+ goto out;+ }++ if (bitmap_ctx->chunk_end == 0)+ break;++ count = fn(bitmap_ctx->bitmap, bitmap_ctx->chunk_current, bitmap_ctx->chunk_end);++ bitmap_ctx->run_offset += count;+ bitmap_ctx->chunk_current += count;+ *bit_count += count;++ } while (bitmap_ctx->chunk_current >= bitmap_ctx->chunk_end && count);++out:+ return error;++}++// Returns count of number of bits clear+static errno_t hfs_bit_count_clr(bitmap_context_t *bitmap_ctx, uint32_t *count)+{+ return hfs_bit_count(bitmap_ctx, bit_count_clr, count);+}++// Returns count of number of bits set+static errno_t hfs_bit_count_set(bitmap_context_t *bitmap_ctx, uint32_t *count)+{+ return hfs_bit_count(bitmap_ctx, bit_count_set, count);+}++static uint32_t hfs_bit_offset(bitmap_context_t *bitmap_ctx)+{+ return bitmap_ctx->run_offset;+}++/*+ * Perform a full scan of the bitmap file.+ * Note: during the scan of bitmap file, it may drop and reacquire the+ * bitmap lock to let someone else use the bitmap for fairness.+ * Currently it is used by HFS_GET_FSINFO statistic gathing, which+ * is run while other processes might perform HFS operations.+ */++errno_t hfs_find_free_extents(struct hfsmount *hfsmp,+ void (*callback)(void *data, off_t free_extent_size), void *callback_arg)+{+ struct bitmap_context bitmap_ctx;+ uint32_t count;+ errno_t error = 0;++ if ((hfsmp->hfs_flags & HFS_SUMMARY_TABLE) == 0) {+ error = hfs_init_summary(hfsmp);+ if (error)+ return error;+ }++ bzero(&bitmap_ctx, sizeof(struct bitmap_context));++ /*+ * The journal maintains list of recently deallocated blocks to+ * issue DKIOCUNMAPs when the corresponding journal transaction is+ * flushed to the disk. To avoid any race conditions, we only+ * want one active trim list. Therefore we make sure that the+ * journal trim list is sync'ed, empty, and not modifiable for+ * the duration of our scan.+ *+ * Take the journal lock before flushing the journal to the disk.+ * We will keep on holding the journal lock till we don't get the+ * bitmap lock to make sure that no new journal transactions can+ * start. This will make sure that the journal trim list is not+ * modified after the journal flush and before getting bitmap lock.+ * We can release the journal lock after we acquire the bitmap+ * lock as it will prevent any further block deallocations.+ */+ hfs_journal_lock(hfsmp);++ /* Flush the journal and wait for all I/Os to finish up */+ error = hfs_flush(hfsmp, HFS_FLUSH_JOURNAL_META);+ if (error) {+ hfs_journal_unlock(hfsmp);+ return error;+ }++ /*+ * Take bitmap lock to ensure it is not being modified.+ * Since we are reading larger than normal blocks from the bitmap, which+ * might confuse other parts of the bitmap code using normal blocks, we+ * take exclusive lock here.+ */+ bitmap_ctx.lockflags = hfs_systemfile_lock(hfsmp, SFL_BITMAP, HFS_EXCLUSIVE_LOCK);++#if !HFS_ALLOC_TEST+ bitmap_ctx.lock_start = mach_absolute_time();+#endif++ /* Release the journal lock */+ hfs_journal_unlock(hfsmp);++ /*+ * Bitmap is read in large block size (up to 1MB),+ * unlike the runtime which reads the bitmap in the+ * 4K block size. If the bitmap is read by both ways+ * at the same time, it can result in multiple buf_t with+ * different sizes and potentially case data corruption.+ * To avoid this, we invalidate all the existing buffers+ * associated with the bitmap vnode.+ */+ error = buf_invalidateblks(hfsmp->hfs_allocation_vp, 0, 0, 0);+ if (error)+ goto out;++ /*+ * Get the list of all free extent ranges. hfs_alloc_scan_range()+ * will call hfs_fsinfo_data_add() to account for all the free+ * extent ranges found during scan.+ */+ bitmap_ctx.hfsmp = hfsmp;+ bitmap_ctx.run_offset = 0;++ while (bitmap_ctx.run_offset < hfsmp->totalBlocks) {++ uint32_t start = hfs_bit_offset(&bitmap_ctx);++ if ((error = hfs_bit_count_clr(&bitmap_ctx, &count)) != 0)+ goto out;++ if (count)+ callback(callback_arg, hfs_blk_to_bytes(count, hfsmp->blockSize));++ if ((error = update_summary_table(&bitmap_ctx, start, count, false)) != 0)+ goto out;++ start = hfs_bit_offset(&bitmap_ctx);++ if ((error = hfs_bit_count_set(&bitmap_ctx, &count)) != 0)+ goto out;++ if ((error = update_summary_table(&bitmap_ctx, start, count, true)) != 0)+ goto out;+ }++out:+ if (bitmap_ctx.lockflags) {+ hfs_systemfile_unlock(hfsmp, bitmap_ctx.lockflags);+ }++ return error;+}+diff --git a/xnu/files/bsd/hfs/hfs.h b/xnu/files/bsd/hfs/hfs.hnew file mode 100644index 0000000..1a6b5a8--- /dev/null+++ b/xnu/files/bsd/hfs/hfs.h@@ -0,0 +1,1351 @@+/*+ * Copyright (c) 2000-2020 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@+ */++#ifndef __HFS__+#define __HFS__++/* If set to 1, enables the code to allocate blocks from the start+ * of the disk instead of the nextAllocation for sparse devices like+ * sparse disk images or sparsebundle images. The free extent cache+ * for such volumes is also maintained based on the start block instead+ * of number of contiguous allocation blocks. These devices prefer+ * allocation of blocks near the start of the disk to avoid the+ * increasing the image size, but it can also result in file fragmentation.+ */+#define HFS_SPARSE_DEV 1++#if DEBUG+#define HFS_CHECK_LOCK_ORDER 1+#endif++#define HFS_TMPDBG 0++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE+#include <sys/param.h>+#include <sys/queue.h>+#include <sys/mount.h>+#include <sys/vnode.h>+#include <sys/quota.h>+#include <sys/dirent.h>+#include <sys/event.h>+#include <sys/disk.h>+#include <kern/thread_call.h>+#include <kern/locks.h>+#include <vm/vm_kern.h>+#include <sys/sysctl.h>+#include <uuid/uuid.h>+#include <IOKit/IOLib.h>+#include <libkern/OSAtomic.h>++#include "../hfs_encodings/hfs_encodings.h"++#include "hfs_journal.h"+#include "hfs_format.h"+#include "hfs_catalog.h"+#include "hfs_cnode.h"+#include "hfs_macos_defs.h"+#include "hfs_hotfiles.h"+#include "hfs_fsctl.h"++__BEGIN_DECLS++#if CONFIG_PROTECT+/* Forward declare the cprotect struct */+struct cprotect;+#endif++/*+ * Just reported via MIG interface.+ */+#define VERSION_STRING "hfs-2 (4-12-99)"++#define HFS_LINK_MAX 32767++#define HFS_MAX_DEFERED_ALLOC (1024*1024)++#define HFS_MAX_FILES (UINT32_MAX - kHFSFirstUserCatalogNodeID)++// 400 megs is a "big" file (i.e. one that when deleted+// would touch enough data that we should break it into+// multiple separate transactions)+#define HFS_BIGFILE_SIZE (400LL * 1024LL * 1024LL)++enum { kMDBSize = 512 }; /* Size of I/O transfer to read entire MDB */++enum { kMasterDirectoryBlock = 2 }; /* MDB offset on disk in 512-byte blocks */+enum { kMDBOffset = kMasterDirectoryBlock * 512 }; /* MDB offset on disk in bytes */++#define kRootDirID kHFSRootFolderID+++/* number of locked buffer caches to hold for b-tree meta data */+#define kMaxLockedMetaBuffers 32++extern struct timezone gTimeZone;+++/* How many free extents to cache per volume */+#define kMaxFreeExtents 10++/* Maximum file size that we're willing to defrag on open */+#define HFS_MAX_DEFRAG_SIZE 104857600 // 100 * 1024 * 1024 (100MB)+#define HFS_INITIAL_DEFRAG_SIZE 20971520 // 20 * 1024 * 1024 (20MB)+++/* The maximum time hfs locks can be held while performing hfs statistics gathering */+#define HFS_FSINFO_MAX_LOCKHELD_TIME 20 * 1000000ULL /* at most 20 milliseconds. */++/*+ * HFS_MINFREE gives the minimum acceptable percentage+ * of file system blocks which may be free (but this+ * minimum will never exceed HFS_MAXRESERVE bytes). If+ * the free block count drops below this level only the+ * superuser may continue to allocate blocks.+ */+#define HFS_MINFREE 1+#define HFS_MAXRESERVE ((u_int64_t)(250*1024*1024))+#define HFS_BT_MAXRESERVE ((u_int64_t)(10*1024*1024))++/*+ * The system distinguishes between the desirable low-disk+ * notifiaction levels for root volumes and non-root volumes.+ * The various thresholds are computed as a fraction of the+ * volume size, all capped at a certain fixed level+ */++#define HFS_ROOTVERYLOWDISKTRIGGERFRACTION 5+#define HFS_ROOTVERYLOWDISKTRIGGERLEVEL ((u_int64_t)(512*1024*1024))+#define HFS_ROOTLOWDISKTRIGGERFRACTION 10+#define HFS_ROOTLOWDISKTRIGGERLEVEL ((u_int64_t)(1024*1024*1024))+#define HFS_ROOTNEARLOWDISKTRIGGERFRACTION 10.5+#define HFS_ROOTNEARLOWDISKTRIGGERLEVEL ((u_int64_t)(1024*1024*1024 + 100*1024*1024))+#define HFS_ROOTLOWDISKSHUTOFFFRACTION 11+#define HFS_ROOTLOWDISKSHUTOFFLEVEL ((u_int64_t)(1024*1024*1024 + 250*1024*1024))++#define HFS_VERYLOWDISKTRIGGERFRACTION 1+#define HFS_VERYLOWDISKTRIGGERLEVEL ((u_int64_t)(150*1024*1024))+#define HFS_LOWDISKTRIGGERFRACTION 2+#define HFS_LOWDISKTRIGGERLEVEL ((u_int64_t)(500*1024*1024))+#define HFS_NEARLOWDISKTRIGGERFRACTION 10+#define HFS_NEARLOWDISKTRIGGERLEVEL ((uint64_t)(1024*1024*1024))+#define HFS_LOWDISKSHUTOFFFRACTION 12+#define HFS_LOWDISKSHUTOFFLEVEL ((u_int64_t)(1024*1024*1024 + 200*1024*1024))++/* Internal Data structures*/++#define NEW_XATTR TARGET_CPU_ARM64++#if NEW_XATTR++// number of concurrent xattr IOs permitted+#define XATTR_NUM_FEXTS 64u+// bitmap size, in 64bit words, used to track concurrent xattr IOs+#define XATTR_BM_SIZE ((XATTR_NUM_FEXTS) / (NBBY * sizeof(uint64_t)))++/*+ * State for all stream based xattr IO on a volume.+ *+ * Fixed size thread local storage for use across the IO stack.+ *+ * Fields:+ * - lock+ * A spin lock used to access both the free file extent bitmap, `free_bm',+ * and the xattr file extents themselves, `xattr_fexts'.+ * - free_bm+ * This bitmap represents the unused indices of `xattr_fexts'. The name is+ * somewhat backwards: set bits (with a value of one) denote *used* indices.+ * - xattr_fexts+ * These are references to xattr file extents used as thread local storage to+ * communicate from top level xattr IO functions, through the cluster layer,+ * down into lower level IO functions (hfs_vnop_blockmap()).+ * Each index which contains a non-NULL fext should have its corresponding+ * bit within `free_bm' set. Though the reverse is not strictly true: a bit+ * within the bitmap may be set before the corresponding fext is. This is+ * the case when memory for a file extent reference is preallocated before+ * the value of the file extent is available.+ * This is an array of pointers rather than an array of file extents because:+ * - it avoids both copying a full fext into and out from the array+ * - it prints more nicely in lldb+ */+typedef struct {+ lck_spin_t lock;+ uint64_t free_bm[XATTR_BM_SIZE];+ const HFSPlusExtentDescriptor *xattr_fexts[XATTR_NUM_FEXTS];+} xattr_io_info_t;++#endif++/* This structure describes the HFS specific mount structure data. */+typedef struct hfsmount {+ u_int32_t hfs_flags; /* see below */++ /* Physical Description */+ u_int32_t hfs_logical_block_size; /* Logical block size of the disk as reported by ioctl(DKIOCGETBLOCKSIZE), always a multiple of 512 */+ daddr64_t hfs_logical_block_count; /* Number of logical blocks on the disk, as reported by ioctl(DKIOCGETBLOCKCOUNT) */+ u_int64_t hfs_logical_bytes; /* Number of bytes on the disk device this HFS is mounted on (blockcount * blocksize) */+ /*+ * Regarding the two AVH sector fields below:+ * Under normal circumstances, the filesystem's notion of the "right" location for the AVH is such that+ * the partition and filesystem's are in sync. However, during a filesystem resize, HFS proactively+ * writes a new AVH at the end of the filesystem, assuming that the partition will be resized accordingly.+ *+ * However, it is not technically a corruption if the partition size is never modified. As a result, we need+ * to keep two copies of the AVH around "just in case" the partition size is not modified.+ */+ daddr64_t hfs_partition_avh_sector; /* location of Alt VH w.r.t partition size */+ daddr64_t hfs_fs_avh_sector; /* location of Alt VH w.r.t filesystem size */++ u_int32_t hfs_physical_block_size; /* Physical block size of the disk as reported by ioctl(DKIOCGETPHYSICALBLOCKSIZE) */+ u_int32_t hfs_log_per_phys; /* Number of logical blocks per physical block size */++ /* Access to VFS and devices */+ struct mount *hfs_mp; /* filesystem vfs structure */+ struct vnode *hfs_devvp; /* block device mounted vnode */+ struct vnode * hfs_extents_vp;+ struct vnode * hfs_catalog_vp;+ struct vnode * hfs_allocation_vp;+ struct vnode * hfs_attribute_vp;+ struct vnode * hfs_startup_vp;+ struct vnode * hfs_attrdata_vp; /* pseudo file */+#if NEW_XATTR+ xattr_io_info_t hfs_xattr_io; /* Note, this is a big structure ~(64 * 8 bytes) */+#endif+ struct cnode * hfs_extents_cp;+ struct cnode * hfs_catalog_cp;+ struct cnode * hfs_allocation_cp;+ struct cnode * hfs_attribute_cp;+ struct cnode * hfs_startup_cp;+ dev_t hfs_raw_dev; /* device mounted */+ u_int32_t hfs_logBlockSize; /* Size of buffer cache buffer for I/O */++ /* Default values for HFS standard and non-init access */+ uid_t hfs_uid; /* uid to set as owner of the files */+ gid_t hfs_gid; /* gid to set as owner of the files */+ mode_t hfs_dir_mask; /* mask to and with directory protection bits */+ mode_t hfs_file_mask; /* mask to and with file protection bits */+ u_int32_t hfs_encoding; /* Default encoding for non hfs+ volumes */++ /* Persistent fields (on disk, dynamic) */+ time_t hfs_mtime; /* file system last modification time */+ u_int32_t hfs_filecount; /* number of files in file system */+ u_int32_t hfs_dircount; /* number of directories in file system */+ u_int32_t freeBlocks; /* free allocation blocks */+ u_int32_t reclaimBlocks; /* number of blocks we are reclaiming during resize */+ u_int32_t tentativeBlocks; /* tentative allocation blocks -- see note below */+ u_int32_t nextAllocation; /* start of next allocation search */+ u_int32_t sparseAllocation; /* start of allocations for sparse devices */+ u_int32_t vcbNxtCNID; /* next unused catalog node ID - protected by catalog lock */+ u_int32_t vcbWrCnt; /* file system write count */+ u_int64_t encodingsBitmap; /* in-use encodings */+ u_int16_t vcbNmFls; /* HFS Only - root dir file count */+ u_int16_t vcbNmRtDirs; /* HFS Only - root dir directory count */++ /* Persistent fields (on disk, static) */+ u_int16_t vcbSigWord;++ // Volume will be inconsistent if header is not flushed+ bool hfs_header_dirty;++ // Volume header is dirty, but won't be inconsistent if not flushed+ bool hfs_header_minor_change;++ u_int32_t vcbAtrb;+ u_int32_t vcbJinfoBlock;+ u_int32_t localCreateDate;/* volume create time from volume header (For HFS+, value is in local time) */+ time_t hfs_itime; /* file system creation time (creation date of the root folder) */+ time_t hfs_btime; /* file system last backup time */+ u_int32_t blockSize; /* size of allocation blocks */+ u_int32_t totalBlocks; /* total allocation blocks */+ u_int32_t allocLimit; /* Do not allocate this block or beyond */+ /*+ * NOTE: When resizing a volume to make it smaller, allocLimit is set to the allocation+ * block number which will contain the new alternate volume header. At all other times,+ * allocLimit is set to totalBlocks. The allocation code uses allocLimit instead of+ * totalBlocks to limit which blocks may be allocated, so that during a resize, we don't+ * put new content into the blocks we're trying to truncate away.+ */+ int32_t vcbClpSiz;+ u_int32_t vcbFndrInfo[8];+ int16_t vcbVBMSt; /* HFS only */+ int16_t vcbAlBlSt; /* HFS only */++ /* vcb stuff */+ u_int8_t vcbVN[256]; /* volume name in UTF-8 */+ u_int32_t volumeNameEncodingHint;+ u_int32_t hfsPlusIOPosOffset; /* Disk block where HFS+ starts */+ u_int32_t vcbVBMIOSize; /* volume bitmap I/O size */++ /* cache of largest known free extents */+ u_int32_t vcbFreeExtCnt;+ HFSPlusExtentDescriptor vcbFreeExt[kMaxFreeExtents];+ lck_spin_t vcbFreeExtLock;++ /* Summary Table */+ u_int8_t *hfs_summary_table; /* Each bit is 1 vcbVBMIOSize of bitmap, byte indexed */+ u_int32_t hfs_summary_size; /* number of BITS in summary table defined above (not bytes!) */+ u_int32_t hfs_summary_bytes; /* number of BYTES in summary table */++ u_int32_t scan_var; /* For initializing the summary table */+++ u_int32_t reserveBlocks; /* free block reserve */+ u_int32_t loanedBlocks; /* blocks on loan for delayed allocations */+ u_int32_t lockedBlocks; /* blocks reserved and locked */++ /*+ * HFS+ Private system directories (two). Any access+ * (besides looking at the cd_cnid) requires holding+ * the Catalog File lock.+ */+ struct cat_desc hfs_private_desc[2];+ struct cat_attr hfs_private_attr[2];++ u_int32_t hfs_metadata_createdate;++ /* Quota variables: */+ struct quotafile hfs_qfiles[MAXQUOTAS]; /* quota files */++ /* Journaling variables: */+ struct journal *jnl; // the journal for this volume (if one exists)+ struct vnode *jvp; // device where the journal lives (may be equal to devvp)+ u_int32_t jnl_start; // start block of the journal file (so we don't delete it)+ u_int32_t jnl_size;+ u_int32_t hfs_jnlfileid;+ u_int32_t hfs_jnlinfoblkid;+ lck_rw_t hfs_global_lock;+ thread_t hfs_global_lockowner;+ u_int32_t hfs_transaction_nesting;++ /*+ * Notification variables+ * See comments in hfs mount code for what the+ * default levels are set to.+ */+ u_int32_t hfs_notification_conditions;+ u_int32_t hfs_freespace_notify_dangerlimit;+ u_int32_t hfs_freespace_notify_warninglimit;+ u_int32_t hfs_freespace_notify_nearwarninglimit;+ u_int32_t hfs_freespace_notify_desiredlevel;++ /* time mounted and last mounted mod time "snapshot" */+ time_t hfs_mount_time;+ time_t hfs_last_mounted_mtime;++ /* Metadata allocation zone variables: */+ u_int32_t hfs_metazone_start;+ u_int32_t hfs_metazone_end;+ u_int32_t hfs_hotfile_start;+ u_int32_t hfs_hotfile_end;+ u_int32_t hfs_min_alloc_start;+ u_int32_t hfs_freed_block_count;+ u_int64_t hfs_cs_hotfile_size; // in bytes+ int hfs_hotfile_freeblks;+ int hfs_hotfile_blk_adjust; // since we pass this to OSAddAtomic, this needs to be 4-byte aligned+ int hfs_hotfile_maxblks;+ int hfs_overflow_maxblks;+ int hfs_catalog_maxblks;++ /* Hot File Clustering variables: */+ lck_mtx_t hfc_mutex; /* serialize hot file stages */+ enum hfc_stage hfc_stage; /* what are we up to... */+ time_t hfc_timebase; /* recording period start time */+ time_t hfc_timeout; /* recording period stop time */+ struct hotfile_data *hfc_recdata;+ struct hotfilelist *hfc_filelist;+ uint32_t hfc_maxfiles; /* maximum files to track */+ struct vnode * hfc_filevp;++ /* defrag-on-open variables */+ int hfs_defrag_nowait; //issue defrags now, regardless of whether or not we've gone past 3 min.+ uint64_t hfs_defrag_max; //maximum file size we'll defragment on this mount++#if HFS_SPARSE_DEV+ /* Sparse device variables: */+ struct vnode * hfs_backingvp;+ u_int32_t hfs_last_backingstatfs;+ u_int32_t hfs_sparsebandblks;+ u_int64_t hfs_backingfs_maxblocks;+#endif+ size_t hfs_max_inline_attrsize;++ lck_mtx_t hfs_mutex; /* protects access to hfsmount data */++ uint32_t hfs_syncers; // Count of the number of syncers running+ enum {+ HFS_THAWED,+ HFS_WANT_TO_FREEZE, // This state stops hfs_sync from starting+ HFS_FREEZING, // We're in this state whilst we're flushing+ HFS_FROZEN // Everything gets blocked in hfs_lock_global+ } hfs_freeze_state;+ union {+ /*+ * When we're freezing (HFS_FREEZING) but not yet+ * frozen (HFS_FROZEN), we record the freezing thread+ * so that we stop other threads from taking locks,+ * but allow the freezing thread.+ */+ const struct thread *hfs_freezing_thread;+ /*+ * Once we have frozen (HFS_FROZEN), we record the+ * process so that if it dies, we can automatically+ * unfreeze.+ */+ proc_t hfs_freezing_proc;+ };++ thread_t hfs_downgrading_thread; /* thread who's downgrading to rdonly */++ /* Resize variables: */+ u_int32_t hfs_resize_blocksmoved;+ u_int32_t hfs_resize_totalblocks;+ u_int32_t hfs_resize_progress;+#if CONFIG_PROTECT+ /* Data Protection fields */+ cpx_t hfs_resize_cpx;+ u_int16_t hfs_running_cp_major_vers;+ uint32_t default_cp_class; /* default effective class value */+ uint64_t cproot_flags;+ uint8_t cp_crypto_generation;+ cp_lock_state_t hfs_cp_lock_state; /* per-mount device lock state info */+#if HFS_CONFIG_KEY_ROLL+ uint32_t hfs_auto_roll_min_key_os_version;+ uint32_t hfs_auto_roll_max_key_os_version;+#endif+#if HFS_TMPDBG+#if !SECURE_KERNEL+ boolean_t hfs_cp_verbose;+#endif+#endif++#endif++ /* the full UUID of the volume, not the one stored in finderinfo */+ uuid_t hfs_full_uuid;++ /* Per mount cnode hash variables: */+ lck_mtx_t hfs_chash_mutex; /* protects access to cnode hash table */+ u_long hfs_cnodehash; /* size of cnode hash table - 1 */+ LIST_HEAD(cnodehashhead, cnode) *hfs_cnodehashtbl; /* base of cnode hash */++ /* Per mount fileid hash variables (protected by catalog lock!) */+ u_long hfs_idhash; /* size of cnid/fileid hash table -1 */+ LIST_HEAD(idhashhead, cat_preflightid) *hfs_idhashtbl; /* base of ID hash */++ // Records the oldest outstanding sync request+ struct timeval hfs_sync_req_oldest;++ /* Records the syncer thread so that we can avoid the syncer+ queing more syncs. */+ thread_t hfs_syncer_thread;++ // Not currently used except for debugging purposes+ // Since we pass this to OSAddAtomic, this needs to be 4-byte aligned.+ uint32_t hfs_active_threads;++ enum {+ // These are indices into the array below++ // Tentative ranges can be claimed back at any time+ HFS_TENTATIVE_BLOCKS = 0,++ // Locked ranges cannot be claimed back, but the allocation+ // won't have been written to disk yet+ HFS_LOCKED_BLOCKS = 1,+ };+ // These lists are not sorted like a range list usually is+ struct rl_head hfs_reserved_ranges[2];+} hfsmount_t;++/*+ * HFS_META_DELAY is a duration (in usecs) used for triggering the+ * hfs_syncer() routine. We will back off if writes are in+ * progress, but...+ * HFS_MAX_META_DELAY is the maximum time we will allow the+ * syncer to be delayed.+ */+enum {+ HFS_META_DELAY = 100 * 1000, // 0.1 secs+ HFS_MAX_META_DELAY = 5000 * 1000 // 5 secs+};++#define HFS_META_DELAY_TS \+ (struct timespec){ 0, HFS_META_DELAY * NSEC_PER_USEC }++typedef hfsmount_t ExtendedVCB;++/* Aliases for legacy (Mac OS 9) field names */+#define vcbLsMod hfs_mtime+#define vcbVolBkUp hfs_btime+#define extentsRefNum hfs_extents_vp+#define catalogRefNum hfs_catalog_vp+#define allocationsRefNum hfs_allocation_vp+#define vcbFilCnt hfs_filecount+#define vcbDirCnt hfs_dircount++static inline void MarkVCBDirty(hfsmount_t *hfsmp)+{+ hfsmp->hfs_header_dirty = true;+}++static inline void MarkVCBClean(hfsmount_t *hfsmp)+{+ hfsmp->hfs_header_dirty = false;+ hfsmp->hfs_header_minor_change = false;+}++static inline bool IsVCBDirty(ExtendedVCB *vcb)+{+ return vcb->hfs_header_minor_change || vcb->hfs_header_dirty;+}++// Header is changed but won't be inconsistent if we don't write it+static inline void hfs_note_header_minor_change(hfsmount_t *hfsmp)+{+ hfsmp->hfs_header_minor_change = true;+}++// Must header be flushed for volume to be consistent?+static inline bool hfs_header_needs_flushing(hfsmount_t *hfsmp)+{+ return (hfsmp->hfs_header_dirty+ || ISSET(hfsmp->hfs_catalog_cp->c_flag, C_MODIFIED)+ || ISSET(hfsmp->hfs_extents_cp->c_flag, C_MODIFIED)+ || (hfsmp->hfs_attribute_cp+ && ISSET(hfsmp->hfs_attribute_cp->c_flag, C_MODIFIED))+ || (hfsmp->hfs_allocation_cp+ && ISSET(hfsmp->hfs_allocation_cp->c_flag, C_MODIFIED))+ || (hfsmp->hfs_startup_cp+ && ISSET(hfsmp->hfs_startup_cp->c_flag, C_MODIFIED)));+}++/*+ * There are two private directories in HFS+.+ *+ * One contains inodes for files that are hardlinked or open/unlinked.+ * The other contains inodes for directories that are hardlinked.+ */+enum privdirtype {FILE_HARDLINKS, DIR_HARDLINKS};++#define HFS_ALLOCATOR_SCAN_INFLIGHT 0x0001 /* scan started */+#define HFS_ALLOCATOR_SCAN_COMPLETED 0x0002 /* initial scan was completed */++/* HFS mount point flags */+#define HFS_READ_ONLY 0x00001+#define HFS_UNKNOWN_PERMS 0x00002+#define HFS_WRITEABLE_MEDIA 0x00004+#define HFS_CLEANED_ORPHANS 0x00008+#define HFS_X 0x00010+#define HFS_CASE_SENSITIVE 0x00020+#define HFS_STANDARD 0x00040+#define HFS_METADATA_ZONE 0x00080+#define HFS_FRAGMENTED_FREESPACE 0x00100+#define HFS_NEED_JNL_RESET 0x00200+#define HFS_HAS_SPARSE_DEVICE 0x00400+#define HFS_RESIZE_IN_PROGRESS 0x00800+#define HFS_QUOTAS 0x01000+#define HFS_CREATING_BTREE 0x02000+/* When set, do not update nextAllocation in the mount structure */+#define HFS_SKIP_UPDATE_NEXT_ALLOCATION 0x04000+/* When set, the file system supports extent-based extended attributes */+#define HFS_XATTR_EXTENTS 0x08000+#define HFS_FOLDERCOUNT 0x10000+/* When set, the file system exists on a virtual device, like disk image */+#define HFS_VIRTUAL_DEVICE 0x20000+/* When set, we're in hfs_changefs, so hfs_sync should do nothing. */+#define HFS_IN_CHANGEFS 0x40000+/* When set, we are in process of downgrading or have downgraded to read-only,+ * so hfs_start_transaction should return EROFS.+ */+#define HFS_RDONLY_DOWNGRADE 0x80000+#define HFS_DID_CONTIG_SCAN 0x100000+#define HFS_UNMAP 0x200000+#define HFS_SSD 0x400000+#define HFS_SUMMARY_TABLE 0x800000+#define HFS_CS 0x1000000+#define HFS_CS_METADATA_PIN 0x2000000+#define HFS_CS_HOTFILE_PIN 0x4000000 /* cooperative fusion (enables a hotfile variant) */+#define HFS_FEATURE_BARRIER 0x8000000 /* device supports barrier-only flush */+#define HFS_CS_SWAPFILE_PIN 0x10000000+#define HFS_RUN_SYNCER 0x20000000++/* Macro to update next allocation block in the HFS mount structure. If+ * the HFS_SKIP_UPDATE_NEXT_ALLOCATION is set, do not update+ * nextAllocation block.+ */+#define HFS_UPDATE_NEXT_ALLOCATION(hfsmp, new_nextAllocation) \+ { \+ if ((hfsmp->hfs_flags & HFS_SKIP_UPDATE_NEXT_ALLOCATION) == 0)\+ hfsmp->nextAllocation = new_nextAllocation; \+ } \++/* Macro for incrementing and decrementing the folder count in a cnode+ * attribute only if the HFS_FOLDERCOUNT bit is set in the mount flags+ * and kHFSHasFolderCount bit is set in the cnode flags. Currently these+ * bits are only set for case sensitive HFS+ volumes.+ */+#define INC_FOLDERCOUNT(hfsmp, cattr) \+ if ((hfsmp->hfs_flags & HFS_FOLDERCOUNT) && \+ (cattr.ca_recflags & kHFSHasFolderCountMask)) { \+ cattr.ca_dircount++; \+ } \++#define DEC_FOLDERCOUNT(hfsmp, cattr) \+ if ((hfsmp->hfs_flags & HFS_FOLDERCOUNT) && \+ (cattr.ca_recflags & kHFSHasFolderCountMask) && \+ (cattr.ca_dircount > 0)) { \+ cattr.ca_dircount--; \+ } \++typedef struct filefork FCB;++/*+ * Macros for creating item names for our special/private directories.+ */+#define MAKE_INODE_NAME(name, size, linkno) \+ (void) snprintf((name), size, "%s%d", HFS_INODE_PREFIX, (linkno))+#define HFS_INODE_PREFIX_LEN 5++#define MAKE_DIRINODE_NAME(name, size, linkno) \+ (void) snprintf((name), size, "%s%d", HFS_DIRINODE_PREFIX, (linkno))+#define HFS_DIRINODE_PREFIX_LEN 4++#define MAKE_DELETED_NAME(NAME, size, FID) \+ (void) snprintf((NAME), size, "%s%d", HFS_DELETE_PREFIX, (FID))+#define HFS_DELETE_PREFIX_LEN 4+++#define HFS_AVERAGE_NAME_SIZE 22+#define AVERAGE_HFSDIRENTRY_SIZE (8+HFS_AVERAGE_NAME_SIZE+4)++#define STD_DIRENT_LEN(namlen) \+ ((sizeof(struct dirent) - (NAME_MAX+1)) + (((namlen)+1 + 3) &~ 3))++#define EXT_DIRENT_LEN(namlen) \+ ((sizeof(struct direntry) + (namlen) - (MAXPATHLEN-1) + 7) & ~7)+++enum { kHFSPlusMaxFileNameBytes = kHFSPlusMaxFileNameChars * 3 };+++/* macro to determine if hfs or hfsplus */+#define ISHFSPLUS(VCB) ((VCB)->vcbSigWord == kHFSPlusSigWord)+#define ISHFS(VCB) ((VCB)->vcbSigWord == kHFSSigWord)+++/*+ * Various ways to acquire a VFS mount point pointer:+ */+#define VTOVFS(VP) vnode_mount((VP))+#define HFSTOVFS(HFSMP) ((HFSMP)->hfs_mp)+#define VCBTOVFS(VCB) HFSTOVFS(VCB)++/*+ * Various ways to acquire an HFS mount point pointer:+ */+#define VTOHFS(VP) ((struct hfsmount *)vfs_fsprivate(vnode_mount((VP))))+#define VFSTOHFS(MP) ((struct hfsmount *)vfs_fsprivate((MP)))+#define VCBTOHFS(VCB) (VCB)+#define FCBTOHFS(FCB) ((struct hfsmount *)vfs_fsprivate(vnode_mount((FCB)->ff_cp->c_vp)))++/*+ * Various ways to acquire a VCB (legacy) pointer:+ */+#define VTOVCB(VP) VTOHFS(VP)+#define VFSTOVCB(MP) VFSTOHFS(MP)+#define HFSTOVCB(HFSMP) (HFSMP)+#define FCBTOVCB(FCB) FCBTOHFS(FCB)+++#define E_NONE 0+#define kHFSBlockSize 512++/*+ * Macros for getting the MDB/VH sector and offset+ */+#define HFS_PRI_SECTOR(blksize) (1024 / (blksize))+#define HFS_PRI_OFFSET(blksize) ((blksize) > 1024 ? 1024 : 0)++#define HFS_ALT_SECTOR(blksize, blkcnt) (((blkcnt) - 1) - (512 / (blksize)))+#define HFS_ALT_OFFSET(blksize) ((blksize) > 1024 ? (blksize) - 1024 : 0)++/* Convert the logical sector number to be aligned on physical block size boundary.+ * We are assuming the partition is a multiple of physical block size.+ */+#define HFS_PHYSBLK_ROUNDDOWN(sector_num, log_per_phys) ((sector_num / log_per_phys) * log_per_phys)++/*+ * HFS specific fcntl()'s+ */+#define HFS_GET_BOOT_INFO (FCNTL_FS_SPECIFIC_BASE + 0x00004)+#define HFS_SET_BOOT_INFO (FCNTL_FS_SPECIFIC_BASE + 0x00005)+/* See HFSIOC_EXT_BULKACCESS and friends for HFS specific fsctls*/++++/*+ * This is the straight GMT conversion constant:+ * 00:00:00 January 1, 1970 - 00:00:00 January 1, 1904+ * (3600 * 24 * ((365 * (1970 - 1904)) + (((1970 - 1904) / 4) + 1)))+ */+#define MAC_GMT_FACTOR 2082844800UL++static inline __attribute__((const))+off_t hfs_blk_to_bytes(uint32_t blk, uint32_t blk_size)+{+ return (off_t)blk * blk_size; // Avoid the overflow+}++/*+ * For now, we use EIO to indicate consistency issues. It is safe to+ * return or assign an error value to HFS_EINCONSISTENT but it is+ * *not* safe to compare against it because EIO can be generated for+ * other reasons. We take advantage of the fact that == has+ * left-to-right associativity and so any uses of:+ *+ * if (error == HFS_EINCONSISTENT)+ *+ * will produce a compiler warning: "comparison between pointer and+ * integer".+ *+ * Note that not everwhere is consistent with the use of+ * HFS_EINCONSISTENT. Some places return EINVAL, EIO directly or+ * other error codes.+ */+#define HFS_EINCONSISTENT (void *)0 == (void *)0 ? EIO : EIO++#define HFS_ERESERVEDNAME -8++extern int (**hfs_specop_p)(void *);++/*****************************************************************************+ FUNCTION PROTOTYPES+******************************************************************************/++/*****************************************************************************+ hfs_vnop_xxx functions from different files+******************************************************************************/+int hfs_vnop_readdirattr(struct vnop_readdirattr_args *); /* in hfs_attrlist.c */+int hfs_vnop_getattrlistbulk(struct vnop_getattrlistbulk_args *); /* in hfs_attrlist.c */++int hfs_vnop_inactive(struct vnop_inactive_args *); /* in hfs_cnode.c */+int hfs_vnop_reclaim(struct vnop_reclaim_args *); /* in hfs_cnode.c */++int hfs_set_backingstore (struct vnode *vp, int val); /* in hfs_cnode.c */+int hfs_is_backingstore (struct vnode *vp, int *val); /* in hfs_cnode.c */++int hfs_vnop_link(struct vnop_link_args *); /* in hfs_link.c */++int hfs_vnop_lookup(struct vnop_lookup_args *); /* in hfs_lookup.c */++int hfs_vnop_search(struct vnop_searchfs_args *); /* in hfs_search.c */++int hfs_vnop_read(struct vnop_read_args *); /* in hfs_readwrite.c */+int hfs_vnop_write(struct vnop_write_args *); /* in hfs_readwrite.c */+int hfs_vnop_ioctl(struct vnop_ioctl_args *); /* in hfs_readwrite.c */+int hfs_vnop_select(struct vnop_select_args *); /* in hfs_readwrite.c */+int hfs_vnop_strategy(struct vnop_strategy_args *); /* in hfs_readwrite.c */+int hfs_vnop_allocate(struct vnop_allocate_args *); /* in hfs_readwrite.c */+int hfs_vnop_pagein(struct vnop_pagein_args *); /* in hfs_readwrite.c */+int hfs_vnop_pageout(struct vnop_pageout_args *); /* in hfs_readwrite.c */+int hfs_vnop_bwrite(struct vnop_bwrite_args *); /* in hfs_readwrite.c */+int hfs_vnop_blktooff(struct vnop_blktooff_args *); /* in hfs_readwrite.c */+int hfs_vnop_offtoblk(struct vnop_offtoblk_args *); /* in hfs_readwrite.c */+int hfs_vnop_blockmap(struct vnop_blockmap_args *); /* in hfs_readwrite.c */+errno_t hfs_flush_invalid_ranges(vnode_t vp); /* in hfs_readwrite.c */++int hfs_vnop_getxattr(struct vnop_getxattr_args *); /* in hfs_xattr.c */+int hfs_vnop_setxattr(struct vnop_setxattr_args *); /* in hfs_xattr.c */+int hfs_vnop_removexattr(struct vnop_removexattr_args *); /* in hfs_xattr.c */+int hfs_vnop_listxattr(struct vnop_listxattr_args *); /* in hfs_xattr.c */+#if NAMEDSTREAMS+extern int hfs_vnop_getnamedstream(struct vnop_getnamedstream_args*);+extern int hfs_vnop_makenamedstream(struct vnop_makenamedstream_args*);+extern int hfs_vnop_removenamedstream(struct vnop_removenamedstream_args*);+#endif+++/*****************************************************************************+ Functions from MacOSStubs.c+******************************************************************************/+time_t to_bsd_time(u_int32_t hfs_time);++u_int32_t to_hfs_time(time_t bsd_time);+++/*****************************************************************************+ Functions from hfs_notifications.c+******************************************************************************/+void hfs_generate_volume_notifications(struct hfsmount *hfsmp);+++/*****************************************************************************+ Functions from hfs_readwrite.c+******************************************************************************/+extern int hfs_relocate(struct vnode *, u_int32_t, kauth_cred_t, struct proc *);++/* flags for hfs_pin_block_range() and hfs_pin_vnode() */+#define HFS_PIN_IT 0x0001+#define HFS_UNPIN_IT 0x0002+#define HFS_TEMP_PIN 0x0004+#define HFS_EVICT_PIN 0x0008+#define HFS_DATALESS_PIN 0x0010++//+// pin/un-pin an explicit range of blocks to the "fast" (usually ssd) device+//+int hfs_pin_block_range(struct hfsmount *hfsmp, int pin_state, uint32_t start_block, uint32_t nblocks);++//+// pin/un-pin all the extents belonging to a vnode.+// also, if it is non-null, "num_blocks_pinned" returns the number of blocks pin/unpinned by the function+//+int hfs_pin_vnode(struct hfsmount *hfsmp, struct vnode *vp, int pin_state, uint32_t *num_blocks_pinned);+++int hfs_pin_overflow_extents (struct hfsmount *hfsmp, uint32_t fileid, uint8_t forktype, uint32_t *pinned);+++/* Flags for HFS truncate */+#define HFS_TRUNCATE_SKIPTIMES 0x00000002 /* implied by skipupdate; it is a subset */+++extern int hfs_truncate(struct vnode *, off_t, int, int, vfs_context_t);++extern int hfs_release_storage (struct hfsmount *hfsmp, struct filefork *datafork,+ struct filefork *rsrcfork, u_int32_t fileid);++extern int hfs_prepare_release_storage (struct hfsmount *hfsmp, struct vnode *vp);++extern int hfs_bmap(struct vnode *, daddr_t, struct vnode **, daddr64_t *, unsigned int *);++extern errno_t hfs_ubc_setsize(vnode_t vp, off_t len, bool have_cnode_lock);+++/*****************************************************************************+ Functions from hfs_resize.c+******************************************************************************/+int hfs_extendfs(struct hfsmount *hfsmp, u_int64_t newsize, vfs_context_t context);+int hfs_truncatefs(struct hfsmount *hfsmp, u_int64_t newsize, vfs_context_t context);+++/*****************************************************************************+ Functions from hfs_vfsops.c+******************************************************************************/++extern void hfs_getvoluuid(struct hfsmount *hfsmp, uuid_t result);++/* used as a callback by the journaling code */+extern void hfs_sync_metadata(void *arg);++extern int hfs_vget(struct hfsmount *, cnid_t, struct vnode **, int, int);++extern void hfs_setencodingbits(struct hfsmount *hfsmp, u_int32_t encoding);++enum volop {VOL_UPDATE, VOL_MKDIR, VOL_RMDIR, VOL_MKFILE, VOL_RMFILE};+extern int hfs_volupdate(struct hfsmount *hfsmp, enum volop op, int inroot);++enum {+ HFS_FVH_WAIT = 0x0001,+ HFS_FVH_WRITE_ALT = 0x0002,+ HFS_FVH_FLUSH_IF_DIRTY = 0x0004,+};+typedef uint32_t hfs_flush_volume_header_options_t;+int hfs_flushvolumeheader(struct hfsmount *hfsmp, hfs_flush_volume_header_options_t);++extern int hfs_extendfs(struct hfsmount *, u_int64_t, vfs_context_t);+extern int hfs_truncatefs(struct hfsmount *, u_int64_t, vfs_context_t);+extern int hfs_resize_progress(struct hfsmount *, u_int32_t *);++/* If a runtime corruption is detected, mark the volume inconsistent+ * bit in the volume attributes.+ */++typedef enum {+ HFS_INCONSISTENCY_DETECTED,++ // Used when unable to rollback an operation that failed+ HFS_ROLLBACK_FAILED,++ // Used when the latter part of an operation failed, but we chose not to roll back+ HFS_OP_INCOMPLETE,++ // Used when someone told us to force an fsck on next mount+ HFS_FSCK_FORCED,+} hfs_inconsistency_reason_t;++void hfs_mark_inconsistent(struct hfsmount *hfsmp,+ hfs_inconsistency_reason_t reason);++void hfs_scan_blocks (struct hfsmount *hfsmp);+int hfs_vfs_root(struct mount *mp, struct vnode **vpp, vfs_context_t context);++/*****************************************************************************+ Functions from hfs_vfsutils.c+******************************************************************************/+u_int32_t BestBlockSizeFit(u_int32_t allocationBlockSize,+ u_int32_t blockSizeLimit,+ u_int32_t baseMultiple);++OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,+ off_t embeddedOffset, u_int64_t disksize, struct proc *p, void *args, kauth_cred_t cred);++OSErr hfs_ValidateHFSPlusVolumeHeader(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp);++extern int hfsUnmount(struct hfsmount *hfsmp, struct proc *p);++extern bool overflow_extents(struct filefork *fp);++extern int hfs_owner_rights(struct hfsmount *hfsmp, uid_t cnode_uid, kauth_cred_t cred,+ struct proc *p, int invokesuperuserstatus);++extern int check_for_dataless_file(struct vnode *vp, uint64_t op_type);+extern int hfs_generate_document_id(struct hfsmount *hfsmp, uint32_t *docid);+extern void hfs_pin_fs_metadata(struct hfsmount *hfsmp);++/* Return information about number of metadata blocks for volume */+extern int hfs_getinfo_metadata_blocks(struct hfsmount *hfsmp, struct hfsinfo_metadata *hinfo);++/*+ * Journal lock function prototypes+ */+int hfs_lock_global (struct hfsmount *hfsmp, enum hfs_locktype locktype);+void hfs_unlock_global (struct hfsmount *hfsmp);++/* HFS mount lock/unlock prototypes */+void hfs_lock_mount (struct hfsmount *hfsmp);+void hfs_unlock_mount (struct hfsmount *hfsmp);+++/* HFS System file locking */+#define SFL_CATALOG 0x0001+#define SFL_EXTENTS 0x0002+#define SFL_BITMAP 0x0004+#define SFL_ATTRIBUTE 0x0008+#define SFL_STARTUP 0x0010+#define SFL_VM_PRIV 0x0020+#define SFL_VALIDMASK (SFL_CATALOG | SFL_EXTENTS | SFL_BITMAP | SFL_ATTRIBUTE | SFL_STARTUP | SFL_VM_PRIV)++extern u_int32_t GetFileInfo(ExtendedVCB *vcb, u_int32_t dirid, const char *name,+ struct cat_attr *fattr, struct cat_fork *forkinfo);++extern void hfs_remove_orphans(struct hfsmount *);++u_int32_t GetLogicalBlockSize(struct vnode *vp);++extern u_int32_t hfs_free_cnids(struct hfsmount * hfsmp);+extern u_int32_t hfs_freeblks(struct hfsmount * hfsmp, int wantreserve);++short MacToVFSError(OSErr err);++void hfs_metadatazone_init(struct hfsmount *hfsmp, int disable);++/* HFS directory hint functions. */+extern directoryhint_t * hfs_getdirhint(struct cnode *, int, int);+extern void hfs_reldirhint(struct cnode *, directoryhint_t *);+extern void hfs_reldirhints(struct cnode *, int);+extern void hfs_insertdirhint(struct cnode *, directoryhint_t *);++extern int hfs_namecmp(const u_int8_t *str1, size_t len1, const u_int8_t *str2, size_t len2);++extern int hfs_early_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,+ void *_args, off_t embeddedOffset, daddr64_t mdb_offset,+ HFSMasterDirectoryBlock *mdbp, kauth_cred_t cred);++extern int hfs_virtualmetafile(struct cnode *);++extern int hfs_start_transaction(struct hfsmount *hfsmp);+extern int hfs_end_transaction(struct hfsmount *hfsmp);+extern void hfs_journal_lock(struct hfsmount *hfsmp);+extern void hfs_journal_unlock(struct hfsmount *hfsmp);+extern void hfs_syncer_lock(struct hfsmount *hfsmp);+extern void hfs_syncer_unlock(struct hfsmount *hfsmp);+extern void hfs_syncer_wait(struct hfsmount *hfsmp, struct timespec *ts);+extern void hfs_syncer_wakeup(struct hfsmount *hfsmp);+extern void hfs_syncer(void *arg, wait_result_t);+extern void hfs_sync_ejectable(struct hfsmount *hfsmp);++typedef enum hfs_flush_mode {+ HFS_FLUSH_JOURNAL, // Flush journal+ HFS_FLUSH_JOURNAL_META, // Flush journal and metadata blocks+ HFS_FLUSH_FULL, // Flush journal and does a cache flush+ HFS_FLUSH_CACHE, // Flush track cache to media+ HFS_FLUSH_BARRIER, // Barrier-only flush to ensure write order+ HFS_FLUSH_JOURNAL_BARRIER // Flush journal with barrier+} hfs_flush_mode_t;++extern errno_t hfs_flush(struct hfsmount *hfsmp, hfs_flush_mode_t mode);++extern void hfs_trim_callback(void *arg, uint32_t extent_count, const dk_extent_t *extents);++/* Erase unused Catalog nodes due to <rdar://problem/6947811>. */+extern int hfs_erase_unused_nodes(struct hfsmount *hfsmp);++extern uint64_t hfs_usecs_to_deadline(uint64_t usecs);++extern int hfs_freeze(struct hfsmount *hfsmp);+extern int hfs_thaw(struct hfsmount *hfsmp, const struct proc *process);++void hfs_close_jvp(hfsmount_t *hfsmp);++// Return a heap address suitable for logging or tracing+uintptr_t obfuscate_addr(void *addr);++typedef enum {+ HFS_CNODE_ZONE,+ HFS_FILEFORK_ZONE,+ HFS_DIRHINT_ZONE,+ HFS_NUM_ZONES+} hfs_zone_kind_t;++typedef struct hfs_zone_entry {+ hfs_zone_kind_t hze_kind;+ size_t hze_elem_size;+ const char * hze_name;+} hfs_zone_entry_t;++typedef struct hfs_zone {+ zone_t hz_zone;+ size_t hz_elem_size;+} hfs_zone_t;++void hfs_init_zones(void);+void *hfs_zalloc(hfs_zone_kind_t type);+void hfs_zfree(void *ptr, hfs_zone_kind_t type);++void hfs_sysctl_register(void);+void hfs_sysctl_unregister(void);++/*****************************************************************************+ Typed allocator wrappers+******************************************************************************/++#if KERNEL++extern uint64_t hfs_allocated;++#define _io_ptr_load_and_erase(elem) \+({ \+ _Static_assert(sizeof(elem) == sizeof(void *), \+ "elem isn't pointer sized"); \+ __auto_type __eptr = &(elem); \+ __auto_type __elem = *__eptr; \+ *__eptr = (__typeof__(__elem))NULL; \+ __elem; \+})++#define _io_malloc_type(type) \+({ \+ void *__ptr = NULL; \+ __ptr = IOMallocType(type); \+ if (__ptr) { \+ size_t __size = sizeof(type); \+ OSAddAtomic64(__size, &hfs_allocated); \+ } \+ (type *)__ptr; \+})++#define _io_free_type(ptr, type) \+({ \+ __auto_type __ptr = _io_ptr_load_and_erase(ptr); \+ if (__ptr) { \+ size_t __size = sizeof(type); \+ IOFreeType(__ptr, type); \+ OSAddAtomic64(-(int64_t)__size, &hfs_allocated);\+ } \+})++#define _io_malloc(helper, size) \+({ \+ void *__ptr = NULL; \+ __auto_type __size = size; \+ __ptr = helper(__size); \+ if (__ptr) { \+ OSAddAtomic64(__size, &hfs_allocated); \+ } \+ __ptr; \+})++#define _io_free(helper, ptr, size) \+({ \+ __auto_type __ptr = _io_ptr_load_and_erase(ptr); \+ __auto_type __size = size; \+ if (__ptr) { \+ helper(__ptr, __size); \+ OSAddAtomic64(-(int64_t)__size, &hfs_allocated);\+ } \+})++#define _io_new(helper, type, count) \+({ \+ void *__ptr = NULL; \+ __auto_type __count = count; \+ __ptr = helper(type, __count); \+ if (__ptr) { \+ size_t __size = sizeof(type) * __count; \+ OSAddAtomic64(__size, &hfs_allocated); \+ } \+ __ptr; \+})++#define _io_delete(helper, ptr, type, count) \+({ \+ __auto_type __ptr = _io_ptr_load_and_erase(ptr); \+ __auto_type __hfs_count = count; \+ if (__ptr) { \+ size_t __total_size = sizeof(type) * __hfs_count;\+ helper(__ptr, type, __hfs_count); \+ OSAddAtomic64(-(int64_t)__total_size, &hfs_allocated);\+ } \+})++#define _io_new_with_hdr(helper, hdr_type, type, count) \+({ \+ void *__ptr = NULL; \+ __auto_type __count = count; \+ __ptr = helper(hdr_type, type, __count); \+ if (__ptr) { \+ size_t __size = sizeof(hdr_type) + (sizeof(type) * __count); \+ OSAddAtomic64(__size, &hfs_allocated); \+ } \+ __ptr; \+})++#define _io_delete_with_hdr(helper, ptr, hdr_type, type, count) \+({ \+ __auto_type __ptr = _io_ptr_load_and_erase(ptr); \+ __auto_type __hfs_count = count; \+ if (__ptr) { \+ size_t __total_size = sizeof(hdr_type) + (sizeof(type) * __hfs_count);\+ helper(__ptr, hdr_type, type, __hfs_count); \+ OSAddAtomic64(-(int64_t)__total_size, &hfs_allocated);\+ } \+})++// Wrappers to allocate uninitialized and zero initialized memory.+// The '_zero' wrappers additionally zeros out the allocated memory.++// Wrapper to allocate a single object of a given type, it should be used for+// fixed size allocation. Please NOTE: IOMallocType() returns allocated fixed+// length allocation that is automatically zeroed.+#define hfs_malloc_type(type) _io_malloc_type(type)++// Wrapper to allocate a memory region which contains pointers or kernel+// addresses.+#define hfs_malloc(size) _io_malloc(IOMalloc, size)+#define hfs_malloc_zero(size) _io_malloc(IOMallocZero, size)++// Wrapper to allocate data only memory region which doesn't contain any+// pointers or kernel addresses.+#define hfs_malloc_data(size) _io_malloc(IOMallocData, size)+#define hfs_malloc_zero_data(size) _io_malloc(IOMallocZeroData, size)++// Wrapper to allocate an array which contains pointers or kernel addresses.+#define hfs_new(type, count) _io_new(IONew, type, count)+#define hfs_new_zero(type, count) _io_new(IONewZero, type, count)+#define hfs_new_with_hdr(hdr_type, type, count) _io_new_with_hdr(IONew, hdr_type, type, count)+#define hfs_new_zero_with_hdr(hdr_type, type, count) _io_new_with_hdr(IONewZero, hdr_type, type, count)++// Wrapper to allocate an array of a certain number of data-only types that+// does not contain any pointers or kernel addresses.+#define hfs_new_data(type, count) _io_new(IONewData, type, count)+#define hfs_new_zero_data(type, count) _io_new(IONewZeroData, type, count)+++// Wrappers to release allocated memory.++// Wrapper to release a single object of a given type which was allocated by+// hfs_malloc_type().+#define hfs_free_type(ptr, type) _io_free_type(ptr, type)++// Wrapper to release a memory region which contains pointers or kernel+// addresses.+#define hfs_free(ptr, size) _io_free(IOFree, ptr, size)++// Wrapper to release a memory region which doesn't contain any pointers or+// kernel addresses.+#define hfs_free_data(ptr, size) _io_free(IOFreeData, ptr, size)++// Wrapper to release an array which contains pointers or kernel addresses.+#define hfs_delete(ptr, type, count) _io_delete(IODelete, ptr, type, count)+#define hfs_delete_with_hdr(ptr, hdr_type, type, count) _io_delete_with_hdr(IODelete, ptr, hdr_type, type, count)++// Wrapper to release an array of a certain number of data-only types that does+// not contain any pointers or kernel addresses.+#define hfs_delete_data(ptr, type, count) _io_delete(IODeleteData, ptr, type, count)++#endif /* KERNEL */++/*****************************************************************************+ Functions from hfs_vnops.c+******************************************************************************/+int hfs_write_access(struct vnode *vp, kauth_cred_t cred, struct proc *p, Boolean considerFlags);++int hfs_chmod(struct vnode *vp, int mode, kauth_cred_t cred, struct proc *p);++int hfs_chown(struct vnode *vp, uid_t uid, gid_t gid, kauth_cred_t cred, struct proc *p);++int hfs_vnop_create(struct vnop_create_args *ap);++int hfs_vnop_remove(struct vnop_remove_args*);++#define kMaxSecsForFsync 5+#define HFS_SYNCTRANS 1+extern int hfs_btsync(struct vnode *vp, int sync_transaction);++extern void replace_desc(struct cnode *cp, struct cat_desc *cdp);++extern int hfs_vgetrsrc(struct hfsmount *hfsmp, struct vnode *vp,+ struct vnode **rvpp);++typedef enum {+ // Push all modifications to disk (including minor ones)+ HFS_UPDATE_FORCE = 0x01,+} hfs_update_options_t;++extern int hfs_update(struct vnode *, int options);++typedef enum hfs_sync_mode {+ HFS_FSYNC,+ HFS_FSYNC_FULL,+ HFS_FSYNC_BARRIER+} hfs_fsync_mode_t;++extern int hfs_fsync(struct vnode *, int, hfs_fsync_mode_t, struct proc *);++const struct cat_fork *+hfs_prepare_fork_for_update(filefork_t *ff,+ const struct cat_fork *cf,+ struct cat_fork *cf_buf,+ uint32_t block_size);++struct decmpfs_cnode;+struct decmpfs_cnode *hfs_lazy_init_decmpfs_cnode (struct cnode *cp);++/*****************************************************************************+ Functions from hfs_xattr.c+******************************************************************************/++/*+ * Maximum extended attribute size supported for all extended attributes except+ * resource fork and finder info.+ */+#define HFS_XATTR_MAXSIZE INT32_MAX++/* Number of bits used to represent maximum extended attribute size */+#define HFS_XATTR_SIZE_BITS 31++int hfs_attrkeycompare(HFSPlusAttrKey *searchKey, HFSPlusAttrKey *trialKey);+int hfs_buildattrkey(u_int32_t fileID, const char *attrname, HFSPlusAttrKey *key);+void hfs_xattr_init(struct hfsmount * hfsmp);+int file_attribute_exist(struct hfsmount *hfsmp, uint32_t fileID);+int init_attrdata_vnode(struct hfsmount *hfsmp);+int hfs_xattr_read(vnode_t vp, const char *name, void *data, size_t *size);+int hfs_getxattr_internal(cnode_t *, struct vnop_getxattr_args *,+ struct hfsmount *, u_int32_t);+int hfs_xattr_write(vnode_t vp, const char *name, const void *data, size_t size);+int hfs_setxattr_internal(struct cnode *, const void *, size_t,+ struct vnop_setxattr_args *, struct hfsmount *, u_int32_t);+extern int hfs_removeallattr(struct hfsmount *hfsmp, u_int32_t fileid,+ bool *open_transaction);++int hfs_removexattr_by_id (struct hfsmount *hfsmp, uint32_t fileid, const char *xattr_name );++extern int hfs_set_volxattr(struct hfsmount *hfsmp, unsigned int xattrtype, int state);++++/*****************************************************************************+ Functions from hfs_link.c+******************************************************************************/++extern int hfs_unlink(struct hfsmount *hfsmp, struct vnode *dvp, struct vnode *vp,+ struct componentname *cnp, int skip_reserve);+extern int hfs_lookup_siblinglinks(struct hfsmount *hfsmp, cnid_t linkfileid,+ cnid_t *prevlinkid, cnid_t *nextlinkid);+extern int hfs_lookup_lastlink(struct hfsmount *hfsmp, cnid_t linkfileid,+ cnid_t *nextlinkid, struct cat_desc *cdesc);+extern void hfs_privatedir_init(struct hfsmount *, enum privdirtype);++extern void hfs_savelinkorigin(cnode_t *cp, cnid_t parentcnid);+extern void hfs_relorigins(struct cnode *cp);+extern void hfs_relorigin(struct cnode *cp, cnid_t parentcnid);+extern int hfs_haslinkorigin(cnode_t *cp);+extern cnid_t hfs_currentparent(cnode_t *cp, bool have_lock);+extern cnid_t hfs_currentcnid(cnode_t *cp);+errno_t hfs_first_link(hfsmount_t *hfsmp, cnode_t *cp, cnid_t *link_id);+++/*****************************************************************************+ Functions from VolumeAllocation.c+ ******************************************************************************/+extern int hfs_isallocated(struct hfsmount *hfsmp, u_int32_t startingBlock, u_int32_t numBlocks);++extern int hfs_count_allocated(struct hfsmount *hfsmp, u_int32_t startBlock,+ u_int32_t numBlocks, u_int32_t *alloc_count);++extern int hfs_isrbtree_active (struct hfsmount *hfsmp);++/*****************************************************************************+ Functions from hfs_fsinfo.c+ ******************************************************************************/+extern errno_t hfs_get_fsinfo(struct hfsmount *hfsmp, void *a_data);+extern void hfs_fsinfo_data_add(struct hfs_fsinfo_data *fsinfo, uint64_t entry);++#if NEW_XATTR+bool hfs_xattr_fext_find(xattr_io_info_t *info, uint32_t fs_bsize,+ uint64_t off, HFSPlusExtentDescriptor *out, uint64_t *off_out);+#endif++struct hfs_sysctl_chain {+ struct sysctl_oid *oid;+ struct hfs_sysctl_chain *next;+};++extern struct hfs_sysctl_chain *sysctl_list;++SYSCTL_DECL(_vfs_generic_hfs);++#define HFS_SYSCTL(kind, parent, flags, name, ...) \+ SYSCTL_##kind(parent, flags, name, __VA_ARGS__); \+ struct hfs_sysctl_chain hfs_sysctl_##parent##_##name##_chain = { \+ .oid = &sysctl_##parent##_##name \+ }; \+ static __attribute__((__constructor__)) void \+ hfs_sysctl_register_##parent##_##name(void) { \+ hfs_sysctl_##parent##_##name##_chain.next = sysctl_list; \+ sysctl_list = &hfs_sysctl_##parent##_##name##_chain; \+ }++__END_DECLS++#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */+#endif /* __HFS__ */diff --git a/xnu/files/bsd/hfs/hfs_alloc_trace.h b/xnu/files/bsd/hfs/hfs_alloc_trace.hnew file mode 100644index 0000000..304a194--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_alloc_trace.h@@ -0,0 +1,34 @@+//+// hfs_alloc_trace.h+// hfs+//+// Created by Chris Suter on 8/19/15.+//+//++#ifndef hfs_alloc_trace_h+#define hfs_alloc_trace_h++#include <sys/types.h>+#include <stdbool.h>++enum {+ HFS_ALLOC_BACKTRACE_LEN = 4,+};++#pragma pack(push, 8)++struct hfs_alloc_trace_info {+ int entry_count;+ bool more;+ struct hfs_alloc_info_entry {+ uint64_t ptr;+ uint64_t sequence;+ uint64_t size;+ uint64_t backtrace[HFS_ALLOC_BACKTRACE_LEN];+ } entries[];+};++#pragma pack(pop)++#endif /* hfs_alloc_trace_h */diff --git a/xnu/files/bsd/hfs/hfs_attrlist.c b/xnu/files/bsd/hfs/hfs_attrlist.cnew file mode 100644index 0000000..e92e370--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_attrlist.c@@ -0,0 +1,1743 @@+/*+ * Copyright (c) 2000-2015 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@+ */++/*+ * hfs_attrlist.c - HFS attribute list processing+ *+ * Copyright (c) 1998-2002, Apple Inc. All Rights Reserved.+ */++#include <sys/param.h>+#include <sys/systm.h>+#include <sys/kernel.h>+#include <sys/malloc.h>+#include <sys/attr.h>+#include <sys/stat.h>+#include <sys/unistd.h>+#include <sys/vm.h>+#include <sys/kauth.h>+#include <sys/fsctl.h>++#include <kern/locks.h>++#include "hfs.h"+#include "hfs_cnode.h"+#include "hfs_mount.h"+#include "hfs_dbg.h"+#include "hfs_attrlist.h"+#include "hfs_btreeio.h"+#include "hfs_cprotect.h"++/* Packing routines: */++static void packnameattr(struct attrblock *abp, struct vnode *vp,+ const u_int8_t *name, int namelen);++static void packcommonattr(struct attrblock *abp, struct hfsmount *hfsmp,+ struct vnode *vp, struct cat_desc * cdp,+ struct cat_attr * cap, struct vfs_context *ctx);++static void packfileattr(struct attrblock *abp, struct hfsmount *hfsmp,+ struct cat_attr *cattrp, struct cat_fork *datafork,+ struct cat_fork *rsrcfork, struct vnode *vp);++static void packdirattr(struct attrblock *abp, struct hfsmount *hfsmp,+ struct vnode *vp, struct cat_desc * descp,+ struct cat_attr * cattrp);++static u_int32_t hfs_real_user_access(vnode_t vp, vfs_context_t ctx);++static void get_vattr_data_for_attrs(struct attrlist *, struct vnode_attr *,+ struct hfsmount *, struct vnode *, struct cat_desc *, struct cat_attr *,+ struct cat_fork *, struct cat_fork *, vfs_context_t);++static void vattr_data_for_common_attrs(struct attrlist *, struct vnode_attr *,+ struct hfsmount *, struct vnode *, struct cat_desc *, struct cat_attr *,+ vfs_context_t);++static void vattr_data_for_dir_attrs(struct attrlist *, struct vnode_attr *,+ struct hfsmount *, struct vnode *, struct cat_desc *, struct cat_attr *);++static void vattr_data_for_file_attrs(struct attrlist *, struct vnode_attr *,+ struct hfsmount *, struct cat_attr *, struct cat_fork *, struct cat_fork *,+ struct vnode *vp);++static int hfs_readdirattr_internal(struct vnode *, struct attrlist *,+ struct vnode_attr *, uio_t, uint64_t, int, uint32_t *, int *, int *,+ vfs_context_t);++/*+ * readdirattr operation will return attributes for the items in the+ * directory specified.+ *+ * It does not do . and .. entries. The problem is if you are at the root of the+ * hfs directory and go to .. you could be crossing a mountpoint into a+ * different (ufs) file system. The attributes that apply for it may not+ * apply for the file system you are doing the readdirattr on. To make life+ * simpler, this call will only return entries in its directory, hfs like.+ */+int+hfs_vnop_readdirattr(ap)+ struct vnop_readdirattr_args /* {+ struct vnode *a_vp;+ struct attrlist *a_alist;+ struct uio *a_uio;+ u_long a_maxcount;+ u_long a_options;+ u_long *a_newstate;+ int *a_eofflag;+ u_long *a_actualcount;+ vfs_context_t a_context;+ } */ *ap;+{+ int error;+ struct attrlist *alist = ap->a_alist;++ /* Check for invalid options and buffer space. */+ if (((ap->a_options & ~(FSOPT_NOINMEMUPDATE | FSOPT_NOFOLLOW)) != 0) ||+ (ap->a_maxcount <= 0)) {+ return (EINVAL);+ }+ /*+ * Reject requests for unsupported attributes.+ */+ if ((alist->bitmapcount != ATTR_BIT_MAP_COUNT) ||+ (alist->commonattr & ~HFS_ATTR_CMN_VALID) ||+ (alist->volattr != 0) ||+ (alist->dirattr & ~HFS_ATTR_DIR_VALID) ||+ (alist->fileattr & ~HFS_ATTR_FILE_VALID) ||+ (alist->forkattr != 0)) {+ return (EINVAL);+ }++ error = hfs_readdirattr_internal(ap->a_vp, alist, NULL, ap->a_uio,+ (uint64_t)ap->a_options, ap->a_maxcount, ap->a_newstate,+ ap->a_eofflag, (int *)ap->a_actualcount, ap->a_context);++ return (error);+}+++/*+ * getattrlistbulk, like readdirattr, will return attributes for the items in+ * the directory specified.+ *+ * It does not do . and .. entries. The problem is if you are at the root of the+ * hfs directory and go to .. you could be crossing a mountpoint into a+ * different (ufs) file system. The attributes that apply for it may not+ * apply for the file system you are doing the readdirattr on. To make life+ * simpler, this call will only return entries in its directory, hfs like.+ */+int+hfs_vnop_getattrlistbulk(ap)+ struct vnop_getattrlistbulk_args /* {+ struct vnodeop_desc *a_desc;+ vnode_t a_vp;+ struct attrlist *a_alist;+ struct vnode_attr *a_vap;+ struct uio *a_uio;+ void *a_private;+ uint64_t a_options;+ int32_t *a_eofflag;+ int32_t *a_actualcount;+ vfs_context_t a_context;+ } */ *ap;+{+ int error = 0;++ error = hfs_readdirattr_internal(ap->a_vp, ap->a_alist, ap->a_vap,+ ap->a_uio, (uint64_t)ap->a_options, 0, NULL, ap->a_eofflag,+ (int *)ap->a_actualcount, ap->a_context);++ return (error);+}++/*+ * Common function for both hfs_vnop_readdirattr and hfs_vnop_getattrlistbulk.+ * This either fills in a vnode_attr structure or fills in an attrbute buffer+ * Currently the difference in behaviour required for the two vnops is keyed+ * on whether the passed in vnode_attr pointer is null or not. If the pointer+ * is null we fill in buffer passed and if it is not null we fill in the fields+ * of the vnode_attr structure.+ */+int+hfs_readdirattr_internal(struct vnode *dvp, struct attrlist *alist,+ struct vnode_attr *vap, uio_t uio, uint64_t options, int maxcount,+ uint32_t *newstate, int *eofflag, int *actualcount, vfs_context_t ctx)+{+ struct cnode *dcp;+ struct hfsmount * hfsmp;+ u_int32_t fixedblocksize;+ u_int32_t maxattrblocksize = 0;+ u_int32_t currattrbufsize;+ void *attrbufptr = NULL;+ void *attrptr = NULL;+ void *varptr = NULL;+ caddr_t namebuf = NULL;+ struct attrblock attrblk;+ int error = 0;+ int index = 0;+ int i = 0;+ struct cat_desc *lastdescp = NULL;+ struct cat_entrylist *ce_list = NULL;+ directoryhint_t *dirhint = NULL;+ unsigned int tag;+ int maxentries = 0;+ int lockflags;+ u_int32_t dirchg = 0;+ int reachedeof = 0;+ int internal_actualcount;+ int internal_eofflag;++ /* Lets makse sure we have something assign to actualcount always, min change required */+ if (actualcount == NULL) {+ actualcount = &internal_actualcount;+ }+ /* Lets makse sure we have something assign to eofflag always, min change required */+ if (eofflag == NULL) {+ eofflag = &internal_eofflag;+ }++ *(actualcount) = 0;+ *(eofflag) = 0;++ if ((uio_resid(uio) <= 0) || (uio_iovcnt(uio) > 1))+ return (EINVAL);++ if (VTOC(dvp)->c_bsdflags & UF_COMPRESSED) {+ int compressed = hfs_file_is_compressed(VTOC(dvp), 0); /* 0 == take the cnode lock */++ if (!compressed) {+ error = check_for_dataless_file(dvp, NAMESPACE_HANDLER_READ_OP);+ if (error) {+ return error;+ }+ }+ }++ /*+ * Take an exclusive directory lock since we manipulate the directory hints+ */+ if ((error = hfs_lock(VTOC(dvp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ return (error);+ }+ dcp = VTOC(dvp);+ hfsmp = VTOHFS(dvp);++ dirchg = dcp->c_dirchangecnt;++ /* Extract directory index and tag (sequence number) from uio_offset */+ index = uio_offset(uio) & HFS_INDEX_MASK;+ tag = uio_offset(uio) & ~HFS_INDEX_MASK;++ /*+ * We can't just use the valence as an optimization to avoid+ * going to the catalog. It might be wrong (== 0), and that would+ * cause us to avoid iterating the directory when it might actually have+ * contents. Instead, use the catalog to tell us when we've hit EOF+ * for this directory+ */++ /* Get a buffer to hold packed attributes. */+ fixedblocksize = (sizeof(u_int32_t) + hfs_attrblksize(alist)); /* 4 bytes for length */++ if (!vap) {+ maxattrblocksize = fixedblocksize;+ if (alist->commonattr & ATTR_CMN_NAME)+ maxattrblocksize += kHFSPlusMaxFileNameBytes + 1;++ attrbufptr = hfs_malloc_data(maxattrblocksize);+ attrptr = attrbufptr;+ varptr = (char *)attrbufptr + fixedblocksize; /* Point to variable-length storage */+ } else {+ if ((alist->commonattr & ATTR_CMN_NAME) && !vap->va_name) {+ namebuf = hfs_malloc_data(MAXPATHLEN);+ if (!namebuf) {+ error = ENOMEM;+ goto exit2;+ }+ vap->va_name = namebuf;+ }+ }+ /* Get a detached directory hint (cnode must be locked exclusive) */+ dirhint = hfs_getdirhint(dcp, ((index - 1) & HFS_INDEX_MASK) | tag, TRUE);++ /* Hide tag from catalog layer. */+ dirhint->dh_index &= HFS_INDEX_MASK;+ if (dirhint->dh_index == HFS_INDEX_MASK) {+ dirhint->dh_index = -1;+ }++ /*+ * Obtain a list of catalog entries and pack their attributes until+ * the output buffer is full or maxcount entries have been packed.+ */++ /*+ * Constrain our list size.+ */+ maxentries = uio_resid(uio) / (fixedblocksize + HFS_AVERAGE_NAME_SIZE);+ /* There is maxcount for the bulk vnop */+ if (!vap)+ maxentries = min(maxentries, maxcount);+ maxentries = min(maxentries, (int)MAXCATENTRIES);+ if (maxentries < 1) {+ error = EINVAL;+ goto exit2;+ }++ /* Initialize a catalog entry list. */+ ce_list = hfs_new_zero_with_hdr(struct cat_entrylist, struct cat_entry, maxentries);+ ce_list->maxentries = maxentries;++ /*+ * Populate the ce_list from the catalog file.+ */+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);++ error = cat_getentriesattr(hfsmp, dirhint, ce_list, &reachedeof);+ /* Don't forget to release the descriptors later! */++ hfs_systemfile_unlock(hfsmp, lockflags);++ if ((error == ENOENT) || (reachedeof != 0)) {+ *(eofflag) = TRUE;+ error = 0;+ }+ if (error) {+ goto exit1;+ }++ dcp->c_touch_acctime = TRUE;++ /*+ * Check for a FS corruption in the valence. We're holding the cnode lock+ * exclusive since we need to serialize the directory hints, so if we found+ * that the valence reported 0, but we actually found some items here, then+ * silently minimally self-heal and bump the valence to 1.+ */+ if ((dcp->c_entries == 0) && (ce_list->realentries > 0)) {+ dcp->c_entries++;+ dcp->c_flag |= C_MODIFIED;+ printf("%s : repairing valence to non-zero!\n", __FUNCTION__);+ /* force an update on dcp while we're still holding the lock. */+ hfs_update(dvp, 0);+ }++ /*+ * Drop the directory lock so we don't deadlock when we:+ * - acquire a child cnode lock+ * - make calls to vnode_authorize()+ * - make calls to kauth_cred_ismember_gid()+ */+ hfs_unlock(dcp);+ dcp = NULL;++ /* Process the catalog entries. */+ for (i = 0; i < (int)ce_list->realentries; ++i) {+ struct cnode *cp = NULL;+ struct vnode *vp = NULL;+ struct cat_desc * cdescp;+ struct cat_attr * cattrp;+ struct cat_fork c_datafork;+ struct cat_fork c_rsrcfork;++ bzero(&c_datafork, sizeof(c_datafork));+ bzero(&c_rsrcfork, sizeof(c_rsrcfork));+ cdescp = &ce_list->entry[i].ce_desc;+ cattrp = &ce_list->entry[i].ce_attr;+ c_datafork.cf_size = ce_list->entry[i].ce_datasize;+ c_datafork.cf_blocks = ce_list->entry[i].ce_datablks;+ c_rsrcfork.cf_size = ce_list->entry[i].ce_rsrcsize;+ c_rsrcfork.cf_blocks = ce_list->entry[i].ce_rsrcblks;++ if (((alist->commonattr & ATTR_CMN_USERACCESS) &&+ (cattrp->ca_recflags & kHFSHasSecurityMask))+#if CONFIG_PROTECT+ ||+ ((alist->commonattr & ATTR_CMN_DATA_PROTECT_FLAGS) && (vap))+#endif+ ) {+ /*+ * Obtain vnode for our vnode_authorize() calls.+ */+ if (hfs_vget(hfsmp, cattrp->ca_fileid, &vp, 0, 0) != 0) {+ vp = NULL;+ }+ } else if (vap || !(options & FSOPT_NOINMEMUPDATE)) {+ /* Get in-memory cnode data (if any). */+ vp = hfs_chash_getvnode(hfsmp, cattrp->ca_fileid, 0, 0, 0);+ }+ if (vp != NULL) {+ cp = VTOC(vp);+ /* Only use cnode's decriptor for non-hardlinks */+ if (!(cp->c_flag & C_HARDLINK))+ cdescp = &cp->c_desc;+ cattrp = &cp->c_attr;+ if (cp->c_datafork) {+ c_datafork.cf_size = cp->c_datafork->ff_size;+ c_datafork.cf_blocks = cp->c_datafork->ff_blocks;+ }+ if (cp->c_rsrcfork) {+ c_rsrcfork.cf_size = cp->c_rsrcfork->ff_size;+ c_rsrcfork.cf_blocks = cp->c_rsrcfork->ff_blocks;+ }+ /* All done with cnode. */+ hfs_unlock(cp);+ cp = NULL;+ }++ if (!vap) {+ *((u_int32_t *)attrptr) = 0;+ attrptr = ((u_int32_t *)attrptr) + 1;+ attrblk.ab_attrlist = alist;+ attrblk.ab_attrbufpp = &attrptr;+ attrblk.ab_varbufpp = &varptr;+ attrblk.ab_flags = 0;+ attrblk.ab_blocksize = maxattrblocksize;+ attrblk.ab_context = ctx;++ /* Pack catalog entries into attribute buffer. */+ hfs_packattrblk(&attrblk, hfsmp, vp, cdescp, cattrp, &c_datafork, &c_rsrcfork, ctx);+ currattrbufsize = ((char *)varptr - (char *)attrbufptr);++ /* All done with vnode. */+ if (vp != NULL) {+ vnode_put(vp);+ vp = NULL;+ }++ /* Make sure there's enough buffer space remaining. */+ // LP64todo - fix this!+ if (uio_resid(uio) < 0 ||+ currattrbufsize > (u_int32_t)uio_resid(uio)) {+ break;+ } else {+ *((u_int32_t *)attrbufptr) = currattrbufsize;+ error = uiomove((caddr_t)attrbufptr, currattrbufsize, uio);+ if (error != E_NONE) {+ break;+ }+ attrptr = attrbufptr;+ /* Point to variable-length storage */+ varptr = (char *)attrbufptr + fixedblocksize;+ /* Save the last valid catalog entry */+ lastdescp = &ce_list->entry[i].ce_desc;+ index++;+ *actualcount += 1;++ /* Termination checks */+ if ((--maxcount <= 0) ||+ // LP64todo - fix this!+ uio_resid(uio) < 0 ||+ ((u_int32_t)uio_resid(uio) < (fixedblocksize + HFS_AVERAGE_NAME_SIZE))){+ break;+ }+ }+ } else {+ size_t orig_resid = (size_t)uio_resid(uio);+ size_t resid;++ get_vattr_data_for_attrs(alist, vap, hfsmp, vp, cdescp,+ cattrp, &c_datafork, &c_rsrcfork, ctx);++#if CONFIG_PROTECT+ if ((alist->commonattr & ATTR_CMN_DATA_PROTECT_FLAGS) &&+ vp) {+ cp_key_class_t class;++ if (!cp_vnode_getclass(vp, &class)) {+ VATTR_RETURN(vap, va_dataprotect_class,+ (uint32_t)class);+ }+ }+#endif+ error = vfs_attr_pack(vp, uio, alist, options, vap,+ NULL, ctx);++ /* All done with vnode. */+ if (vp) {+ vnode_put(vp);+ vp = NULL;+ }++ resid = uio_resid(uio);++ /* Was this entry succesful ? */+ if (error || resid == orig_resid)+ break;++ /* Save the last valid catalog entry */+ lastdescp = &ce_list->entry[i].ce_desc;+ index++;+ *actualcount += 1;++ /* Do we have the bare minimum for the next entry ? */+ if (resid < sizeof(uint32_t))+ break;+ }+ } /* for each catalog entry */++ /*+ * If we couldn't fit all the entries requested in the user's buffer,+ * it's not EOF.+ */+ if (*eofflag && (*actualcount < (int)ce_list->realentries))+ *eofflag = 0;++ /* If we skipped catalog entries for reserved files that should+ * not be listed in namespace, update the index accordingly.+ */+ if (ce_list->skipentries) {+ index += ce_list->skipentries;+ ce_list->skipentries = 0;+ }++ /*+ * If there are more entries then save the last name.+ * Key this behavior based on whether or not we observed EOFFLAG.+ *+ * Do not use the valence as a way to determine if we hit EOF, since+ * it can be wrong. Use the catalog's output only.+ */+ if ((*(eofflag) == 0) && (lastdescp != NULL)) {++ /* Remember last entry */+ if ((dirhint->dh_desc.cd_flags & CD_HASBUF) &&+ (dirhint->dh_desc.cd_nameptr != NULL)) {+ dirhint->dh_desc.cd_flags &= ~CD_HASBUF;+ vfs_removename((const char *)dirhint->dh_desc.cd_nameptr);+ }+ if (lastdescp->cd_nameptr != NULL) {+ dirhint->dh_desc.cd_namelen = lastdescp->cd_namelen;+ dirhint->dh_desc.cd_nameptr = (const u_int8_t *)+ vfs_addname((const char *)lastdescp->cd_nameptr, lastdescp->cd_namelen, 0, 0);+ dirhint->dh_desc.cd_flags |= CD_HASBUF;+ } else {+ dirhint->dh_desc.cd_namelen = 0;+ dirhint->dh_desc.cd_nameptr = NULL;+ }+ dirhint->dh_index = index - 1;+ dirhint->dh_desc.cd_cnid = lastdescp->cd_cnid;+ dirhint->dh_desc.cd_hint = lastdescp->cd_hint;+ dirhint->dh_desc.cd_encoding = lastdescp->cd_encoding;+ }++ /* All done with the catalog descriptors. */+ for (i = 0; i < (int)ce_list->realentries; ++i)+ cat_releasedesc(&ce_list->entry[i].ce_desc);+ ce_list->realentries = 0;++ (void) hfs_lock(VTOC(dvp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ dcp = VTOC(dvp);++exit1:+ /* Pack directory index and tag into uio_offset. */+ while (tag == 0) tag = (++dcp->c_dirhinttag) << HFS_INDEX_BITS;+ uio_setoffset(uio, index | tag);+ dirhint->dh_index |= tag;++exit2:+ if (newstate)+ *newstate = dirchg;++ /*+ * Drop directory hint on error or if there are no more entries,+ * only if EOF was seen.+ */+ if (dirhint) {+ if ((error != 0) || *(eofflag))+ hfs_reldirhint(dcp, dirhint);+ else+ hfs_insertdirhint(dcp, dirhint);+ }+ if (namebuf) {+ hfs_free_data(namebuf, MAXPATHLEN);+ vap->va_name = NULL;+ }+ if (attrbufptr)+ hfs_free_data(attrbufptr, maxattrblocksize);+ if (ce_list)+ hfs_delete_with_hdr(ce_list, struct cat_entrylist, struct cat_entry, maxentries);++ if (vap && *actualcount && error)+ error = 0;++ hfs_unlock(dcp);+ return (error);+}+++/*==================== Attribute list support routines ====================*/++/*+ * Pack cnode attributes into an attribute block.+ */+void+hfs_packattrblk(struct attrblock *abp,+ struct hfsmount *hfsmp,+ struct vnode *vp,+ struct cat_desc *descp,+ struct cat_attr *attrp,+ struct cat_fork *datafork,+ struct cat_fork *rsrcfork,+ struct vfs_context *ctx)+{+ struct attrlist *attrlistp = abp->ab_attrlist;++ if (attrlistp->commonattr)+ packcommonattr(abp, hfsmp, vp, descp, attrp, ctx);++ if (attrlistp->dirattr && S_ISDIR(attrp->ca_mode))+ packdirattr(abp, hfsmp, vp, descp,attrp);++ if (attrlistp->fileattr && !S_ISDIR(attrp->ca_mode))+ packfileattr(abp, hfsmp, attrp, datafork, rsrcfork, vp);+}++static char*+mountpointname(struct mount *mp)+{+ struct vfsstatfs *vsfs = vfs_statfs(mp);++ size_t namelength = strlen(vsfs->f_mntonname);+ int foundchars = 0;+ char *c;++ if (namelength == 0)+ return (NULL);++ /*+ * Look backwards through the name string, looking for+ * the first slash encountered (which must precede the+ * last part of the pathname).+ */+ for (c = vsfs->f_mntonname + namelength - 1;+ namelength > 0; --c, --namelength) {+ if (*c != '/') {+ foundchars = 1;+ } else if (foundchars) {+ return (c + 1);+ }+ }++ return vsfs->f_mntonname;+}+++static void+packnameattr(+ struct attrblock *abp,+ struct vnode *vp,+ const u_int8_t *name,+ int namelen)+{+ void *varbufptr;+ struct attrreference * attr_refptr;+ char *mpname;+ size_t mpnamelen;+ u_int32_t attrlength;+ u_int8_t empty = 0;++ /* A cnode's name may be incorrect for the root of a mounted+ * filesystem (it can be mounted on a different directory name+ * than the name of the volume, such as "blah-1"). So for the+ * root directory, it's best to return the last element of the+ location where the volume's mounted:+ */+ if ((vp != NULL) && vnode_isvroot(vp) &&+ (mpname = mountpointname(vnode_mount(vp)))) {+ mpnamelen = strlen(mpname);++ /* Trim off any trailing slashes: */+ while ((mpnamelen > 0) && (mpname[mpnamelen-1] == '/'))+ --mpnamelen;++ /* If there's anything left, use it instead of the volume's name */+ if (mpnamelen > 0) {+ name = (u_int8_t *)mpname;+ namelen = mpnamelen;+ }+ }+ if (name == NULL) {+ name = ∅+ namelen = 0;+ }++ varbufptr = *abp->ab_varbufpp;+ attr_refptr = (struct attrreference *)(*abp->ab_attrbufpp);++ attrlength = namelen + 1;+ attr_refptr->attr_dataoffset = (char *)varbufptr - (char *)attr_refptr;+ attr_refptr->attr_length = attrlength;+ (void) strncpy((char *)varbufptr, (const char *) name, attrlength);+ /*+ * Advance beyond the space just allocated and+ * round up to the next 4-byte boundary:+ */+ varbufptr = ((char *)varbufptr) + attrlength + ((4 - (attrlength & 3)) & 3);+ ++attr_refptr;++ *abp->ab_attrbufpp = attr_refptr;+ *abp->ab_varbufpp = varbufptr;+}++static void+packcommonattr(+ struct attrblock *abp,+ struct hfsmount *hfsmp,+ struct vnode *vp,+ struct cat_desc * cdp,+ struct cat_attr * cap,+ struct vfs_context * ctx)+{+ attrgroup_t attr = abp->ab_attrlist->commonattr;+ struct mount *mp = HFSTOVFS(hfsmp);+ void *attrbufptr = *abp->ab_attrbufpp;+ void *varbufptr = *abp->ab_varbufpp;+ boolean_t is_64_bit = proc_is64bit(vfs_context_proc(ctx));+ uid_t cuid = 1;+ int isroot = 0;++ if (attr & (ATTR_CMN_OWNERID | ATTR_CMN_GRPID)) {+ cuid = kauth_cred_getuid(vfs_context_ucred(ctx));+ isroot = cuid == 0;+ }++ if (ATTR_CMN_NAME & attr) {+ packnameattr(abp, vp, cdp->cd_nameptr, cdp->cd_namelen);+ attrbufptr = *abp->ab_attrbufpp;+ varbufptr = *abp->ab_varbufpp;+ }+ if (ATTR_CMN_DEVID & attr) {+ *((dev_t *)attrbufptr) = hfsmp->hfs_raw_dev;+ attrbufptr = ((dev_t *)attrbufptr) + 1;+ }+ if (ATTR_CMN_FSID & attr) {+ fsid_t fsid;++ fsid.val[0] = hfsmp->hfs_raw_dev;+ fsid.val[1] = vfs_typenum(mp);+ *((fsid_t *)attrbufptr) = fsid;+ attrbufptr = ((fsid_t *)attrbufptr) + 1;+ }+ if (ATTR_CMN_OBJTYPE & attr) {+ *((fsobj_type_t *)attrbufptr) = IFTOVT(cap->ca_mode);+ attrbufptr = ((fsobj_type_t *)attrbufptr) + 1;+ }+ if (ATTR_CMN_OBJTAG & attr) {+ *((fsobj_tag_t *)attrbufptr) = VT_HFS;+ attrbufptr = ((fsobj_tag_t *)attrbufptr) + 1;+ }+ /*+ * Exporting file IDs from HFS Plus:+ *+ * For "normal" files the c_fileid is the same value as the+ * c_cnid. But for hard link files, they are different - the+ * c_cnid belongs to the active directory entry (ie the link)+ * and the c_fileid is for the actual inode (ie the data file).+ *+ * The stat call (getattr) will always return the c_fileid+ * and Carbon APIs, which are hardlink-ignorant, will always+ * receive the c_cnid (from getattrlist).+ */+ if (ATTR_CMN_OBJID & attr) {+ ((fsobj_id_t *)attrbufptr)->fid_objno = cdp->cd_cnid;+ ((fsobj_id_t *)attrbufptr)->fid_generation = 0;+ attrbufptr = ((fsobj_id_t *)attrbufptr) + 1;+ }+ if (ATTR_CMN_OBJPERMANENTID & attr) {+ ((fsobj_id_t *)attrbufptr)->fid_objno = cdp->cd_cnid;+ ((fsobj_id_t *)attrbufptr)->fid_generation = 0;+ attrbufptr = ((fsobj_id_t *)attrbufptr) + 1;+ }+ if (ATTR_CMN_PAROBJID & attr) {+ ((fsobj_id_t *)attrbufptr)->fid_objno = cdp->cd_parentcnid;+ ((fsobj_id_t *)attrbufptr)->fid_generation = 0;+ attrbufptr = ((fsobj_id_t *)attrbufptr) + 1;+ }+ if (ATTR_CMN_SCRIPT & attr) {+ *((text_encoding_t *)attrbufptr) = cdp->cd_encoding;+ attrbufptr = ((text_encoding_t *)attrbufptr) + 1;+ }+ if (ATTR_CMN_CRTIME & attr) {+ if (is_64_bit) {+ ((struct user64_timespec *)attrbufptr)->tv_sec = cap->ca_itime;+ ((struct user64_timespec *)attrbufptr)->tv_nsec = 0;+ attrbufptr = ((struct user64_timespec *)attrbufptr) + 1;+ }+ else {+ ((struct user32_timespec *)attrbufptr)->tv_sec = cap->ca_itime;+ ((struct user32_timespec *)attrbufptr)->tv_nsec = 0;+ attrbufptr = ((struct user32_timespec *)attrbufptr) + 1;+ }+ }+ if (ATTR_CMN_MODTIME & attr) {+ if (is_64_bit) {+ ((struct user64_timespec *)attrbufptr)->tv_sec = cap->ca_mtime;+ ((struct user64_timespec *)attrbufptr)->tv_nsec = 0;+ attrbufptr = ((struct user64_timespec *)attrbufptr) + 1;+ }+ else {+ ((struct user32_timespec *)attrbufptr)->tv_sec = cap->ca_mtime;+ ((struct user32_timespec *)attrbufptr)->tv_nsec = 0;+ attrbufptr = ((struct user32_timespec *)attrbufptr) + 1;+ }+ }+ if (ATTR_CMN_CHGTIME & attr) {+ if (is_64_bit) {+ ((struct user64_timespec *)attrbufptr)->tv_sec = cap->ca_ctime;+ ((struct user64_timespec *)attrbufptr)->tv_nsec = 0;+ attrbufptr = ((struct user64_timespec *)attrbufptr) + 1;+ }+ else {+ ((struct user32_timespec *)attrbufptr)->tv_sec = cap->ca_ctime;+ ((struct user32_timespec *)attrbufptr)->tv_nsec = 0;+ attrbufptr = ((struct user32_timespec *)attrbufptr) + 1;+ }+ }+ if (ATTR_CMN_ACCTIME & attr) {+ if (is_64_bit) {+ ((struct user64_timespec *)attrbufptr)->tv_sec = cap->ca_atime;+ ((struct user64_timespec *)attrbufptr)->tv_nsec = 0;+ attrbufptr = ((struct user64_timespec *)attrbufptr) + 1;+ }+ else {+ ((struct user32_timespec *)attrbufptr)->tv_sec = cap->ca_atime;+ ((struct user32_timespec *)attrbufptr)->tv_nsec = 0;+ attrbufptr = ((struct user32_timespec *)attrbufptr) + 1;+ }+ }+ if (ATTR_CMN_BKUPTIME & attr) {+ if (is_64_bit) {+ ((struct user64_timespec *)attrbufptr)->tv_sec = cap->ca_btime;+ ((struct user64_timespec *)attrbufptr)->tv_nsec = 0;+ attrbufptr = ((struct user64_timespec *)attrbufptr) + 1;+ }+ else {+ ((struct user32_timespec *)attrbufptr)->tv_sec = cap->ca_btime;+ ((struct user32_timespec *)attrbufptr)->tv_nsec = 0;+ attrbufptr = ((struct user32_timespec *)attrbufptr) + 1;+ }+ }+ if (ATTR_CMN_FNDRINFO & attr) {+ u_int8_t *finfo = NULL;+ bcopy(&cap->ca_finderinfo, attrbufptr, sizeof(u_int8_t) * 32);+ finfo = (u_int8_t*)attrbufptr;++ /* Don't expose a symlink's private type/creator. */+ if (S_ISLNK(cap->ca_mode)) {+ struct FndrFileInfo *fip;++ fip = (struct FndrFileInfo *)attrbufptr;+ fip->fdType = 0;+ fip->fdCreator = 0;+ }++ /* advance 16 bytes into the attrbuf */+ finfo = finfo + 16;++ /* also don't expose the date_added or write_gen_counter fields */+ if (S_ISREG(cap->ca_mode) || S_ISLNK(cap->ca_mode)) {+ struct FndrExtendedFileInfo *extinfo = (struct FndrExtendedFileInfo *)finfo;+ extinfo->document_id = 0;+ extinfo->date_added = 0;+ extinfo->write_gen_counter = 0;+ }+ else if (S_ISDIR(cap->ca_mode)) {+ struct FndrExtendedDirInfo *extinfo = (struct FndrExtendedDirInfo *)finfo;+ extinfo->document_id = 0;+ extinfo->date_added = 0;+ extinfo->write_gen_counter = 0;+ }++ attrbufptr = (char *)attrbufptr + sizeof(u_int8_t) * 32;+ }+ if (ATTR_CMN_OWNERID & attr) {+ uid_t nuid = cap->ca_uid;++ if (!isroot) {+ if (((unsigned int)vfs_flags(HFSTOVFS(hfsmp))) & MNT_UNKNOWNPERMISSIONS)+ nuid = cuid;+ else if (nuid == UNKNOWNUID)+ nuid = cuid;+ }++ *((uid_t *)attrbufptr) = nuid;+ attrbufptr = ((uid_t *)attrbufptr) + 1;+ }+ if (ATTR_CMN_GRPID & attr) {+ gid_t ngid = cap->ca_gid;++ if (!isroot) {+ gid_t cgid = kauth_cred_getgid(vfs_context_ucred(ctx));+ if (((unsigned int)vfs_flags(HFSTOVFS(hfsmp))) & MNT_UNKNOWNPERMISSIONS)+ ngid = cgid;+ else if (ngid == UNKNOWNUID)+ ngid = cgid;+ }++ *((gid_t *)attrbufptr) = ngid;+ attrbufptr = ((gid_t *)attrbufptr) + 1;+ }+ if (ATTR_CMN_ACCESSMASK & attr) {+ /*+ * [2856576] Since we are dynamically changing the owner, also+ * effectively turn off the set-user-id and set-group-id bits,+ * just like chmod(2) would when changing ownership. This prevents+ * a security hole where set-user-id programs run as whoever is+ * logged on (or root if nobody is logged in yet!)+ */+ *((u_int32_t *)attrbufptr) = (cap->ca_uid == UNKNOWNUID) ?+ cap->ca_mode & ~(S_ISUID | S_ISGID) : cap->ca_mode;+ attrbufptr = ((u_int32_t *)attrbufptr) + 1;+ }+ if (ATTR_CMN_FLAGS & attr) {+ *((u_int32_t *)attrbufptr) = cap->ca_flags;+ attrbufptr = ((u_int32_t *)attrbufptr) + 1;+ }+ if (ATTR_CMN_USERACCESS & attr) {+ u_int32_t user_access;++ /* Take the long path when we have an ACL */+ if ((vp != NULLVP) && (cap->ca_recflags & kHFSHasSecurityMask)) {+ user_access = hfs_real_user_access(vp, abp->ab_context);+ } else {+ user_access = DerivePermissionSummary(cap->ca_uid, cap->ca_gid,+ cap->ca_mode, mp, vfs_context_ucred(ctx), 0);+ }+ /* Also consider READ-ONLY file system. */+ if (vfs_flags(mp) & MNT_RDONLY) {+ user_access &= ~W_OK;+ }+ /* Locked objects are not writable either */+ if ((cap->ca_flags & UF_IMMUTABLE) && (vfs_context_suser(abp->ab_context) != 0))+ user_access &= ~W_OK;+ if ((cap->ca_flags & SF_IMMUTABLE) && (vfs_context_suser(abp->ab_context) == 0))+ user_access &= ~W_OK;++ *((u_int32_t *)attrbufptr) = user_access;+ attrbufptr = ((u_int32_t *)attrbufptr) + 1;+ }+ if (ATTR_CMN_FILEID & attr) {+ *((u_int64_t *)attrbufptr) = cap->ca_fileid;+ attrbufptr = ((u_int64_t *)attrbufptr) + 1;+ }+ if (ATTR_CMN_PARENTID & attr) {+ *((u_int64_t *)attrbufptr) = cdp->cd_parentcnid;+ attrbufptr = ((u_int64_t *)attrbufptr) + 1;+ }++ *abp->ab_attrbufpp = attrbufptr;+ *abp->ab_varbufpp = varbufptr;+}++static void+packdirattr(+ struct attrblock *abp,+ struct hfsmount *hfsmp,+ struct vnode *vp,+ struct cat_desc * descp,+ struct cat_attr * cattrp)+{+ attrgroup_t attr = abp->ab_attrlist->dirattr;+ void *attrbufptr = *abp->ab_attrbufpp;+ u_int32_t entries;++ /*+ * The DIR_LINKCOUNT is the count of real directory hard links.+ * (i.e. its not the sum of the implied "." and ".." references+ * typically used in stat's st_nlink field)+ */+ if (ATTR_DIR_LINKCOUNT & attr) {+ *((u_int32_t *)attrbufptr) = cattrp->ca_linkcount;+ attrbufptr = ((u_int32_t *)attrbufptr) + 1;+ }+ if (ATTR_DIR_ENTRYCOUNT & attr) {+ entries = cattrp->ca_entries;++ if (descp->cd_parentcnid == kHFSRootParentID) {+ if (hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid != 0)+ --entries; /* hide private dir */+ if (hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid != 0)+ --entries; /* hide private dir */+ if (hfsmp->jnl ||+ ((hfsmp->vcbAtrb & kHFSVolumeJournaledMask) &&+ (hfsmp->hfs_flags & HFS_READ_ONLY)))+ entries -= 2; /* hide the journal files */+ }++ *((u_int32_t *)attrbufptr) = entries;+ attrbufptr = ((u_int32_t *)attrbufptr) + 1;+ }+ if (ATTR_DIR_MOUNTSTATUS & attr) {+ if (vp != NULL && vnode_mountedhere(vp) != NULL)+ *((u_int32_t *)attrbufptr) = DIR_MNTSTATUS_MNTPOINT;+ else+ *((u_int32_t *)attrbufptr) = 0;+ attrbufptr = ((u_int32_t *)attrbufptr) + 1;+ }+ *abp->ab_attrbufpp = attrbufptr;+}++static void+packfileattr(+ struct attrblock *abp,+ struct hfsmount *hfsmp,+ struct cat_attr *cattrp,+ struct cat_fork *datafork,+ struct cat_fork *rsrcfork,+ struct vnode *vp)+{+#if !HFS_COMPRESSION+#pragma unused(vp)+#endif+ attrgroup_t attr = abp->ab_attrlist->fileattr;+ void *attrbufptr = *abp->ab_attrbufpp;+ void *varbufptr = *abp->ab_varbufpp;+ u_int32_t allocblksize;++ allocblksize = HFSTOVCB(hfsmp)->blockSize;++ off_t datasize = datafork->cf_size;+ off_t totalsize = datasize + rsrcfork->cf_size;+#if HFS_COMPRESSION+ int handle_compressed;+ handle_compressed = (cattrp->ca_flags & UF_COMPRESSED);// && hfs_file_is_compressed(VTOC(vp), 1);++ if (handle_compressed) {+ if (attr & (ATTR_FILE_DATALENGTH|ATTR_FILE_TOTALSIZE)) {+ if ( 0 == hfs_uncompressed_size_of_compressed_file(hfsmp, vp, cattrp->ca_fileid, &datasize, 1) ) { /* 1 == don't take the cnode lock */+ /* total size of a compressed file is just the data size */+ totalsize = datasize;+ }+ }+ }+#endif++ if (ATTR_FILE_LINKCOUNT & attr) {+ *((u_int32_t *)attrbufptr) = cattrp->ca_linkcount;+ attrbufptr = ((u_int32_t *)attrbufptr) + 1;+ }+ if (ATTR_FILE_TOTALSIZE & attr) {+ *((off_t *)attrbufptr) = totalsize;+ attrbufptr = ((off_t *)attrbufptr) + 1;+ }+ if (ATTR_FILE_ALLOCSIZE & attr) {+ *((off_t *)attrbufptr) =+ (off_t)cattrp->ca_blocks * (off_t)allocblksize;+ attrbufptr = ((off_t *)attrbufptr) + 1;+ }+ if (ATTR_FILE_IOBLOCKSIZE & attr) {+ *((u_int32_t *)attrbufptr) = hfsmp->hfs_logBlockSize;+ attrbufptr = ((u_int32_t *)attrbufptr) + 1;+ }+ if (ATTR_FILE_CLUMPSIZE & attr) {+ *((u_int32_t *)attrbufptr) = hfsmp->vcbClpSiz;+ attrbufptr = ((u_int32_t *)attrbufptr) + 1;+ }+ if (ATTR_FILE_DEVTYPE & attr) {+ if (S_ISBLK(cattrp->ca_mode) || S_ISCHR(cattrp->ca_mode))+ *((u_int32_t *)attrbufptr) = (u_int32_t)cattrp->ca_rdev;+ else+ *((u_int32_t *)attrbufptr) = 0;+ attrbufptr = ((u_int32_t *)attrbufptr) + 1;+ }++ if (ATTR_FILE_DATALENGTH & attr) {+ *((off_t *)attrbufptr) = datasize;+ attrbufptr = ((off_t *)attrbufptr) + 1;+ }++#if HFS_COMPRESSION+ /* fake the data fork size on a decmpfs compressed file to reflect the+ * uncompressed size. This ensures proper reading and copying of these files.+ * NOTE: we may need to get the vnode here because the vnode parameter+ * passed by hfs_vnop_readdirattr() may be null.+ */++ if ( handle_compressed ) {+ if (attr & ATTR_FILE_DATAALLOCSIZE) {+ *((off_t *)attrbufptr) = (off_t)rsrcfork->cf_blocks * (off_t)allocblksize;+ attrbufptr = ((off_t *)attrbufptr) + 1;+ }+ if (attr & ATTR_FILE_RSRCLENGTH) {+ *((off_t *)attrbufptr) = 0;+ attrbufptr = ((off_t *)attrbufptr) + 1;+ }+ if (attr & ATTR_FILE_RSRCALLOCSIZE) {+ *((off_t *)attrbufptr) = 0;+ attrbufptr = ((off_t *)attrbufptr) + 1;+ }+ }+ else+#endif+ {+ if (ATTR_FILE_DATAALLOCSIZE & attr) {+ *((off_t *)attrbufptr) = (off_t)datafork->cf_blocks * (off_t)allocblksize;+ attrbufptr = ((off_t *)attrbufptr) + 1;+ }+ if (ATTR_FILE_RSRCLENGTH & attr) {+ *((off_t *)attrbufptr) = rsrcfork->cf_size;+ attrbufptr = ((off_t *)attrbufptr) + 1;+ }+ if (ATTR_FILE_RSRCALLOCSIZE & attr) {+ *((off_t *)attrbufptr) = (off_t)rsrcfork->cf_blocks * (off_t)allocblksize;+ attrbufptr = ((off_t *)attrbufptr) + 1;+ }+ }+ *abp->ab_attrbufpp = attrbufptr;+ *abp->ab_varbufpp = varbufptr;+}++/*+ * Calculate the total size of an attribute block.+ */+int+hfs_attrblksize(struct attrlist *attrlist)+{+ int size;+ attrgroup_t a;+ int sizeof_timespec;+ boolean_t is_64_bit = proc_is64bit(current_proc());++ if (is_64_bit)+ sizeof_timespec = sizeof(struct user64_timespec);+ else+ sizeof_timespec = sizeof(struct user32_timespec);++ hfs_assert((attrlist->commonattr & ~ATTR_CMN_VALIDMASK) == 0);++ hfs_assert((attrlist->volattr & ~ATTR_VOL_VALIDMASK) == 0);++ hfs_assert((attrlist->dirattr & ~ATTR_DIR_VALIDMASK) == 0);++ hfs_assert((attrlist->fileattr & ~ATTR_FILE_VALIDMASK) == 0);++ // disable this because it will break the simulator/build machines each+ // time a new _CMNEXT_ bit is added+ // hfs_assert(((attrlist->forkattr & ~ATTR_FORK_VALIDMASK) == 0) ||+ // ((attrlist->forkattr & ~ATTR_CMNEXT_VALIDMASK) == 0));++ size = 0;++ if ((a = attrlist->commonattr) != 0) {+ if (a & ATTR_CMN_NAME) size += sizeof(struct attrreference);+ if (a & ATTR_CMN_DEVID) size += sizeof(dev_t);+ if (a & ATTR_CMN_FSID) size += sizeof(fsid_t);+ if (a & ATTR_CMN_OBJTYPE) size += sizeof(fsobj_type_t);+ if (a & ATTR_CMN_OBJTAG) size += sizeof(fsobj_tag_t);+ if (a & ATTR_CMN_OBJID) size += sizeof(fsobj_id_t);+ if (a & ATTR_CMN_OBJPERMANENTID) size += sizeof(fsobj_id_t);+ if (a & ATTR_CMN_PAROBJID) size += sizeof(fsobj_id_t);+ if (a & ATTR_CMN_SCRIPT) size += sizeof(text_encoding_t);+ if (a & ATTR_CMN_CRTIME) size += sizeof_timespec;+ if (a & ATTR_CMN_MODTIME) size += sizeof_timespec;+ if (a & ATTR_CMN_CHGTIME) size += sizeof_timespec;+ if (a & ATTR_CMN_ACCTIME) size += sizeof_timespec;+ if (a & ATTR_CMN_BKUPTIME) size += sizeof_timespec;+ if (a & ATTR_CMN_FNDRINFO) size += 32 * sizeof(u_int8_t);+ if (a & ATTR_CMN_OWNERID) size += sizeof(uid_t);+ if (a & ATTR_CMN_GRPID) size += sizeof(gid_t);+ if (a & ATTR_CMN_ACCESSMASK) size += sizeof(u_int32_t);+ if (a & ATTR_CMN_FLAGS) size += sizeof(u_int32_t);+ if (a & ATTR_CMN_USERACCESS) size += sizeof(u_int32_t);+ if (a & ATTR_CMN_FILEID) size += sizeof(u_int64_t);+ if (a & ATTR_CMN_PARENTID) size += sizeof(u_int64_t);+ }+ if ((a = attrlist->dirattr) != 0) {+ if (a & ATTR_DIR_LINKCOUNT) size += sizeof(u_int32_t);+ if (a & ATTR_DIR_ENTRYCOUNT) size += sizeof(u_int32_t);+ if (a & ATTR_DIR_MOUNTSTATUS) size += sizeof(u_int32_t);+ }+ if ((a = attrlist->fileattr) != 0) {+ if (a & ATTR_FILE_LINKCOUNT) size += sizeof(u_int32_t);+ if (a & ATTR_FILE_TOTALSIZE) size += sizeof(off_t);+ if (a & ATTR_FILE_ALLOCSIZE) size += sizeof(off_t);+ if (a & ATTR_FILE_IOBLOCKSIZE) size += sizeof(u_int32_t);+ if (a & ATTR_FILE_CLUMPSIZE) size += sizeof(u_int32_t);+ if (a & ATTR_FILE_DEVTYPE) size += sizeof(u_int32_t);+ if (a & ATTR_FILE_DATALENGTH) size += sizeof(off_t);+ if (a & ATTR_FILE_DATAALLOCSIZE) size += sizeof(off_t);+ if (a & ATTR_FILE_RSRCLENGTH) size += sizeof(off_t);+ if (a & ATTR_FILE_RSRCALLOCSIZE) size += sizeof(off_t);+ }++ return (size);+}++#define KAUTH_DIR_WRITE_RIGHTS (KAUTH_VNODE_ACCESS | KAUTH_VNODE_ADD_FILE | \+ KAUTH_VNODE_ADD_SUBDIRECTORY | \+ KAUTH_VNODE_DELETE_CHILD)++#define KAUTH_DIR_READ_RIGHTS (KAUTH_VNODE_ACCESS | KAUTH_VNODE_LIST_DIRECTORY)++#define KAUTH_DIR_EXECUTE_RIGHTS (KAUTH_VNODE_ACCESS | KAUTH_VNODE_SEARCH)++#define KAUTH_FILE_WRITE_RIGHTS (KAUTH_VNODE_ACCESS | KAUTH_VNODE_WRITE_DATA)++#define KAUTH_FILE_READRIGHTS (KAUTH_VNODE_ACCESS | KAUTH_VNODE_READ_DATA)++#define KAUTH_FILE_EXECUTE_RIGHTS (KAUTH_VNODE_ACCESS | KAUTH_VNODE_EXECUTE)+++/*+ * Compute the same [expensive] user_access value as getattrlist does+ */+static u_int32_t+hfs_real_user_access(vnode_t vp, vfs_context_t ctx)+{+ u_int32_t user_access = 0;++ if (vnode_isdir(vp)) {+ if (vnode_authorize(vp, NULLVP, KAUTH_DIR_WRITE_RIGHTS, ctx) == 0)+ user_access |= W_OK;+ if (vnode_authorize(vp, NULLVP, KAUTH_DIR_READ_RIGHTS, ctx) == 0)+ user_access |= R_OK;+ if (vnode_authorize(vp, NULLVP, KAUTH_DIR_EXECUTE_RIGHTS, ctx) == 0)+ user_access |= X_OK;+ } else {+ if (vnode_authorize(vp, NULLVP, KAUTH_FILE_WRITE_RIGHTS, ctx) == 0)+ user_access |= W_OK;+ if (vnode_authorize(vp, NULLVP, KAUTH_FILE_READRIGHTS, ctx) == 0)+ user_access |= R_OK;+ if (vnode_authorize(vp, NULLVP, KAUTH_FILE_EXECUTE_RIGHTS, ctx) == 0)+ user_access |= X_OK;+ }+ return (user_access);+}+++u_int32_t+DerivePermissionSummary(uid_t obj_uid, gid_t obj_gid, mode_t obj_mode,+ struct mount *mp, kauth_cred_t cred, __unused struct proc *p)+{+ u_int32_t permissions;++ if (obj_uid == UNKNOWNUID)+ obj_uid = kauth_cred_getuid(cred);++ /* User id 0 (root) always gets access. */+ if (!suser(cred, NULL)) {+ permissions = R_OK | W_OK | X_OK;+ goto Exit;+ };++ /* Otherwise, check the owner. */+ if (hfs_owner_rights(VFSTOHFS(mp), obj_uid, cred, NULL, false) == 0) {+ permissions = ((u_int32_t)obj_mode & S_IRWXU) >> 6;+ goto Exit;+ }++ /* Otherwise, check the groups. */+ if (! (((unsigned int)vfs_flags(mp)) & MNT_UNKNOWNPERMISSIONS)) {+ int is_member;++ if (kauth_cred_ismember_gid(cred, obj_gid, &is_member) == 0 && is_member) {+ permissions = ((u_int32_t)obj_mode & S_IRWXG) >> 3;+ goto Exit;+ }+ }++ /* Otherwise, settle for 'others' access. */+ permissions = (u_int32_t)obj_mode & S_IRWXO;++Exit:+ return (permissions);+}+++/*+ * ===========================================================================+ * Support functions for filling up a vnode_attr structure based on attributes+ * requested.+ * ===========================================================================+ */+void+get_vattr_data_for_attrs(struct attrlist *alp, struct vnode_attr *vap,+ struct hfsmount *hfsmp, struct vnode *vp, struct cat_desc *descp,+ struct cat_attr *atrp, struct cat_fork *datafork, struct cat_fork *rsrcfork,+ vfs_context_t ctx)+{+ if (alp->commonattr || alp->forkattr) {+ vattr_data_for_common_attrs(alp, vap, hfsmp, vp, descp, atrp,+ ctx);+ }++ if (alp->dirattr && S_ISDIR(atrp->ca_mode))+ vattr_data_for_dir_attrs(alp, vap, hfsmp, vp, descp, atrp);++ if (alp->fileattr && !S_ISDIR(atrp->ca_mode)) {+ vattr_data_for_file_attrs(alp, vap, hfsmp, atrp, datafork,+ rsrcfork, vp);+ }+}++static void+copy_name_attr(struct vnode_attr *vap, struct vnode *vp, const u_int8_t *name,+ int namelen)+{+ char *mpname;+ size_t mpnamelen;+ u_int32_t attrlength;+ u_int8_t empty = 0;++ /* A cnode's name may be incorrect for the root of a mounted+ * filesystem (it can be mounted on a different directory name+ * than the name of the volume, such as "blah-1"). So for the+ * root directory, it's best to return the last element of the+ location where the volume's mounted:+ */+ if ((vp != NULL) && vnode_isvroot(vp) &&+ (mpname = mountpointname(vnode_mount(vp)))) {+ mpnamelen = strlen(mpname);++ /* Trim off any trailing slashes: */+ while ((mpnamelen > 0) && (mpname[mpnamelen-1] == '/'))+ --mpnamelen;++ /* If there's anything left, use it instead of the volume's name */+ if (mpnamelen > 0) {+ name = (u_int8_t *)mpname;+ namelen = mpnamelen;+ }+ }++ if (name == NULL) {+ name = ∅+ namelen = 0;+ }++ attrlength = namelen + 1;+ (void) strncpy((char *)vap->va_name, (const char *) name, attrlength);+ /*+ * round upto 8 and zero out the rounded up bytes.+ */+ attrlength = min(kHFSPlusMaxFileNameBytes, ((attrlength + 7) & ~0x07));+ bzero(vap->va_name + attrlength, kHFSPlusMaxFileNameBytes - attrlength);+}++static void+vattr_data_for_common_attrs( struct attrlist *alp, struct vnode_attr *vap,+ struct hfsmount *hfsmp, struct vnode *vp, struct cat_desc *cdp,+ struct cat_attr *cap, vfs_context_t ctx)+{+ attrgroup_t attr = alp->commonattr;+ struct mount *mp = HFSTOVFS(hfsmp);+ uid_t cuid = 1;+ int isroot = 0;++ if (attr & (ATTR_CMN_OWNERID | ATTR_CMN_GRPID)) {+ cuid = kauth_cred_getuid(vfs_context_ucred(ctx));+ isroot = cuid == 0;+ }++ if (ATTR_CMN_NAME & attr) {+ if (vap->va_name) {+ copy_name_attr(vap, vp, cdp->cd_nameptr,+ cdp->cd_namelen);+ VATTR_SET_SUPPORTED(vap, va_name);+ } else {+ VATTR_CLEAR_SUPPORTED(vap, va_name);+ }+ }++ if (ATTR_CMN_DEVID & attr) {+ vap->va_devid = hfsmp->hfs_raw_dev;+ VATTR_SET_SUPPORTED(vap, va_devid);+ }++ if (ATTR_CMN_FSID & attr) {+ vap->va_fsid64.val[0] = hfsmp->hfs_raw_dev;+ vap->va_fsid64.val[1] = vfs_typenum(mp);+ VATTR_SET_SUPPORTED(vap, va_fsid64);+ }+ /*+ * We always provide the objtype even if not asked because VFS helper+ * functions depend on knowing the object's type.+ */+ vap->va_objtype = IFTOVT(cap->ca_mode);+ VATTR_SET_SUPPORTED(vap, va_objtype);++ if (ATTR_CMN_OBJTAG & attr) {+ vap->va_objtag = VT_HFS;+ VATTR_SET_SUPPORTED(vap, va_objtag);+ }+ /*+ * Exporting file IDs from HFS Plus:+ *+ * For "normal" files the c_fileid is the same value as the+ * c_cnid. But for hard link files, they are different - the+ * c_cnid belongs to the active directory entry (ie the link)+ * and the c_fileid is for the actual inode (ie the data file).+ *+ * The stat call (getattr) will always return the c_fileid+ * and Carbon APIs, which are hardlink-ignorant, will always+ * receive the c_cnid (from getattrlist).+ *+ * Forkattrs are now repurposed for Common Extended Attributes.+ */+ if ((ATTR_CMN_OBJID & attr) || (ATTR_CMN_OBJPERMANENTID & attr) ||+ alp->forkattr & ATTR_CMNEXT_LINKID) {+ vap->va_linkid = cdp->cd_cnid;+ VATTR_SET_SUPPORTED(vap, va_linkid);+ }++ if (ATTR_CMN_PAROBJID & attr) {+ vap->va_parentid = cdp->cd_parentcnid;+ VATTR_SET_SUPPORTED(vap, va_parentid);+ }++ if (ATTR_CMN_SCRIPT & attr) {+ vap->va_encoding = cdp->cd_encoding;+ VATTR_SET_SUPPORTED(vap, va_encoding);+ }++ if (ATTR_CMN_CRTIME & attr) {+ vap->va_create_time.tv_sec = cap->ca_itime;+ vap->va_create_time.tv_nsec = 0;+ VATTR_SET_SUPPORTED(vap, va_create_time);+ }++ if (ATTR_CMN_MODTIME & attr) {+ vap->va_modify_time.tv_sec = cap->ca_mtime;+ vap->va_modify_time.tv_nsec = 0;+ VATTR_SET_SUPPORTED(vap, va_modify_time);+ }++ if (ATTR_CMN_CHGTIME & attr) {+ vap->va_change_time.tv_sec = cap->ca_ctime;+ vap->va_change_time.tv_nsec = 0;+ VATTR_SET_SUPPORTED(vap, va_change_time);+ }++ if (ATTR_CMN_ACCTIME & attr) {+ vap->va_access_time.tv_sec = cap->ca_atime;+ vap->va_access_time.tv_nsec = 0;+ VATTR_SET_SUPPORTED(vap, va_access_time);+ }++ if (ATTR_CMN_BKUPTIME & attr) {+ vap->va_backup_time.tv_sec = cap->ca_btime;+ vap->va_backup_time.tv_nsec = 0;+ VATTR_SET_SUPPORTED(vap, va_backup_time);+ }++ if (ATTR_CMN_FNDRINFO & attr) {+ u_int8_t *finfo = NULL;++ bcopy(&cap->ca_finderinfo, &vap->va_finderinfo[0],+ sizeof(u_int8_t) * 32);+ finfo = (u_int8_t*)(&vap->va_finderinfo[0]);++ /* Don't expose a symlink's private type/creator. */+ if (S_ISLNK(cap->ca_mode)) {+ struct FndrFileInfo *fip;++ fip = (struct FndrFileInfo *)finfo;+ fip->fdType = 0;+ fip->fdCreator = 0;+ }++ /* advance 16 bytes into the attrbuf */+ finfo = finfo + 16;++ /* also don't expose the date_added or write_gen_counter fields */+ if (S_ISREG(cap->ca_mode) || S_ISLNK(cap->ca_mode)) {+ struct FndrExtendedFileInfo *extinfo =+ (struct FndrExtendedFileInfo *)finfo;+ extinfo->document_id = 0;+ extinfo->date_added = 0;+ extinfo->write_gen_counter = 0;+ } else if (S_ISDIR(cap->ca_mode)) {+ struct FndrExtendedDirInfo *extinfo =+ (struct FndrExtendedDirInfo *)finfo;+ extinfo->document_id = 0;+ extinfo->date_added = 0;+ extinfo->write_gen_counter = 0;+ }++ VATTR_SET_SUPPORTED(vap, va_finderinfo);+ }++ if (ATTR_CMN_OWNERID & attr) {+ uid_t nuid = cap->ca_uid;++ if (!isroot) {+ if (((unsigned int)vfs_flags(HFSTOVFS(hfsmp))) & MNT_UNKNOWNPERMISSIONS)+ nuid = cuid;+ else if (nuid == UNKNOWNUID)+ nuid = cuid;+ }++ vap->va_uid = nuid;+ VATTR_SET_SUPPORTED(vap, va_uid);+ }++ if (ATTR_CMN_GRPID & attr) {+ gid_t ngid = cap->ca_gid;++ if (!isroot) {+ gid_t cgid = kauth_cred_getgid(vfs_context_ucred(ctx));+ if (((unsigned int)vfs_flags(HFSTOVFS(hfsmp))) & MNT_UNKNOWNPERMISSIONS)+ ngid = cgid;+ else if (ngid == UNKNOWNUID)+ ngid = cgid;+ }++ vap->va_gid = ngid;+ VATTR_SET_SUPPORTED(vap, va_gid);+ }++ if (ATTR_CMN_ACCESSMASK & attr) {+ uint32_t nmode;+ /*+ * [2856576] Since we are dynamically changing the owner, also+ * effectively turn off the set-user-id and set-group-id bits,+ * just like chmod(2) would when changing ownership. This prevents+ * a security hole where set-user-id programs run as whoever is+ * logged on (or root if nobody is logged in yet!)+ */+ nmode = (cap->ca_uid == UNKNOWNUID) ?+ cap->ca_mode & ~(S_ISUID | S_ISGID) : cap->ca_mode;++ vap->va_mode = nmode;+ VATTR_SET_SUPPORTED(vap, va_mode);+ }++ if (ATTR_CMN_FLAGS & attr) {+ vap->va_flags = cap->ca_flags;+ VATTR_SET_SUPPORTED(vap, va_flags);+ }++ if (ATTR_CMN_GEN_COUNT & attr) {+ vap->va_write_gencount = hfs_get_gencount_from_blob(+ (const uint8_t *)cap->ca_finderinfo, cap->ca_mode);+ VATTR_SET_SUPPORTED(vap, va_write_gencount);+ }++ if (ATTR_CMN_DOCUMENT_ID & attr) {+ vap->va_document_id = hfs_get_document_id_from_blob(+ (const uint8_t *)cap->ca_finderinfo, cap->ca_mode);+ VATTR_SET_SUPPORTED(vap, va_document_id);+ }++ if (ATTR_CMN_USERACCESS & attr) {+ u_int32_t user_access;++ /* Take the long path when we have an ACL */+ if ((vp != NULLVP) && (cap->ca_recflags & kHFSHasSecurityMask)) {+ user_access = hfs_real_user_access(vp, ctx);+ } else {+ user_access = DerivePermissionSummary(cap->ca_uid, cap->ca_gid,+ cap->ca_mode, mp, vfs_context_ucred(ctx), 0);+ }+ /* Also consider READ-ONLY file system. */+ if (vfs_flags(mp) & MNT_RDONLY) {+ user_access &= ~W_OK;+ }+ /* Locked objects are not writable either */+ if ((cap->ca_flags & UF_IMMUTABLE) && (vfs_context_suser(ctx) != 0))+ user_access &= ~W_OK;+ if ((cap->ca_flags & SF_IMMUTABLE) && (vfs_context_suser(ctx) == 0))+ user_access &= ~W_OK;++ vap->va_user_access = user_access;+ VATTR_SET_SUPPORTED(vap, va_user_access);+ }++ /*+ * Right now the best we can do is tell if we *don't* have extended+ * security (like hfs_vnop_getattr).+ */+ if (ATTR_CMN_EXTENDED_SECURITY & attr) {+ if (!(cap->ca_recflags & kHFSHasSecurityMask)) {+ vap->va_acl = (kauth_acl_t) KAUTH_FILESEC_NONE;+ VATTR_SET_SUPPORTED(vap, va_acl);+ }+ }++ if (ATTR_CMN_FILEID & attr) {+ vap->va_fileid = cap->ca_fileid;+ VATTR_SET_SUPPORTED(vap, va_fileid);+ }++ if (ATTR_CMN_PARENTID & attr) {+ vap->va_parentid = cdp->cd_parentcnid;+ VATTR_SET_SUPPORTED(vap, va_parentid);+ }++ if (ATTR_CMN_ADDEDTIME & attr) {+ if (cap->ca_recflags & kHFSHasDateAddedMask) {+ vap->va_addedtime.tv_sec = hfs_get_dateadded_from_blob(+ (const uint8_t *)cap->ca_finderinfo, cap->ca_mode);+ vap->va_addedtime.tv_nsec = 0;+ VATTR_SET_SUPPORTED(vap, va_addedtime);+ }+ }+}++static void+vattr_data_for_dir_attrs(struct attrlist *alp, struct vnode_attr *vap,+ struct hfsmount *hfsmp, struct vnode *vp, struct cat_desc * descp,+ struct cat_attr * cattrp)+{+ attrgroup_t attr = alp->dirattr;+ u_int32_t entries;++ /*+ * The DIR_LINKCOUNT is the count of real directory hard links.+ * (i.e. its not the sum of the implied "." and ".." references+ * typically used in stat's st_nlink field)+ */+ if (ATTR_DIR_LINKCOUNT & attr) {+ vap->va_dirlinkcount = cattrp->ca_linkcount;+ VATTR_SET_SUPPORTED(vap, va_dirlinkcount);+ }+ if (ATTR_DIR_ENTRYCOUNT & attr) {+ entries = cattrp->ca_entries;++ if (descp->cd_parentcnid == kHFSRootParentID) {+ if (hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid != 0)+ --entries; /* hide private dir */+ if (hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid != 0)+ --entries; /* hide private dir */+ if (hfsmp->jnl ||+ ((hfsmp->vcbAtrb & kHFSVolumeJournaledMask) &&+ (hfsmp->hfs_flags & HFS_READ_ONLY)))+ entries -= 2; /* hide the journal files */+ }++ vap->va_nchildren = entries;+ VATTR_SET_SUPPORTED(vap, va_nchildren);+ }++ if (ATTR_DIR_MOUNTSTATUS & attr) {+ /*+ * There is not vnode_attr for mount point status.+ * XXX. Should there be ?+ */+ u_int32_t mstatus = 0;++ if (vp != NULL && vnode_mountedhere(vp) != NULL)+ mstatus = DIR_MNTSTATUS_MNTPOINT;+ }+}++static void+vattr_data_for_file_attrs(struct attrlist *alp, struct vnode_attr *vap,+ struct hfsmount *hfsmp, struct cat_attr *cattrp, struct cat_fork *datafork,+ struct cat_fork *rsrcfork, struct vnode *vp)+{+#if !HFS_COMPRESSION+#pragma unused(vp)+#endif+ attrgroup_t attr = alp->fileattr;+ off_t da_size, rsrc_len, rsrc_alloc;+ u_int32_t allocblksize;++ allocblksize = HFSTOVCB(hfsmp)->blockSize;++ off_t datasize = datafork->cf_size;+ off_t totalsize = datasize + rsrcfork->cf_size;+#if HFS_COMPRESSION+ int handle_compressed;+ handle_compressed = (cattrp->ca_flags & UF_COMPRESSED);// && hfs_file_is_compressed(VTOC(vp), 1);++ if (handle_compressed) {+ if (attr & (ATTR_FILE_DATALENGTH|ATTR_FILE_TOTALSIZE)) {+ if ( 0 == hfs_uncompressed_size_of_compressed_file(hfsmp, vp, cattrp->ca_fileid, &datasize, 1) ) { /* 1 == don't take the cnode lock */+ /* total size of a compressed file is just the data size */+ totalsize = datasize;+ }+ }+ }+#endif++ if (ATTR_FILE_LINKCOUNT & attr) {+ vap->va_nlink = cattrp->ca_linkcount;+ VATTR_SET_SUPPORTED(vap, va_nlink);+ }+ if (ATTR_FILE_TOTALSIZE & attr) {+ VATTR_RETURN(vap, va_total_size, totalsize);+ }+ if (ATTR_FILE_ALLOCSIZE & attr) {+ VATTR_RETURN(vap, va_total_alloc,+ (off_t)cattrp->ca_blocks * (off_t)allocblksize );+ }+ if (ATTR_FILE_IOBLOCKSIZE & attr) {+ VATTR_RETURN(vap, va_iosize, hfsmp->hfs_logBlockSize);+ }++ /* ATTR_FILE_CLUMPSIZE is obsolete */++ if (ATTR_FILE_DEVTYPE & attr) {+ dev_t dev = 0;++ if (S_ISBLK(cattrp->ca_mode) || S_ISCHR(cattrp->ca_mode))+ dev = (u_int32_t)cattrp->ca_rdev;++ VATTR_RETURN(vap, va_rdev, dev);+ }++ if (ATTR_FILE_DATALENGTH & attr) {+ VATTR_RETURN(vap, va_data_size, datasize);+ }+#if HFS_COMPRESSION+ /* fake the data fork size on a decmpfs compressed file to reflect the+ * uncompressed size. This ensures proper reading and copying of these+ * files.+ * NOTE: we may need to get the vnode here because the vnode parameter+ * passed by hfs_vnop_readdirattr() may be null.+ */++ if (handle_compressed) {+ da_size = (off_t)rsrcfork->cf_blocks * (off_t)allocblksize;+ rsrc_len = 0;+ rsrc_alloc = 0;+ }+ else+#endif+ {+ da_size = (off_t)datafork->cf_blocks * (off_t)allocblksize;+ rsrc_len = rsrcfork->cf_size;+ rsrc_alloc = (off_t)rsrcfork->cf_blocks * (off_t)allocblksize;+ }++ if (ATTR_FILE_DATAALLOCSIZE & attr) {+ VATTR_RETURN(vap, va_data_alloc, da_size);+ }++ if (ATTR_FILE_RSRCLENGTH & attr) {+ VATTR_RETURN(vap, va_rsrc_length, rsrc_len);+ }++ if (ATTR_FILE_RSRCALLOCSIZE & attr) {+ VATTR_RETURN(vap, va_rsrc_alloc, rsrc_alloc);+ }+}diff --git a/xnu/files/bsd/hfs/hfs_attrlist.h b/xnu/files/bsd/hfs/hfs_attrlist.hnew file mode 100644index 0000000..b9ceb09--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_attrlist.h@@ -0,0 +1,108 @@+/*+ * Copyright (c) 2002-2015 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@+ */+#ifndef _HFS_ATTRLIST_H_+#define _HFS_ATTRLIST_H_++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE+#include <sys/attr.h>+#include <sys/vnode.h>++#include "hfs_catalog.h"+#include "hfs_cnode.h"+++struct attrblock {+ struct attrlist * ab_attrlist;+ void ** ab_attrbufpp;+ void ** ab_varbufpp;+ int ab_flags;+ int ab_blocksize;+ vfs_context_t ab_context;+};++/*+ * The following define the attributes that HFS supports:+ */++#define HFS_ATTR_CMN_VALID \+ (ATTR_CMN_NAME | ATTR_CMN_DEVID | \+ ATTR_CMN_FSID | ATTR_CMN_OBJTYPE | \+ ATTR_CMN_OBJTAG | ATTR_CMN_OBJID | \+ ATTR_CMN_OBJPERMANENTID | ATTR_CMN_PAROBJID | \+ ATTR_CMN_SCRIPT | ATTR_CMN_CRTIME | \+ ATTR_CMN_MODTIME | ATTR_CMN_CHGTIME | \+ ATTR_CMN_ACCTIME | ATTR_CMN_BKUPTIME | \+ ATTR_CMN_FNDRINFO |ATTR_CMN_OWNERID | \+ ATTR_CMN_GRPID | ATTR_CMN_ACCESSMASK | \+ ATTR_CMN_FLAGS | ATTR_CMN_USERACCESS | \+ ATTR_CMN_FILEID | ATTR_CMN_PARENTID )++#define HFS_ATTR_CMN_SEARCH_VALID \+ (ATTR_CMN_NAME | ATTR_CMN_OBJID | \+ ATTR_CMN_PAROBJID | ATTR_CMN_CRTIME | \+ ATTR_CMN_MODTIME | ATTR_CMN_CHGTIME | \+ ATTR_CMN_ACCTIME | ATTR_CMN_BKUPTIME | \+ ATTR_CMN_FNDRINFO | ATTR_CMN_OWNERID | \+ ATTR_CMN_GRPID | ATTR_CMN_ACCESSMASK | \+ ATTR_CMN_FILEID | ATTR_CMN_PARENTID )++++#define HFS_ATTR_DIR_VALID \+ (ATTR_DIR_LINKCOUNT | ATTR_DIR_ENTRYCOUNT | ATTR_DIR_MOUNTSTATUS)++#define HFS_ATTR_DIR_SEARCH_VALID \+ (ATTR_DIR_ENTRYCOUNT)++#define HFS_ATTR_FILE_VALID \+ (ATTR_FILE_LINKCOUNT |ATTR_FILE_TOTALSIZE | \+ ATTR_FILE_ALLOCSIZE | ATTR_FILE_IOBLOCKSIZE | \+ ATTR_FILE_CLUMPSIZE | ATTR_FILE_DEVTYPE | \+ ATTR_FILE_DATALENGTH | ATTR_FILE_DATAALLOCSIZE | \+ ATTR_FILE_RSRCLENGTH | ATTR_FILE_RSRCALLOCSIZE)++#define HFS_ATTR_FILE_SEARCH_VALID \+ (ATTR_FILE_DATALENGTH | ATTR_FILE_DATAALLOCSIZE | \+ ATTR_FILE_RSRCLENGTH | ATTR_FILE_RSRCALLOCSIZE )++extern int hfs_attrblksize(struct attrlist *attrlist);++extern u_int32_t DerivePermissionSummary(uid_t obj_uid, gid_t obj_gid,+ mode_t obj_mode, struct mount *mp,+ kauth_cred_t cred, struct proc *p);++extern void hfs_packattrblk(struct attrblock *abp, struct hfsmount *hfsmp,+ struct vnode *vp, struct cat_desc *descp, struct cat_attr *attrp,+ struct cat_fork *datafork, struct cat_fork *rsrcfork, struct vfs_context *ctx);++#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */+#endif /* ! _HFS_ATTRLIST_H_ */diff --git a/xnu/files/bsd/hfs/hfs_btreeio.c b/xnu/files/bsd/hfs/hfs_btreeio.cnew file mode 100644index 0000000..d307e00--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_btreeio.c@@ -0,0 +1,948 @@+/*+ * Copyright (c) 2000-2017 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@+ */++#include <sys/param.h>+#include <sys/systm.h>+#include <sys/buf.h>+#include <sys/kernel.h>+#include <sys/malloc.h>+#include <sys/mount.h>+#include <sys/vnode.h>+++#include "hfs.h"+#include "hfs_cnode.h"+#include "hfs_dbg.h"+#include "hfs_endian.h"+#include "hfs_btreeio.h"++#include "FileMgrInternal.h"+#include "BTreesPrivate.h"++/* From bsd/vfs/vfs_bio.c */+extern int bdwrite_internal(struct buf *, int);++static int ClearBTNodes(struct vnode *vp, int blksize, off_t offset, off_t amount);+static int btree_journal_modify_block_end(struct hfsmount *hfsmp, struct buf *bp);++void btree_swap_node(struct buf *bp, __unused void *arg);++/*+ * Return btree node size for given vnode.+ *+ * Returns:+ * For btree vnode, returns btree node size.+ * For non-btree vnodes, returns 0.+ */+u_int16_t get_btree_nodesize(struct vnode *vp)+{+ BTreeControlBlockPtr btree;+ u_int16_t node_size = 0;++ if (vnode_issystem(vp)) {+ btree = (BTreeControlBlockPtr) VTOF(vp)->fcbBTCBPtr;+ if (btree) {+ node_size = btree->nodeSize;+ }+ }++ return node_size;+}++OSStatus SetBTreeBlockSize(FileReference vp, ByteCount blockSize, __unused ItemCount minBlockCount)+{+ BTreeControlBlockPtr bTreePtr;++ hfs_assert(vp != NULL);+ hfs_assert(blockSize >= kMinNodeSize);+ if (blockSize > MAXBSIZE )+ return (fsBTBadNodeSize);++ bTreePtr = (BTreeControlBlockPtr)VTOF(vp)->fcbBTCBPtr;+ bTreePtr->nodeSize = blockSize;++ return (E_NONE);+}+++OSStatus GetBTreeBlock(FileReference vp, u_int32_t blockNum, GetBlockOptions options, BlockDescriptor *block)+{+ OSStatus retval = E_NONE;+ struct buf *bp = NULL;+ u_int8_t allow_empty_node;++ /* If the btree block is being read using hint, it is+ * fine for the swap code to find zeroed out nodes.+ */+ if (options & kGetBlockHint) {+ allow_empty_node = true;+ } else {+ allow_empty_node = false;+ }++ if (options & kGetEmptyBlock) {+ daddr64_t blkno;+ off_t offset;++ offset = (daddr64_t)blockNum * (daddr64_t)block->blockSize;+ bp = buf_getblk(vp, (daddr64_t)blockNum, block->blockSize, 0, 0, BLK_META);+ if (bp && !hfs_vnop_blockmap(&(struct vnop_blockmap_args){+ .a_vp = vp,+ .a_foffset = offset,+ .a_size = block->blockSize,+ .a_bpn = &blkno+ })) {+ buf_setblkno(bp, blkno);+ }+ } else {+ retval = buf_meta_bread(vp, (daddr64_t)blockNum, block->blockSize, NOCRED, &bp);+ }+ if (bp == NULL)+ retval = -1; //XXX need better error++ if (retval == E_NONE) {+ block->blockHeader = bp;+ block->buffer = (char *)buf_dataptr(bp);+ block->blockNum = buf_lblkno(bp);+ block->blockReadFromDisk = (buf_fromcache(bp) == 0); /* not found in cache ==> came from disk */++ // XXXdbg+ block->isModified = 0;++ /* Check and endian swap B-Tree node (only if it's a valid block) */+ if (!(options & kGetEmptyBlock)) {++ /* This happens when we first open the b-tree, we might not have all the node data on hand */+ if ((((BTNodeDescriptor *)block->buffer)->kind == kBTHeaderNode) &&+ (((BTHeaderRec *)((char *)block->buffer + 14))->nodeSize != buf_count(bp)) &&+ (SWAP_BE16 (((BTHeaderRec *)((char *)block->buffer + 14))->nodeSize) != buf_count(bp))) {++ /*+ * Don't swap the node descriptor, record offsets, or other records.+ * This record will be invalidated and re-read with the correct node+ * size once the B-tree control block is set up with the node size+ * from the header record.+ */+ retval = hfs_swap_BTNode (block, vp, kSwapBTNodeHeaderRecordOnly, allow_empty_node);++ } else {+ /*+ * In this case, we have enough data in-hand to do basic validation+ * on the B-Tree node.+ */+ if (block->blockReadFromDisk) {+ /*+ * The node was just read from disk, so always swap/check it.+ * This is necessary on big endian since the test below won't trigger.+ */+ retval = hfs_swap_BTNode (block, vp, kSwapBTNodeBigToHost, allow_empty_node);+ }+ else {+ /*+ * Block wasn't read from disk; it was found in the cache.+ */+ if (*((u_int16_t *)((char *)block->buffer + (block->blockSize - sizeof (u_int16_t)))) == 0x0e00) {+ /*+ * The node was left in the cache in non-native order, so swap it.+ * This only happens on little endian, after the node is written+ * back to disk.+ */+ retval = hfs_swap_BTNode (block, vp, kSwapBTNodeBigToHost, allow_empty_node);+ }+ else if (*((u_int16_t *)((char *)block->buffer + (block->blockSize - sizeof (u_int16_t)))) == 0x000e) {+ /*+ * The node was in-cache in native-endianness. We don't need to do+ * anything here, because the node is ready to use. Set retval == 0.+ */+ retval = 0;+ }+ /*+ * If the node doesn't have hex 14 (0xe) in the last two bytes of the buffer,+ * it doesn't necessarily mean that this is a bad node. Zeroed nodes that are+ * marked as unused in the b-tree map node would be OK and not have valid content.+ */+ }+ }++ /*+ * If we got an error, then the node is only partially swapped.+ * We mark the buffer invalid so that the next attempt to get the+ * node will read it and attempt to swap again, and will notice+ * the error again. If we didn't do this, the next attempt to get+ * the node might use the partially swapped node as-is.+ */+ if (retval)+ buf_markinvalid(bp);+ }+ }++ if (retval) {+ if (bp)+ buf_brelse(bp);+ block->blockHeader = NULL;+ block->buffer = NULL;+ }++ return (retval);+}+++void ModifyBlockStart(FileReference vp, BlockDescPtr blockPtr)+{+ struct hfsmount *hfsmp = VTOHFS(vp);+ struct buf *bp = NULL;++ if (hfsmp->jnl == NULL) {+ return;+ }++ bp = (struct buf *) blockPtr->blockHeader;+ if (bp == NULL) {+ panic("hfs: ModifyBlockStart: null bp for blockdescptr %p?!?\n", blockPtr);+ return;+ }++ journal_modify_block_start(hfsmp->jnl, bp);+ blockPtr->isModified = 1;+}++void+btree_swap_node(struct buf *bp, __unused void *arg)+{+ // struct hfsmount *hfsmp = (struct hfsmount *)arg;+ int retval;+ struct vnode *vp = buf_vnode(bp);+ BlockDescriptor block;++ /* Prepare the block pointer */+ block.blockHeader = bp;+ block.buffer = (char *)buf_dataptr(bp);+ block.blockNum = buf_lblkno(bp);+ /* not found in cache ==> came from disk */+ block.blockReadFromDisk = (buf_fromcache(bp) == 0);+ block.blockSize = buf_count(bp);++ /* Swap the data now that this node is ready to go to disk.+ * We allow swapping of zeroed out nodes here because we might+ * be writing node whose last record just got deleted.+ */+ retval = hfs_swap_BTNode (&block, vp, kSwapBTNodeHostToBig, true);+ if (retval)+ panic("hfs: btree_swap_node: about to write corrupt node!\n");+}+++static int+btree_journal_modify_block_end(struct hfsmount *hfsmp, struct buf *bp)+{+ return journal_modify_block_end(hfsmp->jnl, bp, btree_swap_node, hfsmp);+}+++OSStatus ReleaseBTreeBlock(FileReference vp, BlockDescPtr blockPtr, ReleaseBlockOptions options)+{+ struct hfsmount *hfsmp = VTOHFS(vp);+ OSStatus retval = E_NONE;+ struct buf *bp = NULL;++ bp = (struct buf *) blockPtr->blockHeader;++ if (bp == NULL) {+ retval = -1;+ goto exit;+ }++ if (options & kTrashBlock) {+ buf_markinvalid(bp);++ if (hfsmp->jnl && (buf_flags(bp) & B_LOCKED)) {+ journal_kill_block(hfsmp->jnl, bp);+ } else {+ buf_brelse(bp); /* note: B-tree code will clear blockPtr->blockHeader and blockPtr->buffer */+ }++ /* Don't let anyone else try to use this bp, it's been consumed */+ blockPtr->blockHeader = NULL;++ } else {+ if (options & kForceWriteBlock) {+ if (hfsmp->jnl) {+ if (blockPtr->isModified == 0) {+ panic("hfs: releaseblock: modified is 0 but forcewrite set! bp %p\n", bp);+ }++ retval = btree_journal_modify_block_end(hfsmp, bp);+ blockPtr->isModified = 0;+ } else {+ retval = VNOP_BWRITE(bp);+ }++ /* Don't let anyone else try to use this bp, it's been consumed */+ blockPtr->blockHeader = NULL;++ } else if (options & kMarkBlockDirty) {+ struct timeval tv;+ microuptime(&tv);+ if ((options & kLockTransaction) && hfsmp->jnl == NULL) {+ /*+ *+ * Set the B_LOCKED flag and unlock the buffer, causing buf_brelse to move+ * the buffer onto the LOCKED free list. This is necessary, otherwise+ * getnewbuf() would try to reclaim the buffers using buf_bawrite, which+ * isn't going to work.+ *+ */+ /* Don't hog all the buffers... */+ if (count_lock_queue() > kMaxLockedMetaBuffers) {+ hfs_btsync(vp, HFS_SYNCTRANS);+ /* Rollback sync time to cause a sync on lock release... */+ (void) BTSetLastSync(VTOF(vp), tv.tv_sec - (kMaxSecsForFsync + 1));+ }+ buf_setflags(bp, B_LOCKED);+ }++ /*+ * Delay-write this block.+ * If the maximum delayed buffers has been exceeded then+ * free up some buffers and fall back to an asynchronous write.+ */+ if (hfsmp->jnl) {+ if (blockPtr->isModified == 0) {+ panic("hfs: releaseblock: modified is 0 but markdirty set! bp %p\n", bp);+ }+ retval = btree_journal_modify_block_end(hfsmp, bp);+ blockPtr->isModified = 0;+ } else if (bdwrite_internal(bp, 1) != 0) {+ hfs_btsync(vp, 0);+ /* Rollback sync time to cause a sync on lock release... */+ (void) BTSetLastSync(VTOF(vp), tv.tv_sec - (kMaxSecsForFsync + 1));++ buf_clearflags(bp, B_LOCKED);+ buf_bawrite(bp);+ }++ /* Don't let anyone else try to use this bp, it's been consumed */+ blockPtr->blockHeader = NULL;++ } else {+ // check if we had previously called journal_modify_block_start()+ // on this block and if so, abort it (which will call buf_brelse()).+ if (hfsmp->jnl && blockPtr->isModified) {+ // XXXdbg - I don't want to call modify_block_abort()+ // because I think it may be screwing up the+ // journal and blowing away a block that has+ // valid data in it.+ //+ // journal_modify_block_abort(hfsmp->jnl, bp);+ //panic("hfs: releaseblock called for 0x%x but mod_block_start previously called.\n", bp);+ btree_journal_modify_block_end(hfsmp, bp);+ blockPtr->isModified = 0;+ } else {+ buf_brelse(bp); /* note: B-tree code will clear blockPtr->blockHeader and blockPtr->buffer */+ }++ /* Don't let anyone else try to use this bp, it's been consumed */+ blockPtr->blockHeader = NULL;+ }+ }++exit:+ return (retval);+}+++OSStatus ExtendBTreeFile(FileReference vp, FSSize minEOF, FSSize maxEOF)+{+#pragma unused (maxEOF)++ OSStatus retval = 0, ret = 0;+ int64_t actualBytesAdded, origSize;+ u_int64_t bytesToAdd;+ u_int32_t startAllocation;+ u_int32_t fileblocks;+ BTreeInfoRec btInfo;+ ExtendedVCB *vcb;+ FCB *filePtr;+ struct proc *p = NULL;+ int64_t trim = 0;+ int lockflags = 0;++ filePtr = GetFileControlBlock(vp);++ if ( (off_t)minEOF > filePtr->fcbEOF )+ {+ bytesToAdd = minEOF - filePtr->fcbEOF;++ if (bytesToAdd < filePtr->ff_clumpsize)+ bytesToAdd = filePtr->ff_clumpsize; //XXX why not always be a mutiple of clump size?+ }+ else+ {+ return -1;+ }++ vcb = VTOVCB(vp);++ /*+ * The Extents B-tree can't have overflow extents. ExtendFileC will+ * return an error if an attempt is made to extend the Extents B-tree+ * when the resident extents are exhausted.+ */++ /* Protect allocation bitmap and extents overflow file. */+ lockflags = SFL_BITMAP;+ if (VTOC(vp)->c_fileid != kHFSExtentsFileID)+ lockflags |= SFL_EXTENTS;+ lockflags = hfs_systemfile_lock(vcb, lockflags, HFS_EXCLUSIVE_LOCK);++ (void) BTGetInformation(filePtr, 0, &btInfo);++#if 0 // XXXdbg+ /*+ * The b-tree code expects nodes to be contiguous. So when+ * the allocation block size is less than the b-tree node+ * size, we need to force disk allocations to be contiguous.+ */+ if (vcb->blockSize >= btInfo.nodeSize) {+ extendFlags = 0;+ } else {+ /* Ensure that all b-tree nodes are contiguous on disk */+ extendFlags = kEFContigMask;+ }+#endif++ origSize = filePtr->fcbEOF;+ fileblocks = filePtr->ff_blocks;+ startAllocation = vcb->nextAllocation;++ // loop trying to get a contiguous chunk that's an integer multiple+ // of the btree node size. if we can't get a contiguous chunk that+ // is at least the node size then we break out of the loop and let+ // the error propagate back up.+ while((off_t)bytesToAdd >= btInfo.nodeSize) {+ do {+ retval = ExtendFileC(vcb, filePtr, bytesToAdd, 0,+ kEFContigMask | kEFMetadataMask | kEFNoClumpMask,+ (int64_t *)&actualBytesAdded);+ if (retval == dskFulErr && actualBytesAdded == 0) {+ bytesToAdd >>= 1;+ if (bytesToAdd < btInfo.nodeSize) {+ break;+ } else if ((bytesToAdd % btInfo.nodeSize) != 0) {+ // make sure it's an integer multiple of the nodeSize+ bytesToAdd -= (bytesToAdd % btInfo.nodeSize);+ }+ }+ } while (retval == dskFulErr && actualBytesAdded == 0);++ if (retval == dskFulErr && actualBytesAdded == 0 && bytesToAdd <= btInfo.nodeSize) {+ break;+ }++ filePtr->fcbEOF = (u_int64_t)filePtr->ff_blocks * (u_int64_t)vcb->blockSize;+ bytesToAdd = minEOF - filePtr->fcbEOF;+ }++ /*+ * If a new extent was added then move the roving allocator+ * reference forward by the current b-tree file size so+ * there's plenty of room to grow.+ */+ if ((retval == 0) &&+ ((VCBTOHFS(vcb)->hfs_flags & HFS_METADATA_ZONE) == 0) &&+ (vcb->nextAllocation > startAllocation) &&+ ((vcb->nextAllocation + fileblocks) < vcb->allocLimit)) {+ HFS_UPDATE_NEXT_ALLOCATION(vcb, vcb->nextAllocation + fileblocks);+ }++ filePtr->fcbEOF = (u_int64_t)filePtr->ff_blocks * (u_int64_t)vcb->blockSize;++ // XXXdbg ExtendFileC() could have returned an error even though+ // it grew the file to be big enough for our needs. If this is+ // the case, we don't care about retval so we blow it away.+ //+ if (filePtr->fcbEOF >= (off_t)minEOF && retval != 0) {+ retval = 0;+ }++ // XXXdbg if the file grew but isn't large enough or isn't an+ // even multiple of the nodeSize then trim things back. if+ // the file isn't large enough we trim back to the original+ // size. otherwise we trim back to be an even multiple of the+ // btree node size.+ //+ if ((filePtr->fcbEOF < (off_t)minEOF) || ((filePtr->fcbEOF - origSize) % btInfo.nodeSize) != 0) {++ if (filePtr->fcbEOF < (off_t)minEOF) {+ retval = dskFulErr;++ if (filePtr->fcbEOF < origSize) {+ panic("hfs: btree file eof %lld less than orig size %lld!\n",+ filePtr->fcbEOF, origSize);+ }++ trim = filePtr->fcbEOF - origSize;+ } else {+ trim = ((filePtr->fcbEOF - origSize) % btInfo.nodeSize);+ }++ ret = TruncateFileC(vcb, filePtr, filePtr->fcbEOF - trim, 0, 0, FTOC(filePtr)->c_fileid, 0);+ filePtr->fcbEOF = (u_int64_t)filePtr->ff_blocks * (u_int64_t)vcb->blockSize;++ // XXXdbg - panic if the file didn't get trimmed back properly+ if ((filePtr->fcbEOF % btInfo.nodeSize) != 0) {+ panic("hfs: truncate file didn't! fcbEOF %lld nsize %d fcb %p\n",+ filePtr->fcbEOF, btInfo.nodeSize, filePtr);+ }++ if (ret) {+ // XXXdbg - this probably doesn't need to be a panic()+ panic("hfs: error truncating btree files (sz 0x%llx, trim %lld, ret %ld)\n",+ filePtr->fcbEOF, trim, (long)ret);+ goto out;+ }+ }++ if(VTOC(vp)->c_fileid != kHFSExtentsFileID) {+ /*+ * Get any extents overflow b-tree changes to disk ASAP!+ */+ (void) BTFlushPath(VTOF(vcb->extentsRefNum));+ (void) hfs_fsync(vcb->extentsRefNum, MNT_WAIT, 0, p);+ }+ hfs_systemfile_unlock(vcb, lockflags);+ lockflags = 0;++ if ((filePtr->fcbEOF % btInfo.nodeSize) != 0) {+ panic("hfs: extendbtree: fcb %p has eof 0x%llx not a multiple of 0x%x (trim %llx)\n",+ filePtr, filePtr->fcbEOF, btInfo.nodeSize, trim);+ }++ /*+ * Update the Alternate MDB or Alternate VolumeHeader+ */+ VTOC(vp)->c_flag |= C_MODIFIED;+ if ((VTOC(vp)->c_fileid == kHFSExtentsFileID) ||+ (VTOC(vp)->c_fileid == kHFSCatalogFileID) ||+ (VTOC(vp)->c_fileid == kHFSAttributesFileID)+ ) {+ MarkVCBDirty( vcb );+ ret = hfs_flushvolumeheader(VCBTOHFS(vcb), HFS_FVH_WAIT | HFS_FVH_WRITE_ALT);+ } else {+ VTOC(vp)->c_touch_chgtime = TRUE;+ VTOC(vp)->c_touch_modtime = TRUE;+ (void) hfs_update(vp, 0);+ }++ ret = ClearBTNodes(vp, btInfo.nodeSize, origSize, (filePtr->fcbEOF - origSize));+out:+ if (retval == 0)+ retval = ret;++ if (lockflags)+ hfs_systemfile_unlock(vcb, lockflags);++ return retval;+}+++/*+ * Clear out (zero) new b-tree nodes on disk.+ */+static int+ClearBTNodes(struct vnode *vp, int blksize, off_t offset, off_t amount)+{+ struct hfsmount *hfsmp = VTOHFS(vp);+ struct buf *bp = NULL;+ daddr64_t blk;+ daddr64_t blkcnt;++ blk = offset / blksize;+ blkcnt = amount / blksize;++ while (blkcnt > 0) {+ bp = buf_getblk(vp, blk, blksize, 0, 0, BLK_META);+ if (bp == NULL)+ continue;++ // XXXdbg+ if (hfsmp->jnl) {+ // XXXdbg -- skipping this for now since it makes a transaction+ // become *way* too large+ //journal_modify_block_start(hfsmp->jnl, bp);+ }+ bzero((char *)buf_dataptr(bp), blksize);++ buf_markaged(bp);++ // XXXdbg+ if (hfsmp->jnl) {+ // XXXdbg -- skipping this for now since it makes a transaction+ // become *way* too large+ //journal_modify_block_end(hfsmp->jnl, bp);++ // XXXdbg - remove this once we decide what to do with the+ // writes to the journal+ if ((blk % 32) == 0)+ VNOP_BWRITE(bp);+ else+ buf_bawrite(bp);+ } else {+ /* wait/yield every 32 blocks so we don't hog all the buffers */+ if ((blk % 32) == 0)+ VNOP_BWRITE(bp);+ else+ buf_bawrite(bp);+ }+ --blkcnt;+ ++blk;+ }++ return (0);+}+++extern char hfs_attrname[];++/*+ * Create an HFS+ Attribute B-tree File.+ *+ * No global resources should be held.+ */+int+hfs_create_attr_btree(struct hfsmount *hfsmp, u_int32_t nodesize, u_int32_t nodecnt)+{+ struct vnode* vp = NULLVP;+ struct cat_desc cndesc;+ struct cat_attr cnattr;+ struct cat_fork cfork;+ BlockDescriptor blkdesc;+ BTNodeDescriptor *ndp;+ BTHeaderRec *bthp;+ BTreeControlBlockPtr btcb = NULL;+ struct buf *bp = NULL;+ void * buffer;+ u_int8_t *bitmap;+ u_int16_t *index;+ u_int32_t node_num, num_map_nodes;+ u_int32_t bytes_per_map_record;+ u_int32_t temp;+ u_int16_t offset;+ int intrans = 0;+ int result;+ int newvnode_flags = 0;++again:+ /*+ * Serialize creation using HFS_CREATING_BTREE flag.+ */+ hfs_lock_mount (hfsmp);+ if (hfsmp->hfs_flags & HFS_CREATING_BTREE) {+ /* Someone else beat us, wait for them to finish. */+ (void) msleep(&hfsmp->hfs_attribute_cp, &hfsmp->hfs_mutex,+ PDROP | PINOD, "hfs_create_attr_btree", 0);+ if (hfsmp->hfs_attribute_vp) {+ return (0);+ }+ goto again;+ }+ hfsmp->hfs_flags |= HFS_CREATING_BTREE;+ hfs_unlock_mount (hfsmp);++ /* Check if were out of usable disk space. */+ if ((hfs_freeblks(hfsmp, 1) == 0)) {+ result = ENOSPC;+ goto exit;+ }++ /*+ * Set up Attribute B-tree vnode+ * (this must be done before we start a transaction+ * or take any system file locks)+ */+ bzero(&cndesc, sizeof(cndesc));+ cndesc.cd_parentcnid = kHFSRootParentID;+ cndesc.cd_flags |= CD_ISMETA;+ cndesc.cd_nameptr = (const u_int8_t *)hfs_attrname;+ cndesc.cd_namelen = strlen(hfs_attrname);+ cndesc.cd_cnid = kHFSAttributesFileID;++ bzero(&cnattr, sizeof(cnattr));+ cnattr.ca_linkcount = 1;+ cnattr.ca_mode = S_IFREG;+ cnattr.ca_fileid = cndesc.cd_cnid;++ bzero(&cfork, sizeof(cfork));+ cfork.cf_clump = nodesize * nodecnt;++ result = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr,+ &cfork, &vp, &newvnode_flags);+ if (result) {+ goto exit;+ }+ /*+ * Set up Attribute B-tree control block+ */+ btcb = hfs_malloc_type(BTreeControlBlock);++ btcb->nodeSize = nodesize;+ btcb->maxKeyLength = kHFSPlusAttrKeyMaximumLength;+ btcb->btreeType = 0xFF;+ btcb->attributes = kBTVariableIndexKeysMask | kBTBigKeysMask;+ btcb->version = kBTreeVersion;+ btcb->writeCount = 1;+ btcb->flags = 0; /* kBTHeaderDirty */+ btcb->fileRefNum = vp;+ btcb->getBlockProc = GetBTreeBlock;+ btcb->releaseBlockProc = ReleaseBTreeBlock;+ btcb->setEndOfForkProc = ExtendBTreeFile;+ btcb->keyCompareProc = (KeyCompareProcPtr)hfs_attrkeycompare;++ /*+ * NOTE: We must make sure to zero out this pointer if we error out in this function!+ * If we don't, then unmount will treat it as a valid pointer which can lead to a+ * use-after-free+ */+ VTOF(vp)->fcbBTCBPtr = btcb;++ /*+ * Allocate some space+ */+ if (hfs_start_transaction(hfsmp) != 0) {+ result = EINVAL;+ goto exit;+ }+ intrans = 1;++ /* Note ExtendBTreeFile will acquire the necessary system file locks. */+ result = ExtendBTreeFile(vp, nodesize, cfork.cf_clump);+ if (result)+ goto exit;++ btcb->totalNodes = VTOF(vp)->ff_size / nodesize;++ /*+ * Figure out how many map nodes we'll need.+ *+ * bytes_per_map_record = the number of bytes in the map record of a+ * map node. Since that is the only record in the node, it is the size+ * of the node minus the node descriptor at the start, and two record+ * offsets at the end of the node. The "- 2" is to round the size down+ * to a multiple of 4 bytes (since sizeof(BTNodeDescriptor) is not a+ * multiple of 4).+ *+ * The value "temp" here is the number of *bits* in the map record of+ * the header node.+ */+ bytes_per_map_record = nodesize - sizeof(BTNodeDescriptor) - 2*sizeof(u_int16_t) - 2;+ temp = 8 * (nodesize - sizeof(BTNodeDescriptor)+ - sizeof(BTHeaderRec)+ - kBTreeHeaderUserBytes+ - 4 * sizeof(u_int16_t));+ if (btcb->totalNodes > temp) {+ num_map_nodes = howmany(btcb->totalNodes - temp, bytes_per_map_record * 8);+ }+ else {+ num_map_nodes = 0;+ }++ btcb->freeNodes = btcb->totalNodes - 1 - num_map_nodes;++ /*+ * Initialize the b-tree header on disk+ */+ bp = buf_getblk(vp, 0, nodesize, 0, 0, BLK_META);+ if (bp == NULL) {+ result = EIO;+ goto exit;+ }++ buffer = (void *)buf_dataptr(bp);+ blkdesc.buffer = buffer;+ blkdesc.blockHeader = (void *)bp;+ blkdesc.blockReadFromDisk = 0;+ blkdesc.isModified = 0;++ ModifyBlockStart(vp, &blkdesc);++ if (buf_size(bp) != nodesize)+ panic("hfs_create_attr_btree: bad buffer size (%d)\n", buf_size(bp));++ bzero(buffer, nodesize);+ index = (u_int16_t *)buffer;++ /* FILL IN THE NODE DESCRIPTOR: */+ ndp = (BTNodeDescriptor *)buffer;+ if (num_map_nodes != 0)+ ndp->fLink = 1;+ ndp->kind = kBTHeaderNode;+ ndp->numRecords = 3;+ offset = sizeof(BTNodeDescriptor);+ index[(nodesize / 2) - 1] = offset;++ /* FILL IN THE HEADER RECORD: */+ bthp = (BTHeaderRec *)((u_int8_t *)buffer + offset);+ bthp->nodeSize = nodesize;+ bthp->totalNodes = btcb->totalNodes;+ bthp->freeNodes = btcb->freeNodes;+ bthp->clumpSize = cfork.cf_clump;+ bthp->btreeType = 0xFF;+ bthp->attributes = kBTVariableIndexKeysMask | kBTBigKeysMask;+ bthp->maxKeyLength = kHFSPlusAttrKeyMaximumLength;+ bthp->keyCompareType = kHFSBinaryCompare;+ offset += sizeof(BTHeaderRec);+ index[(nodesize / 2) - 2] = offset;++ /* FILL IN THE USER RECORD: */+ offset += kBTreeHeaderUserBytes;+ index[(nodesize / 2) - 3] = offset;++ /* Mark the header node and map nodes in use in the map record.+ *+ * NOTE: Assumes that the header node's map record has at least+ * (num_map_nodes + 1) bits.+ */+ bitmap = (u_int8_t *) buffer + offset;+ temp = num_map_nodes + 1; /* +1 for the header node */+ while (temp >= 8) {+ *(bitmap++) = 0xFF;+ temp -= 8;+ }+ *bitmap = ~(0xFF >> temp);++ offset += nodesize - sizeof(BTNodeDescriptor) - sizeof(BTHeaderRec)+ - kBTreeHeaderUserBytes - (4 * sizeof(int16_t));+ index[(nodesize / 2) - 4] = offset;++ if (hfsmp->jnl) {+ result = btree_journal_modify_block_end(hfsmp, bp);+ } else {+ result = VNOP_BWRITE(bp);+ }+ if (result)+ goto exit;++ /* Create the map nodes: node numbers 1 .. num_map_nodes */+ for (node_num=1; node_num <= num_map_nodes; ++node_num) {+ bp = buf_getblk(vp, node_num, nodesize, 0, 0, BLK_META);+ if (bp == NULL) {+ result = EIO;+ goto exit;+ }+ buffer = (void *)buf_dataptr(bp);+ blkdesc.buffer = buffer;+ blkdesc.blockHeader = (void *)bp;+ blkdesc.blockReadFromDisk = 0;+ blkdesc.isModified = 0;++ ModifyBlockStart(vp, &blkdesc);++ bzero(buffer, nodesize);+ index = (u_int16_t *)buffer;++ /* Fill in the node descriptor */+ ndp = (BTNodeDescriptor *)buffer;+ if (node_num != num_map_nodes)+ ndp->fLink = node_num + 1;+ ndp->kind = kBTMapNode;+ ndp->numRecords = 1;+ offset = sizeof(BTNodeDescriptor);+ index[(nodesize / 2) - 1] = offset;+++ /* Fill in the map record's offset */+ /* Note: We assume that the map record is all zeroes */+ offset = sizeof(BTNodeDescriptor) + bytes_per_map_record;+ index[(nodesize / 2) - 2] = offset;++ if (hfsmp->jnl) {+ result = btree_journal_modify_block_end(hfsmp, bp);+ } else {+ result = VNOP_BWRITE(bp);+ }+ if (result)+ goto exit;+ }++ /* Update vp/cp for attribute btree */+ hfs_lock_mount (hfsmp);+ hfsmp->hfs_attribute_cp = VTOC(vp);+ hfsmp->hfs_attribute_vp = vp;+ hfs_unlock_mount (hfsmp);++ (void) hfs_flushvolumeheader(hfsmp, HFS_FVH_WAIT | HFS_FVH_WRITE_ALT);++ if (intrans) {+ hfs_end_transaction(hfsmp);+ intrans = 0;+ }++ /* Initialize the vnode for virtual attribute data file */+ result = init_attrdata_vnode(hfsmp);+ if (result) {+ printf("hfs_create_attr_btree: vol=%s init_attrdata_vnode() error=%d\n", hfsmp->vcbVN, result);+ }++exit:++ if (vp && result) {+ /*+ * If we're about to error out, then make sure to zero out the B-Tree control block pointer+ * from the filefork of the EA B-Tree cnode/vnode. Failing to do this will lead to a use+ * after free at unmount or BTFlushPath. Since we're about to error out anyway, this memory+ * will be freed.+ */+ VTOF(vp)->fcbBTCBPtr = NULL;+ }+++ if (vp) {+ hfs_unlock(VTOC(vp));+ }+ if (result) {+ hfs_free_type(btcb, BTreeControlBlock);+ if (vp) {+ vnode_put(vp);+ }+ /* XXX need to give back blocks ? */+ }+ if (intrans) {+ hfs_end_transaction(hfsmp);+ }++ /*+ * All done, clear HFS_CREATING_BTREE, and wake up any sleepers.+ */+ hfs_lock_mount (hfsmp);+ hfsmp->hfs_flags &= ~HFS_CREATING_BTREE;+ wakeup((caddr_t)&hfsmp->hfs_attribute_cp);+ hfs_unlock_mount (hfsmp);++ return (result);+}+diff --git a/xnu/files/bsd/hfs/hfs_btreeio.h b/xnu/files/bsd/hfs/hfs_btreeio.hnew file mode 100644index 0000000..740734d--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_btreeio.h@@ -0,0 +1,59 @@+/*+ * Copyright (c) 2005-2015 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@+ */+#ifndef _HFS_BTREEIO_H_+#define _HFS_BTREEIO_H_++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE++#include "hfs.h"+#include "BTreesInternal.h"++/* BTree accessor routines */+extern OSStatus SetBTreeBlockSize(FileReference vp, ByteCount blockSize,+ ItemCount minBlockCount);++extern OSStatus GetBTreeBlock(FileReference vp, u_int32_t blockNum,+ GetBlockOptions options, BlockDescriptor *block);++extern OSStatus ReleaseBTreeBlock(FileReference vp, BlockDescPtr blockPtr,+ ReleaseBlockOptions options);++extern OSStatus ExtendBTreeFile(FileReference vp, FSSize minEOF, FSSize maxEOF);++extern void ModifyBlockStart(FileReference vp, BlockDescPtr blockPtr);++int hfs_create_attr_btree(struct hfsmount *hfsmp, u_int32_t nodesize, u_int32_t nodecnt);++u_int16_t get_btree_nodesize(struct vnode *vp);++#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */+#endif /* ! _HFS_BTREEIO_H_ */diff --git a/xnu/files/bsd/hfs/hfs_builtin.c b/xnu/files/bsd/hfs/hfs_builtin.cnew file mode 100644index 0000000..666a098--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_builtin.c@@ -0,0 +1,67 @@+/*+ * HakiOS: what HFS's kext had in its C++ part (hfs_iokit.cpp), for HFS built into the kernel.+ *+ * The kext registered the filesystem from its IOService's start(); built in, it is an entry of the static table+ * (bsd/vfs/vfs_conf.c) and hfs_init() does the rest. The IOKit questions -- is the medium ejectable, which media+ * carry a given content UUID, the platform's serial number -- have no use for a data volume on the phone's own+ * flash, and the keys of content protection are AppleKeyStore's, which this kernel does not have: a volume made+ * without content protection never asks for them.+ */+#include <sys/types.h>+#include <sys/errno.h>+#include <stdbool.h>+#include <mach/kern_return.h>+#include "hfs.h"+#include "hfs_iokit.h"++#ifndef panic_on_assert+bool panic_on_assert = false;+#endif++int+hfs_is_ejectable(__unused const char *cdev_name)+{+ return 0;+}++void+hfs_iterate_media_with_content(__unused const char *content_uuid_cstring,+ __unused int (*func)(const char *bsd_name, const char *uuid_str, void *arg), __unused void *arg)+{+}++kern_return_t+hfs_get_platform_serial_number(__unused char *serial_number_str, __unused uint32_t len)+{+ return KERN_FAILURE;+}++#if CONFIG_PROTECT+int+hfs_unwrap_key(__unused aks_cred_t access, __unused const aks_wrapped_key_t wrapped_key_in,+ __unused aks_raw_key_t key_out)+{+ return ENOTSUP;+}++int+hfs_rewrap_key(__unused aks_cred_t access, __unused cp_key_class_t dp_class,+ __unused const aks_wrapped_key_t wrapped_key_in, __unused aks_wrapped_key_t wrapped_key_out)+{+ return ENOTSUP;+}++int+hfs_new_key(__unused aks_cred_t access, __unused cp_key_class_t dp_class, __unused aks_raw_key_t key_out,+ __unused aks_wrapped_key_t wrapped_key_out)+{+ return ENOTSUP;+}++int+hfs_backup_key(__unused aks_cred_t access, __unused const aks_wrapped_key_t wrapped_key_in,+ __unused aks_wrapped_key_t wrapped_key_out)+{+ return ENOTSUP;+}+#endif /* CONFIG_PROTECT */diff --git a/xnu/files/bsd/hfs/hfs_catalog.c b/xnu/files/bsd/hfs/hfs_catalog.cnew file mode 100644index 0000000..98fcb51--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_catalog.c@@ -0,0 +1,4131 @@+/*+ * Copyright (c) 2000-2015 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@+ */++#include <sys/systm.h>+#include <sys/kernel.h>+#include <sys/malloc.h>+#include <sys/stat.h>+#include <sys/mount.h>+#include <sys/vnode.h>+#include <sys/dirent.h>+#include <vfs/vfs_support.h>+#include <libkern/libkern.h>++#include <sys/utfconv.h>++#include "hfs.h"+#include "hfs_catalog.h"+#include "hfs_format.h"+#include "hfs_endian.h"++#include "BTreesInternal.h"+#include "BTreesPrivate.h"+#include "HFSUnicodeWrappers.h"+++/*+ * Initialization of an FSBufferDescriptor structure.+ */+#define BDINIT(bd, addr) { \+ (bd).bufferAddress = (addr); \+ (bd).itemSize = sizeof(*(addr)); \+ (bd).itemCount = 1; \+}+++struct btobj {+ BTreeIterator iterator;+ HFSPlusCatalogKey key;+ CatalogRecord data;+};++struct update_state {+ struct cat_desc * s_desc;+ struct cat_attr * s_attr;+ const struct cat_fork * s_datafork;+ const struct cat_fork * s_rsrcfork;+ struct hfsmount * s_hfsmp;+};++struct position_state {+ int error;+ u_int32_t count;+ u_int32_t index;+ u_int32_t parentID;+ struct hfsmount *hfsmp;+};++/* Map file mode type to directory entry types */+u_char modetodirtype[16] = {+ DT_REG, DT_FIFO, DT_CHR, DT_UNKNOWN,+ DT_DIR, DT_UNKNOWN, DT_BLK, DT_UNKNOWN,+ DT_REG, DT_UNKNOWN, DT_LNK, DT_UNKNOWN,+ DT_SOCK, DT_UNKNOWN, DT_WHT, DT_UNKNOWN+};+#define MODE_TO_DT(mode) (modetodirtype[((mode) & S_IFMT) >> 12])+++#define HFS_LOOKUP_SYSFILE 0x1 /* If set, allow lookup of system files */+#define HFS_LOOKUP_HARDLINK 0x2 /* If set, allow lookup of hard link records and not resolve the hard links */+#define HFS_LOOKUP_CASESENSITIVE 0x4 /* If set, verify results of a file/directory record match input case */+static int cat_lookupbykey(struct hfsmount *hfsmp, CatalogKey *keyp, int flags, u_int32_t hint, int wantrsrc,+ struct cat_desc *descp, struct cat_attr *attrp, struct cat_fork *forkp, cnid_t *desc_cnid);++int cat_lookupmangled(struct hfsmount *hfsmp, struct cat_desc *descp, int wantrsrc,+ struct cat_desc *outdescp, struct cat_attr *attrp, struct cat_fork *forkp);++/* Internal catalog support routines */++static int cat_findposition(const CatalogKey *ckp, const CatalogRecord *crp,+ struct position_state *state);++static int resolvelinkid(struct hfsmount *hfsmp, u_int32_t linkref, ino_t *ino);++static int getkey(struct hfsmount *hfsmp, cnid_t cnid, CatalogKey * key);++static int buildkey(struct hfsmount *hfsmp, struct cat_desc *descp,+ HFSPlusCatalogKey *key, int retry);++static void buildthreadkey(HFSCatalogNodeID parentID, CatalogKey *key);++static void buildrecord(struct cat_attr *attrp, cnid_t cnid, u_int32_t encoding, CatalogRecord *crp, u_int32_t *recordSize);++static int catrec_update(const CatalogKey *ckp, CatalogRecord *crp, struct update_state *state);++static int builddesc(const HFSPlusCatalogKey *key, cnid_t cnid, u_int32_t hint, u_int32_t encoding,+ int isdir, struct cat_desc *descp);++static void getbsdattr(struct hfsmount *hfsmp, const struct HFSPlusCatalogFile *crp, struct cat_attr * attrp);++static cnid_t getcnid(const CatalogRecord *crp);+static u_int32_t getencoding(const CatalogRecord *crp);+static cnid_t getparentcnid(const CatalogRecord *recp);++static int isadir(const CatalogRecord *crp);++static int buildthread(void *keyp, void *recp, int directory);++static int cat_makealias(struct hfsmount *hfsmp, u_int32_t inode_num, struct HFSPlusCatalogFile *crp);++static int cat_update_internal(struct hfsmount *hfsmp, int update_hardlink, struct cat_desc *descp, struct cat_attr *attrp,+ const struct cat_fork *dataforkp, const struct cat_fork *rsrcforkp);++++/* HFS ID Hashtable Functions */+#define IDHASH(hfsmp, inum) (&hfsmp->hfs_idhashtbl[(inum) & hfsmp->hfs_idhash])++/* Initialize the HFS ID hash table */+void+hfs_idhash_init (struct hfsmount *hfsmp) {+ /* secured by catalog lock so no lock init needed */+ hfsmp->hfs_idhashtbl = hashinit(HFS_IDHASH_DEFAULT, M_TEMP, &hfsmp->hfs_idhash);+}++/* Free the HFS ID hash table */+void+hfs_idhash_destroy (struct hfsmount *hfsmp) {+ /* during failed mounts & unmounts */+ hashdestroy(hfsmp->hfs_idhashtbl, M_TEMP, hfsmp->hfs_idhash);+ hfsmp->hfs_idhashtbl = NULL;+}++/*+from hfs_catalog.h:+typedef struct cat_preflightid {+ cnid_t fileid;+ LIST_ENTRY(cat_preflightid) id_hash;+} cat_preflightid_t;++from hfs.h:+ u_long hfs_idhash; / size of cnid/fileid hash table -1 /+ LIST_HEAD(idhashhead, cat_preflightid) *hfs_idhashtbl; / base of ID hash /+*/++/*+ * Check the run-time ID hashtable.+ *+ * The catalog lock must be held (like other functions in this file).+ *+ * Returns:+ * 1 if the ID is in the hash table.+ * 0 if the ID is not in the hash table+ */+int cat_check_idhash (struct hfsmount *hfsmp, cnid_t test_fileid) {++ cat_preflightid_t *preflight;+ int found = 0;++ for (preflight = IDHASH(hfsmp, test_fileid)->lh_first; preflight ; preflight = preflight->id_hash.le_next) {+ if (preflight->fileid == test_fileid) {+ found = 1;+ break;+ }+ }++ return found;+}++/* Insert the supplied preflight into the ID hash table */+int cat_insert_idhash (struct hfsmount *hfsmp, cat_preflightid_t *preflight) {++ if (preflight) {+ LIST_INSERT_HEAD(IDHASH(hfsmp, (preflight->fileid)), preflight, id_hash);+ return 0;+ }+ return -1;+}+++/* Remove the data structure with the specified ID from the hashtable */+int cat_remove_idhash (cat_preflightid_t *preflight) {++ if ((preflight) && ((preflight->id_hash.le_next || preflight->id_hash.le_prev))) {+ LIST_REMOVE (preflight, id_hash);+ preflight->id_hash.le_next = NULL;+ preflight->id_hash.le_prev = NULL;++ return 0;+ }++ return -1;+}++/*+ * Acquire a new CNID for use.+ *+ * This is slightly more complicated than just pulling the value from the+ * hfsmount data structure. We need to validate that the ID is not in-use+ * even if we've not wrapped around and that there are not any lingering+ * or orphaned fileIDs for this ID.+ *+ * Also validate that there are not any pending insertions into the+ * catalog by checking the ID hash table.+ */+int+cat_acquire_cnid (struct hfsmount *hfsmp, cnid_t *new_cnid)+{+ uint32_t nextCNID;+ struct BTreeIterator *iterator;+ FSBufferDescriptor btdata;+ uint16_t datasize;+ CatalogRecord *recp;+ int result = 0;+ int wrapped = 0;++ /*+ * Get the next CNID. We can change it since we hold the catalog lock.+ */+nextid:+ nextCNID = hfsmp->vcbNxtCNID;+ if (nextCNID == 0xFFFFFFFF) {+ wrapped++;+ if (wrapped > 1) {+ /* don't allow more than one wrap-around */+ return ENOSPC;+ }+ hfs_lock_mount (hfsmp);+ hfsmp->vcbNxtCNID = kHFSFirstUserCatalogNodeID;+ hfsmp->vcbAtrb |= kHFSCatalogNodeIDsReusedMask;+ hfs_unlock_mount (hfsmp);+ } else {+ hfsmp->vcbNxtCNID++;+ }+ hfs_note_header_minor_change(hfsmp);++ /* First check that there are not any entries pending in the hash table with this ID */+ if (cat_check_idhash (hfsmp, nextCNID)) {+ /* Someone wants to insert this into the catalog but hasn't done so yet. Skip it */+ goto nextid;+ }++ /* Check to see if a thread record exists for the target ID we just got */+ iterator = hfs_malloc_type(struct BTreeIterator);+ buildthreadkey(nextCNID, (CatalogKey *)&iterator->key);++ recp = hfs_malloc_type(CatalogRecord);+ BDINIT(btdata, recp);++ result = BTSearchRecord(hfsmp->hfs_catalog_cp->c_datafork, iterator, &btdata, &datasize, iterator);+ hfs_free_type(recp, CatalogRecord);+ hfs_free_type(iterator, struct BTreeIterator);++ if (result == btNotFound) {+ /* Good. File ID was not in use. Move on to checking EA B-Tree */+ result = file_attribute_exist (hfsmp, nextCNID);+ if (result == EEXIST) {+ /* This CNID has orphaned EAs. Skip it and move on to the next one */+ result = 0;+ goto nextid;+ }+ if (result) {+ /* For any other error, return the result */+ return result;+ }++ /*+ * Now validate that there are no lingering cnodes with this ID. If a cnode+ * has been removed on-disk (marked C_NOEXISTS), but has not yet been reclaimed,+ * then it will still have an entry in the cnode hash table. This means that+ * a subsequent lookup will find THAT entry and believe this one has been deleted+ * prematurely. If there is a lingering cnode, then just skip this entry and move on.+ *+ * Note that we pass (existence_only == 1) argument to hfs_chash_snoop.+ */+ if (hfsmp->vcbAtrb & kHFSCatalogNodeIDsReusedMask) {+ if (hfs_chash_snoop (hfsmp, nextCNID, 1, NULL, NULL) == 0) {+ goto nextid;+ }+ }++ /*+ * If we get here, then we didn't see any thread records, orphaned EAs,+ * or stale cnodes. This ID is safe to vend out.+ */+ *new_cnid = nextCNID;+ }+ else if (result == noErr) {+ /* move on to the next ID */+ goto nextid;+ }+ else {+ /* For any other situation, just bail out */+ return EIO;+ }++ return 0;++}++int+cat_preflight(struct hfsmount *hfsmp, catops_t ops, cat_cookie_t *cookie, __unused proc_t p)+{+ int lockflags = 0;+ int result;++ if (hfsmp->hfs_catalog_cp->c_lockowner != current_thread())+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);++ result = BTReserveSpace(hfsmp->hfs_catalog_cp->c_datafork, ops, (void*)cookie);++ if (lockflags)+ hfs_systemfile_unlock(hfsmp, lockflags);++ return MacToVFSError(result);+}++void+cat_postflight(struct hfsmount *hfsmp, cat_cookie_t *cookie, __unused proc_t p)+{+ int lockflags = 0;++ if (hfsmp->hfs_catalog_cp->c_lockowner != current_thread())+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);++ (void) BTReleaseReserve(hfsmp->hfs_catalog_cp->c_datafork, (void*)cookie);++ if (lockflags)+ hfs_systemfile_unlock(hfsmp, lockflags);+}++void+cat_convertattr(+ struct hfsmount *hfsmp,+ CatalogRecord * recp,+ struct cat_attr *attrp,+ struct cat_fork *datafp,+ struct cat_fork *rsrcfp)+{+ getbsdattr(hfsmp, (struct HFSPlusCatalogFile *)recp, attrp);++ if (isadir(recp)) {+ bzero(datafp, sizeof(*datafp));+ } else {+ /* Convert the data fork. */+ datafp->cf_size = recp->hfsPlusFile.dataFork.logicalSize;+ datafp->cf_new_size = 0;+ datafp->cf_blocks = recp->hfsPlusFile.dataFork.totalBlocks;+ if ((hfsmp->hfc_stage == HFC_RECORDING) &&+ (attrp->ca_atime >= hfsmp->hfc_timebase)) {+ datafp->cf_bytesread =+ recp->hfsPlusFile.dataFork.clumpSize *+ HFSTOVCB(hfsmp)->blockSize;+ } else {+ datafp->cf_bytesread = 0;+ }+ datafp->cf_vblocks = 0;+ bcopy(&recp->hfsPlusFile.dataFork.extents[0],+ &datafp->cf_extents[0], sizeof(HFSPlusExtentRecord));++ /* Convert the resource fork. */+ rsrcfp->cf_size = recp->hfsPlusFile.resourceFork.logicalSize;+ rsrcfp->cf_new_size = 0;+ rsrcfp->cf_blocks = recp->hfsPlusFile.resourceFork.totalBlocks;+ if ((hfsmp->hfc_stage == HFC_RECORDING) &&+ (attrp->ca_atime >= hfsmp->hfc_timebase)) {+ datafp->cf_bytesread =+ recp->hfsPlusFile.resourceFork.clumpSize *+ HFSTOVCB(hfsmp)->blockSize;+ } else {+ datafp->cf_bytesread = 0;+ }+ rsrcfp->cf_vblocks = 0;+ bcopy(&recp->hfsPlusFile.resourceFork.extents[0],+ &rsrcfp->cf_extents[0], sizeof(HFSPlusExtentRecord));+ }+}++/*+ * Convert a raw catalog key and record into an in-core catalog descriptor.+ *+ * Note: The caller is responsible for releasing the catalog descriptor.+ */+int+cat_convertkey(+ struct hfsmount *hfsmp,+ CatalogKey *key,+ CatalogRecord * recp,+ struct cat_desc *descp)+{+ HFSPlusCatalogKey * pluskey = NULL;+ u_int32_t encoding = 0;+ cnid_t cnid = 0;+ int err = 0;++ pluskey = (HFSPlusCatalogKey *)key;+ encoding = getencoding(recp);++ /* Get the CNID before calling builddesc. Need to error check it. */+ cnid = getcnid(recp);+ if (cnid == 0) {+ /* If ths CNID == 0, it's invalid. Mark as corrupt */+ hfs_mark_inconsistent (hfsmp, HFS_INCONSISTENCY_DETECTED);+ err = EINVAL;+ }+ else {+ builddesc(pluskey, cnid, 0, encoding, isadir(recp), descp);+ }++ return err;+}+++/*+ * cat_releasedesc+ */+void+cat_releasedesc(struct cat_desc *descp)+{+ const u_int8_t * name;++ if (descp == NULL)+ return;++ if ((descp->cd_flags & CD_HASBUF) &&+ (descp->cd_nameptr != NULL)) {+ name = descp->cd_nameptr;+ descp->cd_nameptr = NULL;+ descp->cd_namelen = 0;+ vfs_removename((const char *)name);+ }+ descp->cd_nameptr = NULL;+ descp->cd_namelen = 0;+ descp->cd_flags &= ~CD_HASBUF;+}++/*+ * These Catalog functions allow access to the HFS Catalog (database).+ * The catalog b-tree lock must be acquired before calling any of these routines.+ */++/*+ * cat_lookup - lookup a catalog node using a cnode descriptor+ *+ * Note: The caller is responsible for releasing the output+ * catalog descriptor (when supplied outdescp is non-null).+ */+int+cat_lookup(struct hfsmount *hfsmp, struct cat_desc *descp, int wantrsrc, int force_casesensitive_lookup,+ struct cat_desc *outdescp, struct cat_attr *attrp,+ struct cat_fork *forkp, cnid_t *desc_cnid)+{+ CatalogKey * keyp;+ int result = 0;+ int flags;++ flags = force_casesensitive_lookup ? HFS_LOOKUP_CASESENSITIVE : 0;++ keyp = hfs_malloc_type(CatalogKey);++ result = buildkey(hfsmp, descp, (HFSPlusCatalogKey *)keyp, 1);+ if (result)+ goto exit;++ result = cat_lookupbykey(hfsmp, keyp, flags, descp->cd_hint, wantrsrc, outdescp, attrp, forkp, desc_cnid);++ if (result == ENOENT) {+ struct cat_desc temp_desc;+ if (outdescp == NULL) {+ bzero(&temp_desc, sizeof(temp_desc));+ outdescp = &temp_desc;+ }+ result = cat_lookupmangled(hfsmp, descp, wantrsrc, outdescp, attrp, forkp);+ if (desc_cnid) {+ *desc_cnid = outdescp->cd_cnid;+ }+ if (outdescp == &temp_desc) {+ /* Release the local copy of desc */+ cat_releasedesc(outdescp);+ }+ }+exit:+ hfs_free_type(keyp, CatalogKey);++ return (result);+}++int+cat_insertfilethread(struct hfsmount *hfsmp, struct cat_desc *descp)+{+ struct BTreeIterator *iterator;+ struct FSBufferDescriptor file_data;+ struct HFSCatalogFile file_rec;+ u_int16_t datasize;+ FCB *fcb;+ int result;++ if (HFSTOVCB(hfsmp)->vcbSigWord != kHFSSigWord)+ return (EINVAL);++ fcb = GetFileControlBlock(HFSTOVCB(hfsmp)->catalogRefNum);++ iterator = hfs_new_zero(struct BTreeIterator, 2);+ result = buildkey(hfsmp, descp, (HFSPlusCatalogKey *)&iterator[0].key, 0);+ if (result)+ goto exit;++ BDINIT(file_data, &file_rec);+ result = BTSearchRecord(fcb, &iterator[0], &file_data, &datasize, &iterator[0]);+ if (result)+ goto exit;++ if (file_rec.recordType != kHFSFileRecord) {+ result = EISDIR;+ goto exit;+ }++ if ((file_rec.flags & kHFSThreadExistsMask) == 0) {+ struct FSBufferDescriptor thread_data;+ struct HFSCatalogThread thread_rec;++ file_rec.flags |= kHFSThreadExistsMask;+ BDINIT(thread_data, &thread_rec);+ thread_data.itemSize = buildthread(&iterator[0].key, &thread_rec, 0);+ buildthreadkey(file_rec.fileID, (CatalogKey *)&iterator[1].key);++ result = BTInsertRecord(fcb, &iterator[1], &thread_data, thread_data.itemSize);+ if (result)+ goto exit;++ (void) BTReplaceRecord(fcb, &iterator[0], &file_data, datasize);+ (void) BTFlushPath(fcb);+ }+exit:+ (void) BTFlushPath(fcb);+ hfs_delete(iterator, struct BTreeIterator, 2);++ return MacToVFSError(result);+}+++/*+ * cat_findname - obtain a descriptor from cnid+ *+ * Only a thread lookup is performed.+ *+ * Note: The caller is responsible for releasing the output+ * catalog descriptor (when supplied outdescp is non-null).++ */+int+cat_findname(struct hfsmount *hfsmp, cnid_t cnid, struct cat_desc *outdescp)+{+ struct BTreeIterator * iterator;+ FSBufferDescriptor btdata;+ CatalogKey * keyp;+ CatalogRecord * recp;+ int isdir;+ int result;++ isdir = 0;++ iterator = hfs_malloc_type(struct BTreeIterator);+ buildthreadkey(cnid, (CatalogKey *)&iterator->key);+ iterator->hint.nodeNum = 0;++ recp = hfs_malloc_type(CatalogRecord);+ BDINIT(btdata, recp);++ result = BTSearchRecord(VTOF(hfsmp->hfs_catalog_vp), iterator, &btdata, NULL, NULL);+ if (result)+ goto exit;++ /* Turn thread record into a cnode key (in place). */+ switch (recp->recordType) {+ case kHFSPlusFolderThreadRecord:+ isdir = 1;+ /* fall through */+ case kHFSPlusFileThreadRecord:+ keyp = (CatalogKey *)&recp->hfsPlusThread.reserved;+ keyp->hfsPlus.keyLength = kHFSPlusCatalogKeyMinimumLength ++ (keyp->hfsPlus.nodeName.length * 2);+ break;+ default:+ result = ENOENT;+ goto exit;+ }+ builddesc((HFSPlusCatalogKey *)keyp, cnid, 0, 0, isdir, outdescp);++exit:+ hfs_free_type(recp, CatalogRecord);+ hfs_free_type(iterator, struct BTreeIterator);++ return MacToVFSError(result);+}++/*+ * cat_idlookup - lookup a catalog node using a cnode id+ *+ * Note: The caller is responsible for releasing the output+ * catalog descriptor (when supplied outdescp is non-null).+ */+int+cat_idlookup(struct hfsmount *hfsmp, cnid_t cnid, int allow_system_files, int wantrsrc,+ struct cat_desc *outdescp, struct cat_attr *attrp, struct cat_fork *forkp)+{+ struct BTreeIterator * iterator;+ FSBufferDescriptor btdata;+ u_int16_t datasize;+ CatalogKey * keyp;+ CatalogRecord * recp;+ int result;++ iterator = hfs_malloc_type(struct BTreeIterator);+ buildthreadkey(cnid, (CatalogKey *)&iterator->key);++ recp = hfs_malloc_type(CatalogRecord);+ BDINIT(btdata, recp);++ result = BTSearchRecord(VTOF(HFSTOVCB(hfsmp)->catalogRefNum), iterator,+ &btdata, &datasize, iterator);+ if (result)+ goto exit;++ /* Turn thread record into a cnode key (in place) */+ switch (recp->recordType) {+ case kHFSPlusFileThreadRecord:+ case kHFSPlusFolderThreadRecord:+ keyp = (CatalogKey *)&recp->hfsPlusThread.reserved;++ /* check for NULL name */+ if (keyp->hfsPlus.nodeName.length == 0) {+ result = ENOENT;+ goto exit;+ }++ keyp->hfsPlus.keyLength = kHFSPlusCatalogKeyMinimumLength ++ (keyp->hfsPlus.nodeName.length * 2);+ break;++ default:+ result = ENOENT;+ goto exit;+ }++ result = cat_lookupbykey(hfsmp, keyp,+ ((allow_system_files != 0) ? HFS_LOOKUP_SYSFILE : 0),+ 0, wantrsrc, outdescp, attrp, forkp, NULL);+ /* No corresponding file/folder record found for a thread record,+ * mark the volume inconsistent.+ */+ if (result == 0 && outdescp) {+ cnid_t dcnid = outdescp->cd_cnid;+ /*+ * Just for sanity's case, let's make sure that+ * the key in the thread matches the key in the record.+ */+ if (cnid != dcnid) {+ printf("hfs: cat_idlookup: Requested cnid (%d / %08x) != dcnid (%d / %08x)\n", cnid, cnid, dcnid, dcnid);+ result = ENOENT;+ }+ }+exit:+ hfs_free_type(recp, CatalogRecord);+ hfs_free_type(iterator, struct BTreeIterator);++ return MacToVFSError(result);+}+++/*+ * cat_lookupmangled - lookup a catalog node using a mangled name+ */+int+cat_lookupmangled(struct hfsmount *hfsmp, struct cat_desc *descp, int wantrsrc,+ struct cat_desc *outdescp, struct cat_attr *attrp, struct cat_fork *forkp)+{+ cnid_t fileID;+ u_int32_t prefixlen;+ int result;+ u_int8_t utf8[NAME_MAX + 1];+ u_int32_t utf8len;+ u_int16_t unicode[kHFSPlusMaxFileNameChars + 1];+ size_t unicodelen;++ if (wantrsrc)+ return (ENOENT);++ fileID = GetEmbeddedFileID(descp->cd_nameptr, descp->cd_namelen, &prefixlen);+ if (fileID < (cnid_t)kHFSFirstUserCatalogNodeID)+ return (ENOENT);++ if (fileID == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid ||+ fileID == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid ||+ fileID == hfsmp->hfs_jnlfileid ||+ fileID == hfsmp->hfs_jnlinfoblkid) {+ return (ENOENT);+ }++ result = cat_idlookup(hfsmp, fileID, 0, 0, outdescp, attrp, forkp);+ if (result)+ return (ENOENT);+ /* It must be in the correct directory */+ if (descp->cd_parentcnid != outdescp->cd_parentcnid)+ goto falsematch;++ /*+ * Compare the mangled version of file name looked up from the+ * disk with the mangled name provided by the user. Note that+ * this comparison is case-sensitive, which should be fine+ * since we're trying to prevent user space from constructing+ * a mangled name that differs from the one they'd get from the+ * file system.+ */+ result = utf8_decodestr(outdescp->cd_nameptr, outdescp->cd_namelen,+ unicode, &unicodelen, sizeof(unicode), ':', 0);+ if (result) {+ goto falsematch;+ }+ result = ConvertUnicodeToUTF8Mangled(unicodelen, unicode,+ sizeof(utf8), &utf8len, utf8, fileID);+ if ((result != 0) ||+ ((u_int16_t)descp->cd_namelen != utf8len) ||+ (bcmp(descp->cd_nameptr, utf8, utf8len) != 0)) {+ goto falsematch;+ }++ return (0);++falsematch:+ cat_releasedesc(outdescp);+ return (ENOENT);+}+++/*+ * cat_lookupbykey - lookup a catalog node using a cnode key+ */+static int+cat_lookupbykey(struct hfsmount *hfsmp, CatalogKey *keyp, int flags, u_int32_t hint, int wantrsrc,+ struct cat_desc *descp, struct cat_attr *attrp, struct cat_fork *forkp, cnid_t *desc_cnid)+{+ struct BTreeIterator * iterator;+ FSBufferDescriptor btdata;+ CatalogRecord * recp;+ u_int16_t datasize;+ int result;+ u_int32_t ilink = 0;+ cnid_t cnid = 0;+ u_int32_t encoding = 0;+ cnid_t parentid = 0;++ recp = hfs_malloc_type(CatalogRecord);+ BDINIT(btdata, recp);+ iterator = hfs_malloc_type(struct BTreeIterator);+ iterator->hint.nodeNum = hint;+ bcopy(keyp, &iterator->key, sizeof(CatalogKey));++ result = BTSearchRecord(VTOF(HFSTOVCB(hfsmp)->catalogRefNum), iterator,+ &btdata, &datasize, iterator);+ if (result)+ goto exit;++ /* Save the cnid, parentid, and encoding now in case there's a hard link or inode */+ cnid = getcnid(recp);+ if (cnid == 0) {+ /* CNID of 0 is invalid. Mark as corrupt */+ hfs_mark_inconsistent (hfsmp, HFS_INCONSISTENCY_DETECTED);+ result = EINVAL;+ goto exit;+ }++ parentid = keyp->hfsPlus.parentID;++ encoding = getencoding(recp);+ hint = iterator->hint.nodeNum;++ /* Hide the journal files (if any) */+ if ((hfsmp->jnl || ((HFSTOVCB(hfsmp)->vcbAtrb & kHFSVolumeJournaledMask) && (hfsmp->hfs_flags & HFS_READ_ONLY))) &&+ ((cnid == hfsmp->hfs_jnlfileid) || (cnid == hfsmp->hfs_jnlinfoblkid)) &&+ !(flags & HFS_LOOKUP_SYSFILE)) {+ result = HFS_ERESERVEDNAME;+ goto exit;+ }++ if (!(hfsmp->hfs_flags & HFS_CASE_SENSITIVE)) {+ /* Make sure the case of the file was correct if requested */+ if (flags & HFS_LOOKUP_CASESENSITIVE) {+ if (0 != cat_binarykeycompare(&keyp->hfsPlus, (HFSPlusCatalogKey *)&iterator->key)) {+ result = HFS_ERESERVEDNAME;+ goto exit;+ }+ }+ }++ /*+ * When a hardlink link is encountered, auto resolve it.+ *+ * The catalog record will change, and possibly its type.+ */+ if ((attrp || forkp)+ && (recp->recordType == kHFSPlusFileRecord)+ && ((to_bsd_time(recp->hfsPlusFile.createDate) == (time_t)hfsmp->hfs_itime) ||+ (to_bsd_time(recp->hfsPlusFile.createDate) == (time_t)hfsmp->hfs_metadata_createdate))) {+ int isdirlink = 0;+ int isfilelink = 0;++ if ((SWAP_BE32(recp->hfsPlusFile.userInfo.fdType) == kHardLinkFileType) &&+ (SWAP_BE32(recp->hfsPlusFile.userInfo.fdCreator) == kHFSPlusCreator)) {+ isfilelink = 1;+ } else if ((recp->hfsPlusFile.flags & kHFSHasLinkChainMask) &&+ (SWAP_BE32(recp->hfsPlusFile.userInfo.fdType) == kHFSAliasType) &&+ (SWAP_BE32(recp->hfsPlusFile.userInfo.fdCreator) == kHFSAliasCreator)) {+ isdirlink = 1;+ }+ if ((isfilelink || isdirlink) && !(flags & HFS_LOOKUP_HARDLINK)) {+ ilink = recp->hfsPlusFile.hl_linkReference;+ (void) cat_resolvelink(hfsmp, ilink, isdirlink, (struct HFSPlusCatalogFile *)recp);+ }+ }++ if (attrp != NULL) {+ getbsdattr(hfsmp, (struct HFSPlusCatalogFile *)recp, attrp);+ if (ilink) {+ /* Update the inode number for this hard link */+ attrp->ca_linkref = ilink;+ }++ /*+ * Set kHFSHasLinkChainBit for hard links, and reset it for all+ * other items. Also set linkCount to 1 for regular files.+ *+ * Due to some bug (rdar://8505977), some regular files can have+ * kHFSHasLinkChainBit set and linkCount more than 1 even if they+ * are not really hard links. The runtime code should not consider+ * these files has hard links. Therefore we reset the kHFSHasLinkChainBit+ * and linkCount for regular file before we vend it out. This might+ * also result in repairing the bad files on disk, if the corresponding+ * file is modified and updated on disk.+ */+ if (ilink) {+ /* This is a hard link and the link count bit was not set */+ if (!(attrp->ca_recflags & kHFSHasLinkChainMask)) {+ printf ("hfs: set hardlink bit on vol=%s cnid=%u inoid=%u\n", hfsmp->vcbVN, cnid, ilink);+ attrp->ca_recflags |= kHFSHasLinkChainMask;+ }+ } else {+ /* Make sure that this non-hard link (regular) record is not+ * an inode record that was looked up and we do not end up+ * reseting the hard link bit on it.+ */+ if ((parentid != hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid) &&+ (parentid != hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid)) {+ /* This is not a hard link or inode and the link count bit was set */+ if (attrp->ca_recflags & kHFSHasLinkChainMask) {+ printf ("hfs: clear hardlink bit on vol=%s cnid=%u\n", hfsmp->vcbVN, cnid);+ attrp->ca_recflags &= ~kHFSHasLinkChainMask;+ }+ /* This is a regular file and the link count was more than 1 */+ if (S_ISREG(attrp->ca_mode) && (attrp->ca_linkcount > 1)) {+ printf ("hfs: set linkcount=1 on vol=%s cnid=%u old=%u\n", hfsmp->vcbVN, cnid, attrp->ca_linkcount);+ attrp->ca_linkcount = 1;+ }+ }+ }+ }+ if (forkp != NULL) {+ if (isadir(recp)) {+ bzero(forkp, sizeof(*forkp));+ } else if (wantrsrc) {+ /* Convert the resource fork. */+ forkp->cf_size = recp->hfsPlusFile.resourceFork.logicalSize;+ forkp->cf_new_size = 0;+ forkp->cf_blocks = recp->hfsPlusFile.resourceFork.totalBlocks;+ if ((hfsmp->hfc_stage == HFC_RECORDING) &&+ (to_bsd_time(recp->hfsPlusFile.accessDate) >= hfsmp->hfc_timebase)) {+ forkp->cf_bytesread =+ recp->hfsPlusFile.resourceFork.clumpSize *+ HFSTOVCB(hfsmp)->blockSize;+ } else {+ forkp->cf_bytesread = 0;+ }+ forkp->cf_vblocks = 0;+ bcopy(&recp->hfsPlusFile.resourceFork.extents[0],+ &forkp->cf_extents[0], sizeof(HFSPlusExtentRecord));+ } else {+ int i;+ u_int32_t validblks;++ /* Convert the data fork. */+ forkp->cf_size = recp->hfsPlusFile.dataFork.logicalSize;+ forkp->cf_new_size = 0;+ forkp->cf_blocks = recp->hfsPlusFile.dataFork.totalBlocks;+ if ((hfsmp->hfc_stage == HFC_RECORDING) &&+ (to_bsd_time(recp->hfsPlusFile.accessDate) >= hfsmp->hfc_timebase)) {+ forkp->cf_bytesread =+ recp->hfsPlusFile.dataFork.clumpSize *+ HFSTOVCB(hfsmp)->blockSize;+ } else {+ forkp->cf_bytesread = 0;+ }+ forkp->cf_vblocks = 0;+ bcopy(&recp->hfsPlusFile.dataFork.extents[0],+ &forkp->cf_extents[0], sizeof(HFSPlusExtentRecord));++ /* Validate the fork's resident extents. */+ validblks = 0;+ for (i = 0; i < kHFSPlusExtentDensity; ++i) {+ if (forkp->cf_extents[i].startBlock + forkp->cf_extents[i].blockCount >= hfsmp->totalBlocks) {+ /* Suppress any bad extents so a remove can succeed. */+ forkp->cf_extents[i].startBlock = 0;+ forkp->cf_extents[i].blockCount = 0;+ /* Disable writes */+ if (attrp != NULL) {+ attrp->ca_mode &= S_IFMT | S_IRUSR | S_IRGRP | S_IROTH;+ }+ } else {+ validblks += forkp->cf_extents[i].blockCount;+ }+ }+ /* Adjust for any missing blocks. */+ if ((validblks < forkp->cf_blocks) && (forkp->cf_extents[7].blockCount == 0)) {+ off_t psize;++ /*+ * This is technically a volume corruption.+ * If the total number of blocks calculated by iterating + summing+ * the extents in the resident extent records, is less than that+ * which is reported in the catalog entry, we should force a fsck.+ * Only modifying ca_blocks here is not guaranteed to make it out+ * to disk; it is a runtime-only field.+ *+ * Note that we could have gotten into this state if we had invalid ranges+ * that existed in borrowed blocks that somehow made it out to disk.+ * The cnode's on disk block count should never be greater+ * than that which is in its extent records.+ */++ (void) hfs_mark_inconsistent (hfsmp, HFS_INCONSISTENCY_DETECTED);++ forkp->cf_blocks = validblks;+ if (attrp != NULL) {+ attrp->ca_blocks = validblks + recp->hfsPlusFile.resourceFork.totalBlocks;+ }+ psize = (off_t)validblks * (off_t)hfsmp->blockSize;+ if (psize < forkp->cf_size) {+ forkp->cf_size = psize;+ }++ }+ }+ }+ if (descp != NULL) {+ HFSPlusCatalogKey * pluskey = NULL;+ pluskey = (HFSPlusCatalogKey *)&iterator->key;++ builddesc(pluskey, cnid, hint, encoding, isadir(recp), descp);+ }++ if (desc_cnid != NULL) {+ *desc_cnid = cnid;+ }+exit:+ hfs_free_type(iterator, struct BTreeIterator);+ hfs_free_type(recp, CatalogRecord);++ return MacToVFSError(result);+}+++/*+ * cat_create - create a node in the catalog+ * using MacRoman encoding+ *+ * NOTE: both the catalog file and attribute file locks must+ * be held before calling this function.+ *+ * The caller is responsible for releasing the output+ * catalog descriptor (when supplied outdescp is non-null).+ */+int+cat_create(struct hfsmount *hfsmp, cnid_t new_fileid, struct cat_desc *descp, struct cat_attr *attrp,+ struct cat_desc *out_descp)+{+ FCB * fcb;+ struct btobj * bto;+ FSBufferDescriptor btdata;+ u_int32_t datalen;+ int result = 0;+ u_int32_t encoding = kTextEncodingMacRoman;+ int modeformat;++ modeformat = attrp->ca_mode & S_IFMT;++ fcb = hfsmp->hfs_catalog_cp->c_datafork;++ /* The caller is expected to reserve a CNID before calling this function! */++ /* Get space for iterator, key and data */+ bto = hfs_malloc_type(struct btobj);+ bto->iterator.hint.nodeNum = 0;++ result = buildkey(hfsmp, descp, &bto->key, 0);+ if (result)+ goto exit;++ /*+ * Insert the thread record first+ */+ datalen = buildthread((void*)&bto->key, &bto->data, S_ISDIR(attrp->ca_mode));+ btdata.bufferAddress = &bto->data;+ btdata.itemSize = datalen;+ btdata.itemCount = 1;++ /* Caller asserts the following:+ * 1) this CNID is not in use by any orphaned EAs+ * 2) There are no lingering cnodes (removed on-disk but still in-core) with this CNID+ * 3) There are no thread or catalog records for this ID+ */+ buildthreadkey(new_fileid, (CatalogKey *) &bto->iterator.key);+ result = BTInsertRecord(fcb, &bto->iterator, &btdata, datalen);+ if (result) {+ goto exit;+ }++ /*+ * Now insert the file/directory record+ */+ buildrecord(attrp, new_fileid, encoding, &bto->data, &datalen);+ btdata.bufferAddress = &bto->data;+ btdata.itemSize = datalen;+ btdata.itemCount = 1;++ bcopy(&bto->key, &bto->iterator.key, sizeof(bto->key));++ result = BTInsertRecord(fcb, &bto->iterator, &btdata, datalen);+ if (result) {+ if (result == btExists)+ result = EEXIST;++ /* Back out the thread record */+ buildthreadkey(new_fileid, (CatalogKey *)&bto->iterator.key);+ if (BTDeleteRecord(fcb, &bto->iterator)) {+ /* Error on deleting extra thread record, mark+ * volume inconsistent+ */+ printf ("hfs: cat_create() failed to delete thread record id=%u on vol=%s\n", new_fileid, hfsmp->vcbVN);+ hfs_mark_inconsistent(hfsmp, HFS_ROLLBACK_FAILED);+ }+ goto exit;+ }++ /*+ * Insert was successful, update name, parent and volume+ */+ if (out_descp != NULL) {+ HFSPlusCatalogKey * pluskey = NULL;+ pluskey = (HFSPlusCatalogKey *)&bto->iterator.key;++ builddesc(pluskey, new_fileid, bto->iterator.hint.nodeNum,+ encoding, S_ISDIR(attrp->ca_mode), out_descp);+ }+ attrp->ca_fileid = new_fileid;++exit:+ (void) BTFlushPath(fcb);+ hfs_free_type(bto, struct btobj);++ return MacToVFSError(result);+}+++/*+ * cnode_rename - rename a catalog node+ *+ * Assumes that the target's directory exists.+ *+ * Order of B-tree operations:+ * 1. BTSearchRecord(from_cnode, &data);+ * 2. BTInsertRecord(to_cnode, &data);+ * 3. BTDeleteRecord(from_cnode);+ * 4. BTDeleteRecord(from_thread);+ * 5. BTInsertRecord(to_thread);+ *+ * Note: The caller is responsible for releasing the output+ * catalog descriptor (when supplied out_cdp is non-null).+ */+int+cat_rename (+ struct hfsmount * hfsmp,+ struct cat_desc * from_cdp,+ struct cat_desc * todir_cdp,+ struct cat_desc * to_cdp,+ struct cat_desc * out_cdp )+{+ struct BTreeIterator * to_iterator = NULL;+ struct BTreeIterator * from_iterator = NULL;+ FSBufferDescriptor btdata;+ CatalogRecord * recp = NULL;+ HFSPlusCatalogKey * to_key;+ ExtendedVCB * vcb;+ FCB * fcb;+ u_int16_t datasize;+ int result = 0;+ int sourcegone = 0;+ int skipthread = 0;+ int directory = from_cdp->cd_flags & CD_ISDIR;+ int is_dirlink = 0;+ u_int32_t encoding = 0;++ vcb = HFSTOVCB(hfsmp);+ fcb = GetFileControlBlock(vcb->catalogRefNum);++ if (from_cdp->cd_namelen == 0 || to_cdp->cd_namelen == 0)+ return (EINVAL);++ from_iterator = hfs_malloc_type(struct BTreeIterator);+ if ((result = buildkey(hfsmp, from_cdp, (HFSPlusCatalogKey *)&from_iterator->key, 0)))+ goto exit;++ to_iterator = hfs_malloc_type(struct BTreeIterator);+ if ((result = buildkey(hfsmp, to_cdp, (HFSPlusCatalogKey *)&to_iterator->key, 0)))+ goto exit;++ to_key = (HFSPlusCatalogKey *)&to_iterator->key;+ recp = hfs_malloc_type(CatalogRecord);+ BDINIT(btdata, recp);++ /*+ * When moving a directory, make sure its a valid move.+ */+ if (directory && (from_cdp->cd_parentcnid != to_cdp->cd_parentcnid)) {+ struct BTreeIterator *dir_iterator = NULL;++ cnid_t cnid = from_cdp->cd_cnid;+ cnid_t pathcnid = todir_cdp->cd_parentcnid;++ /* First check the obvious ones */+ if (cnid == fsRtDirID ||+ cnid == to_cdp->cd_parentcnid ||+ cnid == pathcnid) {+ result = EINVAL;+ goto exit;+ }+ /* now allocate the dir_iterator */+ dir_iterator = hfs_malloc_type(struct BTreeIterator);++ /*+ * Traverse destination path all the way back to the root+ * making sure that source directory is not encountered.+ *+ */+ while (pathcnid > fsRtDirID) {+ buildthreadkey(pathcnid, (CatalogKey *)&dir_iterator->key);+ result = BTSearchRecord(fcb, dir_iterator, &btdata, &datasize, NULL);+ if (result) {+ hfs_free_type(dir_iterator, struct BTreeIterator);+ goto exit;+ }+ pathcnid = getparentcnid(recp);+ if (pathcnid == cnid || pathcnid == 0) {+ result = EINVAL;+ hfs_free_type(dir_iterator, struct BTreeIterator);+ goto exit;+ }+ }+ hfs_free_type(dir_iterator, struct BTreeIterator);+ }++ /*+ * Step 1: Find cnode data at old location+ */+ result = BTSearchRecord(fcb, from_iterator, &btdata,+ &datasize, from_iterator);+ if (result) {+ if (result != btNotFound)+ goto exit;++ struct cat_desc temp_desc;++ /* Probably the node has mangled name */+ result = cat_lookupmangled(hfsmp, from_cdp, 0, &temp_desc, NULL, NULL);+ if (result)+ goto exit;++ /* The file has mangled name. Search the cnode data using full name */+ bzero(from_iterator, sizeof(*from_iterator));+ result = buildkey(hfsmp, &temp_desc, (HFSPlusCatalogKey *)&from_iterator->key, 0);+ if (result) {+ cat_releasedesc(&temp_desc);+ goto exit;+ }++ result = BTSearchRecord(fcb, from_iterator, &btdata, &datasize, from_iterator);+ if (result) {+ cat_releasedesc(&temp_desc);+ goto exit;+ }++ cat_releasedesc(&temp_desc);+ }++ /* Check if the source is directory hard link. We do not change+ * directory flag because it is later used to initialize result descp+ */+ if ((directory) &&+ (recp->recordType == kHFSPlusFileRecord) &&+ (recp->hfsPlusFile.flags & kHFSHasLinkChainMask)) {+ is_dirlink = 1;+ }++ /*+ * Update the text encoding (on disk and in descriptor),+ * using hfs_pickencoding to get the new encoding when available.+ *+ * Note that hardlink inodes don't require a text encoding hint.+ */+ if (todir_cdp->cd_parentcnid != hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid &&+ todir_cdp->cd_parentcnid != hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {++#if TARGET_OS_OSX+ encoding = hfs_pickencoding(to_key->nodeName.unicode, to_key->nodeName.length);+#else // !TARGET_OS_OSX+ encoding = kTextEncodingMacRoman;+#endif // TARGET_OS_OSX++ hfs_setencodingbits(hfsmp, encoding);+ recp->hfsPlusFile.textEncoding = encoding;+ if (out_cdp)+ out_cdp->cd_encoding = encoding;+ }++#if 0+ /*+ * If the keys are identical then there's nothing left to do!+ *+ * update the hint and exit+ *+ */+ if (hfskeycompare(to_key, iter->key) == 0)+ goto exit;+ if (hfspluskeycompare(to_key, iter->key) == 0)+ goto exit;+#endif++ /* Step 2: Insert cnode at new location */+ result = BTInsertRecord(fcb, to_iterator, &btdata, datasize);+ if (result == btExists) {+ int fromtype = recp->recordType;+ cnid_t cnid = 0;++ if (from_cdp->cd_parentcnid != to_cdp->cd_parentcnid)+ goto exit; /* EEXIST */++ /* Find cnode data at new location */+ result = BTSearchRecord(fcb, to_iterator, &btdata, &datasize, NULL);+ if (result)+ goto exit;++ /* Get the CNID after calling searchrecord */+ cnid = getcnid (recp);+ if (cnid == 0) {+ hfs_mark_inconsistent(hfsmp, HFS_INCONSISTENCY_DETECTED);+ result = EINVAL;+ goto exit;+ }++ if ((fromtype != recp->recordType) ||+ (from_cdp->cd_cnid != cnid)) {+ result = EEXIST;+ goto exit; /* EEXIST */+ }+ /* The old name is a case variant and must be removed */+ result = BTDeleteRecord(fcb, from_iterator);+ if (result)+ goto exit;++ /* Insert cnode (now that case duplicate is gone) */+ result = BTInsertRecord(fcb, to_iterator, &btdata, datasize);+ if (result) {+ /* Try and restore original before leaving */+ // XXXdbg+ #if 1+ {+ int err;+ err = BTInsertRecord(fcb, from_iterator, &btdata, datasize);+ if (err) {+ printf("hfs: cat_create: could not undo (BTInsert = %d)\n", err);+ hfs_mark_inconsistent(hfsmp, HFS_ROLLBACK_FAILED);+ result = err;+ goto exit;+ }+ }+ #else+ (void) BTInsertRecord(fcb, from_iterator, &btdata, datasize);+ #endif+ goto exit;+ }+ sourcegone = 1;+ }+ if (result)+ goto exit;++ /* Step 3: Remove cnode from old location */+ if (!sourcegone) {+ result = BTDeleteRecord(fcb, from_iterator);+ if (result) {+ /* Try and delete new record before leaving */+ // XXXdbg+ #if 1+ {+ int err;+ err = BTDeleteRecord(fcb, to_iterator);+ if (err) {+ printf("hfs: cat_create: could not undo (BTDelete = %d)\n", err);+ hfs_mark_inconsistent(hfsmp, HFS_ROLLBACK_FAILED);+ result = err;+ goto exit;+ }+ }+ #else+ (void) BTDeleteRecord(fcb, to_iterator);+ #endif+ goto exit;+ }+ }++ /* #### POINT OF NO RETURN #### */++ /*+ * Step 4: Remove cnode's old thread record+ */+ buildthreadkey(from_cdp->cd_cnid, (CatalogKey *)&from_iterator->key);+ (void) BTDeleteRecord(fcb, from_iterator);++ /*+ * Step 5: Insert cnode's new thread record+ * (optional for HFS files)+ */+ if (!skipthread) {+ /* For directory hard links, always create a file thread+ * record. For everything else, use the directory flag.+ */+ if (is_dirlink) {+ datasize = buildthread(&to_iterator->key, recp, false);+ } else {+ datasize = buildthread(&to_iterator->key, recp, directory);+ }+ btdata.itemSize = datasize;+ buildthreadkey(from_cdp->cd_cnid, (CatalogKey *)&from_iterator->key);+ result = BTInsertRecord(fcb, from_iterator, &btdata, datasize);+ }++ if (out_cdp) {+ HFSPlusCatalogKey * pluskey = NULL;+ pluskey = (HFSPlusCatalogKey *)&to_iterator->key;++ builddesc(pluskey, from_cdp->cd_cnid, to_iterator->hint.nodeNum,+ encoding, directory, out_cdp);+ }+exit:+ (void) BTFlushPath(fcb);+ if (from_iterator)+ hfs_free_type(from_iterator, struct BTreeIterator);+ if (to_iterator)+ hfs_free_type(to_iterator, struct BTreeIterator);+ if (recp)+ hfs_free_type(recp, CatalogRecord);+ return MacToVFSError(result);+}+++/*+ * cat_delete - delete a node from the catalog+ *+ * Order of B-tree operations:+ * 1. BTDeleteRecord(cnode);+ * 2. BTDeleteRecord(thread);+ * 3. BTUpdateRecord(parent);+ */+int+cat_delete(struct hfsmount *hfsmp, struct cat_desc *descp, struct cat_attr *attrp)+{+ FCB * fcb;+ BTreeIterator *iterator;+ cnid_t cnid;+ int result;++ fcb = hfsmp->hfs_catalog_cp->c_datafork;++ /* Preflight check:+ *+ * The root directory cannot be deleted+ * A directory must be empty+ * A file must be zero length (no blocks)+ */+ if (descp->cd_cnid < kHFSFirstUserCatalogNodeID ||+ descp->cd_parentcnid == kHFSRootParentID)+ return (EINVAL);++ /* XXX Preflight Missing */++ /* Borrow the btcb iterator since we have an exclusive catalog lock. */+ iterator = &((BTreeControlBlockPtr)(fcb->ff_sysfileinfo))->iterator;+ iterator->hint.nodeNum = 0;++ /*+ * Derive a key from either the file ID (for a virtual inode)+ * or the descriptor.+ */+ if (descp->cd_namelen == 0) {+ result = getkey(hfsmp, attrp->ca_fileid, (CatalogKey *)&iterator->key);+ cnid = attrp->ca_fileid;+ } else {+ result = buildkey(hfsmp, descp, (HFSPlusCatalogKey *)&iterator->key, 0);+ cnid = descp->cd_cnid;+ }+ if (result)+ goto exit;++ /* Delete record */+ result = BTDeleteRecord(fcb, iterator);+ if (result) {+ if (result != btNotFound) {+ goto exit;+ }++ struct cat_desc temp_desc;++ /* Probably the node has mangled name */+ result = cat_lookupmangled(hfsmp, descp, 0, &temp_desc, attrp, NULL);+ if (result)+ goto exit;++ /* The file has mangled name. Delete the file using full name */+ bzero(iterator, sizeof(*iterator));+ result = buildkey(hfsmp, &temp_desc, (HFSPlusCatalogKey *)&iterator->key, 0);+ cnid = temp_desc.cd_cnid;+ if (result) {+ cat_releasedesc(&temp_desc);+ goto exit;+ }++ result = BTDeleteRecord(fcb, iterator);+ if (result) {+ cat_releasedesc(&temp_desc);+ goto exit;+ }++ cat_releasedesc(&temp_desc);+ }++ /* Delete thread record. On error, mark volume inconsistent */+ buildthreadkey(cnid, (CatalogKey *)&iterator->key);+ if (BTDeleteRecord(fcb, iterator)) {+ printf ("hfs: cat_delete() failed to delete thread record id=%u on vol=%s\n", cnid, hfsmp->vcbVN);+ hfs_mark_inconsistent(hfsmp, HFS_OP_INCOMPLETE);+ }++exit:+ (void) BTFlushPath(fcb);++ return MacToVFSError(result);+}+++/*+ * cat_update_internal - update the catalog node described by descp+ * using the data from attrp and forkp.+ * If update_hardlink is true, the hard link catalog record is updated+ * and not the inode catalog record.+ */+static int+cat_update_internal(struct hfsmount *hfsmp, int update_hardlink, struct cat_desc *descp, struct cat_attr *attrp,+ const struct cat_fork *dataforkp, const struct cat_fork *rsrcforkp)+{+ FCB * fcb;+ BTreeIterator * iterator;+ struct update_state state;+ int result;++ fcb = hfsmp->hfs_catalog_cp->c_datafork;++ state.s_desc = descp;+ state.s_attr = attrp;+ state.s_datafork = dataforkp;+ state.s_rsrcfork = rsrcforkp;+ state.s_hfsmp = hfsmp;++ /* Borrow the btcb iterator since we have an exclusive catalog lock. */+ iterator = &((BTreeControlBlockPtr)(fcb->ff_sysfileinfo))->iterator;++ /*+ * For open-deleted files we need to do a lookup by cnid+ * (using thread rec).+ *+ * For hard links and if not requested by caller, the target+ * of the update is the inode itself (not the link record)+ * so a lookup by fileid (i.e. thread rec) is needed.+ */+ if ((update_hardlink == false) &&+ ((descp->cd_cnid != attrp->ca_fileid) ||+ (descp->cd_namelen == 0) ||+ (attrp->ca_recflags & kHFSHasLinkChainMask))) {+ result = getkey(hfsmp, attrp->ca_fileid, (CatalogKey *)&iterator->key);+ } else {+ result = buildkey(hfsmp, descp, (HFSPlusCatalogKey *)&iterator->key, 0);+ }+ if (result)+ goto exit;++ /* Pass a node hint */+ iterator->hint.nodeNum = descp->cd_hint;++ result = BTUpdateRecord(fcb, iterator,+ (IterateCallBackProcPtr)catrec_update, &state);+ if (result)+ goto exit;++ /* Update the node hint. */+ descp->cd_hint = iterator->hint.nodeNum;++exit:+ (void) BTFlushPath(fcb);++ return MacToVFSError(result);+}++/*+ * cat_update - update the catalog node described by descp+ * using the data from attrp and forkp.+ */+int+cat_update(struct hfsmount *hfsmp, struct cat_desc *descp, struct cat_attr *attrp,+ const struct cat_fork *dataforkp, const struct cat_fork *rsrcforkp)+{+ return cat_update_internal(hfsmp, false, descp, attrp, dataforkp, rsrcforkp);+}++/*+ * catrec_update - Update the fields of a catalog record+ * This is called from within BTUpdateRecord.+ */+static int+catrec_update(const CatalogKey *ckp, CatalogRecord *crp, struct update_state *state)+{+ struct cat_desc *descp;+ struct cat_attr *attrp;+ const struct cat_fork *forkp;+ struct hfsmount *hfsmp;+ long blksize;++ descp = state->s_desc;+ attrp = state->s_attr;+ hfsmp = state->s_hfsmp;+ blksize = HFSTOVCB(hfsmp)->blockSize;++ switch (crp->recordType) {+ case kHFSPlusFolderRecord: {+ HFSPlusCatalogFolder *dir;++ dir = (struct HFSPlusCatalogFolder *)crp;+ /* Do a quick sanity check */+ if (dir->folderID != attrp->ca_fileid) {+ printf("hfs: catrec_update: id %d != %d, vol=%s\n", dir->folderID, attrp->ca_fileid, hfsmp->vcbVN);+ return (btNotFound);+ }+ dir->flags = attrp->ca_recflags;+ dir->valence = attrp->ca_entries;+ dir->createDate = to_hfs_time(attrp->ca_itime);+ dir->contentModDate = to_hfs_time(attrp->ca_mtime);+ dir->backupDate = to_hfs_time(attrp->ca_btime);+ dir->accessDate = to_hfs_time(attrp->ca_atime);+ attrp->ca_atimeondisk = attrp->ca_atime;+ dir->attributeModDate = to_hfs_time(attrp->ca_ctime);+ /* Note: directory hardlink inodes don't require a text encoding hint. */+ if (ckp->hfsPlus.parentID != hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {+ dir->textEncoding = descp->cd_encoding;+ }+ dir->folderCount = attrp->ca_dircount;+ bcopy(&attrp->ca_finderinfo[0], &dir->userInfo, 32);+ /*+ * Update the BSD Info if it was already initialized on+ * disk or if the runtime values have been modified.+ *+ * If the BSD info was already initialized, but+ * MNT_UNKNOWNPERMISSIONS is set, then the runtime IDs are+ * probably different than what was on disk. We don't want+ * to overwrite the on-disk values (so if we turn off+ * MNT_UNKNOWNPERMISSIONS, the old IDs get used again).+ * This way, we can still change fields like the mode or+ * dates even when MNT_UNKNOWNPERMISSIONS is set.+ *+ * Note that if MNT_UNKNOWNPERMISSIONS is set, hfs_chown+ * won't change the uid or gid from their defaults. So, if+ * the BSD info wasn't set, and the runtime values are not+ * default, then what changed was the mode or flags. We+ * have to set the uid and gid to something, so use the+ * supplied values (which will be default), which has the+ * same effect as creating a new file while+ * MNT_UNKNOWNPERMISSIONS is set.+ */+ if ((dir->bsdInfo.fileMode != 0) ||+ (attrp->ca_flags != 0) ||+ (attrp->ca_uid != hfsmp->hfs_uid) ||+ (attrp->ca_gid != hfsmp->hfs_gid) ||+ ((attrp->ca_mode & ALLPERMS) !=+ (hfsmp->hfs_dir_mask & ACCESSPERMS))) {+ if ((dir->bsdInfo.fileMode == 0) ||+ (((unsigned int)vfs_flags(HFSTOVFS(hfsmp))) & MNT_UNKNOWNPERMISSIONS) == 0) {+ dir->bsdInfo.ownerID = attrp->ca_uid;+ dir->bsdInfo.groupID = attrp->ca_gid;+ }+ dir->bsdInfo.ownerFlags = attrp->ca_flags & 0x000000FF;+ dir->bsdInfo.adminFlags = attrp->ca_flags >> 16;+ dir->bsdInfo.fileMode = attrp->ca_mode;+ /* A directory hardlink has a link count. */+ if (attrp->ca_linkcount > 1 || dir->hl_linkCount > 1) {+ dir->hl_linkCount = attrp->ca_linkcount;+ }+ }+ break;+ }+ case kHFSPlusFileRecord: {+ HFSPlusCatalogFile *file;+ int is_dirlink;++ file = (struct HFSPlusCatalogFile *)crp;+ /* Do a quick sanity check */+ if (file->fileID != attrp->ca_fileid)+ return (btNotFound);+ file->flags = attrp->ca_recflags;+ file->createDate = to_hfs_time(attrp->ca_itime);+ file->contentModDate = to_hfs_time(attrp->ca_mtime);+ file->backupDate = to_hfs_time(attrp->ca_btime);+ file->accessDate = to_hfs_time(attrp->ca_atime);+ attrp->ca_atimeondisk = attrp->ca_atime;+ file->attributeModDate = to_hfs_time(attrp->ca_ctime);+ /*+ * Note: file hardlink inodes don't require a text encoding+ * hint, but they do have a first link value.+ */+ if (ckp->hfsPlus.parentID == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid) {+ file->hl_firstLinkID = attrp->ca_firstlink;+ } else {+ file->textEncoding = descp->cd_encoding;+ }+ bcopy(&attrp->ca_finderinfo[0], &file->userInfo, 32);+ /*+ * Update the BSD Info if it was already initialized on+ * disk or if the runtime values have been modified.+ *+ * If the BSD info was already initialized, but+ * MNT_UNKNOWNPERMISSIONS is set, then the runtime IDs are+ * probably different than what was on disk. We don't want+ * to overwrite the on-disk values (so if we turn off+ * MNT_UNKNOWNPERMISSIONS, the old IDs get used again).+ * This way, we can still change fields like the mode or+ * dates even when MNT_UNKNOWNPERMISSIONS is set.+ *+ * Note that if MNT_UNKNOWNPERMISSIONS is set, hfs_chown+ * won't change the uid or gid from their defaults. So, if+ * the BSD info wasn't set, and the runtime values are not+ * default, then what changed was the mode or flags. We+ * have to set the uid and gid to something, so use the+ * supplied values (which will be default), which has the+ * same effect as creating a new file while+ * MNT_UNKNOWNPERMISSIONS is set.+ *+ * Do not modify bsdInfo for directory hard link records.+ * They are set during creation and are not modifiable, so just+ * leave them alone.+ */+ is_dirlink = (file->flags & kHFSHasLinkChainMask) &&+ (SWAP_BE32(file->userInfo.fdType) == kHFSAliasType) &&+ (SWAP_BE32(file->userInfo.fdCreator) == kHFSAliasCreator);++ if (!is_dirlink &&+ ((file->bsdInfo.fileMode != 0) ||+ (attrp->ca_flags != 0) ||+ (attrp->ca_uid != hfsmp->hfs_uid) ||+ (attrp->ca_gid != hfsmp->hfs_gid) ||+ ((attrp->ca_mode & ALLPERMS) !=+ (hfsmp->hfs_file_mask & ACCESSPERMS)))) {+ if ((file->bsdInfo.fileMode == 0) ||+ (((unsigned int)vfs_flags(HFSTOVFS(hfsmp))) & MNT_UNKNOWNPERMISSIONS) == 0) {+ file->bsdInfo.ownerID = attrp->ca_uid;+ file->bsdInfo.groupID = attrp->ca_gid;+ }+ file->bsdInfo.ownerFlags = attrp->ca_flags & 0x000000FF;+ file->bsdInfo.adminFlags = attrp->ca_flags >> 16;+ file->bsdInfo.fileMode = attrp->ca_mode;+ }+ if (state->s_rsrcfork) {+ forkp = state->s_rsrcfork;+ file->resourceFork.logicalSize = forkp->cf_size;+ file->resourceFork.totalBlocks = forkp->cf_blocks;+ bcopy(&forkp->cf_extents[0], &file->resourceFork.extents,+ sizeof(HFSPlusExtentRecord));+ /* Push blocks read to disk */+ file->resourceFork.clumpSize =+ howmany(forkp->cf_bytesread, blksize);+ }+ if (state->s_datafork) {+ forkp = state->s_datafork;+ file->dataFork.logicalSize = forkp->cf_size;+ file->dataFork.totalBlocks = forkp->cf_blocks;+ bcopy(&forkp->cf_extents[0], &file->dataFork.extents,+ sizeof(HFSPlusExtentRecord));+ /* Push blocks read to disk */+ file->dataFork.clumpSize =+ howmany(forkp->cf_bytesread, blksize);+ }++ if ((file->resourceFork.extents[0].startBlock != 0) &&+ (file->resourceFork.extents[0].startBlock ==+ file->dataFork.extents[0].startBlock)) {+ panic("hfs: catrec_update: rsrc fork == data fork");+ }++ /* Synchronize the lock state */+ if (attrp->ca_flags & (SF_IMMUTABLE | UF_IMMUTABLE))+ file->flags |= kHFSFileLockedMask;+ else+ file->flags &= ~kHFSFileLockedMask;++ /* Push out special field if necessary */+ if (S_ISBLK(attrp->ca_mode) || S_ISCHR(attrp->ca_mode)) {+ file->bsdInfo.special.rawDevice = attrp->ca_rdev;+ }+ else {+ /*+ * Protect against the degenerate case where the descriptor contains the+ * raw inode ID in its CNID field. If the HFSPlusCatalogFile record indicates+ * the linkcount was greater than 1 (the default value), then it must have become+ * a hardlink. In this case, update the linkcount from the cat_attr passed in.+ */+ if ((descp->cd_cnid != attrp->ca_fileid) || (attrp->ca_linkcount > 1 ) ||+ (file->hl_linkCount > 1)) {+ file->hl_linkCount = attrp->ca_linkcount;+ }+ }+ break;+ }+ default:+ return (btNotFound);+ }+ return (0);+}++/* This function sets kHFSHasChildLinkBit in a directory hierarchy in the+ * catalog btree of given cnid by walking up the parent chain till it reaches+ * either the root folder, or the private metadata directory for storing+ * directory hard links. This function updates the corresponding in-core+ * cnode, if any, and the directory record in the catalog btree.+ * On success, returns zero. On failure, returns non-zero value.+ */+int+cat_set_childlinkbit(struct hfsmount *hfsmp, cnid_t cnid)+{+ int retval = 0;+ int lockflags = 0;+ struct cat_desc desc;+ struct cat_attr attr;++ while ((cnid != kHFSRootFolderID) && (cnid != kHFSRootParentID) &&+ (cnid != hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid)) {+ /* Update the bit in corresponding cnode, if any, in the hash.+ * If the cnode has the bit already set, stop the traversal.+ */+ retval = hfs_chash_set_childlinkbit(hfsmp, cnid);+ if (retval == 0) {+ break;+ }++ /* Update the catalog record on disk if either cnode was not+ * found in the hash, or if a cnode was found and the cnode+ * did not have the bit set previously.+ */+ retval = hfs_start_transaction(hfsmp);+ if (retval) {+ break;+ }+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);++ /* Look up our catalog folder record */+ retval = cat_idlookup(hfsmp, cnid, 0, 0, &desc, &attr, NULL);+ if (retval) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ hfs_end_transaction(hfsmp);+ break;+ }++ /* Update the bit in the catalog record */+ attr.ca_recflags |= kHFSHasChildLinkMask;+ retval = cat_update(hfsmp, &desc, &attr, NULL, NULL);+ if (retval) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ hfs_end_transaction(hfsmp);+ cat_releasedesc(&desc);+ break;+ }++ hfs_systemfile_unlock(hfsmp, lockflags);+ hfs_end_transaction(hfsmp);++ cnid = desc.cd_parentcnid;+ cat_releasedesc(&desc);+ }++ return retval;+}++/* This function traverses the parent directory hierarchy from the given+ * directory to one level below root directory and checks if any of its+ * ancestors is -+ * 1. A directory hard link.+ * 2. The 'pointed at' directory.+ * If any of these conditions fail or an internal error is encountered+ * during look up of the catalog record, this function returns non-zero value.+ */+int+cat_check_link_ancestry(struct hfsmount *hfsmp, cnid_t cnid, cnid_t pointed_at_cnid)+{+ HFSPlusCatalogKey *keyp;+ BTreeIterator *ip;+ FSBufferDescriptor btdata;+ HFSPlusCatalogFolder folder;+ FCB *fcb;+ int invalid;+ int result;++ invalid = 0;+ BDINIT(btdata, &folder);+ ip = hfs_malloc_type(BTreeIterator);+ keyp = (HFSPlusCatalogKey *)&ip->key;+ fcb = hfsmp->hfs_catalog_cp->c_datafork;++ while (cnid != kHFSRootParentID) {+ /* Check if the 'pointed at' directory is an ancestor */+ if (pointed_at_cnid == cnid) {+ invalid = 1;+ break;+ }+ if ((result = getkey(hfsmp, cnid, (CatalogKey *)keyp))) {+ printf("hfs: cat_check_link_ancestry: getkey failed id=%u, vol=%s\n", cnid, hfsmp->vcbVN);+ invalid = 1; /* On errors, assume an invalid parent */+ break;+ }+ if ((result = BTSearchRecord(fcb, ip, &btdata, NULL, NULL))) {+ printf("hfs: cat_check_link_ancestry: cannot find id=%u, vol=%s\n", cnid, hfsmp->vcbVN);+ invalid = 1; /* On errors, assume an invalid parent */+ break;+ }+ /* Check if this ancestor is a directory hard link */+ if (folder.flags & kHFSHasLinkChainMask) {+ invalid = 1;+ break;+ }+ cnid = keyp->parentID;+ }+ hfs_free_type(ip, BTreeIterator);+ return (invalid);+}+++/*+ * update_siblinglinks_callback - update a link's chain+ */++struct linkupdate_state {+ cnid_t filelinkid;+ cnid_t prevlinkid;+ cnid_t nextlinkid;+};++static int+update_siblinglinks_callback(__unused const CatalogKey *ckp, CatalogRecord *crp, struct linkupdate_state *state)+{+ HFSPlusCatalogFile *file;++ if (crp->recordType != kHFSPlusFileRecord) {+ printf("hfs: update_siblinglinks_callback: unexpected rec type %d\n", crp->recordType);+ return (btNotFound);+ }++ file = (struct HFSPlusCatalogFile *)crp;+ if (file->flags & kHFSHasLinkChainMask) {+ if (state->prevlinkid != HFS_IGNORABLE_LINK) {+ file->hl_prevLinkID = state->prevlinkid;+ }+ if (state->nextlinkid != HFS_IGNORABLE_LINK) {+ file->hl_nextLinkID = state->nextlinkid;+ }+ } else {+ printf("hfs: update_siblinglinks_callback: file %d isn't a chain\n", file->fileID);+ }+ return (0);+}++/*+ * cat_update_siblinglinks - update a link's chain+ */+int+cat_update_siblinglinks(struct hfsmount *hfsmp, cnid_t linkfileid, cnid_t prevlinkid, cnid_t nextlinkid)+{+ FCB * fcb;+ BTreeIterator * iterator;+ struct linkupdate_state state;+ int result;++ fcb = hfsmp->hfs_catalog_cp->c_datafork;+ state.filelinkid = linkfileid;+ state.prevlinkid = prevlinkid;+ state.nextlinkid = nextlinkid;++ /* Create an iterator for use by us temporarily */+ iterator = hfs_malloc_type(BTreeIterator);++ result = getkey(hfsmp, linkfileid, (CatalogKey *)&iterator->key);+ if (result == 0) {+ result = BTUpdateRecord(fcb, iterator, (IterateCallBackProcPtr)update_siblinglinks_callback, &state);+ (void) BTFlushPath(fcb);+ } else {+ printf("hfs: cat_update_siblinglinks: couldn't resolve cnid=%d, vol=%s\n", linkfileid, hfsmp->vcbVN);+ }++ hfs_free_type(iterator, BTreeIterator);+ return MacToVFSError(result);+}++/*+ * cat_lookuplink - lookup a link by it's name+ */+int+cat_lookuplink(struct hfsmount *hfsmp, struct cat_desc *descp, cnid_t *linkfileid, cnid_t *prevlinkid, cnid_t *nextlinkid)+{+ FCB * fcb;+ BTreeIterator * iterator;+ struct FSBufferDescriptor btdata;+ struct HFSPlusCatalogFile file;+ int result;++ fcb = hfsmp->hfs_catalog_cp->c_datafork;++ /* Create an iterator for use by us temporarily */+ iterator = hfs_malloc_type(BTreeIterator);++ if ((result = buildkey(hfsmp, descp, (HFSPlusCatalogKey *)&iterator->key, 0))) {+ goto exit;+ }+ BDINIT(btdata, &file);++ if ((result = BTSearchRecord(fcb, iterator, &btdata, NULL, NULL))) {+ goto exit;+ }+ if (file.recordType != kHFSPlusFileRecord) {+ result = ENOENT;+ goto exit;+ }+ *linkfileid = file.fileID;++ if (file.flags & kHFSHasLinkChainMask) {+ *prevlinkid = file.hl_prevLinkID;+ *nextlinkid = file.hl_nextLinkID;+ } else {+ *prevlinkid = 0;+ *nextlinkid = 0;+ }+exit:+ hfs_free_type(iterator, BTreeIterator);+ return MacToVFSError(result);+}+++/*+ * cat_lookup_siblinglinks - lookup previous and next link ID for link using its cnid+ */+int+cat_lookup_siblinglinks(struct hfsmount *hfsmp, cnid_t linkfileid, cnid_t *prevlinkid, cnid_t *nextlinkid)+{+ FCB * fcb;+ BTreeIterator * iterator;+ struct FSBufferDescriptor btdata;+ struct HFSPlusCatalogFile file;+ int result;++ fcb = hfsmp->hfs_catalog_cp->c_datafork;++ /* Create an iterator for use by us temporarily */+ iterator = hfs_malloc_type(BTreeIterator);++ if ((result = getkey(hfsmp, linkfileid, (CatalogKey *)&iterator->key))) {+ goto exit;+ }+ BDINIT(btdata, &file);++ if ((result = BTSearchRecord(fcb, iterator, &btdata, NULL, NULL))) {+ goto exit;+ }+ /* The prev/next chain is only valid when kHFSHasLinkChainMask is set. */+ if (file.flags & kHFSHasLinkChainMask) {+ cnid_t parent;++ parent = ((HFSPlusCatalogKey *)&iterator->key)->parentID;++ /* directory inodes don't have a chain (its in an EA) */+ if (parent == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {+ result = ENOLINK; /* signal to caller to get head of list */+ } else if (parent == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid) {+ *prevlinkid = 0;+ *nextlinkid = file.hl_firstLinkID;+ } else {+ *prevlinkid = file.hl_prevLinkID;+ *nextlinkid = file.hl_nextLinkID;+ }+ } else {+ *prevlinkid = 0;+ *nextlinkid = 0;+ }+exit:+ hfs_free_type(iterator, BTreeIterator);+ return MacToVFSError(result);+}+++/*+ * cat_lookup_lastlink - find the last sibling link in the chain (no "next" ptr)+ */+int+cat_lookup_lastlink(struct hfsmount *hfsmp, cnid_t linkfileid,+ cnid_t *lastlink, struct cat_desc *cdesc)+{+ FCB * fcb;+ BTreeIterator * iterator;+ struct FSBufferDescriptor btdata;+ struct HFSPlusCatalogFile file;+ int result = 0;+ int itercount = 0;+ int foundlast = 0;+ cnid_t currentlink = linkfileid;++ fcb = hfsmp->hfs_catalog_cp->c_datafork;++ /* Create an iterator for use by us temporarily */+ iterator = hfs_malloc_type(BTreeIterator);++ while ((foundlast == 0) && (itercount < HFS_LINK_MAX )) {+ itercount++;+ bzero(iterator, sizeof(*iterator));++ if ((result = getkey(hfsmp, currentlink, (CatalogKey *)&iterator->key))) {+ goto exit;+ }+ BDINIT(btdata, &file);++ if ((result = BTSearchRecord(fcb, iterator, &btdata, NULL, NULL))) {+ goto exit;+ }++ /* The prev/next chain is only valid when kHFSHasLinkChainMask is set. */+ if (file.flags & kHFSHasLinkChainMask) {+ cnid_t parent;++ parent = ((HFSPlusCatalogKey *)&iterator->key)->parentID;+ /*+ * The raw inode for a directory hardlink doesn't have a chain.+ * Its link information lives in an EA.+ */+ if (parent == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {+ /* We don't iterate to find the oldest directory hardlink. */+ result = ENOLINK;+ goto exit;+ }+ else if (parent == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid) {+ /* Raw inode for file hardlink (the base inode) */+ currentlink = file.hl_firstLinkID;++ /*+ * One minor special-casing here is necessary.+ * If our ID brought us to the raw hardlink inode, and it does+ * not have any siblings, then it's an open-unlinked file, and we+ * should not proceed any further.+ */+ if (currentlink == 0) {+ result = ENOLINK;+ goto exit;+ }+ }+ else {+ /* Otherwise, this item's parent is a legitimate directory in the namespace */+ if (file.hl_nextLinkID == 0) {+ /* If nextLinkID is 0, then we found the end; no more hardlinks */+ foundlast = 1;+ *lastlink = currentlink;+ /*+ * Since we had to construct a catalog key to do this lookup+ * we still hold it in-hand. We might as well use it to build+ * the descriptor that the caller asked for.+ */+ builddesc ((HFSPlusCatalogKey*)&iterator->key, currentlink, 0, 0, 0, cdesc);+ break;+ }++ currentlink = file.hl_nextLinkID;+ }+ }+ else {+ /* Sorry, can't help you without a link chain */+ result = ENOLINK;+ goto exit;+ }+ }+exit:+ /* If we didn't find what we were looking for, zero out the args */+ if (foundlast == 0) {+ if (cdesc) {+ bzero (cdesc, sizeof(struct cat_desc));+ }+ if (lastlink) {+ *lastlink = 0;+ }+ }++ hfs_free_type(iterator, BTreeIterator);+ return MacToVFSError(result);+}+++/*+ * cat_createlink - create a link in the catalog+ *+ * The following cat_attr fields are expected to be set:+ * ca_linkref+ * ca_itime+ * ca_mode (S_IFREG)+ * ca_recflags+ * ca_flags+ * ca_finderinfo (type and creator)+ */+int+cat_createlink(struct hfsmount *hfsmp, struct cat_desc *descp, struct cat_attr *attrp,+ cnid_t nextlinkid, cnid_t *linkfileid)+{+ FCB * fcb;+ struct btobj * bto;+ FSBufferDescriptor btdata;+ HFSPlusForkData *rsrcforkp;+ u_int32_t nextCNID;+ u_int32_t datalen;+ int thread_inserted = 0;+ int alias_allocated = 0;+ int result = 0;++ fcb = hfsmp->hfs_catalog_cp->c_datafork;++ /*+ * Get the next CNID. Note that we are currently holding catalog lock.+ */+ result = cat_acquire_cnid(hfsmp, &nextCNID);+ if (result) {+ return result;+ }++ /* Get space for iterator, key and data */+ bto = hfs_malloc_type(struct btobj);+ bto->iterator.hint.nodeNum = 0;+ rsrcforkp = &bto->data.hfsPlusFile.resourceFork;++ result = buildkey(hfsmp, descp, &bto->key, 0);+ if (result) {+ printf("hfs: cat_createlink: err %d from buildkey\n", result);+ goto exit;+ }++ /*+ * Insert the thread record first.+ */+ datalen = buildthread((void*)&bto->key, &bto->data, 0);+ btdata.bufferAddress = &bto->data;+ btdata.itemSize = datalen;+ btdata.itemCount = 1;++ buildthreadkey(nextCNID, (CatalogKey *) &bto->iterator.key);+ result = BTInsertRecord(fcb, &bto->iterator, &btdata, datalen);+ if (result) {+ goto exit;+ }+ thread_inserted = 1;++ /*+ * Now insert the link record.+ */+ buildrecord(attrp, nextCNID, kTextEncodingMacUnicode, &bto->data, &datalen);++ bto->data.hfsPlusFile.hl_prevLinkID = 0;+ bto->data.hfsPlusFile.hl_nextLinkID = nextlinkid;+ bto->data.hfsPlusFile.hl_linkReference = attrp->ca_linkref;++ /* For directory hard links, create alias in resource fork */+ if (descp->cd_flags & CD_ISDIR) {+ if ((result = cat_makealias(hfsmp, attrp->ca_linkref, &bto->data.hfsPlusFile))) {+ goto exit;+ }+ alias_allocated = 1;+ }+ btdata.bufferAddress = &bto->data;+ btdata.itemSize = datalen;+ btdata.itemCount = 1;++ bcopy(&bto->key, &bto->iterator.key, sizeof(bto->key));++ result = BTInsertRecord(fcb, &bto->iterator, &btdata, datalen);+ if (result) {+ if (result == btExists)+ result = EEXIST;+ goto exit;+ }+ if (linkfileid != NULL) {+ *linkfileid = nextCNID;+ }+exit:+ if (result) {+ if (thread_inserted) {+ printf("hfs: cat_createlink: BTInsertRecord err=%d, vol=%s\n", MacToVFSError(result), hfsmp->vcbVN);++ buildthreadkey(nextCNID, (CatalogKey *)&bto->iterator.key);+ if (BTDeleteRecord(fcb, &bto->iterator)) {+ printf("hfs: cat_createlink() failed to delete thread record on volume %s\n", hfsmp->vcbVN);+ hfs_mark_inconsistent(hfsmp, HFS_ROLLBACK_FAILED);+ }+ }+ if (alias_allocated && rsrcforkp->extents[0].startBlock != 0) {+ (void) BlockDeallocate(hfsmp, rsrcforkp->extents[0].startBlock,+ rsrcforkp->extents[0].blockCount, 0);+ rsrcforkp->extents[0].startBlock = 0;+ rsrcforkp->extents[0].blockCount = 0;+ }+ }+ (void) BTFlushPath(fcb);+ hfs_free_type(bto, struct btobj);++ return MacToVFSError(result);+}++/* Directory hard links are visible as aliases on pre-Leopard systems and+ * as normal directories on Leopard or later. All directory hard link aliases+ * have the same resource fork content except for the three uniquely+ * identifying values that are updated in the resource fork data when the alias+ * is created. The following array is the constant resource fork data used+ * only for creating directory hard link aliases.+ */+static const char hfs_dirlink_alias_rsrc[] = {+ 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x9e, 0x00, 0x00, 0x00, 0x9e, 0x00, 0x00, 0x00, 0x32,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x9a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9a, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x2b,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,+ 0x01, 0x00, 0x00, 0x00, 0x01, 0x9e, 0x00, 0x00, 0x00, 0x9e, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00,+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x32, 0x00, 0x00, 0x61, 0x6c, 0x69, 0x73,+ 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00+};++/* Constants for directory hard link alias */+enum {+ /* Size of resource fork data array for directory hard link alias */+ kHFSAliasSize = 0x1d0,++ /* Volume type for ejectable devices like disk image */+ kHFSAliasVolTypeEjectable = 0x5,++ /* Offset for volume create date, in Mac OS local time */+ kHFSAliasVolCreateDateOffset = 0x12a,++ /* Offset for the type of volume */+ kHFSAliasVolTypeOffset = 0x130,++ /* Offset for folder ID of the parent directory of the directory inode */+ kHFSAliasParentIDOffset = 0x132,++ /* Offset for folder ID of the directory inode */+ kHFSAliasTargetIDOffset = 0x176,+};++/* Create and write an alias that points at the directory represented by given+ * inode number on the same volume. Directory hard links are visible as+ * aliases in pre-Leopard systems and this function creates these aliases.+ *+ * Note: This code is very specific to creating alias for the purpose+ * of directory hard links only, and should not be generalized.+ */+static int+cat_makealias(struct hfsmount *hfsmp, u_int32_t inode_num, struct HFSPlusCatalogFile *crp)+{+ struct buf *bp;+ daddr64_t blkno;+ u_int32_t blkcount;+ int blksize;+ int sectorsize;+ int result;+ HFSPlusForkData *rsrcforkp;+ char *alias;+ uint32_t *valptr;++ rsrcforkp = &(crp->resourceFork);++ blksize = hfsmp->blockSize;+ blkcount = howmany(kHFSAliasSize, blksize);+ sectorsize = hfsmp->hfs_logical_block_size;+ bzero(rsrcforkp, sizeof(HFSPlusForkData));++ /* Allocate some disk space for the alias content. */+ result = BlockAllocate(hfsmp, 0, blkcount, blkcount,+ HFS_ALLOC_FORCECONTIG | HFS_ALLOC_METAZONE,+ &rsrcforkp->extents[0].startBlock,+ &rsrcforkp->extents[0].blockCount);+ /* Did it fail with an out of space error? If so, re-try and allow journal flushing. */+ if (result == dskFulErr ) {+ result = BlockAllocate(hfsmp, 0, blkcount, blkcount,+ HFS_ALLOC_FORCECONTIG | HFS_ALLOC_METAZONE | HFS_ALLOC_FLUSHTXN,+ &rsrcforkp->extents[0].startBlock,+ &rsrcforkp->extents[0].blockCount);+ }+ if (result) {+ rsrcforkp->extents[0].startBlock = 0;+ goto exit;+ }++ /* Acquire a buffer cache block for our block. */+ blkno = ((u_int64_t)rsrcforkp->extents[0].startBlock * (u_int64_t)blksize) / sectorsize;+ blkno += hfsmp->hfsPlusIOPosOffset / sectorsize;++ bp = buf_getblk(hfsmp->hfs_devvp, blkno, roundup(kHFSAliasSize, hfsmp->hfs_logical_block_size), 0, 0, BLK_META);+ if (hfsmp->jnl) {+ journal_modify_block_start(hfsmp->jnl, bp);+ }++ /* Generate alias content */+ alias = (char *)buf_dataptr(bp);+ bzero(alias, buf_size(bp));+ bcopy(hfs_dirlink_alias_rsrc, alias, kHFSAliasSize);++ /* Set the volume create date, local time in Mac OS format */+ valptr = (uint32_t *)(alias + kHFSAliasVolCreateDateOffset);+ *valptr = OSSwapHostToBigInt32(hfsmp->localCreateDate);++ /* If the file system is on a virtual device like disk image,+ * update the volume type to be ejectable device.+ */+ if (hfsmp->hfs_flags & HFS_VIRTUAL_DEVICE) {+ *(uint16_t *)(alias + kHFSAliasVolTypeOffset) =+ OSSwapHostToBigInt16(kHFSAliasVolTypeEjectable);+ }++ /* Set id of the parent of the target directory */+ valptr = (uint32_t *)(alias + kHFSAliasParentIDOffset);+ *valptr = OSSwapHostToBigInt32(hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid);++ /* Set id of the target directory */+ valptr = (uint32_t *)(alias + kHFSAliasTargetIDOffset);+ *valptr = OSSwapHostToBigInt32(inode_num);++ /* Write alias content to disk. */+ if (hfsmp->jnl) {+ journal_modify_block_end(hfsmp->jnl, bp, NULL, NULL);+ } else if ((result = buf_bwrite(bp))) {+ goto exit;+ }++ /* Finish initializing the fork data. */+ rsrcforkp->logicalSize = kHFSAliasSize;+ rsrcforkp->totalBlocks = rsrcforkp->extents[0].blockCount;++exit:+ if (result && rsrcforkp->extents[0].startBlock != 0) {+ (void) BlockDeallocate(hfsmp, rsrcforkp->extents[0].startBlock, rsrcforkp->extents[0].blockCount, 0);+ rsrcforkp->extents[0].startBlock = 0;+ rsrcforkp->extents[0].blockCount = 0;+ rsrcforkp->logicalSize = 0;+ rsrcforkp->totalBlocks = 0;+ }+ return (result);+}++/*+ * cat_deletelink - delete a link from the catalog+ */+int+cat_deletelink(struct hfsmount *hfsmp, struct cat_desc *descp)+{+ struct HFSPlusCatalogFile file;+ struct cat_attr cattr;+ uint32_t totalBlocks;+ int i;+ int result;++ bzero(&file, sizeof (file));+ bzero(&cattr, sizeof (cattr));+ cattr.ca_fileid = descp->cd_cnid;++ /* Directory links have alias content to remove. */+ if (descp->cd_flags & CD_ISDIR) {+ FCB * fcb;+ BTreeIterator * iterator;+ struct FSBufferDescriptor btdata;++ fcb = hfsmp->hfs_catalog_cp->c_datafork;++ /* Borrow the btcb iterator since we have an exclusive catalog lock. */+ iterator = &((BTreeControlBlockPtr)(fcb->ff_sysfileinfo))->iterator;+ iterator->hint.nodeNum = 0;++ if ((result = buildkey(hfsmp, descp, (HFSPlusCatalogKey *)&iterator->key, 0))) {+ goto exit;+ }+ BDINIT(btdata, &file);++ if ((result = BTSearchRecord(fcb, iterator, &btdata, NULL, NULL))) {+ goto exit;+ }+ }++ result = cat_delete(hfsmp, descp, &cattr);++ if ((result == 0) &&+ (descp->cd_flags & CD_ISDIR) &&+ (file.recordType == kHFSPlusFileRecord)) {++ totalBlocks = file.resourceFork.totalBlocks;++ for (i = 0; (i < 8) && (totalBlocks > 0); i++) {+ if ((file.resourceFork.extents[i].blockCount == 0) &&+ (file.resourceFork.extents[i].startBlock == 0)) {+ break;+ }++ (void) BlockDeallocate(hfsmp,+ file.resourceFork.extents[i].startBlock,+ file.resourceFork.extents[i].blockCount, 0);++ totalBlocks -= file.resourceFork.extents[i].blockCount;+ file.resourceFork.extents[i].startBlock = 0;+ file.resourceFork.extents[i].blockCount = 0;+ }+ }+exit:+ return (result);+}+++/*+ * Callback to collect directory entries.+ * Called with readattr_state for each item in a directory.+ */+struct readattr_state {+ struct hfsmount *hfsmp;+ struct cat_entrylist *list;+ cnid_t dir_cnid;+ int error;+ int reached_eof;+};++static int+getentriesattr_callback(const CatalogKey *key, const CatalogRecord *rec,+ struct readattr_state *state)+{+ struct cat_entrylist *list = state->list;+ struct hfsmount *hfsmp = state->hfsmp;+ struct cat_entry *cep;+ cnid_t parentcnid;++ if (list->realentries >= list->maxentries)+ return (0); /* stop */++ parentcnid = key->hfsPlus.parentID;++ switch(rec->recordType) {+ case kHFSPlusFolderRecord:+ case kHFSPlusFileRecord:+ if (parentcnid != state->dir_cnid) {+ state->error = ENOENT;+ state->reached_eof = 1;+ return (0); /* stop */+ }+ break;+ default:+ state->error = ENOENT;+ return (0); /* stop */+ }++ /* Hide the private system directories and journal files */+ if (parentcnid == kHFSRootFolderID) {+ if (rec->recordType == kHFSPlusFolderRecord) {+ if (rec->hfsPlusFolder.folderID == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid ||+ rec->hfsPlusFolder.folderID == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {+ list->skipentries++;+ return (1); /* continue */+ }+ }+ if ((hfsmp->jnl || ((HFSTOVCB(hfsmp)->vcbAtrb & kHFSVolumeJournaledMask) && (hfsmp->hfs_flags & HFS_READ_ONLY))) &&+ (rec->recordType == kHFSPlusFileRecord) &&+ ((rec->hfsPlusFile.fileID == hfsmp->hfs_jnlfileid) ||+ (rec->hfsPlusFile.fileID == hfsmp->hfs_jnlinfoblkid))) {+ list->skipentries++;+ return (1); /* continue */+ }+ }++ cep = &list->entry[list->realentries++];++ getbsdattr(hfsmp, (const struct HFSPlusCatalogFile *)rec, &cep->ce_attr);+ builddesc((const HFSPlusCatalogKey *)key, getcnid(rec), 0, getencoding(rec),+ isadir(rec), &cep->ce_desc);++ if (rec->recordType == kHFSPlusFileRecord) {+ cep->ce_datasize = rec->hfsPlusFile.dataFork.logicalSize;+ cep->ce_datablks = rec->hfsPlusFile.dataFork.totalBlocks;+ cep->ce_rsrcsize = rec->hfsPlusFile.resourceFork.logicalSize;+ cep->ce_rsrcblks = rec->hfsPlusFile.resourceFork.totalBlocks;++ /* Save link reference for later processing. */+ if ((SWAP_BE32(rec->hfsPlusFile.userInfo.fdType) == kHardLinkFileType) &&+ (SWAP_BE32(rec->hfsPlusFile.userInfo.fdCreator) == kHFSPlusCreator)) {+ cep->ce_attr.ca_linkref = rec->hfsPlusFile.bsdInfo.special.iNodeNum;+ } else if ((rec->hfsPlusFile.flags & kHFSHasLinkChainMask) &&+ (SWAP_BE32(rec->hfsPlusFile.userInfo.fdType) == kHFSAliasType) &&+ (SWAP_BE32(rec->hfsPlusFile.userInfo.fdCreator) == kHFSAliasCreator)) {+ cep->ce_attr.ca_linkref = rec->hfsPlusFile.bsdInfo.special.iNodeNum;+ }+ }++ return (list->realentries < list->maxentries);+}++/*+ * Pack a cat_entrylist buffer with attributes from the catalog+ *+ * Note: index is zero relative+ */+int+cat_getentriesattr(struct hfsmount *hfsmp, directoryhint_t *dirhint, struct cat_entrylist *ce_list, int *reachedeof)+{+ FCB* fcb;+ CatalogKey * key;+ BTreeIterator * iterator;+ struct readattr_state state;+ cnid_t parentcnid;+ int i;+ int index;+ int have_key;+ int result = 0;+ int reached_eof = 0;++ ce_list->realentries = 0;++ fcb = GetFileControlBlock(HFSTOVCB(hfsmp)->catalogRefNum);+ parentcnid = dirhint->dh_desc.cd_parentcnid;++ bzero (&state, sizeof(struct readattr_state));++ state.hfsmp = hfsmp;+ state.list = ce_list;+ state.dir_cnid = parentcnid;+ state.error = 0;++ iterator = hfs_malloc_type(BTreeIterator);+ key = (CatalogKey *)&iterator->key;+ have_key = 0;+ iterator->hint.nodeNum = dirhint->dh_desc.cd_hint;+ index = dirhint->dh_index + 1;++ /*+ * Attempt to build a key from cached filename+ */+ if (dirhint->dh_desc.cd_namelen != 0) {+ if (buildkey(hfsmp, &dirhint->dh_desc, (HFSPlusCatalogKey *)key, 0) == 0) {+ have_key = 1;+ }+ }++ /*+ * If the last entry wasn't cached then position the btree iterator+ */+ if ((index == 0) || !have_key) {+ /*+ * Position the iterator at the directory's thread record.+ * (i.e. just before the first entry)+ */+ buildthreadkey(dirhint->dh_desc.cd_parentcnid, key);+ result = BTSearchRecord(fcb, iterator, NULL, NULL, iterator);+ if (result) {+ result = MacToVFSError(result);+ goto exit;+ }++ /*+ * Iterate until we reach the entry just+ * before the one we want to start with.+ */+ if (index > 0) {+ struct position_state ps;++ ps.error = 0;+ ps.count = 0;+ ps.index = index;+ ps.parentID = dirhint->dh_desc.cd_parentcnid;+ ps.hfsmp = hfsmp;++ result = BTIterateRecords(fcb, kBTreeNextRecord, iterator,+ (IterateCallBackProcPtr)cat_findposition, &ps);+ if (ps.error)+ result = ps.error;+ else+ result = MacToVFSError(result);++ if (result) {+ /*+ * Note: the index may now point to EOF if the directory+ * was modified in between system calls. We will return+ * ENOENT from cat_findposition if this is the case, and+ * when we bail out with an error, our caller (hfs_readdirattr_internal)+ * will suppress the error and indicate EOF to its caller.+ */+ result = MacToVFSError(result);+ goto exit;+ }+ }+ }++ /* Fill list with entries starting at iterator->key. */+ result = BTIterateRecords(fcb, kBTreeNextRecord, iterator,+ (IterateCallBackProcPtr)getentriesattr_callback, &state);++ if (state.error) {+ result = state.error;+ reached_eof = state.reached_eof;+ }+ else if (ce_list->realentries == 0) {+ result = ENOENT;+ reached_eof = 1;+ }+ else {+ result = MacToVFSError(result);+ }++ /*+ * Resolve any hard links.+ */+ for (i = 0; i < (int)ce_list->realentries; ++i) {+ struct FndrFileInfo *fip;+ struct cat_entry *cep;+ struct HFSPlusCatalogFile filerec;+ int isdirlink = 0;+ int isfilelink = 0;++ cep = &ce_list->entry[i];+ if (cep->ce_attr.ca_linkref == 0)+ continue;++ /* Note: Finder info is still in Big Endian */+ fip = (struct FndrFileInfo *)&cep->ce_attr.ca_finderinfo;++ if (S_ISREG(cep->ce_attr.ca_mode) &&+ (SWAP_BE32(fip->fdType) == kHardLinkFileType) &&+ (SWAP_BE32(fip->fdCreator) == kHFSPlusCreator)) {+ isfilelink = 1;+ }+ if (S_ISREG(cep->ce_attr.ca_mode) &&+ (SWAP_BE32(fip->fdType) == kHFSAliasType) &&+ (SWAP_BE32(fip->fdCreator) == kHFSAliasCreator) &&+ (cep->ce_attr.ca_recflags & kHFSHasLinkChainMask)) {+ isdirlink = 1;+ }+ if (isfilelink || isdirlink) {+ if (cat_resolvelink(hfsmp, cep->ce_attr.ca_linkref, isdirlink, &filerec) != 0)+ continue;+ /* Repack entry from inode record. */+ getbsdattr(hfsmp, &filerec, &cep->ce_attr);+ cep->ce_datasize = filerec.dataFork.logicalSize;+ cep->ce_datablks = filerec.dataFork.totalBlocks;+ cep->ce_rsrcsize = filerec.resourceFork.logicalSize;+ cep->ce_rsrcblks = filerec.resourceFork.totalBlocks;+ }+ }++exit:+ hfs_free_type(iterator, BTreeIterator);+ *reachedeof = reached_eof;+ return MacToVFSError(result);+}++#define SMALL_DIRENTRY_SIZE (int)(sizeof(struct dirent) - (MAXNAMLEN + 1) + 8)++/*+ * Callback to pack directory entries.+ * Called with packdirentry_state for each item in a directory.+ */++/* Hard link information collected during cat_getdirentries. */+struct linkinfo {+ u_int32_t link_ref;+ user_addr_t dirent_addr;+};+typedef struct linkinfo linkinfo_t;++/* State information for the getdirentries_callback function. */+struct packdirentry_state {+ int cbs_flags; /* VNODE_READDIR_* flags */+ u_int32_t cbs_parentID;+ u_int32_t cbs_index;+ uio_t cbs_uio;+ ExtendedVCB * cbs_hfsmp;+ int cbs_result;+ int32_t cbs_nlinks;+ int32_t cbs_maxlinks;+ linkinfo_t * cbs_linkinfo;+ struct cat_desc * cbs_desc;+ u_int8_t * cbs_namebuf;+ /*+ * The following fields are only used for NFS readdir, which+ * uses the next file id as the seek offset of each entry.+ */+ struct direntry * cbs_direntry;+ struct direntry * cbs_prevdirentry;+ u_int32_t cbs_previlinkref;+ Boolean cbs_hasprevdirentry;+ Boolean cbs_eof;+};++/*+ * getdirentries callback for HFS Plus directories.+ */+static int+getdirentries_callback(const CatalogKey *ckp, const CatalogRecord *crp,+ struct packdirentry_state *state)+{+ struct hfsmount *hfsmp;+ const CatalogName *cnp;+ cnid_t curID;+ OSErr result;+ struct dirent catent;+ struct direntry * entry = NULL;+ time_t itime;+ u_int32_t ilinkref = 0;+ u_int32_t curlinkref = 0;+ cnid_t cnid;+ int hide = 0;+ u_int8_t type = DT_UNKNOWN;+ u_int8_t is_mangled = 0;+ u_int8_t is_link = 0;+ u_int8_t *nameptr;+ user_addr_t uiobase = USER_ADDR_NULL;+ size_t namelen = 0;+ size_t maxnamelen;+ size_t uiosize = 0;+ caddr_t uioaddr;+ Boolean stop_after_pack = false;++ hfsmp = state->cbs_hfsmp;+ curID = ckp->hfsPlus.parentID;++ /* We're done when parent directory changes */+ if (state->cbs_parentID != curID) {+ /*+ * If the parent ID is different from curID this means we've hit+ * the EOF for the directory. To help future callers, we mark+ * the cbs_eof boolean. However, we should only mark the EOF+ * boolean if we're about to return from this function.+ *+ * This is because this callback function does its own uiomove+ * to get the data to userspace. If we set the boolean before determining+ * whether or not the current entry has enough room to write its+ * data to userland, we could fool the callers of this catalog function+ * into thinking they've hit EOF earlier than they really would have.+ * In that case, we'd know that we have more entries to process and+ * send to userland, but we didn't have enough room.+ *+ * To be safe, we mark cbs_eof here ONLY for the cases where we know we're+ * about to return and won't write any new data back+ * to userland. In the stop_after_pack case, we'll set this boolean+ * regardless, so it's slightly safer to let that logic mark the boolean,+ * especially since it's closer to the return of this function.+ */++ if (state->cbs_flags & VNODE_READDIR_EXTENDED) {+ /* The last record has not been returned yet, so we+ * want to stop after packing the last item+ */+ if (state->cbs_hasprevdirentry) {+ stop_after_pack = true;+ } else {+ state->cbs_eof = true;+ state->cbs_result = ENOENT;+ return (0); /* stop */+ }+ } else {+ state->cbs_eof = true;+ state->cbs_result = ENOENT;+ return (0); /* stop */+ }+ }++ if (state->cbs_flags & VNODE_READDIR_EXTENDED) {+ entry = state->cbs_direntry;+ nameptr = (u_int8_t *)&entry->d_name[0];+ if (state->cbs_flags & VNODE_READDIR_NAMEMAX) {+ /*+ * The NFS server sometimes needs to make filenames fit in+ * NAME_MAX bytes (since its client may not be able to+ * handle a longer name). In that case, NFS will ask us+ * to mangle the name to keep it short enough.+ */+ maxnamelen = NAME_MAX + 1;+ } else {+ maxnamelen = sizeof(entry->d_name);+ }+ } else {+ nameptr = (u_int8_t *)&catent.d_name[0];+ maxnamelen = sizeof(catent.d_name);+ }++ if ((state->cbs_flags & VNODE_READDIR_EXTENDED) && stop_after_pack) {+ /* The last item returns a non-zero invalid cookie */+ cnid = INT_MAX;+ } else {+ switch(crp->recordType) {+ case kHFSPlusFolderRecord:+ type = DT_DIR;+ cnid = crp->hfsPlusFolder.folderID;+ /* Hide our private system directories. */+ if (curID == kHFSRootFolderID) {+ if (cnid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid ||+ cnid == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {+ hide = 1;+ }+ }+ break;+ case kHFSPlusFileRecord:+ itime = to_bsd_time(crp->hfsPlusFile.createDate);+ type = MODE_TO_DT(crp->hfsPlusFile.bsdInfo.fileMode);+ cnid = crp->hfsPlusFile.fileID;+ /*+ * When a hardlink link is encountered save its link ref.+ */+ if ((SWAP_BE32(crp->hfsPlusFile.userInfo.fdType) == kHardLinkFileType) &&+ (SWAP_BE32(crp->hfsPlusFile.userInfo.fdCreator) == kHFSPlusCreator) &&+ ((itime == (time_t)hfsmp->hfs_itime) ||+ (itime == (time_t)hfsmp->hfs_metadata_createdate))) {+ /* If link ref is inode's file id then use it directly. */+ if (crp->hfsPlusFile.flags & kHFSHasLinkChainMask) {+ cnid = crp->hfsPlusFile.hl_linkReference;+ } else {+ ilinkref = crp->hfsPlusFile.hl_linkReference;+ }+ is_link =1;+ } else if ((SWAP_BE32(crp->hfsPlusFile.userInfo.fdType) == kHFSAliasType) &&+ (SWAP_BE32(crp->hfsPlusFile.userInfo.fdCreator) == kHFSAliasCreator) &&+ (crp->hfsPlusFile.flags & kHFSHasLinkChainMask) &&+ (crp->hfsPlusFile.hl_linkReference >= kHFSFirstUserCatalogNodeID) &&+ ((itime == (time_t)hfsmp->hfs_itime) ||+ (itime == (time_t)hfsmp->hfs_metadata_createdate))) {+ /* A directory's link resolves to a directory. */+ type = DT_DIR;+ /* A directory's link ref is always inode's file id. */+ cnid = crp->hfsPlusFile.hl_linkReference;+ is_link = 1;+ }+ /* Hide the journal files */+ if ((curID == kHFSRootFolderID) &&+ ((hfsmp->jnl || ((HFSTOVCB(hfsmp)->vcbAtrb & kHFSVolumeJournaledMask) && (hfsmp->hfs_flags & HFS_READ_ONLY)))) &&+ ((cnid == hfsmp->hfs_jnlfileid) ||+ (cnid == hfsmp->hfs_jnlinfoblkid))) {+ hide = 1;+ }+ break;+ default:+ return (0); /* stop */+ };++ cnp = (const CatalogName*) &ckp->hfsPlus.nodeName;++ namelen = cnp->ustr.length;+ /*+ * For MacRoman encoded names (textEncoding == 0), assume that it's ascii+ * and convert it directly in an attempt to avoid the more+ * expensive utf8_encodestr conversion.+ */+ if ((namelen < maxnamelen) && (crp->hfsPlusFile.textEncoding == 0)) {+ int i;+ u_int16_t ch;+ const u_int16_t *chp;++ chp = &cnp->ustr.unicode[0];+ for (i = 0; i < (int)namelen; ++i) {+ ch = *chp++;+ if (ch > 0x007f || ch == 0x0000) {+ /* Perform expensive utf8_encodestr conversion */+ goto encodestr;+ }+ nameptr[i] = (ch == '/') ? ':' : (u_int8_t)ch;+ }+ nameptr[namelen] = '\0';+ result = 0;+ } else {+encodestr:+ result = utf8_encodestr(cnp->ustr.unicode, namelen * sizeof(UniChar),+ nameptr, &namelen, maxnamelen, ':', 0);+ }++ /* Check result returned from encoding the filename to utf8 */+ if (result == ENAMETOOLONG) {+ /*+ * If we were looking at a catalog record for a hardlink (not the inode),+ * then we want to use its link ID as opposed to the inode ID for+ * a mangled name. For all other cases, they are the same. Note that+ * due to the way directory hardlinks are implemented, the actual link+ * is going to be counted as a file record, so we can catch both+ * with is_link.+ */+ cnid_t linkid = cnid;+ if (is_link) {+ linkid = crp->hfsPlusFile.fileID;+ }++ result = ConvertUnicodeToUTF8Mangled(cnp->ustr.length * sizeof(UniChar),+ cnp->ustr.unicode, maxnamelen,+ (ByteCount*)&namelen, nameptr, linkid);+ is_mangled = 1;+ }+ }++ if (state->cbs_flags & VNODE_READDIR_EXTENDED) {+ /*+ * The index is 1 relative and includes "." and ".."+ *+ * Also stuff the cnid in the upper 32 bits of the cookie.+ * The cookie is stored to the previous entry, which will+ * be packed and copied this time+ */+ state->cbs_prevdirentry->d_seekoff = (state->cbs_index + 3) | ((u_int64_t)cnid << 32);+ uiosize = state->cbs_prevdirentry->d_reclen;+ uioaddr = (caddr_t) state->cbs_prevdirentry;+ } else {+ catent.d_type = type;+ catent.d_namlen = namelen;+ catent.d_reclen = uiosize = STD_DIRENT_LEN(namelen);+ if (hide)+ catent.d_fileno = 0; /* file number = 0 means skip entry */+ else+ catent.d_fileno = cnid;+ uioaddr = (caddr_t) &catent;+ }++ /* Save current base address for post processing of hard-links. */+ if (ilinkref || state->cbs_previlinkref) {+ uiobase = uio_curriovbase(state->cbs_uio);+ }+ /* If this entry won't fit then we're done */+ if ((uiosize > (user_size_t)uio_resid(state->cbs_uio)) ||+ (ilinkref != 0 && state->cbs_nlinks == state->cbs_maxlinks)) {+ return (0); /* stop */+ }++ if (!(state->cbs_flags & VNODE_READDIR_EXTENDED) || state->cbs_hasprevdirentry) {+ state->cbs_result = uiomove(uioaddr, uiosize, state->cbs_uio);+ if (state->cbs_result == 0) {+ ++state->cbs_index;++ /* Remember previous entry */+ state->cbs_desc->cd_cnid = cnid;+ if (type == DT_DIR) {+ state->cbs_desc->cd_flags |= CD_ISDIR;+ } else {+ state->cbs_desc->cd_flags &= ~CD_ISDIR;+ }+ if (state->cbs_desc->cd_nameptr != NULL) {+ state->cbs_desc->cd_namelen = 0;+ }+#if 0+ state->cbs_desc->cd_encoding = xxxx;+#endif+ if (!is_mangled) {+ state->cbs_desc->cd_namelen = namelen;+ bcopy(nameptr, state->cbs_namebuf, namelen + 1);+ } else {+ /* Store unmangled name for the directory hint else it will+ * restart readdir at the last location again+ */+ u_int8_t *new_nameptr;+ size_t bufsize;+ size_t tmp_namelen = 0;++ cnp = (const CatalogName *)&ckp->hfsPlus.nodeName;+ bufsize = 1 + utf8_encodelen(cnp->ustr.unicode,+ cnp->ustr.length * sizeof(UniChar),+ ':', 0);+ new_nameptr = hfs_malloc_data(bufsize);+ result = utf8_encodestr(cnp->ustr.unicode,+ cnp->ustr.length * sizeof(UniChar),+ new_nameptr, &tmp_namelen, bufsize, ':', 0);++ state->cbs_desc->cd_namelen = tmp_namelen;+ bcopy(new_nameptr, state->cbs_namebuf, tmp_namelen + 1);++ hfs_free_data(new_nameptr, bufsize);+ }+ }+ if (state->cbs_hasprevdirentry) {+ curlinkref = ilinkref; /* save current */+ ilinkref = state->cbs_previlinkref; /* use previous */+ }+ /*+ * Record any hard links for post processing.+ */+ if ((ilinkref != 0) &&+ (state->cbs_result == 0) &&+ (state->cbs_nlinks < state->cbs_maxlinks)) {+ state->cbs_linkinfo[state->cbs_nlinks].dirent_addr = uiobase;+ state->cbs_linkinfo[state->cbs_nlinks].link_ref = ilinkref;+ state->cbs_nlinks++;+ }+ if (state->cbs_hasprevdirentry) {+ ilinkref = curlinkref; /* restore current */+ }+ }++ /* Fill the direntry to be used the next time */+ if (state->cbs_flags & VNODE_READDIR_EXTENDED) {+ if (stop_after_pack) {+ state->cbs_eof = true;+ return (0); /* stop */+ }+ entry->d_type = type;+ entry->d_namlen = namelen;+ entry->d_reclen = EXT_DIRENT_LEN(namelen);+ if (hide) {+ /* File number = 0 means skip entry */+ entry->d_fileno = 0;+ } else {+ entry->d_fileno = cnid;+ }+ /* swap the current and previous entry */+ struct direntry * tmp;+ tmp = state->cbs_direntry;+ state->cbs_direntry = state->cbs_prevdirentry;+ state->cbs_prevdirentry = tmp;+ state->cbs_hasprevdirentry = true;+ state->cbs_previlinkref = ilinkref;+ }++ /* Continue iteration if there's room */+ return (state->cbs_result == 0 &&+ uio_resid(state->cbs_uio) >= SMALL_DIRENTRY_SIZE);+}++/*+ * Pack a uio buffer with directory entries from the catalog+ */+int+cat_getdirentries(struct hfsmount *hfsmp, u_int32_t entrycnt, directoryhint_t *dirhint,+ uio_t uio, int flags, int * items, int * eofflag)+{+ FCB* fcb;+ BTreeIterator * iterator;+ CatalogKey * key;+ struct packdirentry_state state;+ void * buffer;+ int bufsize;+ int maxlinks;+ int result = 0;+ int index;+ int have_key;+ int extended;++ extended = flags & VNODE_READDIR_EXTENDED;++ if (extended && (hfsmp->hfs_flags & HFS_STANDARD)) {+ return (ENOTSUP);+ }+ fcb = hfsmp->hfs_catalog_cp->c_datafork;++ #define MAX_LINKINFO_ENTRIES 275+ /*+ * Get a buffer for link info array, btree iterator and a direntry.+ *+ * We impose an cap of 275 link entries when trying to compute+ * the total number of hardlink entries that we'll allow in the+ * linkinfo array, as this has been shown to noticeably impact performance.+ *+ * Note that in the case where there are very few hardlinks,+ * this does not restrict or prevent us from vending out as many entries+ * as we can to the uio_resid, because the getdirentries callback+ * uiomoves the directory entries to the uio itself and does not use+ * this MALLOC'd array. It also limits itself to maxlinks of hardlinks.+ */++ // This value cannot underflow: both entrycnt and the rhs are unsigned 32-bit+ // ints, so the worst-case MIN of them is 0.+ maxlinks = MIN (entrycnt, (u_int32_t)(uio_resid(uio) / SMALL_DIRENTRY_SIZE));+ // Prevent overflow.+ maxlinks = MIN (maxlinks, MAX_LINKINFO_ENTRIES);+ bufsize = MAXPATHLEN + (maxlinks * sizeof(linkinfo_t)) + sizeof(*iterator);++ if (extended) {+ bufsize += 2*sizeof(struct direntry);+ }+ buffer = hfs_malloc_zero_data(bufsize);++ state.cbs_flags = flags;+ state.cbs_hasprevdirentry = false;+ state.cbs_previlinkref = 0;+ state.cbs_nlinks = 0;+ state.cbs_maxlinks = maxlinks;+ state.cbs_linkinfo = (linkinfo_t *)((char *)buffer + MAXPATHLEN);+ /*+ * We need to set cbs_eof to false regardless of whether or not the+ * control flow is actually in the extended case, since we use this+ * field to track whether or not we've returned EOF from the iterator function.+ */+ state.cbs_eof = false;++ iterator = (BTreeIterator *) ((char *)state.cbs_linkinfo + (maxlinks * sizeof(linkinfo_t)));+ key = (CatalogKey *)&iterator->key;+ have_key = 0;+ index = dirhint->dh_index + 1;+ if (extended) {+ state.cbs_direntry = (struct direntry *)((char *)iterator + sizeof(BTreeIterator));+ state.cbs_prevdirentry = state.cbs_direntry + 1;+ }+ /*+ * Attempt to build a key from cached filename+ */+ if (dirhint->dh_desc.cd_namelen != 0) {+ if (buildkey(hfsmp, &dirhint->dh_desc, (HFSPlusCatalogKey *)key, 0) == 0) {+ iterator->hint.nodeNum = dirhint->dh_desc.cd_hint;+ have_key = 1;+ }+ }++ if (index == 0 && dirhint->dh_threadhint != 0) {+ /*+ * Position the iterator at the directory's thread record.+ * (i.e. just before the first entry)+ */+ buildthreadkey(dirhint->dh_desc.cd_parentcnid, key);+ iterator->hint.nodeNum = dirhint->dh_threadhint;+ iterator->hint.index = 0;+ have_key = 1;+ }++ /*+ * If the last entry wasn't cached then position the btree iterator+ */+ if (!have_key) {+ /*+ * Position the iterator at the directory's thread record.+ * (i.e. just before the first entry)+ */+ buildthreadkey(dirhint->dh_desc.cd_parentcnid, key);+ result = BTSearchRecord(fcb, iterator, NULL, NULL, iterator);+ if (result) {+ result = MacToVFSError(result);+ goto cleanup;+ }+ if (index == 0) {+ dirhint->dh_threadhint = iterator->hint.nodeNum;+ }+ /*+ * Iterate until we reach the entry just+ * before the one we want to start with.+ */+ if (index > 0) {+ struct position_state ps;++ ps.error = 0;+ ps.count = 0;+ ps.index = index;+ ps.parentID = dirhint->dh_desc.cd_parentcnid;+ ps.hfsmp = hfsmp;++ result = BTIterateRecords(fcb, kBTreeNextRecord, iterator,+ (IterateCallBackProcPtr)cat_findposition, &ps);+ if (ps.error)+ result = ps.error;+ else+ result = MacToVFSError(result);+ if (result) {+ result = MacToVFSError(result);+ if (result == ENOENT) {+ /*+ * ENOENT means we've hit the EOF.+ * suppress the error, and set the eof flag.+ */+ result = 0;+ dirhint->dh_desc.cd_flags |= CD_EOF;+ *eofflag = 1;+ }+ goto cleanup;+ }+ }+ }++ state.cbs_index = index;+ state.cbs_hfsmp = hfsmp;+ state.cbs_uio = uio;+ state.cbs_desc = &dirhint->dh_desc;+ state.cbs_namebuf = (u_int8_t *)buffer;+ state.cbs_result = 0;+ state.cbs_parentID = dirhint->dh_desc.cd_parentcnid;++ /* Use a temporary buffer to hold intermediate descriptor names. */+ if (dirhint->dh_desc.cd_namelen > 0 && dirhint->dh_desc.cd_nameptr != NULL) {+ bcopy(dirhint->dh_desc.cd_nameptr, buffer, dirhint->dh_desc.cd_namelen+1);+ if (dirhint->dh_desc.cd_flags & CD_HASBUF) {+ dirhint->dh_desc.cd_flags &= ~CD_HASBUF;+ vfs_removename((const char *)dirhint->dh_desc.cd_nameptr);+ }+ }+ dirhint->dh_desc.cd_nameptr = (u_int8_t *)buffer;++ enum BTreeIterationOperations op;+ if (extended && index != 0 && have_key)+ op = kBTreeCurrentRecord;+ else+ op = kBTreeNextRecord;++ /*+ * Process as many entries as possible starting at iterator->key.+ */+ if ((hfsmp->hfs_flags & HFS_STANDARD) == 0) {+ /* HFS+ */+ result = BTIterateRecords(fcb, op, iterator,+ (IterateCallBackProcPtr)getdirentries_callback, &state);++ /* For extended calls, every call to getdirentries_callback()+ * transfers the previous directory entry found to the user+ * buffer. Therefore when BTIterateRecords reaches the end of+ * Catalog BTree, call getdirentries_callback() again with+ * dummy values to copy the last directory entry stored in+ * packdirentry_state+ */+ if (extended && (result == fsBTRecordNotFoundErr)) {+ CatalogKey ckp;+ CatalogRecord crp;++ bzero(&ckp, sizeof(ckp));+ bzero(&crp, sizeof(crp));++ result = getdirentries_callback(&ckp, &crp, &state);+ }+ }++ /* Note that state.cbs_index is still valid on errors */+ *items = state.cbs_index - index;+ index = state.cbs_index;++ /*+ * Also note that cbs_eof is set in all cases if we ever hit EOF+ * during the enumeration by the catalog callback. Mark the directory's hint+ * descriptor as having hit EOF.+ */++ if (state.cbs_eof) {+ dirhint->dh_desc.cd_flags |= CD_EOF;+ *eofflag = 1;+ }++ /* Finish updating the catalog iterator. */+ dirhint->dh_desc.cd_hint = iterator->hint.nodeNum;+ dirhint->dh_desc.cd_flags |= CD_DECOMPOSED;+ dirhint->dh_index = index - 1;++ /* Fix up the name. */+ if (dirhint->dh_desc.cd_namelen > 0) {+ dirhint->dh_desc.cd_nameptr = (const u_int8_t *)vfs_addname((char *)buffer, dirhint->dh_desc.cd_namelen, 0, 0);+ dirhint->dh_desc.cd_flags |= CD_HASBUF;+ } else {+ dirhint->dh_desc.cd_nameptr = NULL;+ dirhint->dh_desc.cd_namelen = 0;+ }++ /*+ * Post process any hard links to get the real file id.+ */+ if (state.cbs_nlinks > 0) {+ ino_t fileid = 0;+ user_addr_t address;+ int i;++ for (i = 0; i < state.cbs_nlinks; ++i) {+ if (resolvelinkid(hfsmp, state.cbs_linkinfo[i].link_ref, &fileid) != 0)+ continue;+ /* This assumes that d_ino is always first field. */+ address = state.cbs_linkinfo[i].dirent_addr;+ if (address == (user_addr_t)0)+ continue;+ if (uio_isuserspace(uio)) {+ if (extended) {+ ino64_t fileid_64 = (ino64_t)fileid;+ (void) copyout(&fileid_64, address, sizeof(fileid_64));+ } else {+ (void) copyout(&fileid, address, sizeof(fileid));+ }+ } else /* system space */ {+ if (extended) {+ ino64_t fileid_64 = (ino64_t)fileid;+ bcopy(&fileid_64, (void*) CAST_DOWN(caddr_t, address), sizeof(fileid_64));+ } else {+ bcopy(&fileid, (void*) CAST_DOWN(caddr_t, address), sizeof(fileid));+ }+ }+ }+ }++ if (state.cbs_result)+ result = state.cbs_result;+ else+ result = MacToVFSError(result);++ if (result == ENOENT) {+ result = 0;+ }++cleanup:+ hfs_free_data(buffer, bufsize);++ return (result);+}+++/*+ * Callback to establish directory position.+ * Called with position_state for each item in a directory.+ */+static int+cat_findposition(const CatalogKey *ckp, const CatalogRecord *crp,+ struct position_state *state)+{+ cnid_t curID = 0;++ if ((state->hfsmp->hfs_flags & HFS_STANDARD) == 0) {+ curID = ckp->hfsPlus.parentID;+ }++ /* Make sure parent directory didn't change */+ if (state->parentID != curID) {+ /*+ * The parent ID is different from curID this means we've hit+ * the EOF for the directory.+ */+ state->error = ENOENT;+ return (0); /* stop */+ }++ /* Count this entry */+ switch(crp->recordType) {+ case kHFSPlusFolderRecord:+ case kHFSPlusFileRecord:+ ++state->count;+ break;+ default:+ printf("hfs: cat_findposition: invalid record type %d in dir %d\n",+ crp->recordType, curID);+ state->error = EINVAL;+ return (0); /* stop */+ };++ return (state->count < state->index);+}+++/*+ * cat_binarykeycompare - compare two HFS Plus catalog keys.++ * The name portion of the key is compared using a 16-bit binary comparison.+ * This is called from the b-tree code.+ */+int+cat_binarykeycompare(HFSPlusCatalogKey *searchKey, HFSPlusCatalogKey *trialKey)+{+ u_int32_t searchParentID, trialParentID;+ int result;++ searchParentID = searchKey->parentID;+ trialParentID = trialKey->parentID;+ result = 0;++ if (searchParentID > trialParentID) {+ ++result;+ } else if (searchParentID < trialParentID) {+ --result;+ } else {+ u_int16_t * str1 = &searchKey->nodeName.unicode[0];+ u_int16_t * str2 = &trialKey->nodeName.unicode[0];+ int length1 = searchKey->nodeName.length;+ int length2 = trialKey->nodeName.length;++ result = UnicodeBinaryCompare (str1, length1, str2, length2);+ }++ return result;+}+++/*+ * Compare two HFS+ catalog keys+ *+ * Result: +n search key > trial key+ * 0 search key = trial key+ * -n search key < trial key+ */+int+CompareExtendedCatalogKeys(HFSPlusCatalogKey *searchKey, HFSPlusCatalogKey *trialKey)+{+ cnid_t searchParentID, trialParentID;+ int result;++ searchParentID = searchKey->parentID;+ trialParentID = trialKey->parentID;++ if (searchParentID > trialParentID) {+ result = 1;+ }+ else if (searchParentID < trialParentID) {+ result = -1;+ } else {+ /* parent node ID's are equal, compare names */+ if ( searchKey->nodeName.length == 0 || trialKey->nodeName.length == 0 )+ result = searchKey->nodeName.length - trialKey->nodeName.length;+ else+ result = FastUnicodeCompare(&searchKey->nodeName.unicode[0],+ searchKey->nodeName.length,+ &trialKey->nodeName.unicode[0],+ trialKey->nodeName.length);+ }++ return result;+}+++/*+ * buildkey - build a Catalog b-tree key from a cnode descriptor+ */+static int+buildkey(struct hfsmount *hfsmp, struct cat_desc *descp,+ HFSPlusCatalogKey *key, int retry)+{+ int utf8_flags = UTF_ESCAPE_ILLEGAL;+ int result = 0;+ size_t unicodeBytes = 0;++ if (descp->cd_namelen == 0 || descp->cd_nameptr[0] == '\0')+ return (EINVAL); /* invalid name */++ key->parentID = descp->cd_parentcnid;+ key->nodeName.length = 0;+ /*+ * Convert filename from UTF-8 into Unicode+ */++ if ((descp->cd_flags & CD_DECOMPOSED) == 0)+ utf8_flags |= UTF_DECOMPOSED;+ result = utf8_decodestr(descp->cd_nameptr, descp->cd_namelen,+ key->nodeName.unicode, &unicodeBytes,+ sizeof(key->nodeName.unicode), ':', utf8_flags);+ key->nodeName.length = unicodeBytes / sizeof(UniChar);+ key->keyLength = kHFSPlusCatalogKeyMinimumLength + unicodeBytes;+ if (result) {+ if (result != ENAMETOOLONG)+ result = EINVAL; /* name has invalid characters */+ return (result);+ }++ return (0);+ }+++/*+ * Resolve hard link reference to obtain the inode record.+ */+int+cat_resolvelink(struct hfsmount *hfsmp, u_int32_t linkref, int isdirlink, struct HFSPlusCatalogFile *recp)+{+ FSBufferDescriptor btdata;+ struct BTreeIterator *iterator;+ struct cat_desc idesc;+ char inodename[32];+ cnid_t parentcnid;+ int result = 0;++ BDINIT(btdata, recp);++ if (isdirlink) {+ MAKE_DIRINODE_NAME(inodename, sizeof(inodename), (unsigned int)linkref);+ parentcnid = hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid;+ } else {+ MAKE_INODE_NAME(inodename, sizeof(inodename), (unsigned int)linkref);+ parentcnid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid;+ }++ /* Get space for iterator */+ iterator = hfs_malloc_type(struct BTreeIterator);++ /* Build a descriptor for private dir. */+ idesc.cd_parentcnid = parentcnid;+ idesc.cd_nameptr = (const u_int8_t *)inodename;+ idesc.cd_namelen = strlen(inodename);+ idesc.cd_flags = 0;+ idesc.cd_hint = 0;+ idesc.cd_encoding = 0;+ (void) buildkey(hfsmp, &idesc, (HFSPlusCatalogKey *)&iterator->key, 0);++ result = BTSearchRecord(VTOF(HFSTOVCB(hfsmp)->catalogRefNum), iterator,+ &btdata, NULL, NULL);++ if (result == 0) {+ /* Make sure there's a reference */+ if (recp->hl_linkCount == 0)+ recp->hl_linkCount = 2;+ } else {+ printf("hfs: cat_resolvelink: can't find inode=%s on vol=%s\n", inodename, hfsmp->vcbVN);+ }++ hfs_free_type(iterator, struct BTreeIterator);++ return (result ? ENOENT : 0);+}++/*+ * Resolve hard link reference to obtain the inode number.+ */+static int+resolvelinkid(struct hfsmount *hfsmp, u_int32_t linkref, ino_t *ino)+{+ struct HFSPlusCatalogFile record;+ int error;++ /*+ * Since we know resolvelinkid is only called from+ * cat_getdirentries, we can assume that only file+ * hardlinks need to be resolved (cat_getdirentries+ * can resolve directory hardlinks in place).+ */+ error = cat_resolvelink(hfsmp, linkref, 0, &record);+ if (error == 0) {+ if (record.fileID == 0)+ error = ENOENT;+ else+ *ino = record.fileID;+ }+ return (error);+}++/*+ * getkey - get a key from id by doing a thread lookup+ */+static int+getkey(struct hfsmount *hfsmp, cnid_t cnid, CatalogKey * key)+{+ struct BTreeIterator * iterator;+ FSBufferDescriptor btdata;+ u_int16_t datasize;+ CatalogKey * keyp;+ CatalogRecord * recp;+ int result;++ iterator = hfs_malloc_type(struct BTreeIterator);+ buildthreadkey(cnid, (CatalogKey *)&iterator->key);++ recp = hfs_malloc_type(CatalogRecord);+ BDINIT(btdata, recp);++ result = BTSearchRecord(VTOF(HFSTOVCB(hfsmp)->catalogRefNum), iterator,+ &btdata, &datasize, iterator);+ if (result)+ goto exit;++ /* Turn thread record into a cnode key (in place) */+ switch (recp->recordType) {+ case kHFSPlusFileThreadRecord:+ case kHFSPlusFolderThreadRecord:+ keyp = (CatalogKey *)&recp->hfsPlusThread.reserved;+ keyp->hfsPlus.keyLength = kHFSPlusCatalogKeyMinimumLength ++ (keyp->hfsPlus.nodeName.length * 2);+ bcopy(keyp, key, keyp->hfsPlus.keyLength + 2);+ break;++ default:+ result = ENOENT;+ break;+ }++exit:+ hfs_free_type(iterator, struct BTreeIterator);+ hfs_free_type(recp, CatalogRecord);++ return MacToVFSError(result);+}++/*+ * getkeyplusattr - From id, fetch the key and the bsd attrs for a file/dir (could pass+ * null arguments to cat_idlookup instead, but we save around 10% by not building the+ * cat_desc here). Both key and attrp must point to real structures.+ *+ * The key's parent id is the only part of the key expected to be used by the caller.+ * The name portion of the key may not always be valid (ie in the case of a hard link).+ */+int+cat_getkeyplusattr(struct hfsmount *hfsmp, cnid_t cnid, CatalogKey * key, struct cat_attr *attrp)+{+ int result;++ result = getkey(hfsmp, cnid, key);++ if (result == 0) {+ result = cat_lookupbykey(hfsmp, key, 0, 0, 0, NULL, attrp, NULL, NULL);+ }+ /*+ * Check for a raw file hardlink inode.+ * Fix up the parent id in the key if necessary.+ * Only hard links created by Mac OS X 10.5 or later can be resolved here.+ */+ if ((result == 0) &&+ (key->hfsPlus.parentID == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid) &&+ (attrp->ca_recflags & kHFSHasLinkChainMask)) {+ cnid_t nextlinkid = 0;+ cnid_t prevlinkid = 0;+ struct cat_desc linkdesc;++ /*+ * Pick up the first link in the chain and get a descriptor for it.+ * This allows blind bulk access checks to work for hardlinks.+ */+ if ((cat_lookup_siblinglinks(hfsmp, cnid, &prevlinkid, &nextlinkid) == 0) &&+ (nextlinkid != 0)) {+ if (cat_findname(hfsmp, nextlinkid, &linkdesc) == 0) {+ key->hfsPlus.parentID = linkdesc.cd_parentcnid;+ cat_releasedesc(&linkdesc);+ }+ }+ }+ return MacToVFSError(result);+}+++/*+ * buildrecord - build a default catalog directory or file record+ */+static void+buildrecord(struct cat_attr *attrp, cnid_t cnid, u_int32_t encoding,+ CatalogRecord *crp, u_int32_t *recordSize)+{+ int type = attrp->ca_mode & S_IFMT;+ u_int32_t createtime = to_hfs_time(attrp->ca_itime);++ struct HFSPlusBSDInfo * bsdp = NULL;++ if (type == S_IFDIR) {+ crp->recordType = kHFSPlusFolderRecord;+ crp->hfsPlusFolder.flags = attrp->ca_recflags;+ crp->hfsPlusFolder.valence = 0;+ crp->hfsPlusFolder.folderID = cnid;+ crp->hfsPlusFolder.createDate = createtime;+ crp->hfsPlusFolder.contentModDate = createtime;+ crp->hfsPlusFolder.attributeModDate = createtime;+ crp->hfsPlusFolder.accessDate = createtime;+ crp->hfsPlusFolder.backupDate = 0;+ crp->hfsPlusFolder.textEncoding = encoding;+ crp->hfsPlusFolder.folderCount = 0;+ bcopy(attrp->ca_finderinfo, &crp->hfsPlusFolder.userInfo, 32);+ bsdp = &crp->hfsPlusFolder.bsdInfo;+ bsdp->special.linkCount = 1;+ *recordSize = sizeof(HFSPlusCatalogFolder);+ } else {+ crp->recordType = kHFSPlusFileRecord;+ crp->hfsPlusFile.flags = attrp->ca_recflags;+ crp->hfsPlusFile.reserved1 = 0;+ crp->hfsPlusFile.fileID = cnid;+ crp->hfsPlusFile.createDate = createtime;+ crp->hfsPlusFile.contentModDate = createtime;+ crp->hfsPlusFile.accessDate = createtime;+ crp->hfsPlusFile.attributeModDate = createtime;+ crp->hfsPlusFile.backupDate = 0;+ crp->hfsPlusFile.textEncoding = encoding;+ crp->hfsPlusFile.reserved2 = 0;+ bcopy(attrp->ca_finderinfo, &crp->hfsPlusFile.userInfo, 32);+ bsdp = &crp->hfsPlusFile.bsdInfo;+ /* BLK/CHR need to save the device info */+ if (type == S_IFBLK || type == S_IFCHR) {+ bsdp->special.rawDevice = attrp->ca_rdev;+ } else {+ bsdp->special.linkCount = 1;+ }+ bzero(&crp->hfsPlusFile.dataFork, 2*sizeof(HFSPlusForkData));+ *recordSize = sizeof(HFSPlusCatalogFile);+ }++ bsdp->ownerID = attrp->ca_uid;+ bsdp->groupID = attrp->ca_gid;+ bsdp->fileMode = attrp->ca_mode;+ bsdp->adminFlags = attrp->ca_flags >> 16;+ bsdp->ownerFlags = attrp->ca_flags & 0x000000FF;++}+++/*+ * builddesc - build a cnode descriptor from an HFS+ key+ */+static int+builddesc(const HFSPlusCatalogKey *key, cnid_t cnid, u_int32_t hint, u_int32_t encoding,+ int isdir, struct cat_desc *descp)+{+ int result = 0;+ unsigned char * nameptr;+ size_t bufsize;+ size_t utf8len;+ unsigned char tmpbuff[128];++ /* guess a size... */+ bufsize = (3 * key->nodeName.length) + 1;+ if (bufsize >= sizeof(tmpbuff) - 1) {+ nameptr = hfs_malloc_data(bufsize);+ } else {+ nameptr = &tmpbuff[0];+ }++ result = utf8_encodestr(key->nodeName.unicode,+ key->nodeName.length * sizeof(UniChar),+ nameptr, (size_t *)&utf8len,+ bufsize, ':', 0);++ if (result == ENAMETOOLONG) {+ if (nameptr != &tmpbuff[0])+ hfs_free_data(nameptr, bufsize);+ bufsize = 1 + utf8_encodelen(key->nodeName.unicode,+ key->nodeName.length * sizeof(UniChar),+ ':', 0);+ nameptr = hfs_malloc_data(bufsize);++ result = utf8_encodestr(key->nodeName.unicode,+ key->nodeName.length * sizeof(UniChar),+ nameptr, (size_t *)&utf8len,+ bufsize, ':', 0);+ }+ descp->cd_parentcnid = key->parentID;+ descp->cd_nameptr = (const u_int8_t *)vfs_addname((char *)nameptr, utf8len, 0, 0);+ descp->cd_namelen = utf8len;+ descp->cd_cnid = cnid;+ descp->cd_hint = hint;+ descp->cd_flags = CD_DECOMPOSED | CD_HASBUF;+ if (isdir)+ descp->cd_flags |= CD_ISDIR;+ descp->cd_encoding = encoding;+ if (nameptr != &tmpbuff[0]) {+ hfs_free_data(nameptr, bufsize);+ }+ return result;+}+++/*+ * getbsdattr - get attributes in bsd format+ *+ */+static void+getbsdattr(struct hfsmount *hfsmp, const struct HFSPlusCatalogFile *crp, struct cat_attr * attrp)+{+ int isDirectory = (crp->recordType == kHFSPlusFolderRecord);+ const struct HFSPlusBSDInfo *bsd = &crp->bsdInfo;++ attrp->ca_recflags = crp->flags;+ attrp->ca_atime = to_bsd_time(crp->accessDate);+ attrp->ca_atimeondisk = attrp->ca_atime;+ attrp->ca_mtime = to_bsd_time(crp->contentModDate);+ attrp->ca_ctime = to_bsd_time(crp->attributeModDate);+ attrp->ca_itime = to_bsd_time(crp->createDate);+ attrp->ca_btime = to_bsd_time(crp->backupDate);++ if ((bsd->fileMode & S_IFMT) == 0) {+ attrp->ca_flags = 0;+ attrp->ca_uid = hfsmp->hfs_uid;+ attrp->ca_gid = hfsmp->hfs_gid;+ if (isDirectory) {+ attrp->ca_mode = S_IFDIR | (hfsmp->hfs_dir_mask & ACCESSPERMS);+ } else {+ attrp->ca_mode = S_IFREG | (hfsmp->hfs_file_mask & ACCESSPERMS);+ }+ attrp->ca_linkcount = 1;+ attrp->ca_rdev = 0;+ } else {+ attrp->ca_linkcount = 1; /* may be overridden below */+ attrp->ca_rdev = 0;+ attrp->ca_uid = bsd->ownerID;+ attrp->ca_gid = bsd->groupID;+ attrp->ca_flags = bsd->ownerFlags | (bsd->adminFlags << 16);+ attrp->ca_mode = (mode_t)bsd->fileMode;+ switch (attrp->ca_mode & S_IFMT) {+ case S_IFCHR: /* fall through */+ case S_IFBLK:+ attrp->ca_rdev = bsd->special.rawDevice;+ break;+ case S_IFIFO:+ case S_IFSOCK:+ case S_IFDIR:+ case S_IFREG:+ /* Pick up the hard link count */+ if (bsd->special.linkCount > 0)+ attrp->ca_linkcount = bsd->special.linkCount;+ break;+ }++ /*+ * Override the permissions as determined by the mount auguments+ * in ALMOST the same way unset permissions are treated but keep+ * track of whether or not the file or folder is hfs locked+ * by leaving the h_pflags field unchanged from what was unpacked+ * out of the catalog.+ */+ /*+ * This code was used to do UID translation with MNT_IGNORE_OWNERS+ * (aka MNT_UNKNOWNPERMISSIONS) at the HFS layer. It's largely done+ * at the VFS layer, so there is no need to do it here now; this also+ * allows VFS to let root see the real UIDs.+ *+ * if (((unsigned int)vfs_flags(HFSTOVFS(hfsmp))) & MNT_UNKNOWNPERMISSIONS) {+ * attrp->ca_uid = hfsmp->hfs_uid;+ * attrp->ca_gid = hfsmp->hfs_gid;+ * }+ */+ }++ if (isDirectory) {+ if (!S_ISDIR(attrp->ca_mode)) {+ attrp->ca_mode &= ~S_IFMT;+ attrp->ca_mode |= S_IFDIR;+ }+ attrp->ca_entries = ((const HFSPlusCatalogFolder *)crp)->valence;+ attrp->ca_dircount = ((hfsmp->hfs_flags & HFS_FOLDERCOUNT) && (attrp->ca_recflags & kHFSHasFolderCountMask)) ?+ ((const HFSPlusCatalogFolder *)crp)->folderCount : 0;++ /* Keep UF_HIDDEN bit in sync with Finder Info's invisible bit */+ if (((const HFSPlusCatalogFolder *)crp)->userInfo.frFlags & OSSwapHostToBigConstInt16(kFinderInvisibleMask))+ attrp->ca_flags |= UF_HIDDEN;+ } else {+ /* Keep IMMUTABLE bits in sync with HFS locked flag */+ if (crp->flags & kHFSFileLockedMask) {+ /* The file's supposed to be locked:+ Make sure at least one of the IMMUTABLE bits is set: */+ if ((attrp->ca_flags & (SF_IMMUTABLE | UF_IMMUTABLE)) == 0)+ attrp->ca_flags |= UF_IMMUTABLE;+ } else {+ /* The file's supposed to be unlocked: */+ attrp->ca_flags &= ~(SF_IMMUTABLE | UF_IMMUTABLE);+ }+ /* Keep UF_HIDDEN bit in sync with Finder Info's invisible bit */+ if (crp->userInfo.fdFlags & OSSwapHostToBigConstInt16(kFinderInvisibleMask))+ attrp->ca_flags |= UF_HIDDEN;+ /* get total blocks (both forks) */+ attrp->ca_blocks = crp->dataFork.totalBlocks + crp->resourceFork.totalBlocks;++ /* On HFS+ the ThreadExists flag must always be set. */+ if ((hfsmp->hfs_flags & HFS_STANDARD) == 0)+ attrp->ca_recflags |= kHFSThreadExistsMask;++ /* Pick up the hardlink first link, if any. */+ attrp->ca_firstlink = (attrp->ca_recflags & kHFSHasLinkChainMask) ? crp->hl_firstLinkID : 0;+ }++ attrp->ca_fileid = crp->fileID;++ bcopy(&crp->userInfo, attrp->ca_finderinfo, 32);+}++/*+ * Build a catalog node thread record from a catalog key+ * and return the size of the record.+ */+static int+buildthread(void *keyp, void *recp, int directory)+{+ int size = 0;++ HFSPlusCatalogKey *key = (HFSPlusCatalogKey *)keyp;+ HFSPlusCatalogThread *rec = (HFSPlusCatalogThread *)recp;++ size = sizeof(HFSPlusCatalogThread);+ if (directory)+ rec->recordType = kHFSPlusFolderThreadRecord;+ else+ rec->recordType = kHFSPlusFileThreadRecord;+ rec->reserved = 0;+ rec->parentID = key->parentID;+ bcopy(&key->nodeName, &rec->nodeName,+ sizeof(UniChar) * (key->nodeName.length + 1));++ /* HFS Plus has variable sized thread records */+ size -= (sizeof(rec->nodeName.unicode) -+ (rec->nodeName.length * sizeof(UniChar)));++ return (size);+}++/*+ * Build a catalog node thread key.+ */+static void+buildthreadkey(HFSCatalogNodeID parentID, CatalogKey *key)+{+ key->hfsPlus.keyLength = kHFSPlusCatalogKeyMinimumLength;+ key->hfsPlus.parentID = parentID;+ key->hfsPlus.nodeName.length = 0;+}++/*+ * Extract the text encoding from a catalog node record.+ */+static u_int32_t+getencoding(const CatalogRecord *crp)+{+ u_int32_t encoding;++ if (crp->recordType == kHFSPlusFolderRecord)+ encoding = crp->hfsPlusFolder.textEncoding;+ else if (crp->recordType == kHFSPlusFileRecord)+ encoding = crp->hfsPlusFile.textEncoding;+ else+ encoding = 0;++ return (encoding);+}++/*+ * Extract the CNID from a catalog node record.+ */+static cnid_t+getcnid(const CatalogRecord *crp)+{+ cnid_t cnid = 0;++ switch (crp->recordType) {+ case kHFSPlusFolderRecord:+ cnid = crp->hfsPlusFolder.folderID;+ break;+ case kHFSPlusFileRecord:+ cnid = crp->hfsPlusFile.fileID;+ break;+ default:+ printf("hfs: getcnid: unknown recordType=%d\n", crp->recordType);+ break;+ }++ return (cnid);+}++/*+ * Extract the parent ID from a catalog node record.+ */+static cnid_t+getparentcnid(const CatalogRecord *recp)+{+ cnid_t cnid = 0;++ switch (recp->recordType) {+ case kHFSPlusFileThreadRecord:+ case kHFSPlusFolderThreadRecord:+ cnid = recp->hfsPlusThread.parentID;+ break;+ default:+ panic("hfs: getparentcnid: unknown recordType (crp @ %p)\n", recp);+ break;+ }++ return (cnid);+}++/*+ * Determine if a catalog node record is a directory.+ */+static int+isadir(const CatalogRecord *crp)+{+ if (crp->recordType == kHFSPlusFolderRecord) {+ return 1;+ }++ return 0;+}++/*+ * cat_lookup_dirlink - lookup a catalog record for directory hard link+ * (not inode) using catalog record id. Note that this function does+ * NOT resolve directory hard link to its directory inode and return+ * the link record.+ *+ * Note: The caller is responsible for releasing the output catalog+ * descriptor (when supplied outdescp is non-null).+ */+int+cat_lookup_dirlink(struct hfsmount *hfsmp, cnid_t dirlink_id,+ u_int8_t forktype, struct cat_desc *outdescp,+ struct cat_attr *attrp, struct cat_fork *forkp)+{+ struct BTreeIterator *iterator = NULL;+ FSBufferDescriptor btdata;+ u_int16_t datasize;+ CatalogKey *keyp;+ CatalogRecord *recp = NULL;+ int error;++ /* No directory hard links on standard HFS */+ if (hfsmp->vcbSigWord == kHFSSigWord) {+ return ENOTSUP;+ }++ iterator = hfs_malloc_type(struct BTreeIterator);+ buildthreadkey(dirlink_id, (CatalogKey *)&iterator->key);++ recp = hfs_malloc_type(CatalogRecord);+ BDINIT(btdata, recp);++ error = BTSearchRecord(VTOF(HFSTOVCB(hfsmp)->catalogRefNum), iterator,+ &btdata, &datasize, iterator);+ if (error) {+ goto out;+ }+ /* Directory hard links are catalog file record */+ if (recp->recordType != kHFSPlusFileThreadRecord) {+ error = ENOENT;+ goto out;+ }++ keyp = (CatalogKey *)&recp->hfsPlusThread.reserved;+ keyp->hfsPlus.keyLength = kHFSPlusCatalogKeyMinimumLength ++ (keyp->hfsPlus.nodeName.length * 2);+ if (forktype == kHFSResourceForkType) {+ /* Lookup resource fork for directory hard link */+ error = cat_lookupbykey(hfsmp, keyp, HFS_LOOKUP_HARDLINK, 0, true, outdescp, attrp, forkp, NULL);+ } else {+ /* Lookup data fork, if any, for directory hard link */+ error = cat_lookupbykey(hfsmp, keyp, HFS_LOOKUP_HARDLINK, 0, false, outdescp, attrp, forkp, NULL);+ }+ if (error) {+ printf ("hfs: cat_lookup_dirlink(): Error looking up file record for id=%u (error=%d)\n", dirlink_id, error);+ hfs_mark_inconsistent(hfsmp, HFS_INCONSISTENCY_DETECTED);+ goto out;+ }+ /* Just for sanity, make sure that id in catalog record and thread record match */+ if ((outdescp != NULL) && (dirlink_id != outdescp->cd_cnid)) {+ printf ("hfs: cat_lookup_dirlink(): Requested cnid=%u != found_cnid=%u\n", dirlink_id, outdescp->cd_cnid);+ hfs_mark_inconsistent(hfsmp, HFS_INCONSISTENCY_DETECTED);+ error = ENOENT;+ }++out:+ if (recp) {+ hfs_free_type(recp, CatalogRecord);+ }+ hfs_free_type(iterator, struct BTreeIterator);++ return MacToVFSError(error);+}++/*+ * cnode_update_dirlink - update the catalog node for directory hard link+ * described by descp using the data from attrp and forkp.+ */+int+cat_update_dirlink(struct hfsmount *hfsmp, u_int8_t forktype,+ struct cat_desc *descp, struct cat_attr *attrp, struct cat_fork *forkp)+{+ if (forktype == kHFSResourceForkType) {+ return cat_update_internal(hfsmp, true, descp, attrp, NULL, forkp);+ } else {+ return cat_update_internal(hfsmp, true, descp, attrp, forkp, NULL);+ }+}++void hfs_fork_copy(struct cat_fork *dst, const struct cat_fork *src,+ HFSPlusExtentDescriptor *extents)+{+ /* Copy everything but the extents into the dest fork */+ memcpy(dst, src, offsetof(struct cat_fork, cf_extents));+ /* Then copy the supplied extents into the fork */+ memcpy(dst->cf_extents, extents, sizeof(HFSPlusExtentRecord));+}diff --git a/xnu/files/bsd/hfs/hfs_catalog.h b/xnu/files/bsd/hfs/hfs_catalog.hnew file mode 100644index 0000000..af0be7b--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_catalog.h@@ -0,0 +1,509 @@+/*+ * Copyright (c) 2002-2015 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@+ */+#ifndef __HFS_CATALOG__+#define __HFS_CATALOG__++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE+#include <sys/vnode.h>++#include "hfs_format.h"++/* HFS Catalog */+++/*+ * Catalog ADTs+ *+ * The cat_desc, cat_attr, and cat_fork structures are+ * use to import/export data to/from the Catalog file.+ * The fields in these structures are always in BSD+ * runtime format (e.g. dates and names).+ */++typedef u_int32_t cnid_t;++/*+ * Catalog Node Descriptor (runtime)+ */+struct cat_desc {+ u_int8_t cd_flags; /* see below (8 bits) */+ u_int8_t cd_encoding; /* name encoding */+ int16_t cd_namelen; /* length of cnode name */+ cnid_t cd_parentcnid; /* parent directory CNID */+ u_int32_t cd_hint; /* catalog file hint */+ cnid_t cd_cnid; /* cnode id (for getattrlist) */+ const u_int8_t * cd_nameptr; /* pointer to cnode name */+};++/* cd_flags+ *+ * CD_EOF is used by hfs_vnop_readdir / cat_getdirentries to indicate EOF was+ * encountered during a directory enumeration. When this flag is observed+ * on the next call to hfs_vnop_readdir it tells the caller that there's no+ * need to descend into the catalog as EOF was encountered during the last call.+ * This flag should only be set on the descriptor embedded in the directoryhint.+ */++#define CD_HASBUF 0x01 /* allocated filename buffer */+#define CD_DECOMPOSED 0x02 /* name is fully decomposed */+#define CD_EOF 0x04 /* see above */+#define CD_ISMETA 0x40 /* describes a metadata file */+#define CD_ISDIR 0x80 /* describes a directory */++/*+ * Catalog Node Attributes (runtime)+ */+struct cat_attr {+ cnid_t ca_fileid; /* inode number (for stat) normally == cnid */+ mode_t ca_mode; /* file access mode and type (16 bits) */+ u_int16_t ca_recflags; /* catalog record flags (16 bit integer) */+ u_int32_t ca_linkcount; /* real hard link count */+ uid_t ca_uid; /* file owner */+ gid_t ca_gid; /* file group */+ union {+ dev_t cau_rdev; /* special file device (VBLK or VCHAR only) */+ u_int32_t cau_linkref; /* hardlink reference number */+ } ca_union1;+ time_t ca_atime; /* last access time */+ time_t ca_atimeondisk; /* access time value on disk */+ time_t ca_mtime; /* last data modification time */+ time_t ca_ctime; /* last file status change */+ time_t ca_itime; /* file initialization time */+ time_t ca_btime; /* last backup time */+ u_int32_t ca_flags; /* status flags (chflags) */+ union {+ u_int32_t cau_blocks; /* total file blocks used (rsrc + data) */+ u_int32_t cau_entries; /* total directory entries (valence) */+ } ca_union2;+ union {+ u_int32_t cau_dircount; /* count of sub dirs (for posix nlink) */+ u_int32_t cau_firstlink; /* first hardlink link (files only) */+ } ca_union3;+ union {+ u_int8_t ca_finderinfo[32]; /* Opaque Finder information */+ struct {+ FndrFileInfo ca_finderfileinfo;+ struct FndrExtendedFileInfo ca_finderextendedfileinfo;+ };+ struct {+ FndrDirInfo ca_finderdirinfo;+ struct FndrExtendedDirInfo ca_finderextendeddirinfo;+ };+ };+};++/* Aliases for common fields */+#define ca_rdev ca_union1.cau_rdev+#define ca_linkref ca_union1.cau_linkref+#define ca_blocks ca_union2.cau_blocks+#define ca_entries ca_union2.cau_entries+#define ca_dircount ca_union3.cau_dircount+#define ca_firstlink ca_union3.cau_firstlink++/*+ * Catalog Node Fork (runtime)+ *+ * NOTE: this is not the same as a struct HFSPlusForkData+ *+ * NOTE: if cf_new_size > cf_size, then a write is in progress and is extending+ * the EOF; the new EOF will be cf_new_size. Writes and pageouts may validly+ * write up to cf_new_size, but reads should only read up to cf_size. When+ * an extending write is not in progress, cf_new_size is zero.+ */+struct cat_fork {+ off_t cf_size; /* fork's logical size in bytes */+ off_t cf_new_size; /* fork's logical size after write completes */+ union {+ u_int32_t cfu_clump; /* fork's clump size in bytes (sys files only) */+ u_int64_t cfu_bytesread; /* bytes read from this fork */+ } cf_union;+ u_int32_t cf_vblocks; /* virtual (unalloated) blocks */+ u_int32_t cf_blocks; /* total blocks used by this fork */+ struct HFSPlusExtentDescriptor cf_extents[8]; /* initial set of extents */++ /*+ * NOTE: If you change this structure, make sure you change you change+ * hfs_fork_copy.+ */+};++#define cf_clump cf_union.cfu_clump+#define cf_bytesread cf_union.cfu_bytesread++void hfs_fork_copy(struct cat_fork *dst, const struct cat_fork *src,+ HFSPlusExtentDescriptor *extents);++/*+ * Directory Hint+ * Used to hold state across directory enumerations.+ *+ */+struct directoryhint {+ TAILQ_ENTRY(directoryhint) dh_link; /* chain */+ int dh_index; /* index into directory (zero relative) */+ u_int32_t dh_threadhint; /* node hint of a directory's thread record */+ u_int32_t dh_time;+ struct cat_desc dh_desc; /* entry's descriptor */+};+typedef struct directoryhint directoryhint_t;++/*+ * HFS_MAXDIRHINTS cannot be larger than 63 without reducing+ * HFS_INDEX_BITS, because given the 6-bit tag, at most 63 different+ * tags can exist. When HFS_MAXDIRHINTS is larger than 63, the same+ * list may contain dirhints of the same tag, and a staled dirhint may+ * be returned.+ */+#define HFS_MAXDIRHINTS 32+#define HFS_DIRHINT_TTL 45++#define HFS_INDEX_MASK 0x03ffffff+#define HFS_INDEX_BITS 26+++/*+ * Catalog Node Entry+ *+ * A cat_entry is used for bulk enumerations (hfs_readdirattr).+ */+struct cat_entry {+ struct cat_desc ce_desc;+ struct cat_attr ce_attr;+ off_t ce_datasize;+ off_t ce_rsrcsize;+ u_int32_t ce_datablks;+ u_int32_t ce_rsrcblks;+};++/*+ * Starting in 10.5, hfs_vnop_readdirattr() only makes one+ * call to cat_getentriesattr(). So we increased MAXCATENTRIES+ * while keeping the total size of the CE LIST buffer <= 8K+ * (which works out to be 60 entries per call). The 8K limit+ * keeps the memory coming from a kalloc zone instead of+ * valuable/fragment-able kernel map space.+ */+#define MAXCATENTRIES \+ (1 + (8192 - sizeof (struct cat_entrylist)) / sizeof (struct cat_entry))++/*+ * Catalog Node Entry List+ *+ * A cat_entrylist is a list of Catalog Node Entries.+ */+struct cat_entrylist {+ u_int32_t maxentries; /* number of entries requested */+ u_int32_t realentries; /* number of valid entries returned */+ u_int32_t skipentries; /* number of entries skipped (reserved HFS+ files) */+ struct cat_entry entry[0]; /* array of entries */+};++struct hfsmount;++/*+ * Catalog FileID/CNID Acquisition / Lookup+ *+ * Some use-cases require that we find a valid CNID+ * before we may be ready to enter the item into the namespace.+ * In order to resolve this, we support a hashtable attached to+ * the mount that is secured by the catalog lock.+ *+ * Finding the next valid CNID is easy if the wraparound bit is+ * not set -- you just pull from the hfsmp next pointer.+ * If it is set then you must find a free entry in the catalog+ * and also query the hashtable to see if the item is free or not.+ *+ * If you want to request a CNID before there is a backing item+ * in the catalog, you must find one that is valid, then insert+ * it into the hash table until such time that the item is+ * inserted into the catalog. After successful catalog insertion,+ * you must remove the item from the hashtable.+ */++typedef struct cat_preflightid {+ cnid_t fileid;+ LIST_ENTRY(cat_preflightid) id_hash;+} cat_preflightid_t;++extern int cat_remove_idhash (cat_preflightid_t *preflight);+extern int cat_insert_idhash (struct hfsmount *hfsmp, cat_preflightid_t *preflight);+extern int cat_check_idhash (struct hfsmount *hfsmp, cnid_t test_fileid);++/* initialize the id look up hashtable during mount */+extern void hfs_idhash_init (struct hfsmount *hfsmp);++/* release the id lookup hashtable during unmount */+extern void hfs_idhash_destroy (struct hfsmount *hfsmp);++/* Get a new CNID for use */+extern int cat_acquire_cnid (struct hfsmount *hfsmp, cnid_t *new_cnid);+++/* default size of ID hash is 64 entries */+#define HFS_IDHASH_DEFAULT 64+++/*+ * Catalog Operations Hint+ *+ * lower 16 bits: count of B-tree insert operations+ * upper 16 bits: count of B-tree delete operations+ *+ */+#define CAT_DELETE 0x00010000+#define CAT_CREATE 0x00000002+#define CAT_RENAME 0x00010002+#define CAT_EXCHANGE 0x00010002++typedef u_int32_t catops_t;++/*+ * The size of cat_cookie_t much match the size of+ * the nreserve struct (in BTreeNodeReserve.c).+ */+typedef struct cat_cookie_t {+#if defined(__LP64__)+ char opaque[40];+#else+ char opaque[24];+#endif+} cat_cookie_t;++/* Universal catalog key */+union CatalogKey {+ HFSCatalogKey hfs;+ HFSPlusCatalogKey hfsPlus;+};+typedef union CatalogKey CatalogKey;++/* Universal catalog data record */+union CatalogRecord {+ int16_t recordType;+ HFSCatalogFolder hfsFolder;+ HFSCatalogFile hfsFile;+ HFSCatalogThread hfsThread;+ HFSPlusCatalogFolder hfsPlusFolder;+ HFSPlusCatalogFile hfsPlusFile;+ HFSPlusCatalogThread hfsPlusThread;+};+typedef union CatalogRecord CatalogRecord;++/* Constants for HFS fork types */+enum {+ kHFSDataForkType = 0x0, /* data fork */+ kHFSResourceForkType = 0xff /* resource fork */+};++/*+ * Catalog Interface+ *+ * These functions perform a catalog transactions. The+ * catalog b-tree is abstracted through this interface.+ * (please don't go around it)+ */+++extern void cat_releasedesc(struct cat_desc *descp);++extern int cat_create ( struct hfsmount *hfsmp,+ cnid_t new_fileid,+ struct cat_desc *descp,+ struct cat_attr *attrp,+ struct cat_desc *out_descp);++extern int cat_delete ( struct hfsmount *hfsmp,+ struct cat_desc *descp,+ struct cat_attr *attrp);++extern int cat_lookup ( struct hfsmount *hfsmp,+ struct cat_desc *descp,+ int wantrsrc,+ int force_casesensitive_lookup,+ struct cat_desc *outdescp,+ struct cat_attr *attrp,+ struct cat_fork *forkp,+ cnid_t *desc_cnid);++extern int cat_idlookup (struct hfsmount *hfsmp,+ cnid_t cnid,+ int allow_system_files,+ int wantrsrc,+ struct cat_desc *outdescp,+ struct cat_attr *attrp,+ struct cat_fork *forkp);++extern int cat_findname (struct hfsmount *hfsmp,+ cnid_t cnid,+ struct cat_desc *outdescp);++extern int cat_getentriesattr(+ struct hfsmount *hfsmp,+ directoryhint_t *dirhint,+ struct cat_entrylist *ce_list,+ int *reachedeof);++extern int cat_rename ( struct hfsmount * hfsmp,+ struct cat_desc * from_cdp,+ struct cat_desc * todir_cdp,+ struct cat_desc * to_cdp,+ struct cat_desc * cdp);++extern int cat_update ( struct hfsmount *hfsmp,+ struct cat_desc *descp,+ struct cat_attr *attrp,+ const struct cat_fork *dataforkp,+ const struct cat_fork *rsrcforkp);++extern int cat_getdirentries(+ struct hfsmount *hfsmp,+ u_int32_t entrycnt,+ directoryhint_t *dirhint,+ uio_t uio,+ int extended,+ int * items,+ int * eofflag);++extern int cat_insertfilethread (+ struct hfsmount *hfsmp,+ struct cat_desc *descp);++extern int cat_preflight(+ struct hfsmount *hfsmp,+ catops_t ops,+ cat_cookie_t *cookie,+ struct proc *p);++extern void cat_postflight(+ struct hfsmount *hfsmp,+ cat_cookie_t *cookie,+ struct proc *p);++extern int cat_binarykeycompare(+ HFSPlusCatalogKey *searchKey,+ HFSPlusCatalogKey *trialKey);++extern int CompareCatalogKeys(+ HFSCatalogKey *searchKey,+ HFSCatalogKey *trialKey);++extern int CompareExtendedCatalogKeys(+ HFSPlusCatalogKey *searchKey,+ HFSPlusCatalogKey *trialKey);++extern void cat_convertattr(+ struct hfsmount *hfsmp,+ CatalogRecord * recp,+ struct cat_attr *attrp,+ struct cat_fork *datafp,+ struct cat_fork *rsrcfp);++extern int cat_convertkey(+ struct hfsmount *hfsmp,+ CatalogKey *key,+ CatalogRecord * recp,+ struct cat_desc *descp);++extern int cat_getkeyplusattr(+ struct hfsmount *hfsmp,+ cnid_t cnid,+ CatalogKey *key,+ struct cat_attr *attrp);++/* Hard link functions. */++extern int cat_check_link_ancestry(+ struct hfsmount *hfsmp,+ cnid_t parentid,+ cnid_t pointed_at_cnid);++extern int cat_set_childlinkbit(+ struct hfsmount *hfsmp,+ cnid_t cnid);++#define HFS_IGNORABLE_LINK 0x00000001++extern int cat_resolvelink( struct hfsmount *hfsmp,+ u_int32_t linkref,+ int isdirlink,+ struct HFSPlusCatalogFile *recp);++extern int cat_createlink( struct hfsmount *hfsmp,+ struct cat_desc *descp,+ struct cat_attr *attr,+ cnid_t nextlinkid,+ cnid_t *linkfileid);++/* Finder Info's file type and creator for directory hard link alias */+enum {+ kHFSAliasType = 0x66647270, /* 'fdrp' */+ kHFSAliasCreator = 0x4D414353 /* 'MACS' */+};++extern int cat_deletelink( struct hfsmount *hfsmp,+ struct cat_desc *descp);++extern int cat_update_siblinglinks( struct hfsmount *hfsmp,+ cnid_t linkfileid,+ cnid_t prevlinkid,+ cnid_t nextlinkid);++extern int cat_lookuplink( struct hfsmount *hfsmp,+ struct cat_desc *descp,+ cnid_t *linkfileid,+ cnid_t *prevlinkid,+ cnid_t *nextlinkid);++extern int cat_lookup_siblinglinks( struct hfsmount *hfsmp,+ cnid_t linkfileid,+ cnid_t *prevlinkid,+ cnid_t *nextlinkid);++extern int cat_lookup_lastlink( struct hfsmount *hfsmp,+ cnid_t startid,+ cnid_t *nextlinkid,+ struct cat_desc *cdesc);++extern int cat_lookup_dirlink(struct hfsmount *hfsmp,+ cnid_t dirlink_id,+ u_int8_t forktype,+ struct cat_desc *outdescp,+ struct cat_attr *attrp,+ struct cat_fork *forkp);++extern int cat_update_dirlink(struct hfsmount *hfsmp,+ u_int8_t forktype,+ struct cat_desc *descp,+ struct cat_attr *attrp,+ struct cat_fork *rsrcforkp);++#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */+#endif /* __HFS_CATALOG__ */diff --git a/xnu/files/bsd/hfs/hfs_chash.c b/xnu/files/bsd/hfs/hfs_chash.cnew file mode 100644index 0000000..b3fd87f--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_chash.c@@ -0,0 +1,574 @@+/*+ * Copyright (c) 2002-2015 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@+ */++/*+ * Copyright (c) 1982, 1986, 1989, 1991, 1993, 1995+ * The Regents of the University of California. All rights reserved.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. Redistributions in binary form must reproduce the above copyright+ * notice, this list of conditions and the following disclaimer in the+ * documentation and/or other materials provided with the distribution.+ * 3. All advertising materials mentioning features or use of this software+ * must display the following acknowledgement:+ * This product includes software developed by the University of+ * California, Berkeley and its contributors.+ * 4. Neither the name of the University nor the names of its contributors+ * may be used to endorse or promote products derived from this software+ * without specific prior written permission.+ *+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+ * SUCH DAMAGE.+ *+ * @(#)hfs_chash.c+ * derived from @(#)ufs_ihash.c 8.7 (Berkeley) 5/17/95+ */++#include <sys/param.h>+#include <sys/systm.h>+#include <sys/vnode.h>+#include <sys/kernel.h>+#include <sys/malloc.h>+#include <sys/proc.h>+#include <sys/queue.h>++#include "hfs.h" /* XXX bringup */+#include "hfs_cnode.h"++extern lck_attr_t * hfs_lock_attr;+extern lck_grp_t * hfs_mutex_group;+extern lck_grp_t * hfs_rwlock_group;++lck_grp_t * chash_lck_grp;+lck_grp_attr_t * chash_lck_grp_attr;+lck_attr_t * chash_lck_attr;++#define CNODEHASH(hfsmp, inum) (&hfsmp->hfs_cnodehashtbl[(inum) & hfsmp->hfs_cnodehash])++/*+ * Initialize cnode hash table.+ */+void+hfs_chashinit()+{+ chash_lck_grp_attr= lck_grp_attr_alloc_init();+ chash_lck_grp = lck_grp_alloc_init("cnode_hash", chash_lck_grp_attr);+ chash_lck_attr = lck_attr_alloc_init();+}++static void hfs_chash_lock(struct hfsmount *hfsmp)+{+ lck_mtx_lock(&hfsmp->hfs_chash_mutex);+}++static void hfs_chash_lock_spin(struct hfsmount *hfsmp)+{+ lck_mtx_lock_spin(&hfsmp->hfs_chash_mutex);+}++static void hfs_chash_lock_convert(struct hfsmount *hfsmp)+{+ lck_mtx_convert_spin(&hfsmp->hfs_chash_mutex);+}++static void hfs_chash_unlock(struct hfsmount *hfsmp)+{+ lck_mtx_unlock(&hfsmp->hfs_chash_mutex);+}++void+hfs_chashinit_finish(struct hfsmount *hfsmp)+{+ lck_mtx_init(&hfsmp->hfs_chash_mutex, chash_lck_grp, chash_lck_attr);++ hfsmp->hfs_cnodehashtbl = hashinit(desiredvnodes / 4, M_TEMP, &hfsmp->hfs_cnodehash);+}++void+hfs_delete_chash(struct hfsmount *hfsmp)+{+ lck_mtx_destroy(&hfsmp->hfs_chash_mutex, chash_lck_grp);++ hashdestroy(hfsmp->hfs_cnodehashtbl, M_TEMP, hfsmp->hfs_cnodehash);+ hfsmp->hfs_cnodehashtbl = NULL;+}+++/*+ * Use the device, inum pair to find the incore cnode.+ *+ * If it is in core, but locked, wait for it.+ */+struct vnode *+hfs_chash_getvnode(struct hfsmount *hfsmp, ino_t inum, int wantrsrc, int skiplock, int allow_deleted)+{+ struct cnode *cp;+ struct vnode *vp;+ int error;+ u_int32_t vid;++ /*+ * Go through the hash list+ * If a cnode is in the process of being cleaned out or being+ * allocated, wait for it to be finished and then try again.+ */+loop:+ hfs_chash_lock_spin(hfsmp);++ for (cp = CNODEHASH(hfsmp, inum)->lh_first; cp; cp = cp->c_hash.le_next) {+ if (cp->c_fileid != inum)+ continue;+ /* Wait if cnode is being created or reclaimed. */+ if (ISSET(cp->c_hflag, H_ALLOC | H_TRANSIT | H_ATTACH)) {+ SET(cp->c_hflag, H_WAITING);++ (void) msleep(cp, &hfsmp->hfs_chash_mutex, PDROP | PINOD,+ "hfs_chash_getvnode", 0);+ goto loop;+ }+ /* Obtain the desired vnode. */+ vp = wantrsrc ? cp->c_rsrc_vp : cp->c_vp;+ if (vp == NULLVP)+ goto exit;++ vid = vnode_vid(vp);+ hfs_chash_unlock(hfsmp);++ if ((error = vnode_getwithvid(vp, vid))) {+ /*+ * If vnode is being reclaimed, or has+ * already changed identity, no need to wait+ */+ return (NULL);+ }+ if (!skiplock && hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0) {+ vnode_put(vp);+ return (NULL);+ }++ /*+ * Skip cnodes that are not in the name space anymore+ * we need to check with the cnode lock held because+ * we may have blocked acquiring the vnode ref or the+ * lock on the cnode which would allow the node to be+ * unlinked+ */+ if (!allow_deleted) {+ if (cp->c_flag & (C_NOEXISTS | C_DELETED)) {+ if (!skiplock) {+ hfs_unlock(cp);+ }+ vnode_put(vp);+ return (NULL);+ }+ }+ return (vp);+ }+exit:+ hfs_chash_unlock(hfsmp);+ return (NULL);+}+++/*+ * Use the device, fileid pair to snoop an incore cnode.+ *+ * A cnode can exists in chash even after it has been+ * deleted from the catalog, so this function returns+ * ENOENT if C_NOEXIST is set in the cnode's flag.+ *+ */+int+hfs_chash_snoop(struct hfsmount *hfsmp, ino_t inum, int existence_only,+ int (*callout)(const cnode_t *cp, void *), void * arg)+{+ struct cnode *cp;+ int result = ENOENT;++ /*+ * Go through the hash list+ * If a cnode is in the process of being cleaned out or being+ * allocated, wait for it to be finished and then try again.+ */+ hfs_chash_lock(hfsmp);++ for (cp = CNODEHASH(hfsmp, inum)->lh_first; cp; cp = cp->c_hash.le_next) {+ if (cp->c_fileid != inum)+ continue;++ /*+ * Under normal circumstances, we would want to return ENOENT if a cnode is in+ * the hash and it is marked C_NOEXISTS or C_DELETED. However, if the CNID+ * namespace has wrapped around, then we have the possibility of collisions.+ * In that case, we may use this function to validate whether or not we+ * should trust the nextCNID value in the hfs mount point.+ *+ * If we didn't do this, then it would be possible for a cnode that is no longer backed+ * by anything on-disk (C_NOEXISTS) to still exist in the hash along with its+ * vnode. The cat_create routine could then create a new entry in the catalog+ * re-using that CNID. Then subsequent hfs_getnewvnode calls will repeatedly fail+ * trying to look it up/validate it because it is marked C_NOEXISTS. So we want+ * to prevent that from happening as much as possible.+ */+ if (existence_only) {+ result = 0;+ break;+ }++ /* Skip cnodes that have been removed from the catalog */+ if (cp->c_flag & (C_NOEXISTS | C_DELETED)) {+ result = EACCES;+ break;+ }++ /* Skip cnodes being created or reclaimed. */+ if (!ISSET(cp->c_hflag, H_ALLOC | H_TRANSIT | H_ATTACH)) {+ result = callout(cp, arg);+ }+ break;+ }+ hfs_chash_unlock(hfsmp);++ return (result);+}++/*+ * Use the device, fileid pair to find the incore cnode.+ * If no cnode if found one is created+ *+ * If it is in core, but locked, wait for it.+ *+ * If the cnode is C_DELETED, then return NULL since that+ * inum is no longer valid for lookups (open-unlinked file).+ *+ * If the cnode is C_DELETED but also marked C_RENAMED, then that means+ * the cnode was renamed over and a new entry exists in its place. The caller+ * should re-drive the lookup to get the newer entry. In that case, we'll still+ * return NULL for the cnode, but also return GNV_CHASH_RENAMED in the output flags+ * of this function to indicate the caller that they should re-drive.+ */+struct cnode *+hfs_chash_getcnode(struct hfsmount *hfsmp, ino_t inum, struct vnode **vpp,+ int wantrsrc, int skiplock, int *out_flags, int *hflags)+{+ struct cnode *cp;+ struct cnode *ncp = NULL;+ vnode_t vp;+ u_int32_t vid;++ /*+ * Go through the hash list+ * If a cnode is in the process of being cleaned out or being+ * allocated, wait for it to be finished and then try again.+ */+loop:+ hfs_chash_lock_spin(hfsmp);++loop_with_lock:+ for (cp = CNODEHASH(hfsmp, inum)->lh_first; cp; cp = cp->c_hash.le_next) {+ if (cp->c_fileid != inum)+ continue;+ /*+ * Wait if cnode is being created, attached to or reclaimed.+ */+ if (ISSET(cp->c_hflag, H_ALLOC | H_ATTACH | H_TRANSIT)) {+ SET(cp->c_hflag, H_WAITING);++ (void) msleep(cp, &hfsmp->hfs_chash_mutex, PINOD,+ "hfs_chash_getcnode", 0);+ goto loop_with_lock;+ }+ vp = wantrsrc ? cp->c_rsrc_vp : cp->c_vp;+ if (vp == NULL) {+ /*+ * The desired vnode isn't there so tag the cnode.+ */+ SET(cp->c_hflag, H_ATTACH);+ *hflags |= H_ATTACH;++ hfs_chash_unlock(hfsmp);+ } else {+ vid = vnode_vid(vp);++ hfs_chash_unlock(hfsmp);++ if (vnode_getwithvid(vp, vid))+ goto loop;+ }+ if (ncp) {+ /*+ * someone else won the race to create+ * this cnode and add it to the hash+ * just dump our allocation+ */+ hfs_zfree(ncp, HFS_CNODE_ZONE);+ ncp = NULL;+ }++ if (!skiplock) {+ hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ }++ /*+ * Skip cnodes that are not in the name space anymore+ * we need to check with the cnode lock held because+ * we may have blocked acquiring the vnode ref or the+ * lock on the cnode which would allow the node to be+ * unlinked.+ *+ * Don't return a cnode in this case since the inum+ * is no longer valid for lookups.+ */+ if ((cp->c_flag & (C_NOEXISTS | C_DELETED)) && !wantrsrc) {+ int renamed = 0;+ if (cp->c_flag & C_RENAMED) {+ renamed = 1;+ }+ if (!skiplock)+ hfs_unlock(cp);+ if (vp != NULLVP) {+ vnode_put(vp);+ } else {+ hfs_chash_lock_spin(hfsmp);+ CLR(cp->c_hflag, H_ATTACH);+ *hflags &= ~H_ATTACH;+ if (ISSET(cp->c_hflag, H_WAITING)) {+ CLR(cp->c_hflag, H_WAITING);+ wakeup((caddr_t)cp);+ }+ hfs_chash_unlock(hfsmp);+ }+ vp = NULL;+ cp = NULL;+ if (renamed) {+ *out_flags = GNV_CHASH_RENAMED;+ }+ }+ *vpp = vp;+ return (cp);+ }++ /*+ * Allocate a new cnode+ */+ if (skiplock && !wantrsrc)+ panic("%s - should never get here when skiplock is set \n", __FUNCTION__);++ if (ncp == NULL) {+ hfs_chash_unlock(hfsmp);++ ncp = hfs_zalloc(HFS_CNODE_ZONE);++ /*+ * since we dropped the chash lock,+ * we need to go back and re-verify+ * that this node hasn't come into+ * existence...+ */+ goto loop;+ }+ hfs_chash_lock_convert(hfsmp);+ bzero(ncp, sizeof(*ncp));++ SET(ncp->c_hflag, H_ALLOC);+ *hflags |= H_ALLOC;+ ncp->c_fileid = inum;+ TAILQ_INIT(&ncp->c_hintlist); /* make the list empty */+ TAILQ_INIT(&ncp->c_originlist);++ lck_rw_init(&ncp->c_rwlock, hfs_rwlock_group, hfs_lock_attr);+ if (!skiplock)+ (void) hfs_lock(ncp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);++ /* Insert the new cnode with it's H_ALLOC flag set */+ LIST_INSERT_HEAD(CNODEHASH(hfsmp, inum), ncp, c_hash);+ hfs_chash_unlock(hfsmp);++ *vpp = NULL;+ return (ncp);+}+++void+hfs_chashwakeup(struct hfsmount *hfsmp, struct cnode *cp, int hflags)+{+ hfs_chash_lock_spin(hfsmp);++ CLR(cp->c_hflag, hflags);++ if (ISSET(cp->c_hflag, H_WAITING)) {+ CLR(cp->c_hflag, H_WAITING);+ wakeup((caddr_t)cp);+ }+ hfs_chash_unlock(hfsmp);+}+++/*+ * Re-hash two cnodes in the hash table.+ */+void+hfs_chash_rehash(struct hfsmount *hfsmp, struct cnode *cp1, struct cnode *cp2)+{+ hfs_chash_lock_spin(hfsmp);++ LIST_REMOVE(cp1, c_hash);+ LIST_REMOVE(cp2, c_hash);+ LIST_INSERT_HEAD(CNODEHASH(hfsmp, cp1->c_fileid), cp1, c_hash);+ LIST_INSERT_HEAD(CNODEHASH(hfsmp, cp2->c_fileid), cp2, c_hash);++ hfs_chash_unlock(hfsmp);+}+++/*+ * Remove a cnode from the hash table.+ */+int+hfs_chashremove(struct hfsmount *hfsmp, struct cnode *cp)+{+ hfs_chash_lock_spin(hfsmp);++ /* Check if a vnode is getting attached */+ if (ISSET(cp->c_hflag, H_ATTACH)) {+ hfs_chash_unlock(hfsmp);+ return (EBUSY);+ }+ if (cp->c_hash.le_next || cp->c_hash.le_prev) {+ LIST_REMOVE(cp, c_hash);+ cp->c_hash.le_next = NULL;+ cp->c_hash.le_prev = NULL;+ }+ hfs_chash_unlock(hfsmp);++ return (0);+}++/*+ * Remove a cnode from the hash table and wakeup any waiters.+ */+void+hfs_chash_abort(struct hfsmount *hfsmp, struct cnode *cp)+{+ hfs_chash_lock_spin(hfsmp);++ LIST_REMOVE(cp, c_hash);+ cp->c_hash.le_next = NULL;+ cp->c_hash.le_prev = NULL;++ CLR(cp->c_hflag, H_ATTACH | H_ALLOC);+ if (ISSET(cp->c_hflag, H_WAITING)) {+ CLR(cp->c_hflag, H_WAITING);+ wakeup((caddr_t)cp);+ }+ hfs_chash_unlock(hfsmp);+}+++/*+ * mark a cnode as in transition+ */+void+hfs_chash_mark_in_transit(struct hfsmount *hfsmp, struct cnode *cp)+{+ hfs_chash_lock_spin(hfsmp);++ SET(cp->c_hflag, H_TRANSIT);++ hfs_chash_unlock(hfsmp);+}++/* Search a cnode in the hash. This function does not return cnode which+ * are getting created, destroyed or in transition. Note that this function+ * does not acquire the cnode hash mutex, and expects the caller to acquire it.+ * On success, returns pointer to the cnode found. On failure, returns NULL.+ */+static+struct cnode *+hfs_chash_search_cnid(struct hfsmount *hfsmp, cnid_t cnid)+{+ struct cnode *cp;++ for (cp = CNODEHASH(hfsmp, cnid)->lh_first; cp; cp = cp->c_hash.le_next) {+ if (cp->c_fileid == cnid) {+ break;+ }+ }++ /* If cnode is being created or reclaimed, return error. */+ if (cp && ISSET(cp->c_hflag, H_ALLOC | H_TRANSIT | H_ATTACH)) {+ cp = NULL;+ }++ return cp;+}++/* Search a cnode corresponding to given device and ID in the hash. If the+ * found cnode has kHFSHasChildLinkBit cleared, set it. If the cnode is not+ * found, no new cnode is created and error is returned.+ *+ * Return values -+ * -1 : The cnode was not found.+ * 0 : The cnode was found, and the kHFSHasChildLinkBit was already set.+ * 1 : The cnode was found, the kHFSHasChildLinkBit was not set, and the+ * function had to set that bit.+ */+int+hfs_chash_set_childlinkbit(struct hfsmount *hfsmp, cnid_t cnid)+{+ int retval = -1;+ struct cnode *cp;++ hfs_chash_lock_spin(hfsmp);++ cp = hfs_chash_search_cnid(hfsmp, cnid);+ if (cp) {+ if (cp->c_attr.ca_recflags & kHFSHasChildLinkMask) {+ retval = 0;+ } else {+ cp->c_attr.ca_recflags |= kHFSHasChildLinkMask;+ retval = 1;+ }+ }+ hfs_chash_unlock(hfsmp);++ return retval;+}diff --git a/xnu/files/bsd/hfs/hfs_cnode.c b/xnu/files/bsd/hfs/hfs_cnode.cnew file mode 100644index 0000000..774e0b1--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_cnode.c@@ -0,0 +1,2545 @@+/*+ * Copyright (c) 2002-2015 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@+ */+#include <sys/param.h>+#include <sys/systm.h>+#include <sys/proc.h>+#include <sys/vnode.h>+#include <sys/mount.h>+#include <sys/kernel.h>+#include <sys/malloc.h>+#include <sys/time.h>+#include <sys/ubc.h>+#include <sys/quota.h>+#include <sys/kdebug.h>+#include <libkern/OSByteOrder.h>+#include <sys/namei.h>++#include <kern/locks.h>++#include <miscfs/specfs/specdev.h>+#include <miscfs/fifofs/fifo.h>++#include "hfs.h"+#include "hfs_catalog.h"+#include "hfs_cnode.h"+#include "hfs_quota.h"+#include "hfs_format.h"+#include "hfs_kdebug.h"+#include "hfs_cprotect.h"++extern int prtactive;++extern lck_attr_t * hfs_lock_attr;+extern lck_grp_t * hfs_mutex_group;+extern lck_grp_t * hfs_rwlock_group;++static void hfs_reclaim_cnode(hfsmount_t *hfsmp, struct cnode *);+static int hfs_cnode_teardown (struct vnode *vp, vfs_context_t ctx, int reclaim);+static int hfs_isordered(struct cnode *, struct cnode *);++extern int hfs_removefile_callback(struct buf *bp, void *hfsmp);++uint32_t _hfs_max_origins = MAX_CACHED_ORIGINS_DEFAULT;+uint32_t _hfs_max_file_origins = MAX_CACHED_FILE_ORIGINS_DEFAULT;++__inline__ int hfs_checkdeleted (struct cnode *cp) {+ return ((cp->c_flag & (C_DELETED | C_NOEXISTS)) ? ENOENT : 0);+}++/*+ * Function used by a special fcntl() that decorates a cnode/vnode that+ * indicates it is backing another filesystem, like a disk image.+ *+ * the argument 'val' indicates whether or not to set the bit in the cnode flags+ *+ * Returns non-zero on failure. 0 on success+ */+int hfs_set_backingstore (struct vnode *vp, int val) {+ struct cnode *cp = NULL;+ int err = 0;++ cp = VTOC(vp);+ if (!vnode_isreg(vp) && !vnode_isdir(vp)) {+ return EINVAL;+ }++ /* lock the cnode */+ err = hfs_lock (cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ if (err) {+ return err;+ }++ if (val) {+ cp->c_flag |= C_BACKINGSTORE;+ }+ else {+ cp->c_flag &= ~C_BACKINGSTORE;+ }++ /* unlock everything */+ hfs_unlock (cp);++ return err;+}++/*+ * Function used by a special fcntl() that check to see if a cnode/vnode+ * indicates it is backing another filesystem, like a disk image.+ *+ * the argument 'val' is an output argument for whether or not the bit is set+ *+ * Returns non-zero on failure. 0 on success+ */++int hfs_is_backingstore (struct vnode *vp, int *val) {+ struct cnode *cp = NULL;+ int err = 0;++ if (!vnode_isreg(vp) && !vnode_isdir(vp)) {+ *val = 0;+ return 0;+ }++ cp = VTOC(vp);++ /* lock the cnode */+ err = hfs_lock (cp, HFS_SHARED_LOCK, HFS_LOCK_DEFAULT);+ if (err) {+ return err;+ }++ if (cp->c_flag & C_BACKINGSTORE) {+ *val = 1;+ }+ else {+ *val = 0;+ }++ /* unlock everything */+ hfs_unlock (cp);++ return err;+}+++/*+ * hfs_cnode_teardown+ *+ * This is an internal function that is invoked from both hfs_vnop_inactive+ * and hfs_vnop_reclaim. As VNOP_INACTIVE is not necessarily called from vnodes+ * being recycled and reclaimed, it is important that we do any post-processing+ * necessary for the cnode in both places. Important tasks include things such as+ * releasing the blocks from an open-unlinked file when all references to it have dropped,+ * and handling resource forks separately from data forks.+ *+ * Note that we take only the vnode as an argument here (rather than the cnode).+ * Recall that each cnode supports two forks (rsrc/data), and we can always get the right+ * cnode from either of the vnodes, but the reverse is not true -- we can't determine which+ * vnode we need to reclaim if only the cnode is supplied.+ *+ * This function is idempotent and safe to call from both hfs_vnop_inactive and hfs_vnop_reclaim+ * if both are invoked right after the other. In the second call, most of this function's if()+ * conditions will fail, since they apply generally to cnodes still marked with C_DELETED.+ * As a quick check to see if this function is necessary, determine if the cnode is already+ * marked C_NOEXISTS. If it is, then it is safe to skip this function. The only tasks that+ * remain for cnodes marked in such a fashion is to teardown their fork references and+ * release all directory hints and hardlink origins. However, both of those are done+ * in hfs_vnop_reclaim. hfs_update, by definition, is not necessary if the cnode's catalog+ * entry is no longer there.+ *+ * 'reclaim' argument specifies whether or not we were called from hfs_vnop_reclaim. If we are+ * invoked from hfs_vnop_reclaim, we can not call functions that cluster_push since the UBC info+ * is totally gone by that point.+ *+ * Assumes that both truncate and cnode locks for 'cp' are held.+ */+static+int hfs_cnode_teardown (struct vnode *vp, vfs_context_t ctx, int reclaim)+{+ int forkcount = 0;+ enum vtype v_type;+ struct cnode *cp;+ int error = 0;+ bool started_tr = false;+ struct hfsmount *hfsmp = VTOHFS(vp);+ struct proc *p = vfs_context_proc(ctx);+ int truncated = 0;+ cat_cookie_t cookie;+ int cat_reserve = 0;+ int lockflags;+ int ea_error = 0;++ v_type = vnode_vtype(vp);+ cp = VTOC(vp);++ if (cp->c_datafork) {+ ++forkcount;+ }+ if (cp->c_rsrcfork) {+ ++forkcount;+ }++ /*+ * Push file data out for normal files that haven't been evicted from+ * the namespace. We only do this if this function was not called from reclaim,+ * because by that point the UBC information has been totally torn down.+ *+ * There should also be no way that a normal file that has NOT been deleted from+ * the namespace to skip INACTIVE and go straight to RECLAIM. That race only happens+ * when the file becomes open-unlinked.+ */+ if ((v_type == VREG) &&+ (!ISSET(cp->c_flag, C_DELETED)) &&+ (!ISSET(cp->c_flag, C_NOEXISTS)) &&+ (VTOF(vp)->ff_blocks) &&+ (reclaim == 0)) {+ /*+ * If we're called from hfs_vnop_inactive, all this means is at the time+ * the logic for deciding to call this function, there were not any lingering+ * mmap/fd references for this file. However, there is nothing preventing the system+ * from creating a new reference in between the time that logic was checked+ * and we entered hfs_vnop_inactive. As a result, the only time we can guarantee+ * that there aren't any references is during vnop_reclaim.+ */+ hfs_filedone(vp, ctx, 0);+ }++ /*+ * Remove any directory hints or cached origins+ */+ if (v_type == VDIR) {+ hfs_reldirhints(cp, 0);+ }+ if (cp->c_flag & C_HARDLINK) {+ hfs_relorigins(cp);+ }++ /*+ * -- Handle open unlinked files --+ *+ * If the vnode is in use, it means a force unmount is in progress+ * in which case we defer cleaning up until either we come back+ * through here via hfs_vnop_reclaim, at which point the UBC+ * information will have been torn down and the vnode might no+ * longer be in use, or if it's still in use, it will get cleaned+ * up when next remounted.+ */+ if (ISSET(cp->c_flag, C_DELETED) && !vnode_isinuse(vp, 0)) {+ /*+ * This check is slightly complicated. We should only truncate data+ * in very specific cases for open-unlinked files. This is because+ * we want to ensure that the resource fork continues to be available+ * if the caller has the data fork open. However, this is not symmetric;+ * someone who has the resource fork open need not be able to access the data+ * fork once the data fork has gone inactive.+ *+ * If we're the last fork, then we have cleaning up to do.+ *+ * A) last fork, and vp == c_vp+ * Truncate away own fork data. If rsrc fork is not in core, truncate it too.+ *+ * B) last fork, and vp == c_rsrc_vp+ * Truncate ourselves, assume data fork has been cleaned due to C).+ *+ * If we're not the last fork, then things are a little different:+ *+ * C) not the last fork, vp == c_vp+ * Truncate ourselves. Once the file has gone out of the namespace,+ * it cannot be further opened. Further access to the rsrc fork may+ * continue, however.+ *+ * D) not the last fork, vp == c_rsrc_vp+ * Don't enter the block below, just clean up vnode and push it out of core.+ */++ if ((v_type == VREG || v_type == VLNK) &&+ ((forkcount == 1) || (!VNODE_IS_RSRC(vp)))) {++ /* Truncate away our own fork data. (Case A, B, C above) */+ if (VTOF(vp)->ff_blocks != 0) {+ /*+ * SYMLINKS only:+ *+ * Encapsulate the entire change (including truncating the link) in+ * nested transactions if we are modifying a symlink, because we know that its+ * file length will be at most 4k, and we can fit both the truncation and+ * any relevant bitmap changes into a single journal transaction. We also want+ * the kill_block code to execute in the same transaction so that any dirty symlink+ * blocks will not be written. Otherwise, rely on+ * hfs_truncate doing its own transactions to ensure that we don't blow up+ * the journal.+ */+ if (!started_tr && (v_type == VLNK)) {+ if (hfs_start_transaction(hfsmp) != 0) {+ error = EINVAL;+ goto out;+ }+ else {+ started_tr = true;+ }+ }++ /*+ * At this point, we have decided that this cnode is+ * suitable for full removal. We are about to deallocate+ * its blocks and remove its entry from the catalog.+ * If it was a symlink, then it's possible that the operation+ * which created it is still in the current transaction group+ * due to coalescing. Take action here to kill the data blocks+ * of the symlink out of the journal before moving to+ * deallocate the blocks. We need to be in the middle of+ * a transaction before calling buf_iterate like this.+ *+ * Note: we have to kill any potential symlink buffers out of+ * the journal prior to deallocating their blocks. This is so+ * that we don't race with another thread that may be doing an+ * an allocation concurrently and pick up these blocks. It could+ * generate I/O against them which could go out ahead of our journal+ * transaction.+ */++ if (hfsmp->jnl && vnode_islnk(vp)) {+ buf_iterate(vp, hfs_removefile_callback, BUF_SKIP_NONLOCKED, (void *)hfsmp);+ }+++ /*+ * This truncate call (and the one below) is fine from VNOP_RECLAIM's+ * context because we're only removing blocks, not zero-filling new+ * ones. The C_DELETED check above makes things much simpler.+ */+ error = hfs_truncate(vp, (off_t)0, IO_NDELAY, 0, ctx);+ if (error) {+ goto out;+ }+ truncated = 1;++ /* (SYMLINKS ONLY): Close/End our transaction after truncating the file record */+ if (started_tr) {+ hfs_end_transaction(hfsmp);+ started_tr = false;+ }++ }++ /*+ * Truncate away the resource fork, if we represent the data fork and+ * it is the last fork. That means, by definition, the rsrc fork is not in+ * core. To avoid bringing a vnode into core for the sole purpose of deleting the+ * data in the resource fork, we call cat_lookup directly, then hfs_release_storage+ * to get rid of the resource fork's data. Note that because we are holding the+ * cnode lock, it is impossible for a competing thread to create the resource fork+ * vnode from underneath us while we do this.+ *+ * This is invoked via case A above only.+ */+ if ((cp->c_blocks > 0) && (forkcount == 1) && (vp != cp->c_rsrc_vp)) {+ struct cat_lookup_buffer *lookup_rsrc = NULL;+ struct cat_desc *desc_ptr = NULL;+ lockflags = 0;++ lookup_rsrc = hfs_malloc_type(struct cat_lookup_buffer);++ if (cp->c_desc.cd_namelen == 0) {+ /* Initialize the rsrc descriptor for lookup if necessary*/+ MAKE_DELETED_NAME (lookup_rsrc->lookup_name, HFS_TEMPLOOKUP_NAMELEN, cp->c_fileid);++ lookup_rsrc->lookup_desc.cd_nameptr = (const uint8_t*) lookup_rsrc->lookup_name;+ lookup_rsrc->lookup_desc.cd_namelen = strlen (lookup_rsrc->lookup_name);+ lookup_rsrc->lookup_desc.cd_parentcnid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid;+ lookup_rsrc->lookup_desc.cd_cnid = cp->c_cnid;++ desc_ptr = &lookup_rsrc->lookup_desc;+ }+ else {+ desc_ptr = &cp->c_desc;+ }++ lockflags = hfs_systemfile_lock (hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);++ error = cat_lookup (hfsmp, desc_ptr, 1, 0, (struct cat_desc *) NULL,+ (struct cat_attr*) NULL, &lookup_rsrc->lookup_fork.ff_data, NULL);++ hfs_systemfile_unlock (hfsmp, lockflags);++ if (error) {+ hfs_free_type(lookup_rsrc, struct cat_lookup_buffer);+ goto out;+ }++ /*+ * Make the filefork in our temporary struct look like a real+ * filefork. Fill in the cp, sysfileinfo and rangelist fields..+ */+ rl_init (&lookup_rsrc->lookup_fork.ff_invalidranges);+ lookup_rsrc->lookup_fork.ff_cp = cp;++ /*+ * If there were no errors, then we have the catalog's fork information+ * for the resource fork in question. Go ahead and delete the data in it now.+ */++ error = hfs_release_storage (hfsmp, NULL, &lookup_rsrc->lookup_fork, cp->c_fileid);+ hfs_free_type(lookup_rsrc, struct cat_lookup_buffer);++ if (error) {+ goto out;+ }++ /*+ * This fileid's resource fork extents have now been fully deleted on-disk+ * and this CNID is no longer valid. At this point, we should be able to+ * zero out cp->c_blocks to indicate there is no data left in this file.+ */+ cp->c_blocks = 0;+ }+ }++ /*+ * If we represent the last fork (or none in the case of a dir),+ * and the cnode has become open-unlinked...+ *+ * We check c_blocks here because it is possible in the force+ * unmount case for the data fork to be in use but the resource+ * fork to not be in use in which case we will truncate the+ * resource fork, but not the data fork. It will get cleaned+ * up upon next mount.+ */+ if (forkcount <= 1 && !cp->c_blocks) {+ /*+ * If it has EA's, then we need to get rid of them.+ *+ * Note that this must happen outside of any other transactions+ * because it starts/ends its own transactions and grabs its+ * own locks. This is to prevent a file with a lot of attributes+ * from creating a transaction that is too large (which panics).+ */+ if (ISSET(cp->c_attr.ca_recflags, kHFSHasAttributesMask))+ ea_error = hfs_removeallattr(hfsmp, cp->c_fileid, &started_tr);++ /*+ * Remove the cnode's catalog entry and release all blocks it+ * may have been using.+ */++ /*+ * Mark cnode in transit so that no one can get this+ * cnode from cnode hash.+ */+ // hfs_chash_mark_in_transit(hfsmp, cp);+ // XXXdbg - remove the cnode from the hash table since it's deleted+ // otherwise someone could go to sleep on the cnode and not+ // be woken up until this vnode gets recycled which could be+ // a very long time...+ hfs_chashremove(hfsmp, cp);++ cp->c_flag |= C_NOEXISTS; // XXXdbg+ cp->c_rdev = 0;++ if (!started_tr) {+ if (hfs_start_transaction(hfsmp) != 0) {+ error = EINVAL;+ goto out;+ }+ started_tr = true;+ }++ /*+ * Reserve some space in the Catalog file.+ */+ if ((error = cat_preflight(hfsmp, CAT_DELETE, &cookie, p))) {+ goto out;+ }+ cat_reserve = 1;++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE, HFS_EXCLUSIVE_LOCK);++ if (cp->c_blocks > 0) {+ printf("hfs_inactive: deleting non-empty%sfile %d, "+ "blks %d\n", VNODE_IS_RSRC(vp) ? " rsrc " : " ",+ (int)cp->c_fileid, (int)cp->c_blocks);+ }++ //+ // release the name pointer in the descriptor so that+ // cat_delete() will use the file-id to do the deletion.+ // in the case of hard links this is imperative (in the+ // case of regular files the fileid and cnid are the+ // same so it doesn't matter).+ //+ cat_releasedesc(&cp->c_desc);++ /*+ * The descriptor name may be zero,+ * in which case the fileid is used.+ */+ error = cat_delete(hfsmp, &cp->c_desc, &cp->c_attr);++ if (error && truncated && (error != ENXIO)) {+ printf("hfs_inactive: couldn't delete a truncated file!");+ }++ /* Update HFS Private Data dir */+ if (error == 0) {+ hfsmp->hfs_private_attr[FILE_HARDLINKS].ca_entries--;+ if (vnode_isdir(vp)) {+ DEC_FOLDERCOUNT(hfsmp, hfsmp->hfs_private_attr[FILE_HARDLINKS]);+ }+ (void)cat_update(hfsmp, &hfsmp->hfs_private_desc[FILE_HARDLINKS],+ &hfsmp->hfs_private_attr[FILE_HARDLINKS], NULL, NULL);+ }++ hfs_systemfile_unlock(hfsmp, lockflags);++ if (error) {+ goto out;+ }++ #if QUOTA+ if (hfsmp->hfs_flags & HFS_QUOTAS)+ (void)hfs_chkiq(cp, -1, NOCRED, 0);+ #endif /* QUOTA */++ /* Already set C_NOEXISTS at the beginning of this block */+ cp->c_flag &= ~C_DELETED;+ cp->c_touch_chgtime = TRUE;+ cp->c_touch_modtime = TRUE;++ if (error == 0)+ hfs_volupdate(hfsmp, (v_type == VDIR) ? VOL_RMDIR : VOL_RMFILE, 0);+ }+ } // if <open unlinked>++ hfs_update(vp, reclaim ? HFS_UPDATE_FORCE : 0);++ /*+ * Since we are about to finish what might be an inactive call, propagate+ * any remaining modified or touch bits from the cnode to the vnode. This+ * serves as a hint to vnode recycling that we shouldn't recycle this vnode+ * synchronously.+ *+ * For now, if the node *only* has a dirty atime, we don't mark+ * the vnode as dirty. VFS's asynchronous recycling can actually+ * lead to worse performance than having it synchronous. When VFS+ * is fixed to be more performant, we can be more honest about+ * marking vnodes as dirty when it's only the atime that's dirty.+ */+ if (hfs_is_dirty(cp) == HFS_DIRTY || ISSET(cp->c_flag, C_DELETED)) {+ vnode_setdirty(vp);+ } else {+ vnode_cleardirty(vp);+ }++out:+ if (cat_reserve)+ cat_postflight(hfsmp, &cookie, p);++ if (started_tr) {+ hfs_end_transaction(hfsmp);+ started_tr = false;+ }++ return error;+}+++/*+ * hfs_vnop_inactive+ *+ * The last usecount on the vnode has gone away, so we need to tear down+ * any remaining data still residing in the cnode. If necessary, write out+ * remaining blocks or delete the cnode's entry in the catalog.+ */+int+hfs_vnop_inactive(struct vnop_inactive_args *ap)+{+ struct vnode *vp = ap->a_vp;+ struct cnode *cp;+ struct hfsmount *hfsmp = VTOHFS(vp);+ struct proc *p = vfs_context_proc(ap->a_context);+ int error = 0;+ int took_trunc_lock = 0;+ enum vtype v_type;++ v_type = vnode_vtype(vp);+ cp = VTOC(vp);++ if ((hfsmp->hfs_flags & HFS_READ_ONLY) || vnode_issystem(vp) ||+ (hfsmp->hfs_freezing_proc == p)) {+ error = 0;+ goto inactive_done;+ }++ /*+ * For safety, do NOT call vnode_recycle from inside this function. This can cause+ * problems in the following scenario:+ *+ * vnode_create -> vnode_reclaim_internal -> vclean -> VNOP_INACTIVE+ *+ * If we're being invoked as a result of a reclaim that was already in-flight, then we+ * cannot call vnode_recycle again. Being in reclaim means that there are no usecounts or+ * iocounts by definition. As a result, if we were to call vnode_recycle, it would immediately+ * try to re-enter reclaim again and panic.+ *+ * Currently, there are three things that can cause us (VNOP_INACTIVE) to get called.+ * 1) last usecount goes away on the vnode (vnode_rele)+ * 2) last iocount goes away on a vnode that previously had usecounts but didn't have+ * vnode_recycle called (vnode_put)+ * 3) vclean by way of reclaim+ *+ * In this function we would generally want to call vnode_recycle to speed things+ * along to ensure that we don't leak blocks due to open-unlinked files. However, by+ * virtue of being in this function already, we can call hfs_cnode_teardown, which+ * will release blocks held by open-unlinked files, and mark them C_NOEXISTS so that+ * there's no entry in the catalog and no backing store anymore. If that's the case,+ * then we really don't care all that much when the vnode actually goes through reclaim.+ * Further, the HFS VNOPs that manipulated the namespace in order to create the open-+ * unlinked file in the first place should have already called vnode_recycle on the vnode+ * to guarantee that it would go through reclaim in a speedy way.+ */++ if (cp->c_flag & C_NOEXISTS) {+ /*+ * If the cnode has already had its cat entry removed, then+ * just skip to the end. We don't need to do anything here.+ */+ error = 0;+ goto inactive_done;+ }++ if ((v_type == VREG || v_type == VLNK)) {+ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ took_trunc_lock = 1;+ }++ (void) hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);++ /*+ * Call cnode_teardown to push out dirty blocks to disk, release open-unlinked+ * files' blocks from being in use, and move the cnode from C_DELETED to C_NOEXISTS.+ */+ error = hfs_cnode_teardown (vp, ap->a_context, 0);++ /*+ * Drop the truncate lock before unlocking the cnode+ * (which can potentially perform a vnode_put and+ * recycle the vnode which in turn might require the+ * truncate lock)+ */+ if (took_trunc_lock) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ }++ hfs_unlock(cp);++inactive_done:++ return error;+}+++/*+ * File clean-up (zero fill and shrink peof).+ */++int+hfs_filedone(struct vnode *vp, vfs_context_t context,+ hfs_file_done_opts_t opts)+{+ struct cnode *cp;+ struct filefork *fp;+ struct hfsmount *hfsmp;+ off_t leof;+ u_int32_t blks, blocksize;++ cp = VTOC(vp);+ fp = VTOF(vp);+ hfsmp = VTOHFS(vp);+ leof = fp->ff_size;++ if ((hfsmp->hfs_flags & HFS_READ_ONLY) || (fp->ff_blocks == 0))+ return (0);++ hfs_flush_invalid_ranges(vp);++ blocksize = VTOVCB(vp)->blockSize;+ blks = leof / blocksize;+ if (((off_t)blks * (off_t)blocksize) != leof)+ blks++;+ /*+ * Shrink the peof to the smallest size neccessary to contain the leof.+ */+ if (blks < fp->ff_blocks) {+ (void) hfs_truncate(vp, leof, IO_NDELAY, HFS_TRUNCATE_SKIPTIMES, context);+ }++ if (!ISSET(opts, HFS_FILE_DONE_NO_SYNC)) {+ hfs_unlock(cp);+ cluster_push(vp, IO_CLOSE);+ hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);++ /*+ * If the hfs_truncate didn't happen to flush the vnode's+ * information out to disk, force it to be updated now that+ * all invalid ranges have been zero-filled and validated:+ */+ hfs_update(vp, 0);+ }++ return (0);+}+++/*+ * Reclaim a cnode so that it can be used for other purposes.+ */+int+hfs_vnop_reclaim(struct vnop_reclaim_args *ap)+{+ struct vnode *vp = ap->a_vp;+ struct cnode *cp;+ struct filefork *fp = NULL;+ struct filefork *altfp = NULL;+ struct hfsmount *hfsmp = VTOHFS(vp);+ vfs_context_t ctx = ap->a_context;+ int reclaim_cnode = 0;+ int err = 0;+ enum vtype v_type;++ v_type = vnode_vtype(vp);+ cp = VTOC(vp);++ /*+ * We don't take the truncate lock since by the time reclaim comes along,+ * all dirty pages have been synced and nobody should be competing+ * with us for this thread.+ */+ (void) hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);++ /*+ * Sync to disk any remaining data in the cnode/vnode. This includes+ * a call to hfs_update if the cnode has outbound data.+ *+ * If C_NOEXISTS is set on the cnode, then there's nothing teardown needs to do+ * because the catalog entry for this cnode is already gone.+ */+ if (!ISSET(cp->c_flag, C_NOEXISTS)) {+ err = hfs_cnode_teardown(vp, ctx, 1);+ }++ /*+ * Keep track of an inactive hot file. Don't bother on ssd's since+ * the tracking is done differently (it's done at read() time)+ */+ if (!vnode_isdir(vp) &&+ !vnode_issystem(vp) &&+ !(cp->c_flag & (C_DELETED | C_NOEXISTS)) &&+ !(hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN)) {+ (void) hfs_addhotfile(vp);+ }+ vnode_removefsref(vp);++ /*+ * Find file fork for this vnode (if any)+ * Also check if another fork is active+ */+ if (cp->c_vp == vp) {+ fp = cp->c_datafork;+ altfp = cp->c_rsrcfork;++ cp->c_datafork = NULL;+ cp->c_vp = NULL;+ } else if (cp->c_rsrc_vp == vp) {+ fp = cp->c_rsrcfork;+ altfp = cp->c_datafork;++ cp->c_rsrcfork = NULL;+ cp->c_rsrc_vp = NULL;+ } else {+ panic("hfs_vnop_reclaim: vp points to wrong cnode (vp=%p cp->c_vp=%p cp->c_rsrc_vp=%p)\n", vp, cp->c_vp, cp->c_rsrc_vp);+ }+ /*+ * On the last fork, remove the cnode from its hash chain.+ */+ if (altfp == NULL) {+ /* If we can't remove it then the cnode must persist! */+ if (hfs_chashremove(hfsmp, cp) == 0)+ reclaim_cnode = 1;+ /*+ * Remove any directory hints+ */+ if (vnode_isdir(vp)) {+ hfs_reldirhints(cp, 0);+ }++ if(cp->c_flag & C_HARDLINK) {+ hfs_relorigins(cp);+ }+ }+ /* Release the file fork and related data */+ if (fp) {+ /* Dump cached symlink data */+ if (vnode_islnk(vp) && (fp->ff_symlinkptr != NULL)) {+ hfs_free_data(fp->ff_symlinkptr, fp->ff_size);+ }+ rl_remove_all(&fp->ff_invalidranges);+ hfs_zfree(fp, HFS_FILEFORK_ZONE);+ }++ /*+ * If there was only one active fork then we can release the cnode.+ */+ if (reclaim_cnode) {+ hfs_chashwakeup(hfsmp, cp, H_ALLOC | H_TRANSIT);+ hfs_unlock(cp);+ hfs_reclaim_cnode(hfsmp, cp);+ }+ else {+ /*+ * cnode in use. If it is a directory, it could have+ * no live forks. Just release the lock.+ */+ hfs_unlock(cp);+ }++ vnode_clearfsnode(vp);+ return (0);+}+++extern int (**hfs_vnodeop_p) (void *);+#if FIFO+extern int (**hfs_fifoop_p) (void *);+#endif++/*+ * hfs_getnewvnode - get new default vnode+ *+ * The vnode is returned with an iocount and the cnode locked.+ * The cnode of the parent vnode 'dvp' may or may not be locked, depending on+ * the circumstances. The cnode in question (if acquiring the resource fork),+ * may also already be locked at the time we enter this function.+ *+ * Note that there are both input and output flag arguments to this function.+ * If one of the input flags (specifically, GNV_USE_VP), is set, then+ * hfs_getnewvnode will use the parameter *vpp, which is traditionally only+ * an output parameter, as both an input and output parameter. It will use+ * the vnode provided in the output, and pass it to vnode_create with the+ * proper flavor so that a new vnode is _NOT_ created on our behalf when+ * we dispatch to VFS. This may be important in various HFS vnode creation+ * routines, such a create or get-resource-fork, because we risk deadlock if+ * jetsam is involved.+ *+ * Deadlock potential exists if jetsam is synchronously invoked while we are waiting+ * for a vnode to be recycled in order to give it the identity we want. If jetsam+ * happens to target a process for termination that is blocked in-kernel, waiting to+ * acquire the cnode lock on our parent 'dvp', while our current thread has it locked,+ * neither side will make forward progress and the watchdog timer will eventually fire.+ * To prevent this, a caller of hfs_getnewvnode may choose to proactively force+ * any necessary vnode reclamation/recycling while it is not holding any locks and+ * thus not prone to deadlock. If this is the case, GNV_USE_VP will be set and+ * the parameter will be used as described above.+ *+ * !!! <NOTE> !!!!+ * In circumstances when GNV_USE_VP is set, this function _MUST_ clean up and either consume+ * or dispose of the provided vnode. We funnel all errors to a single return value so that+ * if provided_vp is still non-NULL, then we will dispose of the vnode. This will occur in+ * all error cases of this function -- anywhere we zero/NULL out the *vpp parameter. It may+ * also occur if the current thread raced with another to create the same vnode, and we+ * find the entry already present in the cnode hash.+ * !!! </NOTE> !!!+ */+int+hfs_getnewvnode(+ struct hfsmount *hfsmp,+ struct vnode *dvp,+ struct componentname *cnp,+ struct cat_desc *descp,+ int flags,+ struct cat_attr *attrp,+ struct cat_fork *forkp,+ struct vnode **vpp,+ int *out_flags)+{+ struct mount *mp = HFSTOVFS(hfsmp);+ struct vnode *vp = NULL;+ struct vnode **cvpp;+ struct vnode *tvp = NULLVP;+ struct cnode *cp = NULL;+ struct filefork *fp = NULL;+ int hfs_standard = 0;+ int retval = 0;+ int issystemfile;+ int wantrsrc;+ int hflags = 0;+ int need_update_identity = 0;+ struct vnode_fsparam vfsp;+ enum vtype vtype;++ struct vnode *provided_vp = NULL;+++#if QUOTA+ int i;+#endif /* QUOTA */++ hfs_standard = (hfsmp->hfs_flags & HFS_STANDARD);++ if (flags & GNV_USE_VP) {+ /* Store the provided VP for later use */+ provided_vp = *vpp;+ }++ /* Zero out the vpp regardless of provided input */+ *vpp = NULL;++ /* Zero out the out_flags */+ *out_flags = 0;++ if (attrp->ca_fileid == 0) {+ retval = ENOENT;+ goto gnv_exit;+ }++#if !FIFO+ if (IFTOVT(attrp->ca_mode) == VFIFO) {+ retval = ENOTSUP;+ goto gnv_exit;+ }+#endif /* !FIFO */+ vtype = IFTOVT(attrp->ca_mode);+ issystemfile = (descp->cd_flags & CD_ISMETA) && (vtype == VREG);+ wantrsrc = flags & GNV_WANTRSRC;++ /* Sanity checks: */+ if (vtype == VBAD ||+ (vtype != VDIR && forkp &&+ (attrp->ca_blocks < forkp->cf_blocks ||+ howmany((uint64_t)forkp->cf_size, hfsmp->blockSize) > forkp->cf_blocks ||+ (vtype == VLNK && (uint64_t)forkp->cf_size > MAXPATHLEN)))) {+ /* Mark the FS as corrupt and bail out */+ hfs_mark_inconsistent(hfsmp, HFS_INCONSISTENCY_DETECTED);+ retval = EINVAL;+ goto gnv_exit;+ }++#ifdef HFS_CHECK_LOCK_ORDER+ /*+ * The only case where it's permissible to hold the parent cnode+ * lock is during a create operation (hfs_makenode) or when+ * we don't need the cnode lock (GNV_SKIPLOCK).+ */+ if ((dvp != NULL) &&+ (flags & (GNV_CREATE | GNV_SKIPLOCK)) == 0 &&+ VTOC(dvp)->c_lockowner == current_thread()) {+ panic("hfs_getnewvnode: unexpected hold of parent cnode %p", VTOC(dvp));+ }+#endif /* HFS_CHECK_LOCK_ORDER */++ /*+ * Get a cnode (new or existing)+ */+ cp = hfs_chash_getcnode(hfsmp, attrp->ca_fileid, vpp, wantrsrc,+ (flags & GNV_SKIPLOCK), out_flags, &hflags);++ /*+ * If the id is no longer valid for lookups we'll get back a NULL cp.+ */+ if (cp == NULL) {+ retval = ENOENT;+ goto gnv_exit;+ }+ /*+ * We may have been provided a vnode via+ * GNV_USE_VP. In this case, we have raced with+ * a 2nd thread to create the target vnode. The provided+ * vnode that was passed in will be dealt with at the+ * end of the function, as we don't zero out the field+ * until we're ready to pass responsibility to VFS.+ */+++ /*+ * If we get a cnode/vnode pair out of hfs_chash_getcnode, then update the+ * descriptor in the cnode as needed if the cnode represents a hardlink.+ * We want the caller to get the most up-to-date copy of the descriptor+ * as possible. However, we only do anything here if there was a valid vnode.+ * If there isn't a vnode, then the cnode is brand new and needs to be initialized+ * as it doesn't have a descriptor or cat_attr yet.+ *+ * If we are about to replace the descriptor with the user-supplied one, then validate+ * that the descriptor correctly acknowledges this item is a hardlink. We could be+ * subject to a race where the calling thread invoked cat_lookup, got a valid lookup+ * result but the file was not yet a hardlink. With sufficient delay between there+ * and here, we might accidentally copy in the raw inode ID into the descriptor in the+ * call below. If the descriptor's CNID is the same as the fileID then it must+ * not yet have been a hardlink when the lookup occurred.+ */++ if (!(hfs_checkdeleted(cp))) {+ //+ // If the bytes of the filename in the descp do not match the bytes in the+ // cnp (and we're not looking up the resource fork), then we want to update+ // the vnode identity to contain the bytes that HFS stores so that when an+ // fsevent gets generated, it has the correct filename. otherwise daemons+ // that match filenames produced by fsevents with filenames they have stored+ // elsewhere (e.g. bladerunner, backupd, mds), the filenames will not match.+ // See: <rdar://problem/8044697> FSEvents doesn't always decompose diacritical unicode chars in the paths of the changed directories+ // for more details.+ //+#ifdef CN_WANTSRSRCFORK+ if (*vpp && cnp && cnp->cn_nameptr && !(cnp->cn_flags & CN_WANTSRSRCFORK) && descp && descp->cd_nameptr && strncmp((const char *)cnp->cn_nameptr, (const char *)descp->cd_nameptr, descp->cd_namelen) != 0) {+#else+ if (*vpp && cnp && cnp->cn_nameptr && descp && descp->cd_nameptr && strncmp((const char *)cnp->cn_nameptr, (const char *)descp->cd_nameptr, descp->cd_namelen) != 0) {+#endif+ vnode_update_identity (*vpp, dvp, (const char *)descp->cd_nameptr, descp->cd_namelen, 0, VNODE_UPDATE_NAME);+ }+ if ((cp->c_flag & C_HARDLINK) && descp->cd_nameptr && descp->cd_namelen > 0) {+ /* If cnode is uninitialized, its c_attr will be zeroed out; cnids wont match. */+ if ((descp->cd_cnid == cp->c_attr.ca_fileid) &&+ (attrp->ca_linkcount != cp->c_attr.ca_linkcount)){++ if ((flags & GNV_SKIPLOCK) == 0) {+ /*+ * Then we took the lock. Drop it before calling+ * vnode_put, which may invoke hfs_vnop_inactive and need to take+ * the cnode lock again.+ */+ hfs_unlock(cp);+ }++ /*+ * Emit ERECYCLE and GNV_CAT_ATTRCHANGED to+ * force a re-drive in the lookup routine.+ * Drop the iocount on the vnode obtained from+ * chash_getcnode if needed.+ */+ if (*vpp != NULL) {+ vnode_put (*vpp);+ *vpp = NULL;+ }++ /*+ * If we raced with VNOP_RECLAIM for this vnode, the hash code could+ * have observed it after the c_vp or c_rsrc_vp fields had been torn down;+ * the hash code peeks at those fields without holding the cnode lock because+ * it needs to be fast. As a result, we may have set H_ATTACH in the chash+ * call above. Since we're bailing out, unset whatever flags we just set, and+ * wake up all waiters for this cnode.+ */+ if (hflags) {+ hfs_chashwakeup(hfsmp, cp, hflags);+ }++ *out_flags = GNV_CAT_ATTRCHANGED;+ retval = ERECYCLE;+ goto gnv_exit;+ }+ else {+ /*+ * Otherwise, CNID != fileid. Go ahead and copy in the new descriptor.+ *+ * Replacing the descriptor here is fine because we looked up the item without+ * a vnode in hand before. If a vnode existed, its identity must be attached to this+ * item. We are not susceptible to the lookup fastpath issue at this point.+ */+ replace_desc(cp, descp);++ /*+ * This item was a hardlink, and its name needed to be updated. By replacing the+ * descriptor above, we've now updated the cnode's internal representation of+ * its link ID/CNID, parent ID, and its name. However, VFS must now be alerted+ * to the fact that this vnode now has a new parent, since we cannot guarantee+ * that the new link lived in the same directory as the alternative name for+ * this item.+ */+ if ((*vpp != NULL) && (cnp || cp->c_desc.cd_nameptr)) {+ /* we could be requesting the rsrc of a hardlink file... */+#ifdef CN_WANTSRSRCFORK+ if (cp->c_desc.cd_nameptr && (cnp == NULL || !(cnp->cn_flags & CN_WANTSRSRCFORK))) {+#else+ if (cp->c_desc.cd_nameptr) {+#endif+ //+ // Update the identity with what we have stored on disk as+ // the name of this file. This is related to:+ // <rdar://problem/8044697> FSEvents doesn't always decompose diacritical unicode chars in the paths of the changed directories+ //+ vnode_update_identity (*vpp, dvp, (const char *)cp->c_desc.cd_nameptr, cp->c_desc.cd_namelen, 0,+ (VNODE_UPDATE_PARENT | VNODE_UPDATE_NAME));+ } else if (cnp) {+ vnode_update_identity (*vpp, dvp, cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_hash,+ (VNODE_UPDATE_PARENT | VNODE_UPDATE_NAME));+ }+ }+ }+ }+ }++ /*+ * At this point, we have performed hardlink and open-unlinked checks+ * above. We have now validated the state of the vnode that was given back+ * to us from the cnode hash code and find it safe to return.+ */+ if (*vpp != NULL) {+ retval = 0;+ goto gnv_exit;+ }++ /*+ * If this is a new cnode then initialize it.+ */+ if (ISSET(cp->c_hflag, H_ALLOC)) {+ lck_rw_init(&cp->c_truncatelock, hfs_rwlock_group, hfs_lock_attr);+#if HFS_COMPRESSION+ cp->c_decmp = NULL;+#endif++ /* Make sure its still valid (ie exists on disk). */+ if (!(flags & GNV_CREATE)) {+ int error = 0;+ if (!hfs_valid_cnode (hfsmp, dvp, (wantrsrc ? NULL : cnp), cp->c_fileid, attrp, &error)) {+ hfs_chash_abort(hfsmp, cp);+ if ((flags & GNV_SKIPLOCK) == 0) {+ hfs_unlock(cp);+ }+ hfs_reclaim_cnode(hfsmp, cp);+ *vpp = NULL;+ /*+ * If we hit this case, that means that the entry was there in the catalog when+ * we did a cat_lookup earlier. Think hfs_lookup. However, in between the time+ * that we checked the catalog and the time we went to get a vnode/cnode for it,+ * it had been removed from the namespace and the vnode totally reclaimed. As a result,+ * it's not there in the catalog during the check in hfs_valid_cnode and we bubble out+ * an ENOENT. To indicate to the caller that they should really double-check the+ * entry (it could have been renamed over and gotten a new fileid), we mark a bit+ * in the output flags.+ */+ if (error == ENOENT) {+ *out_flags = GNV_CAT_DELETED;+ retval = ENOENT;+ goto gnv_exit;+ }++ /*+ * Also, we need to protect the cat_attr acquired during hfs_lookup and passed into+ * this function as an argument because the catalog may have changed w.r.t hardlink+ * link counts and the firstlink field. If that validation check fails, then let+ * lookup re-drive itself to get valid/consistent data with the same failure condition below.+ */+ if (error == ERECYCLE) {+ *out_flags = GNV_CAT_ATTRCHANGED;+ retval = ERECYCLE;+ goto gnv_exit;+ }+ }+ }+ bcopy(attrp, &cp->c_attr, sizeof(struct cat_attr));+ bcopy(descp, &cp->c_desc, sizeof(struct cat_desc));++ /* The name was inherited so clear descriptor state... */+ descp->cd_namelen = 0;+ descp->cd_nameptr = NULL;+ descp->cd_flags &= ~CD_HASBUF;++ /* Tag hardlinks */+ if ((vtype == VREG || vtype == VDIR+ || vtype == VSOCK || vtype == VFIFO)+ && (descp->cd_cnid != attrp->ca_fileid+ || ISSET(attrp->ca_recflags, kHFSHasLinkChainMask))) {+ cp->c_flag |= C_HARDLINK;+ }+ /*+ * Fix-up dir link counts.+ *+ * Earlier versions of Leopard used ca_linkcount for posix+ * nlink support (effectively the sub-directory count + 2).+ * That is now accomplished using the ca_dircount field with+ * the corresponding kHFSHasFolderCountMask flag.+ *+ * For directories the ca_linkcount is the true link count,+ * tracking the number of actual hardlinks to a directory.+ *+ * We only do this if the mount has HFS_FOLDERCOUNT set;+ * at the moment, we only set that for HFSX volumes.+ */+ if ((hfsmp->hfs_flags & HFS_FOLDERCOUNT) &&+ (vtype == VDIR) &&+ !(attrp->ca_recflags & kHFSHasFolderCountMask) &&+ (cp->c_attr.ca_linkcount > 1)) {+ if (cp->c_attr.ca_entries == 0)+ cp->c_attr.ca_dircount = 0;+ else+ cp->c_attr.ca_dircount = cp->c_attr.ca_linkcount - 2;++ cp->c_attr.ca_linkcount = 1;+ cp->c_attr.ca_recflags |= kHFSHasFolderCountMask;+ if ( !(hfsmp->hfs_flags & HFS_READ_ONLY) )+ cp->c_flag |= C_MODIFIED;+ }+#if QUOTA+ if (hfsmp->hfs_flags & HFS_QUOTAS) {+ for (i = 0; i < MAXQUOTAS; i++)+ cp->c_dquot[i] = NODQUOT;+ }+#endif /* QUOTA */+ /* Mark the output flag that we're vending a new cnode */+ *out_flags |= GNV_NEW_CNODE;+ }++ if (vtype == VDIR) {+ if (cp->c_vp != NULL)+ panic("hfs_getnewvnode: orphaned vnode (data)");+ cvpp = &cp->c_vp;+ } else {+ /*+ * Allocate and initialize a file fork...+ */+ fp = hfs_zalloc(HFS_FILEFORK_ZONE);+ fp->ff_cp = cp;+ if (forkp)+ bcopy(forkp, &fp->ff_data, sizeof(struct cat_fork));+ else+ bzero(&fp->ff_data, sizeof(struct cat_fork));+ rl_init(&fp->ff_invalidranges);+ fp->ff_sysfileinfo = 0;++ if (wantrsrc) {+ if (cp->c_rsrcfork != NULL)+ panic("hfs_getnewvnode: orphaned rsrc fork");+ if (cp->c_rsrc_vp != NULL)+ panic("hfs_getnewvnode: orphaned vnode (rsrc)");+ cp->c_rsrcfork = fp;+ cvpp = &cp->c_rsrc_vp;+ if ( (tvp = cp->c_vp) != NULLVP )+ cp->c_flag |= C_NEED_DVNODE_PUT;+ } else {+ if (cp->c_datafork != NULL)+ panic("hfs_getnewvnode: orphaned data fork");+ if (cp->c_vp != NULL)+ panic("hfs_getnewvnode: orphaned vnode (data)");+ cp->c_datafork = fp;+ cvpp = &cp->c_vp;+ if ( (tvp = cp->c_rsrc_vp) != NULLVP)+ cp->c_flag |= C_NEED_RVNODE_PUT;+ }+ }+ if (tvp != NULLVP) {+ /*+ * grab an iocount on the vnode we weren't+ * interested in (i.e. we want the resource fork+ * but the cnode already has the data fork)+ * to prevent it from being+ * recycled by us when we call vnode_create+ * which will result in a deadlock when we+ * try to take the cnode lock in hfs_vnop_fsync or+ * hfs_vnop_reclaim... vnode_get can be called here+ * because we already hold the cnode lock which will+ * prevent the vnode from changing identity until+ * we drop it.. vnode_get will not block waiting for+ * a change of state... however, it will return an+ * error if the current iocount == 0 and we've already+ * started to terminate the vnode... we don't need/want to+ * grab an iocount in the case since we can't cause+ * the fileystem to be re-entered on this thread for this vp+ *+ * the matching vnode_put will happen in hfs_unlock+ * after we've dropped the cnode lock+ */+ if ( vnode_get(tvp) != 0)+ cp->c_flag &= ~(C_NEED_RVNODE_PUT | C_NEED_DVNODE_PUT);+ }+ vfsp.vnfs_mp = mp;+ vfsp.vnfs_vtype = vtype;+ vfsp.vnfs_str = "hfs";+ if ((cp->c_flag & C_HARDLINK) && (vtype == VDIR)) {+ vfsp.vnfs_dvp = NULL; /* no parent for me! */+ vfsp.vnfs_cnp = NULL; /* no name for me! */+ } else {+ vfsp.vnfs_dvp = dvp;+ vfsp.vnfs_cnp = cnp;+ }++ vfsp.vnfs_fsnode = cp;++ /*+ * Special Case HFS Standard VNOPs from HFS+, since+ * HFS standard is readonly/deprecated as of 10.6+ */++#if FIFO+ if (vtype == VFIFO )+ vfsp.vnfs_vops = hfs_fifoop_p;+ else+#endif+ if (vtype == VBLK || vtype == VCHR)+ vfsp.vnfs_vops = hfs_specop_p;+ else+ vfsp.vnfs_vops = hfs_vnodeop_p;++ if (vtype == VBLK || vtype == VCHR)+ vfsp.vnfs_rdev = attrp->ca_rdev;+ else+ vfsp.vnfs_rdev = 0;++ if (forkp)+ vfsp.vnfs_filesize = forkp->cf_size;+ else+ vfsp.vnfs_filesize = 0;++ vfsp.vnfs_flags = VNFS_ADDFSREF;+#ifdef CN_WANTSRSRCFORK+ if (cnp && cnp->cn_nameptr && !(cnp->cn_flags & CN_WANTSRSRCFORK) && cp->c_desc.cd_nameptr && strncmp((const char *)cnp->cn_nameptr, (const char *)cp->c_desc.cd_nameptr, cp->c_desc.cd_namelen) != 0) {+#else+ if (cnp && cnp->cn_nameptr && cp->c_desc.cd_nameptr && strncmp((const char *)cnp->cn_nameptr, (const char *)cp->c_desc.cd_nameptr, cp->c_desc.cd_namelen) != 0) {+#endif+ //+ // We don't want VFS to add an entry for this vnode because the name in the+ // cnp does not match the bytes stored on disk for this file. Instead we'll+ // update the identity later after the vnode is created and we'll do so with+ // the correct bytes for this filename. For more details, see:+ // <rdar://problem/8044697> FSEvents doesn't always decompose diacritical unicode chars in the paths of the changed directories+ //+ vfsp.vnfs_flags |= VNFS_NOCACHE;+ need_update_identity = 1;+ } else if (dvp == NULLVP || cnp == NULL || !(cnp->cn_flags & MAKEENTRY) || (flags & GNV_NOCACHE)) {+ vfsp.vnfs_flags |= VNFS_NOCACHE;+ }++ /* Tag system files */+ vfsp.vnfs_marksystem = issystemfile;++ /* Tag root directory */+ if (descp->cd_cnid == kHFSRootFolderID)+ vfsp.vnfs_markroot = 1;+ else+ vfsp.vnfs_markroot = 0;++ /*+ * If provided_vp was non-NULL, then it is an already-allocated (but not+ * initialized) vnode. We simply need to initialize it to this identity.+ * If it was NULL, then assume that we need to call vnode_create with the+ * normal arguments/types.+ */+ if (provided_vp) {+ vp = provided_vp;+ /*+ * After we assign the value of provided_vp into 'vp' (so that it can be+ * mutated safely by vnode_initialize), we can NULL it out. At this point, the disposal+ * and handling of the provided vnode will be the responsibility of VFS, which will+ * clean it up and vnode_put it properly if vnode_initialize fails.+ */+ provided_vp = NULL;++ retval = vnode_initialize (VNCREATE_FLAVOR, VCREATESIZE, &vfsp, &vp);+ /* See error handling below for resolving provided_vp */+ }+ else {+ /* Do a standard vnode_create */+ retval = vnode_create (VNCREATE_FLAVOR, VCREATESIZE, &vfsp, &vp);+ }++ /*+ * We used a local variable to hold the result of vnode_create/vnode_initialize so that+ * on error cases in vnode_create we won't accidentally harm the cnode's fields+ */++ if (retval) {+ /* Clean up if we encountered an error */+ if (fp) {+ if (fp == cp->c_datafork)+ cp->c_datafork = NULL;+ else+ cp->c_rsrcfork = NULL;++ hfs_zfree(fp, HFS_FILEFORK_ZONE);+ }+ /*+ * If this is a newly created cnode or a vnode reclaim+ * occurred during the attachment, then cleanup the cnode.+ */+ if ((cp->c_vp == NULL) && (cp->c_rsrc_vp == NULL)) {+ hfs_chash_abort(hfsmp, cp);+ if ((flags & GNV_SKIPLOCK) == 0) {+ hfs_unlock(cp);+ }+ hfs_reclaim_cnode(hfsmp, cp);+ }+ else {+ hfs_chashwakeup(hfsmp, cp, H_ALLOC | H_ATTACH);+ if ((flags & GNV_SKIPLOCK) == 0){+ hfs_unlock(cp);+ }+ }+ *vpp = NULL;+ goto gnv_exit;+ }++ /* If no error, then assign the value into the cnode's fields */+ *cvpp = vp;++ vnode_settag(vp, VT_HFS);+ if (cp->c_flag & C_HARDLINK) {+ vnode_setmultipath(vp);+ }++ if (cp->c_attr.ca_recflags & kHFSFastDevCandidateMask) {+ vnode_setfastdevicecandidate(vp);+ }++ if (cp->c_attr.ca_recflags & kHFSAutoCandidateMask) {+ vnode_setautocandidate(vp);+ }+++++ if (vp && need_update_identity) {+ //+ // As above, update the name of the vnode if the bytes stored in hfs do not match+ // the bytes in the cnp. See this radar:+ // <rdar://problem/8044697> FSEvents doesn't always decompose diacritical unicode chars in the paths of the changed directories+ // for more details.+ //+ vnode_update_identity (vp, dvp, (const char *)cp->c_desc.cd_nameptr, cp->c_desc.cd_namelen, 0, VNODE_UPDATE_NAME);+ }++ /*+ * Tag resource fork vnodes as needing an VNOP_INACTIVE+ * so that any deferred removes (open unlinked files)+ * have the chance to process the resource fork.+ */+ if (VNODE_IS_RSRC(vp)) {+ int err;++ KDBG(HFSDBG_GETNEWVNODE, kdebug_vnode(cp->c_vp), kdebug_vnode(cp->c_rsrc_vp));++ /* Force VL_NEEDINACTIVE on this vnode */+ err = vnode_ref(vp);+ if (err == 0) {+ vnode_rele(vp);+ }+ }+ hfs_chashwakeup(hfsmp, cp, H_ALLOC | H_ATTACH);++ /*+ * Stop tracking an active hot file.+ */+ if (!(flags & GNV_CREATE) && (vtype != VDIR) && !issystemfile && !(hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN)) {+ (void) hfs_removehotfile(vp);+ }++#if CONFIG_PROTECT+ /* Initialize the cp data structures. The key should be in place now. */+ if (!issystemfile && (*out_flags & GNV_NEW_CNODE)) {+ cp_entry_init(cp, mp);+ }+#endif++ *vpp = vp;+ retval = 0;++gnv_exit:+ if (provided_vp) {+ /* Release our empty vnode if it was not used */+ vnode_put (provided_vp);+ }+ return retval;+}+++static void+hfs_reclaim_cnode(hfsmount_t *hfsmp, struct cnode *cp)+{+#if QUOTA+ int i;++ for (i = 0; i < MAXQUOTAS; i++) {+ if (cp->c_dquot[i] != NODQUOT) {+ dqreclaim(cp->c_dquot[i]);+ cp->c_dquot[i] = NODQUOT;+ }+ }+#endif /* QUOTA */++ /*+ * If the descriptor has a name then release it+ */+ if ((cp->c_desc.cd_flags & CD_HASBUF) && (cp->c_desc.cd_nameptr != 0)) {+ const char *nameptr;++ nameptr = (const char *) cp->c_desc.cd_nameptr;+ cp->c_desc.cd_nameptr = 0;+ cp->c_desc.cd_flags &= ~CD_HASBUF;+ cp->c_desc.cd_namelen = 0;+ vfs_removename(nameptr);+ }++ /*+ * We only call this function if we are in hfs_vnop_reclaim and+ * attempting to reclaim a cnode with only one live fork. Because the vnode+ * went through reclaim, any future attempts to use this item will have to+ * go through lookup again, which will need to create a new vnode. Thus,+ * destroying the locks below is safe.+ */++ lck_rw_destroy(&cp->c_rwlock, hfs_rwlock_group);+ lck_rw_destroy(&cp->c_truncatelock, hfs_rwlock_group);+#if HFS_COMPRESSION+ if (cp->c_decmp) {+ decmpfs_cnode_destroy(cp->c_decmp);+ decmpfs_cnode_free(cp->c_decmp);+ }+#endif+#if CONFIG_PROTECT+ cp_entry_destroy(hfsmp, cp->c_cpentry);+ cp->c_cpentry = NULL;+#else+ (void)hfsmp; // Prevent compiler warning+#endif++ hfs_zfree(cp, HFS_CNODE_ZONE);+}+++/*+ * hfs_valid_cnode+ *+ * This function is used to validate data that is stored in-core against what is contained+ * in the catalog. Common uses include validating that the parent-child relationship still exist+ * for a specific directory entry (guaranteeing it has not been renamed into a different spot) at+ * the point of the check.+ */+int+hfs_valid_cnode(struct hfsmount *hfsmp, struct vnode *dvp, struct componentname *cnp,+ cnid_t cnid, struct cat_attr *cattr, int *error)+{+ struct cat_attr attr;+ struct cat_desc cndesc;+ int stillvalid = 0;+ int lockflags;++ /* System files are always valid */+ if (cnid < kHFSFirstUserCatalogNodeID) {+ *error = 0;+ return (1);+ }++ /* XXX optimization: check write count in dvp */++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);++ if (dvp && cnp) {+ int lookup = 0;+ struct cat_fork fork;+ bzero(&cndesc, sizeof(cndesc));+ cndesc.cd_nameptr = (const u_int8_t *)cnp->cn_nameptr;+ cndesc.cd_namelen = cnp->cn_namelen;+ cndesc.cd_parentcnid = VTOC(dvp)->c_fileid;+ cndesc.cd_hint = VTOC(dvp)->c_childhint;++ /*+ * We have to be careful when calling cat_lookup. The result argument+ * 'attr' may get different results based on whether or not you ask+ * for the filefork to be supplied as output. This is because cat_lookupbykey+ * will attempt to do basic validation/smoke tests against the resident+ * extents if there are no overflow extent records, but it needs someplace+ * in memory to store the on-disk fork structures.+ *+ * Since hfs_lookup calls cat_lookup with a filefork argument, we should+ * do the same here, to verify that block count differences are not+ * due to calling the function with different styles. cat_lookupbykey+ * will request the volume be fsck'd if there is true on-disk corruption+ * where the number of blocks does not match the number generated by+ * summing the number of blocks in the resident extents.+ */++ lookup = cat_lookup (hfsmp, &cndesc, 0, 0, NULL, &attr, &fork, NULL);++ if ((lookup == 0) && (cnid == attr.ca_fileid)) {+ stillvalid = 1;+ *error = 0;+ }+ else {+ *error = ENOENT;+ }++ /*+ * In hfs_getnewvnode, we may encounter a time-of-check vs. time-of-vnode creation+ * race. Specifically, if there is no vnode/cnode pair for the directory entry+ * being looked up, we have to go to the catalog. But since we don't hold any locks (aside+ * from the dvp in 'shared' mode) there is nothing to protect us against the catalog record+ * changing in between the time we do the cat_lookup there and the time we re-grab the+ * catalog lock above to do another cat_lookup.+ *+ * However, we need to check more than just the CNID and parent-child name relationships above.+ * Hardlinks can suffer the same race in the following scenario: Suppose we do a+ * cat_lookup, and find a leaf record and a raw inode for a hardlink. Now, we have+ * the cat_attr in hand (passed in above). But in between then and now, the vnode was+ * created by a competing hfs_getnewvnode call, and is manipulated and reclaimed before we get+ * a chance to do anything. This is possible if there are a lot of threads thrashing around+ * with the cnode hash. In this case, if we don't check/validate the cat_attr in-hand, we will+ * blindly stuff it into the cnode, which will make the in-core data inconsistent with what is+ * on disk. So validate the cat_attr below, if required. This race cannot happen if the cnode/vnode+ * already exists, as it does in the case of rename and delete.+ */+ if (stillvalid && cattr != NULL) {+ if (cattr->ca_linkcount != attr.ca_linkcount) {+ stillvalid = 0;+ *error = ERECYCLE;+ goto notvalid;+ }++ if (cattr->ca_union1.cau_linkref != attr.ca_union1.cau_linkref) {+ stillvalid = 0;+ *error = ERECYCLE;+ goto notvalid;+ }++ if (cattr->ca_union3.cau_firstlink != attr.ca_union3.cau_firstlink) {+ stillvalid = 0;+ *error = ERECYCLE;+ goto notvalid;+ }++ if (cattr->ca_union2.cau_blocks != attr.ca_union2.cau_blocks) {+ stillvalid = 0;+ *error = ERECYCLE;+ goto notvalid;+ }+ }+ } else {+ if (cat_idlookup(hfsmp, cnid, 0, 0, NULL, NULL, NULL) == 0) {+ stillvalid = 1;+ *error = 0;+ }+ else {+ *error = ENOENT;+ }+ }+notvalid:+ hfs_systemfile_unlock(hfsmp, lockflags);++ return (stillvalid);+}+++/*+ * Per HI and Finder requirements, HFS should add in the+ * date/time that a particular directory entry was added+ * to the containing directory.+ * This is stored in the extended Finder Info for the+ * item in question.+ *+ * Note that this field is also set explicitly in the hfs_vnop_setxattr code.+ * We must ignore user attempts to set this part of the finderinfo, and+ * so we need to save a local copy of the date added, write in the user+ * finderinfo, then stuff the value back in.+ */+void hfs_write_dateadded (struct cat_attr *attrp, u_int32_t dateadded) {+ u_int8_t *finfo = NULL;++ /* overlay the FinderInfo to the correct pointer, and advance */+ finfo = (u_int8_t*)attrp->ca_finderinfo;+ finfo = finfo + 16;++ /*+ * Make sure to write it out as big endian, since that's how+ * finder info is defined.+ *+ * NOTE: This is a Unix-epoch timestamp, not a HFS/Traditional Mac timestamp.+ */+ if (S_ISREG(attrp->ca_mode)) {+ struct FndrExtendedFileInfo *extinfo = (struct FndrExtendedFileInfo *)finfo;+ extinfo->date_added = OSSwapHostToBigInt32(dateadded);+ attrp->ca_recflags |= kHFSHasDateAddedMask;+ }+ else if (S_ISDIR(attrp->ca_mode)) {+ struct FndrExtendedDirInfo *extinfo = (struct FndrExtendedDirInfo *)finfo;+ extinfo->date_added = OSSwapHostToBigInt32(dateadded);+ attrp->ca_recflags |= kHFSHasDateAddedMask;+ }+ /* If it were neither directory/file, then we'd bail out */+ return;+}++static u_int32_t+hfs_get_dateadded_internal(const uint8_t *finderinfo, mode_t mode)+{+ const uint8_t *finfo = NULL;+ u_int32_t dateadded = 0;++++ /* overlay the FinderInfo to the correct pointer, and advance */+ finfo = finderinfo + 16;++ /*+ * FinderInfo is written out in big endian... make sure to convert it to host+ * native before we use it.+ */+ if (S_ISREG(mode)) {+ const struct FndrExtendedFileInfo *extinfo = (const struct FndrExtendedFileInfo *)finfo;+ dateadded = OSSwapBigToHostInt32 (extinfo->date_added);+ }+ else if (S_ISDIR(mode)) {+ const struct FndrExtendedDirInfo *extinfo = (const struct FndrExtendedDirInfo *)finfo;+ dateadded = OSSwapBigToHostInt32 (extinfo->date_added);+ }++ return dateadded;+}++u_int32_t+hfs_get_dateadded(struct cnode *cp)+{+ if ((cp->c_attr.ca_recflags & kHFSHasDateAddedMask) == 0) {+ /* Date added was never set. Return 0. */+ return (0);+ }++ return (hfs_get_dateadded_internal((u_int8_t*)cp->c_finderinfo,+ cp->c_attr.ca_mode));+}++u_int32_t+hfs_get_dateadded_from_blob(const uint8_t *finderinfo, mode_t mode)+{+ return (hfs_get_dateadded_internal(finderinfo, mode));+}++/*+ * Per HI and Finder requirements, HFS maintains a "write/generation+ * count" for each file that is incremented on any write & pageout.+ * It should start at 1 to reserve "0" as a special value. If it+ * should ever wrap around, it will skip using 0.+ *+ * Note that finderinfo is manipulated in hfs_vnop_setxattr and care+ * is and should be taken to ignore user attempts to set the part of+ * the finderinfo that records the generation counter.+ *+ * Any change to the generation counter *must* not be visible before+ * the change that caused it (for obvious reasons), and given the+ * limitations of our current architecture, the change to the+ * generation counter may occur some time afterwards (particularly in+ * the case where a file is mapped writable---more on that below).+ *+ * We make no guarantees about the consistency of a file. In other+ * words, a reader that is operating concurrently with a writer might+ * see some, but not all of writer's changes, and the generation+ * counter will *not* necessarily tell you this has happened. To+ * enforce consistency, clients must make their own arrangements+ * e.g. use file locking.+ *+ * We treat files that are mapped writable as a special case: when+ * that happens, clients requesting the generation count will be told+ * it has a generation count of zero and they use that knowledge as a+ * hint that the file is changing and it therefore might be prudent to+ * wait until it is no longer mapped writable. Clients should *not*+ * rely on this behaviour however; we might decide that it's better+ * for us to publish the fact that a file is mapped writable via+ * alternate means and return the generation counter when it is mapped+ * writable as it still has some, albeit limited, use. We reserve the+ * right to make this change.+ *+ * Lastly, it's important to realise that because data and metadata+ * take different paths through the system, it's possible upon crash+ * or sudden power loss and after a restart, that a change may be+ * visible to the rest of the system without a corresponding change to+ * the generation counter. The reverse may also be true, but for all+ * practical applications this shouldn't be an issue.+ */+void hfs_write_gencount (struct cat_attr *attrp, uint32_t gencount) {+ u_int8_t *finfo = NULL;++ /* overlay the FinderInfo to the correct pointer, and advance */+ finfo = (u_int8_t*)attrp->ca_finderinfo;+ finfo = finfo + 16;++ /*+ * Make sure to write it out as big endian, since that's how+ * finder info is defined.+ *+ * Generation count is only supported for files.+ */+ if (S_ISREG(attrp->ca_mode)) {+ struct FndrExtendedFileInfo *extinfo = (struct FndrExtendedFileInfo *)finfo;+ extinfo->write_gen_counter = OSSwapHostToBigInt32(gencount);+ }++ /* If it were neither directory/file, then we'd bail out */+ return;+}++/*+ * Increase the gen count by 1; if it wraps around to 0, increment by+ * two. The cnode *must* be locked exclusively by the caller.+ *+ * You may think holding the lock is unnecessary because we only need+ * to change the counter, but consider this sequence of events: thread+ * A calls hfs_incr_gencount and the generation counter is 2 upon+ * entry. A context switch occurs and thread B increments the counter+ * to 3, thread C now gets the generation counter (for whatever+ * purpose), and then another thread makes another change and the+ * generation counter is incremented again---it's now 4. Now thread A+ * continues and it sets the generation counter back to 3. So you can+ * see, thread C would miss the change that caused the generation+ * counter to increment to 4 and for this reason the cnode *must*+ * always be locked exclusively.+ */+uint32_t hfs_incr_gencount (struct cnode *cp) {+ u_int8_t *finfo = NULL;+ u_int32_t gcount = 0;++ /* overlay the FinderInfo to the correct pointer, and advance */+ finfo = (u_int8_t*)cp->c_finderinfo;+ finfo = finfo + 16;++ /*+ * FinderInfo is written out in big endian... make sure to convert it to host+ * native before we use it.+ *+ * NOTE: the write_gen_counter is stored in the same location in both the+ * FndrExtendedFileInfo and FndrExtendedDirInfo structs (it's the+ * last 32-bit word) so it is safe to have one code path here.+ */+ if (S_ISDIR(cp->c_attr.ca_mode) || S_ISREG(cp->c_attr.ca_mode)) {+ struct FndrExtendedFileInfo *extinfo = (struct FndrExtendedFileInfo *)finfo;+ gcount = OSSwapBigToHostInt32 (extinfo->write_gen_counter);++ /* Was it zero to begin with (file originated in 10.8 or earlier?) */+ if (gcount == 0) {+ gcount++;+ }++ /* now bump it */+ gcount++;++ /* Did it wrap around ? */+ if (gcount == 0) {+ gcount++;+ }+ extinfo->write_gen_counter = OSSwapHostToBigInt32 (gcount);++ SET(cp->c_flag, C_MINOR_MOD);+ }+ else {+ gcount = 0;+ }++ return gcount;+}++/*+ * There is no need for any locks here (other than an iocount on an+ * associated vnode) because reading and writing an aligned 32 bit+ * integer should be atomic on all platforms we support.+ */+static u_int32_t+hfs_get_gencount_internal(const uint8_t *finderinfo, mode_t mode)+{+ const uint8_t *finfo = NULL;+ u_int32_t gcount = 0;++ /* overlay the FinderInfo to the correct pointer, and advance */+ finfo = finderinfo;+ finfo = finfo + 16;++ /*+ * FinderInfo is written out in big endian... make sure to convert it to host+ * native before we use it.+ *+ * NOTE: the write_gen_counter is stored in the same location in both the+ * FndrExtendedFileInfo and FndrExtendedDirInfo structs (it's the+ * last 32-bit word) so it is safe to have one code path here.+ */+ if (S_ISDIR(mode) || S_ISREG(mode)) {+ const struct FndrExtendedFileInfo *extinfo = (const struct FndrExtendedFileInfo *)finfo;+ gcount = OSSwapBigToHostInt32 (extinfo->write_gen_counter);++ /*+ * Is it zero? File might originate in 10.8 or earlier. We lie and bump it to 1,+ * since the incrementer code is able to handle this case and will double-increment+ * for us.+ */+ if (gcount == 0) {+ gcount++;+ }+ }++ return gcount;+}++/* Getter for the gen count */+u_int32_t hfs_get_gencount (struct cnode *cp) {+ return hfs_get_gencount_internal(cp->c_finderinfo, cp->c_attr.ca_mode);+}++/* Getter for the gen count from a buffer (currently pointer to finderinfo)*/+u_int32_t hfs_get_gencount_from_blob (const uint8_t *finfoblob, mode_t mode) {+ return hfs_get_gencount_internal(finfoblob, mode);+}++void hfs_clear_might_be_dirty_flag(cnode_t *cp)+{+ /*+ * If we're about to touch both mtime and ctime, we can clear the+ * C_MIGHT_BE_DIRTY_FROM_MAPPING since we can guarantee that+ * subsequent page-outs can only be for data made dirty before+ * now.+ */+ CLR(cp->c_flag, C_MIGHT_BE_DIRTY_FROM_MAPPING);+}++/*+ * Touch cnode times based on c_touch_xxx flags+ *+ * cnode must be locked exclusive+ *+ * This will also update the volume modify time+ */+void+hfs_touchtimes(struct hfsmount *hfsmp, struct cnode* cp)+{+ vfs_context_t ctx;++ if (ISSET(hfsmp->hfs_flags, HFS_READ_ONLY) || ISSET(cp->c_flag, C_NOEXISTS)) {+ cp->c_touch_acctime = FALSE;+ cp->c_touch_chgtime = FALSE;+ cp->c_touch_modtime = FALSE;+ CLR(cp->c_flag, C_NEEDS_DATEADDED);+ return;+ }++ ctx = vfs_context_current();+ /*+ * Skip access time updates if:+ * . MNT_NOATIME is set+ * . a file system freeze is in progress+ * . a file system resize is in progress+ * . the vnode associated with this cnode is marked for rapid aging+ */+ if (cp->c_touch_acctime) {+ if ((vfs_flags(hfsmp->hfs_mp) & MNT_NOATIME) ||+ hfsmp->hfs_freeze_state != HFS_THAWED ||+ (hfsmp->hfs_flags & HFS_RESIZE_IN_PROGRESS) ||+ (cp->c_vp && ((vnode_israge(cp->c_vp) || (vfs_ctx_skipatime(ctx)))))) {++ cp->c_touch_acctime = FALSE;+ }+ }+ if (cp->c_touch_acctime || cp->c_touch_chgtime ||+ cp->c_touch_modtime || (cp->c_flag & C_NEEDS_DATEADDED)) {+ struct timeval tv;+ int touchvol = 0;++ if (cp->c_touch_modtime && cp->c_touch_chgtime)+ hfs_clear_might_be_dirty_flag(cp);++ microtime(&tv);++ if (cp->c_touch_acctime) {+ /*+ * When the access time is the only thing changing, we+ * won't necessarily write it to disk immediately. We+ * only do the atime update at vnode recycle time, when+ * fsync is called or when there's another reason to write+ * to the metadata.+ */+ cp->c_atime = tv.tv_sec;+ cp->c_touch_acctime = FALSE;+ }+ if (cp->c_touch_modtime) {+ cp->c_touch_modtime = FALSE;+ time_t new_time = tv.tv_sec;++ if (cp->c_mtime != new_time) {+ cp->c_mtime = new_time;+ cp->c_flag |= C_MINOR_MOD;+ touchvol = 1;+ }+ }+ if (cp->c_touch_chgtime) {+ cp->c_touch_chgtime = FALSE;+ if (cp->c_ctime != tv.tv_sec) {+ cp->c_ctime = tv.tv_sec;+ cp->c_flag |= C_MINOR_MOD;+ touchvol = 1;+ }+ }++ if (cp->c_flag & C_NEEDS_DATEADDED) {+ hfs_write_dateadded (&(cp->c_attr), tv.tv_sec);+ cp->c_flag |= C_MINOR_MOD;+ /* untwiddle the bit */+ cp->c_flag &= ~C_NEEDS_DATEADDED;+ touchvol = 1;+ }++ /* Touch the volume modtime if needed */+ if (touchvol) {+ hfs_note_header_minor_change(hfsmp);+ HFSTOVCB(hfsmp)->vcbLsMod = tv.tv_sec;+ }+ }+}++// Use this if you don't want to check the return code+void hfs_lock_always(cnode_t *cp, enum hfs_locktype locktype)+{+ hfs_lock(cp, locktype, HFS_LOCK_ALWAYS);+}++/*+ * Lock a cnode.+ * N.B. If you add any failure cases, *make* sure hfs_lock_always works+ */+int+hfs_lock(struct cnode *cp, enum hfs_locktype locktype, enum hfs_lockflags flags)+{+ thread_t thread = current_thread();++ if (cp->c_lockowner == thread) {+ /*+ * Only the extents and bitmap files support lock recursion+ * here. The other system files support lock recursion in+ * hfs_systemfile_lock. Eventually, we should change to+ * handle recursion solely in hfs_systemfile_lock.+ */+ if ((cp->c_fileid == kHFSExtentsFileID) ||+ (cp->c_fileid == kHFSAllocationFileID)) {+ cp->c_syslockcount++;+ } else {+ panic("hfs_lock: locking against myself!");+ }+ } else if (locktype == HFS_SHARED_LOCK) {+ lck_rw_lock_shared(&cp->c_rwlock);+ cp->c_lockowner = HFS_SHARED_OWNER;+ } else { /* HFS_EXCLUSIVE_LOCK */+ lck_rw_lock_exclusive(&cp->c_rwlock);+ cp->c_lockowner = thread;++ /* Only the extents and bitmap files support lock recursion. */+ if ((cp->c_fileid == kHFSExtentsFileID) ||+ (cp->c_fileid == kHFSAllocationFileID)) {+ cp->c_syslockcount = 1;+ }+ }++#ifdef HFS_CHECK_LOCK_ORDER+ /*+ * Regular cnodes (non-system files) cannot be locked+ * while holding the journal lock or a system file lock.+ */+ if (!(cp->c_desc.cd_flags & CD_ISMETA) &&+ ((cp->c_fileid > kHFSFirstUserCatalogNodeID) || (cp->c_fileid == kHFSRootFolderID))) {+ vnode_t vp = NULLVP;++ /* Find corresponding vnode. */+ if (cp->c_vp != NULLVP && VTOC(cp->c_vp) == cp) {+ vp = cp->c_vp;+ } else if (cp->c_rsrc_vp != NULLVP && VTOC(cp->c_rsrc_vp) == cp) {+ vp = cp->c_rsrc_vp;+ }+ if (vp != NULLVP) {+ struct hfsmount *hfsmp = VTOHFS(vp);++ if (hfsmp->jnl && (journal_owner(hfsmp->jnl) == thread)) {+ /* This will eventually be a panic here, but we need+ to fix where we create the hot files BTree+ first. */+ printf("hfs_lock: bad lock order (cnode after journal)\n");+ }+ if (hfsmp->hfs_catalog_cp && hfsmp->hfs_catalog_cp->c_lockowner == thread) {+ panic("hfs_lock: bad lock order (cnode after catalog)");+ }+ if (hfsmp->hfs_attribute_cp && hfsmp->hfs_attribute_cp->c_lockowner == thread) {+ panic("hfs_lock: bad lock order (cnode after attribute)");+ }+ if (hfsmp->hfs_extents_cp && hfsmp->hfs_extents_cp->c_lockowner == thread) {+ panic("hfs_lock: bad lock order (cnode after extents)");+ }+ }+ }+#endif /* HFS_CHECK_LOCK_ORDER */++ /*+ * Skip cnodes for regular files that no longer exist+ * (marked deleted, catalog entry gone).+ */+ if (((flags & HFS_LOCK_ALLOW_NOEXISTS) == 0) &&+ ((cp->c_desc.cd_flags & CD_ISMETA) == 0) &&+ (cp->c_flag & C_NOEXISTS)) {+ hfs_unlock(cp);+ return (ENOENT);+ }+ return (0);+}++bool hfs_lock_upgrade(cnode_t *cp)+{+ if (lck_rw_lock_shared_to_exclusive(&cp->c_rwlock)) {+ cp->c_lockowner = current_thread();+ return true;+ } else+ return false;+}++/*+ * Lock a pair of cnodes.+ */+int+hfs_lockpair(struct cnode *cp1, struct cnode *cp2, enum hfs_locktype locktype)+{+ struct cnode *first, *last;+ int error;++ /*+ * If cnodes match then just lock one.+ */+ if (cp1 == cp2) {+ return hfs_lock(cp1, locktype, HFS_LOCK_DEFAULT);+ }++ /*+ * Lock in cnode address order.+ */+ if (cp1 < cp2) {+ first = cp1;+ last = cp2;+ } else {+ first = cp2;+ last = cp1;+ }++ if ( (error = hfs_lock(first, locktype, HFS_LOCK_DEFAULT))) {+ return (error);+ }+ if ( (error = hfs_lock(last, locktype, HFS_LOCK_DEFAULT))) {+ hfs_unlock(first);+ return (error);+ }+ return (0);+}++/*+ * Check ordering of two cnodes. Return true if they are are in-order.+ */+static int+hfs_isordered(struct cnode *cp1, struct cnode *cp2)+{+ if (cp1 == cp2)+ return (0);+ if (cp1 == NULL || cp2 == (struct cnode *)0xffffffff)+ return (1);+ if (cp2 == NULL || cp1 == (struct cnode *)0xffffffff)+ return (0);+ /*+ * Locking order is cnode address order.+ */+ return (cp1 < cp2);+}++/*+ * Acquire 4 cnode locks.+ * - locked in cnode address order (lesser address first).+ * - all or none of the locks are taken+ * - only one lock taken per cnode (dup cnodes are skipped)+ * - some of the cnode pointers may be null+ */+int+hfs_lockfour(struct cnode *cp1, struct cnode *cp2, struct cnode *cp3,+ struct cnode *cp4, enum hfs_locktype locktype, struct cnode **error_cnode)+{+ struct cnode * a[3];+ struct cnode * b[3];+ struct cnode * list[4];+ struct cnode * tmp;+ int i, j, k;+ int error;+ if (error_cnode) {+ *error_cnode = NULL;+ }++ if (hfs_isordered(cp1, cp2)) {+ a[0] = cp1; a[1] = cp2;+ } else {+ a[0] = cp2; a[1] = cp1;+ }+ if (hfs_isordered(cp3, cp4)) {+ b[0] = cp3; b[1] = cp4;+ } else {+ b[0] = cp4; b[1] = cp3;+ }+ a[2] = (struct cnode *)0xffffffff; /* sentinel value */+ b[2] = (struct cnode *)0xffffffff; /* sentinel value */++ /*+ * Build the lock list, skipping over duplicates+ */+ for (i = 0, j = 0, k = 0; (i < 2 || j < 2); ) {+ tmp = hfs_isordered(a[i], b[j]) ? a[i++] : b[j++];+ if (k == 0 || tmp != list[k-1])+ list[k++] = tmp;+ }++ /*+ * Now we can lock using list[0 - k].+ * Skip over NULL entries.+ */+ for (i = 0; i < k; ++i) {+ if (list[i])+ if ((error = hfs_lock(list[i], locktype, HFS_LOCK_DEFAULT))) {+ /* Only stuff error_cnode if requested */+ if (error_cnode) {+ *error_cnode = list[i];+ }+ /* Drop any locks we acquired. */+ while (--i >= 0) {+ if (list[i])+ hfs_unlock(list[i]);+ }+ return (error);+ }+ }+ return (0);+}+++/*+ * Unlock a cnode.+ */+void+hfs_unlock(struct cnode *cp)+{+ vnode_t rvp = NULLVP;+ vnode_t vp = NULLVP;+ u_int32_t c_flag = 0;++ /*+ * Only the extents and bitmap file's support lock recursion.+ */+ if ((cp->c_fileid == kHFSExtentsFileID) ||+ (cp->c_fileid == kHFSAllocationFileID)) {+ if (--cp->c_syslockcount > 0) {+ return;+ }+ }++ const thread_t thread = current_thread();++ if (cp->c_lockowner == thread) {+ c_flag = cp->c_flag;++ // If we have the truncate lock, we must defer the puts+ if (cp->c_truncatelockowner == thread) {+ if (ISSET(c_flag, C_NEED_DVNODE_PUT)+ && !cp->c_need_dvnode_put_after_truncate_unlock) {+ CLR(c_flag, C_NEED_DVNODE_PUT);+ cp->c_need_dvnode_put_after_truncate_unlock = true;+ }+ if (ISSET(c_flag, C_NEED_RVNODE_PUT)+ && !cp->c_need_rvnode_put_after_truncate_unlock) {+ CLR(c_flag, C_NEED_RVNODE_PUT);+ cp->c_need_rvnode_put_after_truncate_unlock = true;+ }+ }++ CLR(cp->c_flag, (C_NEED_DATA_SETSIZE | C_NEED_RSRC_SETSIZE+ | C_NEED_DVNODE_PUT | C_NEED_RVNODE_PUT));++ if (c_flag & (C_NEED_DVNODE_PUT | C_NEED_DATA_SETSIZE)) {+ vp = cp->c_vp;+ }+ if (c_flag & (C_NEED_RVNODE_PUT | C_NEED_RSRC_SETSIZE)) {+ rvp = cp->c_rsrc_vp;+ }++ cp->c_lockowner = NULL;+ lck_rw_unlock_exclusive(&cp->c_rwlock);+ } else {+ lck_rw_unlock_shared(&cp->c_rwlock);+ }++ /* Perform any vnode post processing after cnode lock is dropped. */+ if (vp) {+ if (c_flag & C_NEED_DATA_SETSIZE) {+ ubc_setsize(vp, VTOF(vp)->ff_size);+#if HFS_COMPRESSION+ /*+ * If this is a compressed file, we need to reset the+ * compression state. We will have set the size to zero+ * above and it will get fixed up later (in exactly the+ * same way that new vnodes are fixed up). Note that we+ * should only be able to get here if the truncate lock is+ * held exclusively and so we do the reset when that's+ * unlocked.+ */+ decmpfs_cnode *dp = VTOCMP(vp);+ if (dp && decmpfs_cnode_get_vnode_state(dp) != FILE_TYPE_UNKNOWN)+ cp->c_need_decmpfs_reset = true;+#endif+ }+ if (c_flag & C_NEED_DVNODE_PUT)+ vnode_put(vp);+ }+ if (rvp) {+ if (c_flag & C_NEED_RSRC_SETSIZE)+ ubc_setsize(rvp, VTOF(rvp)->ff_size);+ if (c_flag & C_NEED_RVNODE_PUT)+ vnode_put(rvp);+ }+}++/*+ * Unlock a pair of cnodes.+ */+void+hfs_unlockpair(struct cnode *cp1, struct cnode *cp2)+{+ hfs_unlock(cp1);+ if (cp2 != cp1)+ hfs_unlock(cp2);+}++/*+ * Unlock a group of cnodes.+ */+void+hfs_unlockfour(struct cnode *cp1, struct cnode *cp2, struct cnode *cp3, struct cnode *cp4)+{+ struct cnode * list[4];+ int i, k = 0;++ if (cp1) {+ hfs_unlock(cp1);+ list[k++] = cp1;+ }+ if (cp2) {+ for (i = 0; i < k; ++i) {+ if (list[i] == cp2)+ goto skip1;+ }+ hfs_unlock(cp2);+ list[k++] = cp2;+ }+skip1:+ if (cp3) {+ for (i = 0; i < k; ++i) {+ if (list[i] == cp3)+ goto skip2;+ }+ hfs_unlock(cp3);+ list[k++] = cp3;+ }+skip2:+ if (cp4) {+ for (i = 0; i < k; ++i) {+ if (list[i] == cp4)+ return;+ }+ hfs_unlock(cp4);+ }+}+++/*+ * Protect a cnode against a truncation.+ *+ * Used mainly by read/write since they don't hold the+ * cnode lock across calls to the cluster layer.+ *+ * The process doing a truncation must take the lock+ * exclusive. The read/write processes can take it+ * shared. The locktype argument is the same as supplied to+ * hfs_lock.+ */+void+hfs_lock_truncate(struct cnode *cp, enum hfs_locktype locktype, enum hfs_lockflags flags)+{+ thread_t thread = current_thread();++ if (cp->c_truncatelockowner == thread) {+ /*+ * Ignore grabbing the lock if it the current thread already+ * holds exclusive lock.+ *+ * This is needed on the hfs_vnop_pagein path where we need to ensure+ * the file does not change sizes while we are paging in. However,+ * we may already hold the lock exclusive due to another+ * VNOP from earlier in the call stack. So if we already hold+ * the truncate lock exclusive, allow it to proceed, but ONLY if+ * it's in the recursive case.+ */+ if ((flags & HFS_LOCK_SKIP_IF_EXCLUSIVE) == 0) {+ panic("hfs_lock_truncate: cnode %p locked!", cp);+ }+ } else if (locktype == HFS_SHARED_LOCK) {+ lck_rw_lock_shared(&cp->c_truncatelock);+ cp->c_truncatelockowner = HFS_SHARED_OWNER;+ } else { /* HFS_EXCLUSIVE_LOCK */+ lck_rw_lock_exclusive(&cp->c_truncatelock);+ cp->c_truncatelockowner = thread;+ }+}++bool hfs_truncate_lock_upgrade(struct cnode *cp)+{+ hfs_assert(cp->c_truncatelockowner == HFS_SHARED_OWNER);+ if (!lck_rw_lock_shared_to_exclusive(&cp->c_truncatelock))+ return false;+ cp->c_truncatelockowner = current_thread();+ return true;+}++void hfs_truncate_lock_downgrade(struct cnode *cp)+{+ hfs_assert(cp->c_truncatelockowner == current_thread());+ lck_rw_lock_exclusive_to_shared(&cp->c_truncatelock);+ cp->c_truncatelockowner = HFS_SHARED_OWNER;+}++/*+ * Attempt to get the truncate lock. If it cannot be acquired, error out.+ * This function is needed in the degenerate hfs_vnop_pagein during force unmount+ * case. To prevent deadlocks while a VM copy object is moving pages, HFS vnop pagein will+ * temporarily need to disable V2 semantics.+ */+int hfs_try_trunclock (struct cnode *cp, enum hfs_locktype locktype, enum hfs_lockflags flags)+{+ thread_t thread = current_thread();+ boolean_t didlock = false;++ if (cp->c_truncatelockowner == thread) {+ /*+ * Ignore grabbing the lock if the current thread already+ * holds exclusive lock.+ *+ * This is needed on the hfs_vnop_pagein path where we need to ensure+ * the file does not change sizes while we are paging in. However,+ * we may already hold the lock exclusive due to another+ * VNOP from earlier in the call stack. So if we already hold+ * the truncate lock exclusive, allow it to proceed, but ONLY if+ * it's in the recursive case.+ */+ if ((flags & HFS_LOCK_SKIP_IF_EXCLUSIVE) == 0) {+ panic("hfs_lock_truncate: cnode %p locked!", cp);+ }+ } else if (locktype == HFS_SHARED_LOCK) {+ didlock = lck_rw_try_lock(&cp->c_truncatelock, LCK_RW_TYPE_SHARED);+ if (didlock) {+ cp->c_truncatelockowner = HFS_SHARED_OWNER;+ }+ } else { /* HFS_EXCLUSIVE_LOCK */+ didlock = lck_rw_try_lock (&cp->c_truncatelock, LCK_RW_TYPE_EXCLUSIVE);+ if (didlock) {+ cp->c_truncatelockowner = thread;+ }+ }++ return didlock;+}+++/*+ * Unlock the truncate lock, which protects against size changes.+ *+ * If HFS_LOCK_SKIP_IF_EXCLUSIVE flag was set, it means that a previous+ * hfs_lock_truncate() might have skipped grabbing a lock because+ * the current thread was already holding the lock exclusive and+ * we may need to return from this function without actually unlocking+ * the truncate lock.+ */+void+hfs_unlock_truncate(struct cnode *cp, enum hfs_lockflags flags)+{+ thread_t thread = current_thread();++ /*+ * If HFS_LOCK_SKIP_IF_EXCLUSIVE is set in the flags AND the current+ * lock owner of the truncate lock is our current thread, then+ * we must have skipped taking the lock earlier by in+ * hfs_lock_truncate() by setting HFS_LOCK_SKIP_IF_EXCLUSIVE in the+ * flags (as the current thread was current lock owner).+ *+ * If HFS_LOCK_SKIP_IF_EXCLUSIVE is not set (most of the time) then+ * we check the lockowner field to infer whether the lock was taken+ * exclusively or shared in order to know what underlying lock+ * routine to call.+ */+ if (flags & HFS_LOCK_SKIP_IF_EXCLUSIVE) {+ if (cp->c_truncatelockowner == thread) {+ return;+ }+ }++ /* HFS_LOCK_EXCLUSIVE */+ if (thread == cp->c_truncatelockowner) {+ vnode_t vp = NULL, rvp = NULL;++ /*+ * If there are pending set sizes, the cnode lock should be dropped+ * first.+ */+ hfs_assert(!(cp->c_lockowner == thread+ && ISSET(cp->c_flag, C_NEED_DATA_SETSIZE | C_NEED_RSRC_SETSIZE)));++ if (cp->c_need_dvnode_put_after_truncate_unlock) {+ vp = cp->c_vp;+ cp->c_need_dvnode_put_after_truncate_unlock = false;+ }+ if (cp->c_need_rvnode_put_after_truncate_unlock) {+ rvp = cp->c_rsrc_vp;+ cp->c_need_rvnode_put_after_truncate_unlock = false;+ }++#if HFS_COMPRESSION+ bool reset_decmpfs = cp->c_need_decmpfs_reset;+ cp->c_need_decmpfs_reset = false;+#endif++ cp->c_truncatelockowner = NULL;+ lck_rw_unlock_exclusive(&cp->c_truncatelock);++#if HFS_COMPRESSION+ if (reset_decmpfs) {+ decmpfs_cnode *dp = cp->c_decmp;+ if (dp && decmpfs_cnode_get_vnode_state(dp) != FILE_TYPE_UNKNOWN)+ decmpfs_cnode_set_vnode_state(dp, FILE_TYPE_UNKNOWN, 0);+ }+#endif++ // Do the puts now+ if (vp)+ vnode_put(vp);+ if (rvp)+ vnode_put(rvp);+ } else { /* HFS_LOCK_SHARED */+ lck_rw_unlock_shared(&cp->c_truncatelock);+ }+}diff --git a/xnu/files/bsd/hfs/hfs_cnode.h b/xnu/files/bsd/hfs/hfs_cnode.hnew file mode 100644index 0000000..62c6a14--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_cnode.h@@ -0,0 +1,630 @@+/*+ * Copyright (c) 2002-2015 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@+ */+#ifndef _HFS_CNODE_H_+#define _HFS_CNODE_H_++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE+#include <stdbool.h>+#include <sys/types.h>+#include <sys/queue.h>+#include <sys/stat.h>+#include <sys/vnode.h>+#include <sys/quota.h>+#if HFS_COMPRESSION+#include <sys/decmpfs.h>+#endif+#if CONFIG_PROTECT+#include <sys/cprotect.h>+#endif+#include <kern/locks.h>++#include "hfs_catalog.h"+#include "rangelist.h"+#include "hfs_dbg.h"++/*+ * The filefork is used to represent an HFS file fork (data or resource).+ * Reading or writing any of these fields requires holding cnode lock.+ */+struct filefork {+ struct cnode *ff_cp; /* cnode associated with this fork */+ struct rl_head ff_invalidranges; /* Areas of disk that should read back as zeroes */+ union {+ void *ffu_sysfileinfo; /* additional info for system files */+ char *ffu_symlinkptr; /* symbolic link pathname */+ } ff_union;+ struct cat_fork ff_data; /* fork data (size, extents) */+};+typedef struct filefork filefork_t;+++#define HFS_TEMPLOOKUP_NAMELEN 32++/*+ * Catalog Lookup struct (runtime)+ *+ * This is used so that when we need to malloc a container for a catalog+ * lookup operation, we can acquire memory for everything in one fell swoop+ * as opposed to putting many of these objects on the stack. The cat_fork+ * data structure can take up 100+bytes easily, and that can add to stack+ * overhead.+ *+ * As a result, we use this to easily pass around the memory needed for a+ * lookup operation.+ */+struct cat_lookup_buffer {+ struct cat_desc lookup_desc;+ struct cat_attr lookup_attr;+ struct filefork lookup_fork;+ struct componentname lookup_cn;+ char lookup_name[HFS_TEMPLOOKUP_NAMELEN]; /* for open-unlinked paths only */+};+++/* Aliases for common fields */+#define ff_size ff_data.cf_size+#define ff_new_size ff_data.cf_new_size+#define ff_clumpsize ff_data.cf_clump+#define ff_bytesread ff_data.cf_bytesread+#define ff_extents ff_data.cf_extents++/*+ * Note that the blocks fields are protected by the cnode lock, *not*+ * the truncate lock.+ */+#define ff_blocks ff_data.cf_blocks+#define ff_unallocblocks ff_data.cf_vblocks+static inline uint32_t ff_allocblocks(filefork_t *ff)+{+ hfs_assert(ff->ff_blocks >= ff->ff_unallocblocks);+ return ff->ff_blocks - ff->ff_unallocblocks;+}++#define ff_symlinkptr ff_union.ffu_symlinkptr+#define ff_sysfileinfo ff_union.ffu_sysfileinfo+++/* The btree code still needs these... */+#define fcbEOF ff_size+#define fcbExtents ff_extents+#define fcbBTCBPtr ff_sysfileinfo++typedef u_int8_t atomicflag_t;+++/*+ * Hardlink Origin (for hardlinked directories).+ */+struct linkorigin {+ TAILQ_ENTRY(linkorigin) lo_link; /* chain */+ void * lo_thread; /* thread that performed the lookup */+ cnid_t lo_cnid; /* hardlink's cnid */+ cnid_t lo_parentcnid; /* hardlink's parent cnid */+};+typedef struct linkorigin linkorigin_t;++extern uint32_t _hfs_max_origins;+extern uint32_t _hfs_max_file_origins;++#define MAX_CACHED_ORIGINS_DEFAULT 10+#define MAX_CACHED_ORIGINS (_hfs_max_origins)+#define MAX_CACHED_FILE_ORIGINS_DEFAULT 8+#define MAX_CACHED_FILE_ORIGINS (_hfs_max_file_origins)++/*+ * The cnode is used to represent each active (or recently active)+ * file or directory in the HFS filesystem.+ *+ * Reading or writing any of these fields requires holding c_lock.+ */+struct cnode {+ lck_rw_t c_rwlock; /* cnode's lock */+ thread_t c_lockowner; /* cnode's lock owner (exclusive case only) */+ lck_rw_t c_truncatelock; /* protects file from truncation during read/write */+ thread_t c_truncatelockowner; /* truncate lock owner (exclusive case only) */+ LIST_ENTRY(cnode) c_hash; /* cnode's hash chain */+ u_int32_t c_flag; /* cnode's runtime flags */+ u_int32_t c_hflag; /* cnode's flags for maintaining hash - protected by global hash lock */+ struct vnode *c_vp; /* vnode for data fork or dir */+ struct vnode *c_rsrc_vp; /* vnode for resource fork */+ struct dquot *c_dquot[MAXQUOTAS]; /* cnode's quota info */+ u_int32_t c_childhint; /* catalog hint for children (small dirs only) */+ u_int32_t c_dirthreadhint; /* catalog hint for directory's thread rec */+ struct cat_desc c_desc; /* cnode's descriptor */+ struct cat_attr c_attr; /* cnode's attributes */+ TAILQ_HEAD(hfs_originhead, linkorigin) c_originlist; /* hardlink origin cache */+ TAILQ_HEAD(hfs_hinthead, directoryhint) c_hintlist; /* readdir directory hint list */+ int16_t c_dirhinttag; /* directory hint tag */+ union {+ int16_t cu_dirhintcnt; /* directory hint count */+ int16_t cu_syslockcount; /* system file use only */+ } c_union;+ u_int32_t c_dirchangecnt; /* changes each insert/delete (in-core only) */+ struct filefork *c_datafork; /* cnode's data fork */+ struct filefork *c_rsrcfork; /* cnode's rsrc fork */+ atomicflag_t c_touch_acctime;+ atomicflag_t c_touch_chgtime;+ atomicflag_t c_touch_modtime;++ // The following flags are protected by the truncate lock+ union {+ struct {+ bool c_need_dvnode_put_after_truncate_unlock : 1;+ bool c_need_rvnode_put_after_truncate_unlock : 1;+#if HFS_COMPRESSION+ bool c_need_decmpfs_reset : 1;+#endif+ };+ uint8_t c_tflags;+ };++ /*+ * Where we're using a journal, we keep track of the last+ * transaction that we did an update in. If a minor modification+ * is made, we'll still push it if we're still on the same+ * transaction.+ */+ uint32_t c_update_txn;++#if HFS_COMPRESSION+ struct decmpfs_cnode *c_decmp;+#endif /* HFS_COMPRESSION */+#if CONFIG_PROTECT+ struct cprotect *c_cpentry; /* content protection data */+#endif+};+typedef struct cnode cnode_t;++/* Aliases for common cnode fields */+#define c_cnid c_desc.cd_cnid+#define c_hint c_desc.cd_hint+#define c_parentcnid c_desc.cd_parentcnid+#define c_encoding c_desc.cd_encoding++#define c_fileid c_attr.ca_fileid+#define c_mode c_attr.ca_mode+#define c_linkcount c_attr.ca_linkcount+#define c_uid c_attr.ca_uid+#define c_gid c_attr.ca_gid+#define c_rdev c_attr.ca_union1.cau_rdev+#define c_atime c_attr.ca_atime+#define c_mtime c_attr.ca_mtime+#define c_ctime c_attr.ca_ctime+#define c_itime c_attr.ca_itime+#define c_btime c_attr.ca_btime+#define c_bsdflags c_attr.ca_flags+#define c_finderinfo c_attr.ca_finderinfo+#define c_blocks c_attr.ca_union2.cau_blocks+#define c_entries c_attr.ca_union2.cau_entries+#define c_zftimeout c_childhint++#define c_dirhintcnt c_union.cu_dirhintcnt+#define c_syslockcount c_union.cu_syslockcount+++/* hash maintenance flags kept in c_hflag and protected by hfs_chash_mutex */+#define H_ALLOC 0x00001 /* CNode is being allocated */+#define H_ATTACH 0x00002 /* CNode is being attached to by another vnode */+#define H_TRANSIT 0x00004 /* CNode is getting recycled */+#define H_WAITING 0x00008 /* CNode is being waited for */+++/*+ * Runtime cnode flags (kept in c_flag)+ */+#define C_NEED_RVNODE_PUT 0x0000001 /* Need to do a vnode_put on c_rsrc_vp after the unlock */+#define C_NEED_DVNODE_PUT 0x0000002 /* Need to do a vnode_put on c_vp after the unlock */+#define C_ZFWANTSYNC 0x0000004 /* fsync requested and file has holes */+#define C_FROMSYNC 0x0000008 /* fsync was called from sync */++#define C_MODIFIED 0x0000010 /* CNode has been modified */+#define C_NOEXISTS 0x0000020 /* CNode has been deleted, catalog entry is gone */+#define C_DELETED 0x0000040 /* CNode has been marked to be deleted */+#define C_HARDLINK 0x0000080 /* CNode is a hard link (file or dir) */++/*+ * A minor modification is one where the volume would not be inconsistent if+ * the change was not pushed to disk. For example, changes to times.+ */+#define C_MINOR_MOD 0x0000100 /* CNode has a minor modification */++#define C_HASXATTRS 0x0000200 /* cnode has extended attributes */+#define C_NEG_ENTRIES 0x0000400 /* directory has negative name entries */+/*+ * For C_SSD_STATIC: SSDs may want to deal with the file payload data in a+ * different manner knowing that the content is not likely to be modified. This is+ * purely advisory at the HFS level, and is not maintained after the cnode goes out of core.+ */+#define C_SSD_STATIC 0x0000800 /* Assume future writes contain static content */++#define C_NEED_DATA_SETSIZE 0x0001000 /* Do a ubc_setsize(0) on c_rsrc_vp after the unlock */+#define C_NEED_RSRC_SETSIZE 0x0002000 /* Do a ubc_setsize(0) on c_vp after the unlock */+#define C_DIR_MODIFICATION 0x0004000 /* Directory is being modified, wait for lookups */+#define C_ALWAYS_ZEROFILL 0x0008000 /* Always zero-fill the file on an fsync */++#define C_RENAMED 0x0010000 /* cnode was deleted as part of rename; C_DELETED should also be set */+#define C_NEEDS_DATEADDED 0x0020000 /* cnode needs date-added written to the finderinfo bit */+#define C_BACKINGSTORE 0x0040000 /* cnode is a backing store for an existing or currently-mounting filesystem */++/*+ * This flag indicates the cnode might be dirty because it+ * was mapped writable so if we get any page-outs, update+ * the modification and change times.+ */+#define C_MIGHT_BE_DIRTY_FROM_MAPPING 0x0080000++/*+ * For C_SSD_GREEDY_MODE: SSDs may want to write the file payload data using the greedy mode knowing+ * that the content needs to be written out to the disk quicker than normal at the expense of storage efficiency.+ * This is purely advisory at the HFS level, and is not maintained after the cnode goes out of core.+ */+#define C_SSD_GREEDY_MODE 0x0100000 /* Assume future writes are recommended to be written in SLC mode */++/* 0x0200000 is currently unused */++#define C_IO_ISOCHRONOUS 0x0400000 /* device-specific isochronous throughput I/O */++#define ZFTIMELIMIT (5 * 60)++/*+ * The following is the "invisible" bit from the fdFlags field+ * in the FndrFileInfo.+ */+enum { kFinderInvisibleMask = 1 << 14 };+++/*+ * Convert between cnode pointers and vnode pointers+ */+#define VTOC(vp) ((struct cnode *)vnode_fsnode((vp)))++#define CTOV(cp,rsrc) (((rsrc) && S_ISREG((cp)->c_mode)) ? \+ (cp)->c_rsrc_vp : (cp)->c_vp)++/*+ * Convert between vnode pointers and file forks+ *+ * Note: no CTOF since that is ambiguous+ */++#define FTOC(fp) ((fp)->ff_cp)++#define VTOF(vp) ((vp) == VTOC((vp))->c_rsrc_vp ? \+ VTOC((vp))->c_rsrcfork : \+ VTOC((vp))->c_datafork)++#define VCTOF(vp, cp) ((vp) == (cp)->c_rsrc_vp ? \+ (cp)->c_rsrcfork : \+ (cp)->c_datafork)++#define FTOV(fp) ((fp) == FTOC(fp)->c_rsrcfork ? \+ FTOC(fp)->c_rsrc_vp : \+ FTOC(fp)->c_vp)++/*+ * This is a helper function used for determining whether or not a cnode has become open+ * unlinked in between the time we acquired its vnode and the time we acquire the cnode lock+ * to start manipulating it. Due to the SMP nature of VFS, it is probably necessary to+ * use this macro every time we acquire a cnode lock, as the content of the Cnode may have+ * been modified in betweeen the lookup and a VNOP. Whether or not to call this is dependent+ * upon the VNOP in question. Sometimes it is OK to use an open-unlinked file, for example, in,+ * reading. But other times, such as on the source of a VNOP_RENAME, it should be disallowed.+ */+int hfs_checkdeleted(struct cnode *cp);++/*+ * Test for a resource fork+ */+#define FORK_IS_RSRC(fp) ((fp) == FTOC(fp)->c_rsrcfork)++#define VNODE_IS_RSRC(vp) ((vp) == VTOC((vp))->c_rsrc_vp)++#if HFS_COMPRESSION+/*+ * VTOCMP(vp) returns a pointer to vp's decmpfs_cnode; this could be NULL+ * if the file is not compressed or if hfs_file_is_compressed() hasn't+ * yet been called on this file.+ */+#define VTOCMP(vp) (VTOC((vp))->c_decmp)+int hfs_file_is_compressed(struct cnode *cp, int skiplock);+int hfs_uncompressed_size_of_compressed_file(struct hfsmount *hfsmp, struct vnode *vp, cnid_t fid, off_t *size, int skiplock);+int hfs_hides_rsrc(vfs_context_t ctx, struct cnode *cp, int skiplock);+int hfs_hides_xattr(vfs_context_t ctx, struct cnode *cp, const char *name, int skiplock);+#endif++#define ATIME_ONDISK_ACCURACY 300++static inline bool hfs_should_save_atime(cnode_t *cp)+{+ /*+ * We only write atime updates to disk if the delta is greater+ * than ATIME_ONDISK_ACCURACY.+ */+ return (cp->c_atime < cp->c_attr.ca_atimeondisk+ || cp->c_atime - cp->c_attr.ca_atimeondisk > ATIME_ONDISK_ACCURACY);+}++typedef enum {+ HFS_NOT_DIRTY = 0,+ HFS_DIRTY = 1,+ HFS_DIRTY_ATIME = 2+} hfs_dirty_t;++static inline hfs_dirty_t hfs_is_dirty(cnode_t *cp)+{+ if (ISSET(cp->c_flag, C_NOEXISTS))+ return HFS_NOT_DIRTY;++ if (ISSET(cp->c_flag, C_MODIFIED | C_MINOR_MOD | C_NEEDS_DATEADDED)+ || cp->c_touch_chgtime || cp->c_touch_modtime) {+ return HFS_DIRTY;+ }++ if (cp->c_touch_acctime || hfs_should_save_atime(cp))+ return HFS_DIRTY_ATIME;++ return HFS_NOT_DIRTY;+}++/* This overlays the FileID portion of NFS file handles. */+struct hfsfid {+ u_int32_t hfsfid_cnid; /* Catalog node ID. */+ u_int32_t hfsfid_gen; /* Generation number (create date). */+};+++/* Get new default vnode */+extern int hfs_getnewvnode(struct hfsmount *hfsmp, struct vnode *dvp, struct componentname *cnp,+ struct cat_desc *descp, int flags, struct cat_attr *attrp,+ struct cat_fork *forkp, struct vnode **vpp, int *out_flags);++/* Input flags for hfs_getnewvnode */++#define GNV_WANTRSRC 0x01 /* Request the resource fork vnode. */+#define GNV_SKIPLOCK 0x02 /* Skip taking the cnode lock (when getting resource fork). */+#define GNV_CREATE 0x04 /* The vnode is for a newly created item. */+#define GNV_NOCACHE 0x08 /* Delay entering this item in the name cache */+#define GNV_USE_VP 0x10 /* Use the vnode provided in *vpp instead of creating a new one */++/* Output flags for hfs_getnewvnode */+#define GNV_CHASH_RENAMED 0x01 /* The cnode was renamed in-flight */+#define GNV_CAT_DELETED 0x02 /* The cnode was deleted from the catalog */+#define GNV_NEW_CNODE 0x04 /* We are vending out a newly initialized cnode */+#define GNV_CAT_ATTRCHANGED 0x08 /* Something in struct cat_attr changed in between cat_lookups */+++/* Touch cnode times based on c_touch_xxx flags */+extern void hfs_touchtimes(struct hfsmount *, struct cnode *);+extern void hfs_write_dateadded (struct cat_attr *cattrp, u_int32_t dateadded);+extern u_int32_t hfs_get_dateadded (struct cnode *cp);+extern u_int32_t hfs_get_dateadded_from_blob(const uint8_t * /* finderinfo */, mode_t /* mode */);++/* Gen counter methods */+extern void hfs_write_gencount(struct cat_attr *cattrp, uint32_t gencount);+extern uint32_t hfs_get_gencount(struct cnode *cp);+extern uint32_t hfs_incr_gencount (struct cnode *cp);+extern uint32_t hfs_get_gencount_from_blob(const uint8_t * /* finderinfo */, mode_t /* mode */);++/* Document id methods */+extern uint32_t hfs_get_document_id(struct cnode * /* cp */);+extern uint32_t hfs_get_document_id_from_blob(const uint8_t * /* finderinfo */, mode_t /* mode */);++/* Zero-fill file and push regions out to disk */+enum {+ // Use this flag if you're going to sync later+ HFS_FILE_DONE_NO_SYNC = 1,+};+typedef uint32_t hfs_file_done_opts_t;+extern int hfs_filedone(struct vnode *vp, vfs_context_t context,+ hfs_file_done_opts_t opts);++/*+ * HFS cnode hash functions.+ */+extern void hfs_chashinit(void);+extern void hfs_chashinit_finish(struct hfsmount *hfsmp);+extern void hfs_delete_chash(struct hfsmount *hfsmp);+extern int hfs_chashremove(struct hfsmount *hfsmp, struct cnode *cp);+extern void hfs_chash_abort(struct hfsmount *hfsmp, struct cnode *cp);+extern void hfs_chash_rehash(struct hfsmount *hfsmp, struct cnode *cp1, struct cnode *cp2);+extern void hfs_chashwakeup(struct hfsmount *hfsmp, struct cnode *cp, int flags);+extern void hfs_chash_mark_in_transit(struct hfsmount *hfsmp, struct cnode *cp);++extern struct vnode * hfs_chash_getvnode(struct hfsmount *hfsmp, ino_t inum, int wantrsrc,+ int skiplock, int allow_deleted);+extern struct cnode * hfs_chash_getcnode(struct hfsmount *hfsmp, ino_t inum, struct vnode **vpp,+ int wantrsrc, int skiplock, int *out_flags, int *hflags);+extern int hfs_chash_snoop(struct hfsmount *, ino_t, int, int (*)(const cnode_t *, void *), void *);+extern int hfs_valid_cnode(struct hfsmount *hfsmp, struct vnode *dvp, struct componentname *cnp,+ cnid_t cnid, struct cat_attr *cattr, int *error);++extern int hfs_chash_set_childlinkbit(struct hfsmount *hfsmp, cnid_t cnid);++/*+ * HFS cnode lock functions.+ *+ * HFS Locking Order:+ *+ * 1. cnode truncate lock (if needed) -- see below for more on this+ *+ * + hfs_vnop_pagein/out handles recursive use of this lock (by+ * using flag option HFS_LOCK_SKIP_IF_EXCLUSIVE) although there+ * are issues with this (see #16620278).+ *+ * + If locking multiple cnodes then the truncate lock must be taken on+ * all (in address order), before taking the cnode locks.+ *+ * 2. Hot Files stage mutex (grabbed before manipulating individual vnodes/cnodes)+ *+ * 3. cnode locks in address order (if needed)+ *+ * 4. journal (if needed)+ *+ * 5. Hot Files B-Tree lock (not treated as a system file)+ *+ * 6. system files (as needed)+ *+ * A. Catalog B-tree file+ * B. Attributes B-tree file+ * C. Startup file (if there is one)+ * D. Allocation Bitmap file (always exclusive, supports recursion)+ * E. Overflow Extents B-tree file (always exclusive, supports recursion)+ *+ * 7. hfs mount point (always last)+ *+ *+ * I. HFS cnode hash lock (must not acquire any new locks while holding this lock, always taken last)+ */++/*+ * -- The Truncate Lock --+ *+ * The truncate lock is used for a few purposes (more than its name+ * might suggest). The first thing to note is that the cnode lock+ * cannot be held whilst issuing any I/O other than metadata changes,+ * so the truncate lock, in either shared or exclusive form, must+ * usually be held in these cases. This includes calls to ubc_setsize+ * where the new size is less than the current size known to the VM+ * subsystem (for two reasons: a) because reaping pages can block+ * (e.g. on pages that are busy or being cleaned); b) reaping pages+ * might require page-in for tasks that have that region mapped+ * privately). The same applies to other calls into the VM subsystem.+ *+ * Here are some (but not necessarily all) cases that the truncate+ * lock protects for:+ *+ * + When reading and writing a file, we hold the truncate lock+ * shared to ensure that the underlying blocks cannot be deleted+ * and on systems that use content protection, this also ensures+ * the keys remain valid (which might be being used by the+ * underlying layers).+ *+ * + We need to protect against the following sequence of events:+ *+ * A file is initially size X. A thread issues an append to that+ * file. Another thread truncates the file and then extends it+ * to a a new size Y. Now the append can be applied at offset X+ * and then the data is lost when the file is truncated; or it+ * could be applied after the truncate, i.e. at offset 0; or it+ * can be applied at offset Y. What we *cannot* do is apply the+ * append at offset X and for the data to be visible at the end.+ * (Note that we are free to choose when we apply the append+ * operation.)+ *+ * To solve this, we keep things simple and take the truncate lock+ * exclusively in order to sequence the append with other size+ * changes. Therefore any size change must take the truncate lock+ * exclusively.+ *+ * (N.B. we could do better and allow readers to run concurrently+ * during the append and other size changes.)+ *+ * So here are the rules:+ *+ * + If you plan to change ff_size, you must take the truncate lock+ * exclusively, *but* be careful what I/O you do whilst you have+ * the truncate lock exclusively and try and avoid it if you can:+ * if the VM subsystem tries to do something with some pages on a+ * different thread and you try and do some I/O with those same+ * pages, we will deadlock. (See #16620278.)+ *+ * + If you do anything that requires blocks to not be deleted or+ * encryption keys to remain valid, you must take the truncate lock+ * shared.+ *+ * + And it follows therefore, that if you want to delete blocks or+ * delete keys, you must take the truncate lock exclusively. Note+ * that for asynchronous writes, the truncate lock will be dropped+ * after issuing I/O but before the I/O has completed which means+ * that before manipulating keys, you *must* issue+ * vnode_wait_for_writes in addition to holding the truncate lock.+ *+ * N.B. ff_size is actually protected by the cnode lock and so you+ * must hold the cnode lock exclusively to change it and shared to+ * read it.+ *+ */++enum hfs_locktype {+ HFS_SHARED_LOCK = 1,+ HFS_EXCLUSIVE_LOCK = 2+};++/* Option flags for cnode and truncate lock functions */+enum hfs_lockflags {+ HFS_LOCK_DEFAULT = 0x0, /* Default flag, no options provided */+ HFS_LOCK_ALLOW_NOEXISTS = 0x1, /* Allow locking of all cnodes, including cnode marked deleted with no catalog entry */+ HFS_LOCK_SKIP_IF_EXCLUSIVE = 0x2, /* Skip locking if the current thread already holds the lock exclusive */++ // Used when you do not want to check return from hfs_lock+ HFS_LOCK_ALWAYS = HFS_LOCK_ALLOW_NOEXISTS,+};+#define HFS_SHARED_OWNER (void *)0xffffffff++void hfs_lock_always(cnode_t *cnode, enum hfs_locktype);+int hfs_lock(struct cnode *, enum hfs_locktype, enum hfs_lockflags);+bool hfs_lock_upgrade(cnode_t *cp);+int hfs_lockpair(struct cnode *, struct cnode *, enum hfs_locktype);+int hfs_lockfour(struct cnode *, struct cnode *, struct cnode *, struct cnode *,+ enum hfs_locktype, struct cnode **);+void hfs_unlock(struct cnode *);+void hfs_unlockpair(struct cnode *, struct cnode *);+void hfs_unlockfour(struct cnode *, struct cnode *, struct cnode *, struct cnode *);++void hfs_lock_truncate(struct cnode *, enum hfs_locktype, enum hfs_lockflags);+bool hfs_truncate_lock_upgrade(struct cnode *cp);+void hfs_truncate_lock_downgrade(struct cnode *cp);+void hfs_unlock_truncate(struct cnode *, enum hfs_lockflags);+int hfs_try_trunclock(struct cnode *, enum hfs_locktype, enum hfs_lockflags);++extern int hfs_systemfile_lock(struct hfsmount *, int, enum hfs_locktype);+extern void hfs_systemfile_unlock(struct hfsmount *, int);++void hfs_clear_might_be_dirty_flag(cnode_t *cp);++int hfs_set_bsd_flags(struct hfsmount *, struct cnode *,+ u_int32_t, u_int32_t, vfs_context_t, int *);+bool hfs_is_journal_file(struct hfsmount *, struct cnode *);++// cnode must be locked+static inline __attribute__((pure))+bool hfs_has_rsrc(const cnode_t *cp)+{+ if (cp->c_rsrcfork)+ return cp->c_rsrcfork->ff_blocks > 0;+ else+ return cp->c_datafork && cp->c_blocks > cp->c_datafork->ff_blocks;+}++#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */++#endif /* ! _HFS_CNODE_H_ */diff --git a/xnu/files/bsd/hfs/hfs_cprotect.c b/xnu/files/bsd/hfs/hfs_cprotect.cnew file mode 100644index 0000000..1e2f28f--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_cprotect.c@@ -0,0 +1,2789 @@+/*+ * Copyright (c) 2000-2015 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 CONFIG_PROTECT++#include <sys/mount.h>+#include <sys/random.h>+#include <sys/xattr.h>+#include <sys/vnode_if.h>+#include <sys/fcntl.h>+#include <libkern/OSByteOrder.h>+#include <libkern/crypto/sha1.h>+#include <sys/proc.h>+#include <sys/kauth.h>+#include <sys/sysctl.h>+#include <sys/ubc.h>+#include <uuid/uuid.h>++#include "hfs.h"+#include "hfs_cnode.h"+#include "hfs_fsctl.h"+#include "hfs_cprotect.h"+#include "hfs_iokit.h"++#if HFS_CONFIG_KEY_ROLL+#include "hfs_key_roll.h"+#endif++#define PTR_ADD(type, base, offset) (type)((uintptr_t)(base) + (offset))++extern int (**hfs_vnodeop_p) (void *);++/*+ * CP private functions+ */+static int cp_root_major_vers(mount_t mp);+static int cp_getxattr(cnode_t *, struct hfsmount *hfsmp, struct cprotect **);+static void cp_entry_dealloc(hfsmount_t *hfsmp, struct cprotect *entry);+static int cp_restore_keys(struct cprotect *, struct hfsmount *hfsmp, struct cnode *);+static int cp_lock_vnode_callback(vnode_t, void *);+static int cp_vnode_is_eligible (vnode_t);+static int cp_check_access (cnode_t *cp, struct hfsmount *hfsmp, int vnop);+static int cp_unwrap(struct hfsmount *, struct cprotect *, struct cnode *);+static void cp_init_access(aks_cred_t access, struct cnode *cp);++// -- cp_key_pair accessors --++void cpkp_init(cp_key_pair_t *cpkp, uint16_t max_pers_key_len,+ uint16_t max_cached_key_len)+{+ cpkp->cpkp_max_pers_key_len = max_pers_key_len;+ cpkp->cpkp_pers_key_len = 0;++ cpx_t embedded_cpx = cpkp_cpx(cpkp);+ /* XNU requires us to allocate the AES context separately */+ cpx_alloc_ctx (embedded_cpx);++ cpx_init(cpkp_cpx(cpkp), max_cached_key_len);++ // Default to using offsets+ cpx_set_use_offset_for_iv(cpkp_cpx(cpkp), true);+}++uint16_t cpkp_max_pers_key_len(const cp_key_pair_t *cpkp)+{+ return cpkp->cpkp_max_pers_key_len;+}++uint16_t cpkp_pers_key_len(const cp_key_pair_t *cpkp)+{+ return cpkp->cpkp_pers_key_len;+}++static bool cpkp_has_pers_key(const cp_key_pair_t *cpkp)+{+ return cpkp->cpkp_pers_key_len > 0;+}++static void *cpkp_pers_key(const cp_key_pair_t *cpkp)+{+ return PTR_ADD(void *, &cpkp->cpkp_cpx, cpx_sizex(cpkp_cpx(cpkp)));+}++static void cpkp_set_pers_key_len(cp_key_pair_t *cpkp, uint16_t key_len)+{+ if (key_len > cpkp->cpkp_max_pers_key_len)+ panic("hfs_cprotect: key too big!");+ cpkp->cpkp_pers_key_len = key_len;+}++#pragma clang diagnostic push+#pragma clang diagnostic ignored "-Wcast-qual"+cpx_t cpkp_cpx(const cp_key_pair_t *cpkp)+{+ // Cast to remove const qualifier+ return (cpx_t)&cpkp->cpkp_cpx;+}+#pragma clang diagnostic pop++size_t cpkp_size(uint16_t pers_key_len, uint16_t cached_key_len)+{+ return sizeof(cp_key_pair_t) + pers_key_len + cpx_size(cached_key_len);+}++size_t cpkp_sizex(const cp_key_pair_t *cpkp)+{+ return cpkp_size(cpkp->cpkp_max_pers_key_len, cpx_max_key_len(cpkp_cpx(cpkp)));+}++void cpkp_flush(cp_key_pair_t *cpkp)+{+ cpx_flush(cpkp_cpx(cpkp));+ cpkp->cpkp_pers_key_len = 0;+ bzero(cpkp_pers_key(cpkp), cpkp->cpkp_max_pers_key_len);+}++bool cpkp_can_copy(const cp_key_pair_t *src, const cp_key_pair_t *dst)+{+ return (cpkp_pers_key_len(src) <= dst->cpkp_max_pers_key_len+ && cpx_can_copy(cpkp_cpx(src), cpkp_cpx(dst)));+}++void cpkp_copy(const cp_key_pair_t *src, cp_key_pair_t *dst)+{+ const uint16_t key_len = cpkp_pers_key_len(src);+ cpkp_set_pers_key_len(dst, key_len);+ memcpy(cpkp_pers_key(dst), cpkp_pers_key(src), key_len);+ cpx_copy(cpkp_cpx(src), cpkp_cpx(dst));+}++// --++bool cp_is_supported_version(uint16_t vers)+{+ return vers == CP_VERS_4 || vers == CP_VERS_5;+}++/*+ * Return the appropriate key and, if requested, the physical offset and+ * maximum length for a particular I/O operation.+ */+void cp_io_params(__unused hfsmount_t *hfsmp, cprotect_t cpr,+ __unused off_rsrc_t off_rsrc,+ __unused int direction, cp_io_params_t *io_params)+{+#if HFS_CONFIG_KEY_ROLL+ hfs_cp_key_roll_ctx_t *ckr = cpr->cp_key_roll_ctx;++ if (ckr && off_rsrc < ckr->ckr_off_rsrc) {+ /*+ * When we're in the process of rolling an extent, ckr_off_rsrc will+ * indicate the end of the extent.+ */+ const off_rsrc_t roll_loc = ckr->ckr_off_rsrc+ - hfs_blk_to_bytes(ckr->ckr_roll_extent.blockCount,+ hfsmp->blockSize);++ if (off_rsrc < roll_loc) {+ io_params->max_len = roll_loc - off_rsrc;+ io_params->phys_offset = -1;+ } else {+ /*+ * We should never get reads to the extent we're rolling+ * because the pages should be locked in the UBC. If we+ * did get reads it's not obvious what the right thing to+ * do is either: we could read from the old location, but+ * we might have written later data to the new location,+ * or we could read from the new location, but data might+ * not have been written there yet.+ *+ * Note that whilst raw encrypted reads don't lock any+ * pages, or take a cluster_read_direct lock, the call to+ * hfs_key_roll_up_to in hfs_vnop_read will have ensured+ * that the file has been rolled beyond the offset being+ * read so this path should never be taken in that case.+ */+ hfs_assert(direction == VNODE_WRITE);++ // For release builds, just in case...+ if (direction == VNODE_READ) {+ // Use the old key and offset+ goto old_key;+ }++ io_params->max_len = ckr->ckr_off_rsrc - off_rsrc;+ io_params->phys_offset = hfs_blk_to_bytes(ckr->ckr_roll_extent.startBlock,+ hfsmp->blockSize) + off_rsrc - roll_loc;+ }++ // Use new key+ io_params->cpx = cpkp_cpx(ckr->ckr_keys);+ return;+ }+old_key:+ // Use old key...+#endif++ io_params->max_len = INT64_MAX;+ io_params->phys_offset = -1;+ io_params->cpx = cpkp_cpx(cpr->cp_keys);+}++static void cp_flush_cached_keys(cprotect_t cpr)+{+ cpx_flush(cpkp_cpx(cpr->cp_keys));+#if HFS_CONFIG_KEY_ROLL+ if (cpr->cp_key_roll_ctx)+ cpx_flush(cpkp_cpx(cpr->cp_key_roll_ctx->ckr_keys));+#endif+}++static bool cp_needs_pers_key(cprotect_t cpr)+{+ if (CP_CLASS(cpr->cp_pclass) == PROTECTION_CLASS_F)+ return !cpx_has_key(cpkp_cpx(cpr->cp_keys));+ else+ return !cpkp_has_pers_key(cpr->cp_keys);+}++static cp_key_revision_t cp_initial_key_revision(__unused hfsmount_t *hfsmp)+{+ return 1;+}++cp_key_revision_t cp_next_key_revision(cp_key_revision_t rev)+{+ rev = (rev + 0x0100) ^ (mach_absolute_time() & 0xff);+ if (!rev)+ rev = 1;+ return rev;+}++/*+ * Allocate and initialize a cprotect blob for a new cnode.+ * Called from hfs_getnewvnode: cnode is locked exclusive.+ *+ * Read xattr data off the cnode. Then, if conditions permit,+ * unwrap the file key and cache it in the cprotect blob.+ */+int+cp_entry_init(struct cnode *cp, struct mount *mp)+{+ struct cprotect *entry = NULL;+ int error = 0;+ struct hfsmount *hfsmp = VFSTOHFS(mp);++ /*+ * The cnode should be locked at this point, regardless of whether or not+ * we are creating a new item in the namespace or vending a vnode on behalf+ * of lookup. The only time we tell getnewvnode to skip the lock is when+ * constructing a resource fork vnode. But a resource fork vnode must come+ * after the regular data fork cnode has already been constructed.+ */+ if (!cp_fs_protected (mp)) {+ cp->c_cpentry = NULL;+ return 0;+ }++ if (!S_ISREG(cp->c_mode) && !S_ISDIR(cp->c_mode)) {+ cp->c_cpentry = NULL;+ return 0;+ }++ if (hfsmp->hfs_running_cp_major_vers == 0) {+ panic ("hfs cp: no running mount point version! ");+ }++ hfs_assert(cp->c_cpentry == NULL);++ error = cp_getxattr(cp, hfsmp, &entry);+ if (error == ENOATTR) {+ /*+ * Normally, we should always have a CP EA for a file or directory that+ * we are initializing here. However, there are some extenuating circumstances,+ * such as the root directory immediately following a newfs_hfs.+ *+ * As a result, we leave code here to deal with an ENOATTR which will always+ * default to a 'D/NONE' key, though we don't expect to use it much.+ */+ cp_key_class_t target_class = PROTECTION_CLASS_D;++ if (S_ISDIR(cp->c_mode)) {+ target_class = PROTECTION_CLASS_DIR_NONE;+ }++ cp_key_revision_t key_revision = cp_initial_key_revision(hfsmp);++ /* allow keybag to override our class preferences */+ error = cp_new (&target_class, hfsmp, cp, cp->c_mode, CP_KEYWRAP_DIFFCLASS,+ key_revision, (cp_new_alloc_fn)cp_entry_alloc, (void **)&entry);+ if (error == 0) {+ entry->cp_pclass = target_class;+ entry->cp_key_os_version = cp_os_version();+ entry->cp_key_revision = key_revision;+ error = cp_setxattr (cp, entry, hfsmp, cp->c_fileid, XATTR_CREATE);+ }+ }++ /*+ * Bail out if:+ * a) error was not ENOATTR (we got something bad from the getxattr call)+ * b) we encountered an error setting the xattr above.+ * c) we failed to generate a new cprotect data structure.+ */+ if (error) {+ goto out;+ }++ cp->c_cpentry = entry;++out:+ if (error == 0) {+ entry->cp_backing_cnode = cp;+ }+ else {+ if (entry) {+ cp_entry_destroy(hfsmp, entry);+ }+ cp->c_cpentry = NULL;+ }++ return error;+}++/*+ * cp_setup_newentry+ *+ * Generate a keyless cprotect structure for use with the new AppleKeyStore kext.+ * Since the kext is now responsible for vending us both wrapped/unwrapped keys+ * we need to create a keyless xattr upon file / directory creation. When we have the inode value+ * and the file/directory is established, then we can ask it to generate keys. Note that+ * this introduces a potential race; If the device is locked and the wrapping+ * keys are purged between the time we call this function and the time we ask it to generate+ * keys for us, we could have to fail the open(2) call and back out the entry.+ */++int cp_setup_newentry (struct hfsmount *hfsmp, struct cnode *dcp,+ cp_key_class_t suppliedclass, mode_t cmode,+ struct cprotect **tmpentry)+{+ int isdir = 0;+ struct cprotect *entry = NULL;+ uint32_t target_class = hfsmp->default_cp_class;+ suppliedclass = CP_CLASS(suppliedclass);++ if (hfsmp->hfs_running_cp_major_vers == 0) {+ panic ("CP: major vers not set in mount!");+ }++ if (S_ISDIR (cmode)) {+ isdir = 1;+ }++ /* Decide the target class. Input argument takes priority. */+ if (cp_is_valid_class (isdir, suppliedclass)) {+ /* caller supplies -1 if it was not specified so we will default to the mount point value */+ target_class = suppliedclass;+ /*+ * One exception, F is never valid for a directory+ * because its children may inherit and userland will be+ * unable to read/write to the files.+ */+ if (isdir) {+ if (target_class == PROTECTION_CLASS_F) {+ *tmpentry = NULL;+ return EINVAL;+ }+ }+ }+ else {+ /*+ * If no valid class was supplied, behave differently depending on whether or not+ * the item being created is a file or directory.+ *+ * for FILE:+ * If parent directory has a non-zero class, use that.+ * If parent directory has a zero class (not set), then attempt to+ * apply the mount point default.+ *+ * for DIRECTORY:+ * Directories always inherit from the parent; if the parent+ * has a NONE class set, then we can continue to use that.+ */+ if ((dcp) && (dcp->c_cpentry)) {+ uint32_t parentclass = CP_CLASS(dcp->c_cpentry->cp_pclass);+ /* If the parent class is not valid, default to the mount point value */+ if (cp_is_valid_class(1, parentclass)) {+ if (isdir) {+ target_class = parentclass;+ }+ else if (parentclass != PROTECTION_CLASS_DIR_NONE) {+ /* files can inherit so long as it's not NONE */+ target_class = parentclass;+ }+ }+ /* Otherwise, we already defaulted to the mount point's default */+ }+ }++ /* Generate the cprotect to vend out */+ entry = cp_entry_alloc(NULL, 0, 0, NULL);+ if (entry == NULL) {+ *tmpentry = NULL;+ return ENOMEM;+ }++ /*+ * We don't have keys yet, so fill in what we can. At this point+ * this blob has no keys and it has no backing xattr. We just know the+ * target class.+ */+ entry->cp_flags = CP_NO_XATTR;+ /* Note this is only the effective class */+ entry->cp_pclass = target_class;+ *tmpentry = entry;++ return 0;+}++/*+ * Set up an initial key/class pair for a disassociated cprotect entry.+ * This function is used to generate transient keys that will never be+ * written to disk. We use class F for this since it provides the exact+ * semantics that are needed here. Because we never attach this blob to+ * a cnode directly, we take a pointer to the cprotect struct.+ *+ * This function is primarily used in the HFS FS truncation codepath+ * where we may rely on AES symmetry to relocate encrypted data from+ * one spot in the disk to another.+ */+int cpx_gentempkeys(cpx_t *pcpx, __unused struct hfsmount *hfsmp)+{+ cpx_t cpx = cpx_alloc(CP_MAX_KEYSIZE, true);++ cpx_set_key_len(cpx, CP_MAX_KEYSIZE);+ read_random(cpx_key(cpx), CP_MAX_KEYSIZE);+ cpx_set_use_offset_for_iv(cpx, true);++ *pcpx = cpx;++ return 0;+}++/*+ * Tear down and clear a cprotect blob for a closing file.+ * Called at hfs_reclaim_cnode: cnode is locked exclusive.+ */+void+cp_entry_destroy(hfsmount_t *hfsmp, struct cprotect *entry_ptr)+{+ if (entry_ptr == NULL) {+ /* nothing to clean up */+ return;+ }+ cp_entry_dealloc(hfsmp, entry_ptr);+}+++int+cp_fs_protected (mount_t mnt)+{+ return (vfs_flags(mnt) & MNT_CPROTECT);+}+++/*+ * Return a pointer to underlying cnode if there is one for this vnode.+ * Done without taking cnode lock, inspecting only vnode state.+ */+struct cnode *+cp_get_protected_cnode(struct vnode *vp)+{+ if (!cp_vnode_is_eligible(vp)) {+ return NULL;+ }++ if (!cp_fs_protected(VTOVFS(vp))) {+ /* mount point doesn't support it */+ return NULL;+ }++ return vnode_fsnode(vp);+}+++/*+ * Sets *class to persistent class associated with vnode,+ * or returns error.+ */+int+cp_vnode_getclass(struct vnode *vp, cp_key_class_t *class)+{+ struct cprotect *entry;+ int error = 0;+ struct cnode *cp;+ int took_truncate_lock = 0;+ struct hfsmount *hfsmp = NULL;++ /* Is this an interesting vp? */+ if (!cp_vnode_is_eligible (vp)) {+ return EBADF;+ }++ /* Is the mount point formatted for content protection? */+ if (!cp_fs_protected(VTOVFS(vp))) {+ return ENOTSUP;+ }++ cp = VTOC(vp);+ hfsmp = VTOHFS(vp);++ /*+ * Take the truncate lock up-front in shared mode because we may need+ * to manipulate the CP blob. Pend lock events until we're done here.+ */+ hfs_lock_truncate (cp, HFS_SHARED_LOCK, HFS_LOCK_DEFAULT);+ took_truncate_lock = 1;++ /*+ * We take only the shared cnode lock up-front. If it turns out that+ * we need to manipulate the CP blob to write a key out, drop the+ * shared cnode lock and acquire an exclusive lock.+ */+ error = hfs_lock(cp, HFS_SHARED_LOCK, HFS_LOCK_DEFAULT);+ if (error) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ return error;+ }++ /* pull the class from the live entry */+ entry = cp->c_cpentry;++ if (entry == NULL) {+ panic("Content Protection: uninitialized cnode %p", cp);+ }++ /* Note that we may not have keys yet, but we know the target class. */++ if (error == 0) {+ *class = CP_CLASS(entry->cp_pclass);+ }++ if (took_truncate_lock) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ }++ hfs_unlock(cp);+ return error;+}++/*+ * Sets persistent class for this file or directory.+ * If vnode cannot be protected (system file, non-regular file, non-hfs), EBADF.+ * If the new class can't be accessed now, EPERM.+ * Otherwise, record class and re-wrap key if the mount point is content-protected.+ */+int+cp_vnode_setclass(struct vnode *vp, cp_key_class_t newclass)+{+ struct cnode *cp;+ struct cprotect *entry = 0;+ int error = 0;+ int took_truncate_lock = 0;+ struct hfsmount *hfsmp = NULL;+ int isdir = 0;++ if (vnode_isdir (vp)) {+ isdir = 1;+ }++ /* Ensure we only use the effective class here */+ newclass = CP_CLASS(newclass);++ if (!cp_is_valid_class(isdir, newclass)) {+ printf("hfs: CP: cp_setclass called with invalid class %d\n", newclass);+ return EINVAL;+ }++ /* Is this an interesting vp? */+ if (!cp_vnode_is_eligible(vp)) {+ return EBADF;+ }++ /* Is the mount point formatted for content protection? */+ if (!cp_fs_protected(VTOVFS(vp))) {+ return ENOTSUP;+ }++ hfsmp = VTOHFS(vp);+ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return EROFS;+ }++ /*+ * Take the cnode truncate lock exclusive because we want to manipulate the+ * CP blob. The lock-event handling code is doing the same. This also forces+ * all pending IOs to drain before we can re-write the persistent and cache keys.+ */+ cp = VTOC(vp);+ hfs_lock_truncate (cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ took_truncate_lock = 1;++ /*+ * The truncate lock is not sufficient to guarantee the CP blob+ * isn't being used. We must wait for existing writes to finish.+ */+ vnode_waitforwrites(vp, 0, 0, 0, "cp_vnode_setclass");++ if (hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT)) {+ return EINVAL;+ }++ entry = cp->c_cpentry;+ if (entry == NULL) {+ error = EINVAL;+ goto out;+ }++ /*+ * re-wrap per-file key with new class.+ * Generate an entirely new key if switching to F.+ */+ if (vnode_isreg(vp)) {+ /*+ * The vnode is a file. Before proceeding with the re-wrap, we need+ * to unwrap the keys before proceeding. This is to ensure that+ * the destination class's properties still work appropriately for the+ * target class (since B allows I/O but an unwrap prior to the next unlock+ * will not be allowed).+ */+ if (!cpx_has_key(cpkp_cpx(entry->cp_keys))) {+ error = cp_restore_keys (entry, hfsmp, cp);+ if (error) {+ goto out;+ }+ }++ if (newclass == PROTECTION_CLASS_F) {+ /* Verify that file is blockless if switching to class F */+ if (cp->c_datafork->ff_size > 0) {+ error = EINVAL;+ goto out;+ }++ cp_key_pair_t *cpkp = NULL;+ cprotect_t new_entry = cp_entry_alloc(NULL, 0, CP_MAX_KEYSIZE, &cpkp);++ if (!new_entry) {+ error = ENOMEM;+ goto out;+ }++ /* newclass is only the effective class */+ new_entry->cp_pclass = newclass;+ new_entry->cp_key_os_version = cp_os_version();+ new_entry->cp_key_revision = cp_next_key_revision(entry->cp_key_revision);++ cpx_t cpx = cpkp_cpx(cpkp);++ /* Class F files are not wrapped, so they continue to use MAX_KEYSIZE */+ cpx_set_key_len(cpx, CP_MAX_KEYSIZE);+ read_random (cpx_key(cpx), CP_MAX_KEYSIZE);++ cp_replace_entry(hfsmp, cp, new_entry);++ error = 0;+ goto out;+ }++ /* Deny the setclass if file is to be moved from F to something else */+ if (entry->cp_pclass == PROTECTION_CLASS_F) {+ error = EPERM;+ goto out;+ }++ if (!cpkp_has_pers_key(entry->cp_keys)) {+ struct cprotect *new_entry = NULL;+ /*+ * We want to fail if we can't wrap to the target class. By not setting+ * CP_KEYWRAP_DIFFCLASS, we tell keygeneration that if it can't wrap+ * to 'newclass' then error out.+ */+ uint32_t flags = 0;+ error = cp_generate_keys (hfsmp, cp, newclass, flags, &new_entry);+ if (error == 0) {+ cp_replace_entry (hfsmp, cp, new_entry);+ }+ /* Bypass the setxattr code below since generate_keys does it for us */+ goto out;+ }++ cprotect_t new_entry;+ error = cp_rewrap(cp, hfsmp, &newclass, entry->cp_keys, entry,+ (cp_new_alloc_fn)cp_entry_alloc, (void **)&new_entry);+ if (error) {+ /* we didn't have perms to set this class. leave file as-is and error out */+ goto out;+ }++#if HFS_CONFIG_KEY_ROLL+ hfs_cp_key_roll_ctx_t *new_key_roll_ctx = NULL;+ if (entry->cp_key_roll_ctx) {+ error = cp_rewrap(cp, hfsmp, &newclass, entry->cp_key_roll_ctx->ckr_keys,+ entry->cp_key_roll_ctx,+ (cp_new_alloc_fn)hfs_key_roll_ctx_alloc,+ (void **)&new_key_roll_ctx);++ if (error) {+ cp_entry_dealloc(hfsmp, new_entry);+ goto out;+ }++ new_entry->cp_key_roll_ctx = new_key_roll_ctx;+ }+#endif++ new_entry->cp_pclass = newclass;++ cp_replace_entry(hfsmp, cp, new_entry);+ entry = new_entry;+ }+ else if (vnode_isdir(vp)) {+ /* For directories, just update the pclass. newclass is only effective class */+ entry->cp_pclass = newclass;+ error = 0;+ }+ else {+ /* anything else, just error out */+ error = EINVAL;+ goto out;+ }++ /*+ * We get here if the new class was F, or if we were re-wrapping a cprotect that already+ * existed. If the keys were never generated, then they'll skip the setxattr calls.+ */++ error = cp_setxattr(cp, cp->c_cpentry, VTOHFS(vp), 0, XATTR_REPLACE);+ if (error == ENOATTR) {+ error = cp_setxattr(cp, cp->c_cpentry, VTOHFS(vp), 0, XATTR_CREATE);+ }++out:++ if (took_truncate_lock) {+ hfs_unlock_truncate (cp, HFS_LOCK_DEFAULT);+ }+ hfs_unlock(cp);+ return error;+}+++int cp_vnode_transcode(vnode_t vp, cp_key_t *k)+{+ struct cnode *cp;+ struct cprotect *entry = 0;+ int error = 0;+ int took_truncate_lock = 0;+ struct hfsmount *hfsmp = NULL;++ /* Structures passed between HFS and AKS */+ struct aks_cred_s access_in;+ struct aks_wrapped_key_s wrapped_key_in, wrapped_key_out;++ /* Is this an interesting vp? */+ if (!cp_vnode_is_eligible(vp)) {+ return EBADF;+ }++ /* Is the mount point formatted for content protection? */+ if (!cp_fs_protected(VTOVFS(vp))) {+ return ENOTSUP;+ }++ cp = VTOC(vp);+ hfsmp = VTOHFS(vp);++ /*+ * Take the cnode truncate lock exclusive because we want to manipulate the+ * CP blob. The lock-event handling code is doing the same. This also forces+ * all pending IOs to drain before we can re-write the persistent and cache keys.+ */+ hfs_lock_truncate (cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ took_truncate_lock = 1;++ if (hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT)) {+ return EINVAL;+ }++ entry = cp->c_cpentry;+ if (entry == NULL) {+ error = EINVAL;+ goto out;+ }++ /* Send the per-file key in wrapped form for re-wrap with the current class information+ * Send NULLs in the output parameters of the wrapper() and AKS will do the rest.+ * Don't need to process any outputs, so just clear the locks and pass along the error. */+ if (vnode_isreg(vp)) {++ /* Picked up the following from cp_wrap().+ * If needed, more comments available there. */++ if (CP_CLASS(entry->cp_pclass) == PROTECTION_CLASS_F) {+ error = EINVAL;+ goto out;+ }++ cp_init_access(&access_in, cp);++ bzero(&wrapped_key_in, sizeof(wrapped_key_in));+ bzero(&wrapped_key_out, sizeof(wrapped_key_out));++ cp_key_pair_t *cpkp = entry->cp_keys;++#if HFS_CONFIG_KEY_ROLL+ if (entry->cp_key_roll_ctx)+ cpkp = entry->cp_key_roll_ctx->ckr_keys;+#endif++ wrapped_key_in.key = cpkp_pers_key(cpkp);+ wrapped_key_in.key_len = cpkp_pers_key_len(cpkp);++ if (!wrapped_key_in.key_len) {+ error = EINVAL;+ goto out;+ }++ /* Use the actual persistent class when talking to AKS */+ wrapped_key_in.dp_class = entry->cp_pclass;+ wrapped_key_out.key = k->key;+ wrapped_key_out.key_len = k->len;++ error = hfs_backup_key(&access_in,+ &wrapped_key_in,+ &wrapped_key_out);++ if(error)+ error = EPERM;+ else+ k->len = wrapped_key_out.key_len;+ }++out:+ if (took_truncate_lock) {+ hfs_unlock_truncate (cp, HFS_LOCK_DEFAULT);+ }+ hfs_unlock(cp);+ return error;+}+++/*+ * Check permission for the given operation (read, write) on this node.+ * Additionally, if the node needs work, do it:+ * - create a new key for the file if one hasn't been set before+ * - write out the xattr if it hasn't already been saved+ * - unwrap the key if needed+ *+ * Takes cnode lock, and upgrades to exclusive if modifying cprotect.+ *+ * Note that this function does *NOT* take the cnode truncate lock. This is because+ * the thread calling us may already have the truncate lock. It is not necessary+ * because either we successfully finish this function before the keys are tossed+ * and the IO will fail, or the keys are tossed and then this function will fail.+ * Either way, the cnode lock still ultimately guards the keys. We only rely on the+ * truncate lock to protect us against tossing the keys as a cluster call is in-flight.+ */+int+cp_handle_vnop(struct vnode *vp, int vnop, int ioflag)+{+ struct cprotect *entry;+ int error = 0;+ struct hfsmount *hfsmp = NULL;+ struct cnode *cp = NULL;++ /*+ * First, do validation against the vnode before proceeding any further:+ * Is this vnode originating from a valid content-protected filesystem ?+ */+ if (cp_vnode_is_eligible(vp) == 0) {+ /*+ * It is either not HFS or not a file/dir. Just return success. This is a valid+ * case if servicing i/o against another filesystem type from VFS+ */+ return 0;+ }++ if (cp_fs_protected (VTOVFS(vp)) == 0) {+ /*+ * The underlying filesystem does not support content protection. This is also+ * a valid case. Simply return success.+ */+ return 0;+ }++ /*+ * At this point, we know we have a HFS vnode that backs a file or directory on a+ * filesystem that supports content protection+ */+ cp = VTOC(vp);++ if ((error = hfs_lock(cp, HFS_SHARED_LOCK, HFS_LOCK_DEFAULT))) {+ return error;+ }++ entry = cp->c_cpentry;++ if (entry == NULL) {+ /*+ * If this cnode is not content protected, simply return success.+ * Note that this function is called by all I/O-based call sites+ * when CONFIG_PROTECT is enabled during XNU building.+ */++ /*+ * All files should have cprotect structs. It's possible to encounter+ * a directory from a V2.0 CP system but all files should have protection+ * EAs+ */+ if (vnode_isreg(vp)) {+ error = EPERM;+ }++ goto out;+ }++ vp = CTOV(cp, 0);+ if (vp == NULL) {+ /* is it a rsrc */+ vp = CTOV(cp,1);+ if (vp == NULL) {+ error = EINVAL;+ goto out;+ }+ }+ hfsmp = VTOHFS(vp);++ if ((error = cp_check_access(cp, hfsmp, vnop))) {+ /* check for raw encrypted access before bailing out */+ if ((ioflag & IO_ENCRYPTED)+#if HFS_CONFIG_KEY_ROLL+ // If we're rolling, we need the keys+ && !hfs_is_key_rolling(cp)+#endif+ && (vnop == CP_READ_ACCESS)) {+ /*+ * read access only + asking for the raw encrypted bytes+ * is legitimate, so reset the error value to 0+ */+ error = 0;+ }+ else {+ goto out;+ }+ }++ if (!ISSET(entry->cp_flags, CP_NO_XATTR)) {+ if (!S_ISREG(cp->c_mode))+ goto out;++ // If we have a persistent key and the cached key, we're done+ if (!cp_needs_pers_key(entry)+ && cpx_has_key(cpkp_cpx(entry->cp_keys))) {+ goto out;+ }+ }++ /* upgrade to exclusive lock */+ if (lck_rw_lock_shared_to_exclusive(&cp->c_rwlock) == FALSE) {+ if ((error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ return error;+ }+ } else {+ cp->c_lockowner = current_thread();+ }++ /* generate new keys if none have ever been saved */+ if (cp_needs_pers_key(entry)) {+ struct cprotect *newentry = NULL;+ /*+ * It's ok if this ends up being wrapped in a different class than 'pclass'.+ * class modification is OK here.+ */+ uint32_t flags = CP_KEYWRAP_DIFFCLASS;++ error = cp_generate_keys (hfsmp, cp, CP_CLASS(cp->c_cpentry->cp_pclass), flags, &newentry);+ if (error == 0) {+ cp_replace_entry (hfsmp, cp, newentry);+ entry = newentry;+ }+ else {+ goto out;+ }+ }++ /* unwrap keys if needed */+ if (!cpx_has_key(cpkp_cpx(entry->cp_keys))) {+ if ((vnop == CP_READ_ACCESS) && (ioflag & IO_ENCRYPTED)) {+ /* no need to try to restore keys; they are not going to be used */+ error = 0;+ }+ else {+ error = cp_restore_keys(entry, hfsmp, cp);+ if (error) {+ goto out;+ }+ }+ }++ /* write out the xattr if it's new */+ if (entry->cp_flags & CP_NO_XATTR)+ error = cp_setxattr(cp, entry, VTOHFS(cp->c_vp), 0, XATTR_CREATE);++out:++ hfs_unlock(cp);+ return error;+}++#if HFS_TMPDBG+#if !SECURE_KERNEL+static void cp_log_eperm (struct vnode* vp, int pclass, boolean_t create) {+ char procname[256] = {};+ const char *fname = "unknown";+ const char *dbgop = "open";++ int ppid = proc_selfpid();+ /* selfname does a strlcpy so we're OK */+ proc_selfname(procname, sizeof(procname));+ if (vp && vp->v_name) {+ /* steal from the namecache */+ fname = vp->v_name;+ }++ if (create) {+ dbgop = "create";+ }++ printf("proc %s (pid %d) class %d, op: %s failure @ file %s\n", procname, ppid, pclass, dbgop, fname);+}+#endif+#endif+++int+cp_handle_open(struct vnode *vp, int mode)+{+ struct cnode *cp = NULL ;+ struct cprotect *entry = NULL;+ struct hfsmount *hfsmp;+ int error = 0;++ /* If vnode not eligible, just return success */+ if (!cp_vnode_is_eligible(vp)) {+ return 0;+ }++ /* If mount point not properly set up, then also return success */+ if (!cp_fs_protected(VTOVFS(vp))) {+ return 0;+ }++ cp = VTOC(vp);++ // Allow if raw encrypted mode requested+ if (ISSET(mode, FENCRYPTED)) {+#if HFS_CONFIG_KEY_ROLL+ // If we're rolling, we need the keys+ hfs_lock_always(cp, HFS_SHARED_LOCK);+ bool rolling = hfs_is_key_rolling(cp);+ hfs_unlock(cp);+ if (!rolling)+ return 0;+#else+ return 0;+#endif+ }+ if (ISSET(mode, FUNENCRYPTED)) {+ return 0;+ }++ /* We know the vnode is in a valid state. Acquire cnode and validate */+ hfsmp = VTOHFS(vp);++ if ((error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ return error;+ }++ entry = cp->c_cpentry;+ if (entry == NULL) {+ /*+ * If the mount is protected and we couldn't get a cprotect for this vnode,+ * then it's not valid for opening.+ */+ if (vnode_isreg(vp)) {+ error = EPERM;+ }+ goto out;+ }++ if (!S_ISREG(cp->c_mode))+ goto out;++ /*+ * Does the cnode have keys yet? If not, then generate them.+ */+ if (cp_needs_pers_key(entry)) {+ struct cprotect *newentry = NULL;+ /* Allow the keybag to override our class preferences */+ uint32_t flags = CP_KEYWRAP_DIFFCLASS;+ error = cp_generate_keys (hfsmp, cp, CP_CLASS(cp->c_cpentry->cp_pclass), flags, &newentry);+ if (error == 0) {+ cp_replace_entry (hfsmp, cp, newentry);+ entry = newentry;+ }+ else {+ goto out;+ }+ }++ /*+ * We want to minimize the number of unwraps that we'll have to do since+ * the cost can vary, depending on the platform we're running.+ */+ switch (CP_CLASS(entry->cp_pclass)) {+ case PROTECTION_CLASS_B:+ if (mode & O_CREAT) {+ /*+ * Class B always allows creation. Since O_CREAT was passed through+ * we infer that this was a newly created vnode/cnode. Even though a potential+ * race exists when multiple threads attempt to create/open a particular+ * file, only one can "win" and actually create it. VFS will unset the+ * O_CREAT bit on the loser.+ *+ * Note that skipping the unwrap check here is not a security issue --+ * we have to unwrap the key permanently upon the first I/O.+ */+ break;+ }++ if (cpx_has_key(cpkp_cpx(entry->cp_keys)) && !ISSET(mode, FENCRYPTED)) {+ /*+ * For a class B file, attempt the unwrap if we have the key in+ * core already.+ * The device could have just transitioned into the lock state, and+ * this vnode may not yet have been purged from the vnode cache (which would+ * remove the keys).+ */+ struct aks_cred_s access_in;+ struct aks_wrapped_key_s wrapped_key_in;++ cp_init_access(&access_in, cp);+ bzero(&wrapped_key_in, sizeof(wrapped_key_in));+ wrapped_key_in.key = cpkp_pers_key(entry->cp_keys);+ wrapped_key_in.key_len = cpkp_pers_key_len(entry->cp_keys);+ /* Use the persistent class when talking to AKS */+ wrapped_key_in.dp_class = entry->cp_pclass;+ error = hfs_unwrap_key(&access_in, &wrapped_key_in, NULL);+ if (error) {+ error = EPERM;+ }+ break;+ }+ /* otherwise, fall through to attempt the unwrap/restore */+ case PROTECTION_CLASS_A:+ case PROTECTION_CLASS_C:+ /*+ * At this point, we know that we need to attempt an unwrap if needed; we want+ * to makes sure that open(2) fails properly if the device is either just-locked+ * or never made it past first unlock. Since the keybag serializes access to the+ * unwrapping keys for us and only calls our VFS callback once they've been purged,+ * we will get here in two cases:+ *+ * A) we're in a window before the wrapping keys are purged; this is OK since when they get+ * purged, the vnode will get flushed if needed.+ *+ * B) The keys are already gone. In this case, the restore_keys call below will fail.+ *+ * Since this function is bypassed entirely if we're opening a raw encrypted file,+ * we can always attempt the restore.+ */+ if (!cpx_has_key(cpkp_cpx(entry->cp_keys))) {+ error = cp_restore_keys(entry, hfsmp, cp);+ }++ if (error) {+ error = EPERM;+ }++ break;++ case PROTECTION_CLASS_D:+ default:+ break;+ }++out:++#if HFS_TMPDBG+#if !SECURE_KERNEL+ if ((hfsmp->hfs_cp_verbose) && (error == EPERM)) {+ cp_log_eperm (vp, CP_CLASS(entry->cp_pclass), false);+ }+#endif+#endif++ hfs_unlock(cp);+ return error;+}+++/*+ * cp_getrootxattr:+ * Gets the EA we set on the root folder (fileid 1) to get information about the+ * version of Content Protection that was used to write to this filesystem.+ * Note that all multi-byte fields are written to disk little endian so they must be+ * converted to native endian-ness as needed.+ */+int+cp_getrootxattr(struct hfsmount* hfsmp, struct cp_root_xattr *outxattr)+{+ void *buf;++ /*+ * We allow for an extra 64 bytes to cater for upgrades. This wouldn't+ * be necessary if the xattr routines just returned what we asked for.+ */+ size_t bufsize = roundup(sizeof(struct cp_root_xattr) + 64, 64);++ int error = 0;++ hfs_assert(outxattr);++ buf = hfs_malloc_data(bufsize);++ uio_t uio = uio_create(1, 0, UIO_SYSSPACE, UIO_READ);++ uio_addiov(uio, CAST_USER_ADDR_T(buf), bufsize);++ size_t attrsize = bufsize;++ struct vnop_getxattr_args args = {+ .a_uio = uio,+ .a_name = CONTENT_PROTECTION_XATTR_NAME,+ .a_size = &attrsize+ };++ error = hfs_getxattr_internal(NULL, &args, hfsmp, 1);++ uio_free(uio);++ if (error != 0) {+ goto out;+ }++ if (attrsize < CP_ROOT_XATTR_MIN_LEN) {+ error = HFS_EINCONSISTENT;+ goto out;+ }++ const struct cp_root_xattr *xattr = buf;++ bzero(outxattr, sizeof(*outxattr));++ /* Now convert the multi-byte fields to native endianness */+ outxattr->major_version = OSSwapLittleToHostInt16(xattr->major_version);+ outxattr->minor_version = OSSwapLittleToHostInt16(xattr->minor_version);+ outxattr->flags = OSSwapLittleToHostInt64(xattr->flags);++ if (outxattr->major_version >= CP_VERS_5) {+ if (attrsize < sizeof(struct cp_root_xattr)) {+ error = HFS_EINCONSISTENT;+ goto out;+ }+#if HFS_CONFIG_KEY_ROLL+ outxattr->auto_roll_min_version = OSSwapLittleToHostInt32(xattr->auto_roll_min_version);+ outxattr->auto_roll_max_version = OSSwapLittleToHostInt32(xattr->auto_roll_max_version);+#endif+ }++out:+ hfs_free_data(buf, bufsize);+ return error;+}++/*+ * cp_setrootxattr:+ * Sets the EA we set on the root folder (fileid 1) to get information about the+ * version of Content Protection that was used to write to this filesystem.+ * Note that all multi-byte fields are written to disk little endian so they must be+ * converted to little endian as needed.+ *+ * This will be written to the disk when it detects the EA is not there, or when we need+ * to make a modification to the on-disk version that can be done in-place.+ */+int+cp_setrootxattr(struct hfsmount *hfsmp, struct cp_root_xattr *newxattr)+{+ int error = 0;+ struct vnop_setxattr_args args;++ args.a_desc = NULL;+ args.a_vp = NULL;+ args.a_name = CONTENT_PROTECTION_XATTR_NAME;+ args.a_uio = NULL; //pass data ptr instead+ args.a_options = 0;+ args.a_context = NULL; //no context needed, only done from mount.++ const uint64_t flags = newxattr->flags;++ /* Now convert the multi-byte fields to little endian before writing to disk. */+ newxattr->flags = OSSwapHostToLittleInt64(newxattr->flags);++ int xattr_size = sizeof(struct cp_root_xattr);++#if HFS_CONFIG_KEY_ROLL+ bool upgraded = false;++ if (newxattr->auto_roll_min_version || newxattr->auto_roll_max_version) {+ if (newxattr->major_version < CP_VERS_5) {+ printf("hfs: upgrading to cp version %u\n", CP_CURRENT_VERS);++ newxattr->major_version = CP_CURRENT_VERS;+ newxattr->minor_version = CP_MINOR_VERS;++ upgraded = true;+ }++ newxattr->auto_roll_min_version = OSSwapHostToLittleInt32(newxattr->auto_roll_min_version);+ newxattr->auto_roll_max_version = OSSwapHostToLittleInt32(newxattr->auto_roll_max_version);+ } else if (newxattr->major_version == CP_VERS_4)+ xattr_size = offsetof(struct cp_root_xattr, auto_roll_min_version);+#endif++ newxattr->major_version = OSSwapHostToLittleInt16(newxattr->major_version);+ newxattr->minor_version = OSSwapHostToLittleInt16(newxattr->minor_version);++ error = hfs_setxattr_internal(NULL, (caddr_t)newxattr,+ xattr_size, &args, hfsmp, 1);++ if (!error) {+ hfsmp->cproot_flags = flags;+#if HFS_CONFIG_KEY_ROLL+ if (upgraded)+ hfsmp->hfs_running_cp_major_vers = CP_CURRENT_VERS;+#endif+ }++ return error;+}+++/*+ * Stores new xattr data on the cnode.+ * cnode lock held exclusive (if available).+ *+ * This function is also invoked during file creation.+ */+int cp_setxattr(struct cnode *cp, struct cprotect *entry, struct hfsmount *hfsmp,+ uint32_t fileid, int options)+{+ int error = 0;+ cp_key_pair_t *cpkp = entry->cp_keys;+#if HFS_CONFIG_KEY_ROLL+ bool rolling = entry->cp_key_roll_ctx != NULL;++ if (rolling && entry->cp_key_roll_ctx->ckr_off_rsrc == INT64_MAX) {+ // We've finished rolling, but we still have the context+ rolling = false;+ cpkp = entry->cp_key_roll_ctx->ckr_keys;+ }+#endif++ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return EROFS;+ }++ if (hfsmp->hfs_running_cp_major_vers < CP_CURRENT_VERS) {+ // Upgrade+ printf("hfs: upgrading to cp version %u\n", CP_CURRENT_VERS);++ struct cp_root_xattr root_xattr;++ error = cp_getrootxattr(hfsmp, &root_xattr);+ if (error)+ return error;++ root_xattr.major_version = CP_CURRENT_VERS;+ root_xattr.minor_version = CP_MINOR_VERS;++ error = cp_setrootxattr(hfsmp, &root_xattr);+ if (error)+ return error;++ hfsmp->hfs_running_cp_major_vers = CP_CURRENT_VERS;+ }++ struct cp_xattr_v5 *xattr;+ xattr = hfs_malloc_type(struct cp_xattr_v5);++ xattr->xattr_major_version = OSSwapHostToLittleConstInt16(CP_VERS_5);+ xattr->xattr_minor_version = OSSwapHostToLittleConstInt16(CP_MINOR_VERS);+ xattr->flags = 0;+#if HFS_CONFIG_KEY_ROLL+ if (rolling)+ xattr->flags |= CP_XAF_KEY_ROLLING;+#endif+ xattr->persistent_class = OSSwapHostToLittleInt32(entry->cp_pclass);+ xattr->key_os_version = OSSwapHostToLittleInt32(entry->cp_key_os_version);+ xattr->key_revision = OSSwapHostToLittleInt16(entry->cp_key_revision);++ uint16_t key_len = cpkp_pers_key_len(cpkp);+ xattr->key_len = OSSwapHostToLittleInt16(key_len);+ memcpy(xattr->persistent_key, cpkp_pers_key(cpkp), key_len);++ size_t xattr_len = offsetof(struct cp_xattr_v5, persistent_key) + key_len;++#if HFS_CONFIG_KEY_ROLL+ if (rolling) {+ struct cp_roll_info *roll_info = PTR_ADD(struct cp_roll_info *, xattr, xattr_len);++ roll_info->off_rsrc = OSSwapHostToLittleInt64(entry->cp_key_roll_ctx->ckr_off_rsrc);++ key_len = cpkp_pers_key_len(entry->cp_key_roll_ctx->ckr_keys);+ roll_info->key_len = OSSwapHostToLittleInt16(key_len);++ memcpy(roll_info->key, cpkp_pers_key(entry->cp_key_roll_ctx->ckr_keys), key_len);++ xattr_len += offsetof(struct cp_roll_info, key) + key_len;+ }+#endif++ struct vnop_setxattr_args args = {+ .a_vp = cp ? cp->c_vp : NULL,+ .a_name = CONTENT_PROTECTION_XATTR_NAME,+ .a_options = options,+ .a_context = vfs_context_current(),+ };++ error = hfs_setxattr_internal(cp, xattr, xattr_len, &args, hfsmp, fileid);++ hfs_free_type(xattr, struct cp_xattr_v5);++ if (error == 0 ) {+ entry->cp_flags &= ~CP_NO_XATTR;+ }++ return error;+}++/*+ * Used by an fcntl to query the underlying FS for its content protection version #+ */++int+cp_get_root_major_vers(vnode_t vp, uint32_t *level)+{+ int err = 0;+ struct hfsmount *hfsmp = NULL;+ struct mount *mp = NULL;++ mp = VTOVFS(vp);++ /* check if it supports content protection */+ if (cp_fs_protected(mp) == 0) {+ return ENOTSUP;+ }++ hfsmp = VFSTOHFS(mp);+ /* figure out the level */++ err = cp_root_major_vers(mp);++ if (err == 0) {+ *level = hfsmp->hfs_running_cp_major_vers;+ }+ /* in error case, cp_root_major_vers will just return EINVAL. Use that */++ return err;+}++/* Used by fcntl to query default protection level of FS */+int cp_get_default_level (struct vnode *vp, uint32_t *level) {+ int err = 0;+ struct hfsmount *hfsmp = NULL;+ struct mount *mp = NULL;++ mp = VTOVFS(vp);++ /* check if it supports content protection */+ if (cp_fs_protected(mp) == 0) {+ return ENOTSUP;+ }++ hfsmp = VFSTOHFS(mp);+ /* figure out the default */++ *level = hfsmp->default_cp_class;+ return err;+}++/********************+ * Private Functions+ *******************/++static int+cp_root_major_vers(mount_t mp)+{+ int err = 0;+ struct cp_root_xattr xattr;+ struct hfsmount *hfsmp = NULL;++ hfsmp = vfs_fsprivate(mp);+ err = cp_getrootxattr (hfsmp, &xattr);++ if (err == 0) {+ hfsmp->hfs_running_cp_major_vers = xattr.major_version;+ }+ else {+ return EINVAL;+ }++ return 0;+}++static int+cp_vnode_is_eligible(struct vnode *vp)+{+ return !vnode_issystem(vp) && (vnode_isreg(vp) || vnode_isdir(vp));+}++#if DEBUG+static const uint32_t cp_magic1 = 0x7b727063; // cpr{+static const uint32_t cp_magic2 = 0x7270637d; // }cpr+#endif++struct cprotect *+cp_entry_alloc(cprotect_t old, uint16_t pers_key_len,+ uint16_t cached_key_len, cp_key_pair_t **pcpkp)+{+ struct cprotect *cp_entry;++ if (pers_key_len > CP_MAX_WRAPPEDKEYSIZE)+ return (NULL);++ size_t size = cpkp_size(pers_key_len, cached_key_len);++#if DEBUG+ size += 4; // Extra for magic2+#endif++ cp_entry = hfs_malloc_type(struct cprotect);+ if (cp_entry == NULL)+ return (NULL);+ cp_entry->cp_keys = hfs_malloc_zero_data(size);+ if (cp_entry->cp_keys == NULL) {+ hfs_free_type(cp_entry, struct cprotect);+ return (NULL);+ }+ if (old) {+ memcpy(cp_entry, old, offsetof(struct cprotect, cp_keys));++#if HFS_CONFIG_KEY_ROLL+ // We don't copy the key roll context+ cp_entry->cp_key_roll_ctx = NULL;+#endif+ }++#if DEBUG+ cp_entry->cp_magic1 = cp_magic1;+ *PTR_ADD(uint32_t *, cp_entry, size - 4) = cp_magic2;+#endif++ cpkp_init(cp_entry->cp_keys, pers_key_len, cached_key_len);++ /*+ * If we've been passed the old entry, then we are in the process of+ * rewrapping in which case we need to copy the cached key. This is+ * important for class B files when the device is locked because we+ * won't be able to unwrap whilst in this state, yet we still need the+ * unwrapped key.+ */+ if (old)+ cpx_copy(cpkp_cpx(old->cp_keys), cpkp_cpx(cp_entry->cp_keys));++ if (pcpkp)+ *pcpkp = cp_entry->cp_keys;++ return cp_entry;+}++static void+cp_entry_dealloc(__unused hfsmount_t *hfsmp, struct cprotect *entry)+{+#if HFS_CONFIG_KEY_ROLL+ hfs_release_key_roll_ctx(hfsmp, entry);+#endif++ cpkp_flush(entry->cp_keys);++ size_t entry_size = cpkp_sizex(entry->cp_keys);++ /*+ * We are freeing the HFS cprotect, which contains the memory for 'cpx'+ * Don't forget to release the CPX AES context+ */+ cpx_t embedded_cpx = cpkp_cpx(entry->cp_keys);+ cpx_free_ctx (embedded_cpx);++#if DEBUG+ hfs_assert(entry->cp_magic1 == cp_magic1);+ hfs_assert(*PTR_ADD(uint32_t *, entry, (sizeof(struct cprotect) - sizeof(cp_key_pair_t)+ + cpkp_sizex(entry->cp_keys) == cp_magic2)));++ entry_size += 4; // Extra for magic2+#endif++ hfs_free_data(entry->cp_keys, entry_size);+ hfs_free_type(entry, struct cprotect);+}++static int cp_read_xattr_v4(__unused hfsmount_t *hfsmp, struct cp_xattr_v4 *xattr,+ size_t xattr_len, cprotect_t *pcpr, cp_getxattr_options_t options)+{+ /* Endian swap the multi-byte fields into host endianness from L.E. */+ xattr->xattr_major_version = OSSwapLittleToHostInt16(xattr->xattr_major_version);+ xattr->xattr_minor_version = OSSwapLittleToHostInt16(xattr->xattr_minor_version);+ xattr->key_size = OSSwapLittleToHostInt32(xattr->key_size);+ xattr->flags = OSSwapLittleToHostInt32(xattr->flags);+ xattr->persistent_class = OSSwapLittleToHostInt32(xattr->persistent_class);+ xattr->key_os_version = OSSwapLittleToHostInt32(xattr->key_os_version);++ /*+ * Prevent a buffer overflow, and validate the key length obtained from the+ * EA. If it's too big, then bail out, because the EA can't be trusted at this+ * point.+ */+ if (xattr->key_size > CP_MAX_WRAPPEDKEYSIZE)+ return HFS_EINCONSISTENT;++ size_t min_len = offsetof(struct cp_xattr_v4, persistent_key) + xattr->key_size;+ if (xattr_len < min_len)+ return HFS_EINCONSISTENT;++ /*+ * Class F files have no backing key; their keylength should be 0,+ * though they should have the proper flags set.+ *+ * A request to instantiate a CP for a class F file should result+ * in a bzero'd cp that just says class F, with key_flushed set.+ */+ if (CP_CLASS(xattr->persistent_class) == PROTECTION_CLASS_F+ || ISSET(xattr->flags, CP_XAF_NEEDS_KEYS)) {+ xattr->key_size = 0;+ }++ /* set up entry with information from xattr */+ cp_key_pair_t *cpkp = NULL;+ cprotect_t entry;++ if (ISSET(options, CP_GET_XATTR_BASIC_INFO)) {+ /* caller passed in a pre-allocated structure to get the basic info */+ entry = *pcpr;+ bzero(entry, offsetof(struct cprotect, cp_keys));+ }+ else {+ entry = cp_entry_alloc(NULL, xattr->key_size, CP_MAX_CACHEBUFLEN, &cpkp);+ }++ entry->cp_pclass = xattr->persistent_class;+ entry->cp_key_os_version = xattr->key_os_version;+++ if (!ISSET(options, CP_GET_XATTR_BASIC_INFO)) {+ if (xattr->key_size) {+ cpkp_set_pers_key_len(cpkp, xattr->key_size);+ memcpy(cpkp_pers_key(cpkp), xattr->persistent_key, xattr->key_size);+ }++ *pcpr = entry;+ }+ else if (xattr->key_size) {+ SET(entry->cp_flags, CP_HAS_A_KEY);+ }++ return 0;+}++int cp_read_xattr_v5(hfsmount_t *hfsmp, struct cp_xattr_v5 *xattr,+ size_t xattr_len, cprotect_t *pcpr, cp_getxattr_options_t options)+{+ if (xattr->xattr_major_version == OSSwapHostToLittleConstInt16(CP_VERS_4)) {+ return cp_read_xattr_v4(hfsmp, (struct cp_xattr_v4 *)xattr, xattr_len, pcpr, options);+ }++ xattr->xattr_major_version = OSSwapLittleToHostInt16(xattr->xattr_major_version);++ if (xattr->xattr_major_version != CP_VERS_5) {+ printf("hfs: cp_getxattr: unsupported xattr version %d\n",+ xattr->xattr_major_version);+ return ENOTSUP;+ }++ size_t min_len = offsetof(struct cp_xattr_v5, persistent_key);++ if (xattr_len < min_len)+ return HFS_EINCONSISTENT;++ xattr->xattr_minor_version = OSSwapLittleToHostInt16(xattr->xattr_minor_version);+ xattr->flags = OSSwapLittleToHostInt32(xattr->flags);+ xattr->persistent_class = OSSwapLittleToHostInt32(xattr->persistent_class);+ xattr->key_os_version = OSSwapLittleToHostInt32(xattr->key_os_version);+ xattr->key_revision = OSSwapLittleToHostInt16(xattr->key_revision);+ xattr->key_len = OSSwapLittleToHostInt16(xattr->key_len);++ uint16_t pers_key_len = xattr->key_len;++ min_len += pers_key_len;+ if (xattr_len < min_len)+ return HFS_EINCONSISTENT;++#if HFS_CONFIG_KEY_ROLL+ struct cp_roll_info *roll_info = NULL;++ if (ISSET(xattr->flags, CP_XAF_KEY_ROLLING)) {+ roll_info = PTR_ADD(struct cp_roll_info *, xattr, min_len);++ min_len += offsetof(struct cp_roll_info, key);++ if (xattr_len < min_len)+ return HFS_EINCONSISTENT;++ roll_info->off_rsrc = OSSwapLittleToHostInt64(roll_info->off_rsrc);++ if (roll_info->off_rsrc % hfsmp->blockSize)+ return HFS_EINCONSISTENT;++ roll_info->key_len = OSSwapLittleToHostInt16(roll_info->key_len);++ min_len += roll_info->key_len;+ if (xattr_len < min_len)+ return HFS_EINCONSISTENT;+ }+#endif++ cp_key_pair_t *cpkp = NULL;+ cprotect_t entry;++ /*+ * If option CP_GET_XATTR_BASIC_INFO is set, we only return basic+ * information about the file's protection (and not the key) and+ * we store the result in the structure the caller passed to us.+ */+ if (ISSET(options, CP_GET_XATTR_BASIC_INFO)) {+ entry = *pcpr;+ bzero(entry, offsetof(struct cprotect, cp_keys));+#if HFS_CONFIG_KEY_ROLL+ if (ISSET(xattr->flags, CP_XAF_KEY_ROLLING)) {+ SET(entry->cp_flags, CP_KEY_IS_ROLLING);+ }+#endif+ } else {+ entry = cp_entry_alloc(NULL, xattr->key_len, CP_MAX_CACHEBUFLEN, &cpkp);+ }++ entry->cp_pclass = xattr->persistent_class;+ entry->cp_key_os_version = xattr->key_os_version;+ entry->cp_key_revision = xattr->key_revision;++ if (!ISSET(options, CP_GET_XATTR_BASIC_INFO)) {+ if (xattr->key_len) {+ cpkp_set_pers_key_len(cpkp, xattr->key_len);+ memcpy(cpkp_pers_key(cpkp), xattr->persistent_key, xattr->key_len);+ }++#if HFS_CONFIG_KEY_ROLL+ if (roll_info) {+ entry->cp_key_roll_ctx = hfs_key_roll_ctx_alloc(NULL, roll_info->key_len,+ CP_MAX_CACHEBUFLEN, &cpkp);++ entry->cp_key_roll_ctx->ckr_off_rsrc = roll_info->off_rsrc;++ if (roll_info->key_len) {+ cpkp_set_pers_key_len(cpkp, roll_info->key_len);+ memcpy(cpkp_pers_key(cpkp), roll_info->key, roll_info->key_len);+ }+ }+#endif++ *pcpr = entry;+ }+ else if (xattr->key_len) {+ SET(entry->cp_flags, CP_HAS_A_KEY);+ }++ return 0;+}++/*+ * Initializes a new cprotect entry with xattr data from the cnode.+ * cnode lock held shared+ */+static int+cp_getxattr(struct cnode *cp, struct hfsmount *hfsmp, cprotect_t *outentry)+{+ size_t xattr_len;+ struct cp_xattr_v5 *xattr;++ xattr_len = sizeof(*xattr);+ xattr = hfs_malloc_type(struct cp_xattr_v5);++ int error = hfs_xattr_read(cp->c_vp, CONTENT_PROTECTION_XATTR_NAME,+ xattr, &xattr_len);++ if (!error) {+ if (xattr_len < CP_XATTR_MIN_LEN)+ error = HFS_EINCONSISTENT;+ else+ error = cp_read_xattr_v5(hfsmp, xattr, xattr_len, outentry, 0);+ }++#if DEBUG+ if (error && error != ENOATTR) {+ printf("cp_getxattr: bad cp xattr (%d):\n", error);+ for (size_t i = 0; i < xattr_len; ++i)+ printf("%02x ", ((uint8_t *)xattr)[i]);+ printf("\n");+ }+#endif++ hfs_free_type(xattr, struct cp_xattr_v5);++ return error;+}++/*+ * If permitted, restore entry's unwrapped key from the persistent key.+ * If not, clear key and set CP_KEY_FLUSHED.+ * cnode lock held exclusive+ */+static int+cp_restore_keys(struct cprotect *entry, struct hfsmount *hfsmp, struct cnode *cp)+{+ int error = 0;++ error = cp_unwrap(hfsmp, entry, cp);+ if (error) {+ cp_flush_cached_keys(entry);+ error = EPERM;+ }+ return error;+}++void cp_device_locked_callback(mount_t mp, cp_lock_state_t state)+{+ struct hfsmount *hfsmp;++ /*+ * When iterating the various mount points that may+ * be present on a content-protected device, we need to skip+ * those that do not have it enabled.+ */+ if (!cp_fs_protected(mp)) {+ return;+ }++ hfsmp = VFSTOHFS(mp);++ hfsmp->hfs_cp_lock_state = state;++ if (state == CP_LOCKED_STATE) {+ /*+ * We respond only to lock events. Since cprotect structs+ * decrypt/restore keys lazily, the unlock events don't+ * actually cause anything to happen.+ */+ vnode_iterate(mp, 0, cp_lock_vnode_callback, (void *)(uintptr_t)state);+ }+}++/*+ * Deny access to protected files if keys have been locked.+ */+static int+cp_check_access(struct cnode *cp, struct hfsmount *hfsmp, int vnop __unused)+{+ int error = 0;++ /*+ * For now it's OK to examine the state variable here without+ * holding the HFS lock. This is only a short-circuit; if the state+ * transitions (or is in transition) after we examine this field, we'd+ * have to handle that anyway.+ */+ if (hfsmp->hfs_cp_lock_state == CP_UNLOCKED_STATE) {+ return 0;+ }++ if (!cp->c_cpentry) {+ /* unprotected node */+ return 0;+ }++ if (!S_ISREG(cp->c_mode)) {+ return 0;+ }++ /* Deny all access for class A files */+ switch (CP_CLASS(cp->c_cpentry->cp_pclass)) {+ case PROTECTION_CLASS_A: {+ error = EPERM;+ break;+ }+ default:+ error = 0;+ break;+ }++ return error;+}++/*+ * Respond to a lock or unlock event.+ * On lock: clear out keys from memory, then flush file contents.+ * On unlock: nothing (function not called).+ */+static int+cp_lock_vnode_callback(struct vnode *vp, void *arg)+{+ cnode_t *cp = NULL;+ struct cprotect *entry = NULL;+ int error = 0;+ int locked = 1;+ unsigned long action = 0;+ int took_truncate_lock = 0;++ error = vnode_getwithref (vp);+ if (error) {+ return error;+ }++ cp = VTOC(vp);++ /*+ * When cleaning cnodes due to a lock event, we must+ * take the truncate lock AND the cnode lock. By taking+ * the truncate lock here, we force (nearly) all pending IOs+ * to drain before we can acquire the truncate lock. All HFS cluster+ * io calls except for swapfile IO need to acquire the truncate lock+ * prior to calling into the cluster layer.+ */+ hfs_lock_truncate (cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ took_truncate_lock = 1;++ hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);++ entry = cp->c_cpentry;+ if (!entry) {+ /* unprotected vnode: not a regular file */+ goto out;+ }++ action = (unsigned long) arg;+ switch (action) {+ case CP_LOCKED_STATE: {+ vfs_context_t ctx;+ if (CP_CLASS(entry->cp_pclass) != PROTECTION_CLASS_A ||+ vnode_isdir(vp)) {+ /*+ * There is no change at lock for other classes than A.+ * B is kept in memory for writing, and class F (for VM) does+ * not have a wrapped key, so there is no work needed for+ * wrapping/unwrapping.+ *+ * Note that 'class F' is relevant here because if+ * hfs_vnop_strategy does not take the cnode lock+ * to protect the cp blob across IO operations, we rely+ * implicitly on the truncate lock to be held when doing IO.+ * The only case where the truncate lock is not held is during+ * swapfile IO because HFS just funnels the VNOP_PAGEOUT+ * directly to cluster_pageout.+ */+ goto out;+ }++ /* Before doing anything else, zero-fill sparse ranges as needed */+ ctx = vfs_context_current();+ (void) hfs_filedone (vp, ctx, 0);++ /* first, sync back dirty pages */+ hfs_unlock (cp);+ ubc_msync (vp, 0, ubc_getsize(vp), NULL, UBC_PUSHALL | UBC_INVALIDATE | UBC_SYNC);+ hfs_lock (cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);++ /* flush keys:+ * There was a concern here(9206856) about flushing keys before nand layer is done using them.+ * But since we are using ubc_msync with UBC_SYNC, it blocks until all IO is completed.+ * Once IOFS caches or is done with these keys, it calls the completion routine in IOSF.+ * Which in turn calls buf_biodone() and eventually unblocks ubc_msync()+ * Also verified that the cached data in IOFS is overwritten by other data, and there+ * is no key leakage in that layer.+ */++ cp_flush_cached_keys(entry);++ /* some write may have arrived in the mean time. dump those pages */+ hfs_unlock(cp);+ locked = 0;++ ubc_msync (vp, 0, ubc_getsize(vp), NULL, UBC_INVALIDATE | UBC_SYNC);+ break;+ }+ case CP_UNLOCKED_STATE: {+ /* no-op */+ break;+ }+ default:+ panic("Content Protection: unknown lock action %lu\n", action);+ }++out:+ if (locked) {+ hfs_unlock(cp);+ }++ if (took_truncate_lock) {+ hfs_unlock_truncate (cp, HFS_LOCK_DEFAULT);+ }++ vnode_put (vp);+ return error;+}+++/*+ * cp_rewrap:+ *+ * Generate a new wrapped key based on the existing cache key.+ */++int+cp_rewrap(struct cnode *cp, __unused hfsmount_t *hfsmp,+ cp_key_class_t *newclass, cp_key_pair_t *cpkp, const void *old_holder,+ cp_new_alloc_fn alloc_fn, void **pholder)+{+ struct cprotect *entry = cp->c_cpentry;++ uint8_t new_persistent_key[CP_MAX_WRAPPEDKEYSIZE];+ unsigned keylen = CP_MAX_WRAPPEDKEYSIZE;+ int error = 0;+ const cp_key_class_t key_class = CP_CLASS(*newclass);++ /* Structures passed between HFS and AKS */+ struct aks_cred_s access_in;+ struct aks_wrapped_key_s wrapped_key_in;+ struct aks_wrapped_key_s wrapped_key_out;++ /*+ * PROTECTION_CLASS_F is in-use by VM swapfile; it represents a transient+ * key that is only good as long as the file is open. There is no+ * wrapped key, so there isn't anything to wrap.+ */+ if (key_class == PROTECTION_CLASS_F) {+ return EINVAL;+ }++ cp_init_access(&access_in, cp);++ bzero(&wrapped_key_in, sizeof(wrapped_key_in));+ wrapped_key_in.key = cpkp_pers_key(cpkp);+ wrapped_key_in.key_len = cpkp_pers_key_len(cpkp);+ /* Use the persistent class when talking to AKS */+ wrapped_key_in.dp_class = entry->cp_pclass;++ bzero(&wrapped_key_out, sizeof(wrapped_key_out));+ wrapped_key_out.key = new_persistent_key;+ wrapped_key_out.key_len = keylen;++ /*+ * inode is passed here to find the backup bag wrapped blob+ * from userspace. This lookup will occur shortly after creation+ * and only if the file still exists. Beyond this lookup the+ * inode is not used. Technically there is a race, we practically+ * don't lose.+ */+ error = hfs_rewrap_key(&access_in,+ key_class, /* new class */+ &wrapped_key_in,+ &wrapped_key_out);++ keylen = wrapped_key_out.key_len;++ if (error == 0) {+ /*+ * Verify that AKS returned to us a wrapped key of the+ * target class requested.+ */+ /* Get the effective class here */+ cp_key_class_t effective = CP_CLASS(wrapped_key_out.dp_class);+ if (effective != key_class) {+ /*+ * Fail the operation if defaults or some other enforcement+ * dictated that the class be wrapped differently.+ */++ /* TODO: Invalidate the key when 12170074 unblocked */+ return EPERM;+ }++ /* Allocate a new cpentry */+ cp_key_pair_t *new_cpkp;+ *pholder = alloc_fn(old_holder, keylen, CP_MAX_CACHEBUFLEN, &new_cpkp);++ /* copy the new key into the entry */+ cpkp_set_pers_key_len(new_cpkp, keylen);+ memcpy(cpkp_pers_key(new_cpkp), new_persistent_key, keylen);++ /* Actually record/store what AKS reported back, not the effective class stored in newclass */+ *newclass = wrapped_key_out.dp_class;+ }+ else {+ error = EPERM;+ }++ return error;+}++static int cpkp_unwrap(cnode_t *cp, cp_key_class_t key_class, cp_key_pair_t *cpkp)+{+ int error = 0;+ uint8_t iv_key[CP_IV_KEYSIZE];+ cpx_t cpx = cpkp_cpx(cpkp);++ /* Structures passed between HFS and AKS */+ struct aks_cred_s access_in;+ struct aks_wrapped_key_s wrapped_key_in;+ struct aks_raw_key_s key_out;++ cp_init_access(&access_in, cp);++ bzero(&wrapped_key_in, sizeof(wrapped_key_in));+ wrapped_key_in.key = cpkp_pers_key(cpkp);+ wrapped_key_in.key_len = cpkp_max_pers_key_len(cpkp);+ /* Use the persistent class when talking to AKS */+ wrapped_key_in.dp_class = key_class;++ bzero(&key_out, sizeof(key_out));+ key_out.iv_key = iv_key;+ key_out.key = cpx_key(cpx);+ /*+ * The unwrapper should validate/set the key length for+ * the IV key length and the cache key length, however we need+ * to supply the correct buffer length so that AKS knows how+ * many bytes it has to work with.+ */+ key_out.iv_key_len = CP_IV_KEYSIZE;+ key_out.key_len = cpx_max_key_len(cpx);++ error = hfs_unwrap_key(&access_in, &wrapped_key_in, &key_out);+ if (!error) {+ if (key_out.key_len == 0 || key_out.key_len > CP_MAX_CACHEBUFLEN) {+ panic ("cp_unwrap: invalid key length! (%ul)\n", key_out.key_len);+ }++ if (key_out.iv_key_len != CP_IV_KEYSIZE)+ panic ("cp_unwrap: invalid iv key length! (%ul)\n", key_out.iv_key_len);++ cpx_set_key_len(cpx, key_out.key_len);++ cpx_set_aes_iv_key(cpx, iv_key);+ cpx_set_is_sep_wrapped_key(cpx, ISSET(key_out.flags, AKS_RAW_KEY_WRAPPEDKEY));+ } else {+ error = EPERM;+ }++ return error;+}++static int+cp_unwrap(__unused struct hfsmount *hfsmp, struct cprotect *entry, struct cnode *cp)+{+ /*+ * PROTECTION_CLASS_F is in-use by VM swapfile; it represents a transient+ * key that is only good as long as the file is open. There is no+ * wrapped key, so there isn't anything to unwrap.+ */+ if (CP_CLASS(entry->cp_pclass) == PROTECTION_CLASS_F) {+ return EPERM;+ }++ int error = cpkp_unwrap(cp, entry->cp_pclass, entry->cp_keys);++#if HFS_CONFIG_KEY_ROLL+ if (!error && entry->cp_key_roll_ctx) {+ error = cpkp_unwrap(cp, entry->cp_pclass, entry->cp_key_roll_ctx->ckr_keys);+ if (error)+ cpx_flush(cpkp_cpx(entry->cp_keys));+ }+#endif++ return error;+}++/*+ * cp_generate_keys+ *+ * Take a cnode that has already been initialized and establish persistent and+ * cache keys for it at this time. Note that at the time this is called, the+ * directory entry has already been created and we are holding the cnode lock+ * on 'cp'.+ *+ */+int cp_generate_keys (struct hfsmount *hfsmp, struct cnode *cp, cp_key_class_t targetclass,+ uint32_t keyflags, struct cprotect **newentry)+{++ int error = 0;+ struct cprotect *newcp = NULL;+ *newentry = NULL;++ /* Target class must be an effective class only */+ targetclass = CP_CLASS(targetclass);++ /* Validate that it has a cprotect already */+ if (cp->c_cpentry == NULL) {+ /* We can't do anything if it shouldn't be protected. */+ return 0;+ }++ /* Asserts for the underlying cprotect */+ if (cp->c_cpentry->cp_flags & CP_NO_XATTR) {+ /* should already have an xattr by this point. */+ error = EINVAL;+ goto out;+ }++ if (S_ISREG(cp->c_mode)) {+ if (!cp_needs_pers_key(cp->c_cpentry)) {+ error = EINVAL;+ goto out;+ }+ }++ cp_key_revision_t key_revision = cp_initial_key_revision(hfsmp);++ error = cp_new (&targetclass, hfsmp, cp, cp->c_mode, keyflags, key_revision,+ (cp_new_alloc_fn)cp_entry_alloc, (void **)&newcp);+ if (error) {+ /*+ * Key generation failed. This is not necessarily fatal+ * since the device could have transitioned into the lock+ * state before we called this.+ */+ error = EPERM;+ goto out;+ }++ newcp->cp_pclass = targetclass;+ newcp->cp_key_os_version = cp_os_version();+ newcp->cp_key_revision = key_revision;++ /*+ * If we got here, then we have a new cprotect.+ * Attempt to write the new one out.+ */+ error = cp_setxattr (cp, newcp, hfsmp, cp->c_fileid, XATTR_REPLACE);++ if (error) {+ /* Tear down the new cprotect; Tell MKB that it's invalid. Bail out */+ /* TODO: rdar://12170074 needs to be fixed before we can tell MKB */+ if (newcp) {+ cp_entry_destroy(hfsmp, newcp);+ }+ goto out;+ }++ /*+ * If we get here then we can assert that:+ * 1) generated wrapped/unwrapped keys.+ * 2) wrote the new keys to disk.+ * 3) cprotect is ready to go.+ */++ *newentry = newcp;++out:+ return error;++}++void cp_replace_entry (hfsmount_t *hfsmp, struct cnode *cp, struct cprotect *newentry)+{+ if (cp->c_cpentry) {+#if HFS_CONFIG_KEY_ROLL+ // Transfer the tentative reservation+ if (cp->c_cpentry->cp_key_roll_ctx && newentry->cp_key_roll_ctx) {+ newentry->cp_key_roll_ctx->ckr_tentative_reservation+ = cp->c_cpentry->cp_key_roll_ctx->ckr_tentative_reservation;++ cp->c_cpentry->cp_key_roll_ctx->ckr_tentative_reservation = NULL;+ }+#endif++ cp_entry_destroy (hfsmp, cp->c_cpentry);+ }+ cp->c_cpentry = newentry;+ newentry->cp_backing_cnode = cp;++ return;+}+++/*+ * cp_new+ *+ * Given a double-pointer to a cprotect, generate keys (either in-kernel or from keystore),+ * allocate a cprotect, and vend it back to the caller.+ *+ * Additionally, decide if keys are even needed -- directories get cprotect data structures+ * but they do not have keys.+ *+ */++int+cp_new(cp_key_class_t *newclass_eff, __unused struct hfsmount *hfsmp, struct cnode *cp,+ mode_t cmode, int32_t keyflags, cp_key_revision_t key_revision,+ cp_new_alloc_fn alloc_fn, void **pholder)+{+ int error = 0;+ uint8_t new_key[CP_MAX_CACHEBUFLEN];+ unsigned new_key_len = CP_MAX_CACHEBUFLEN; /* AKS tell us the proper key length, how much of this is used */+ uint8_t new_persistent_key[CP_MAX_WRAPPEDKEYSIZE];+ unsigned new_persistent_len = CP_MAX_WRAPPEDKEYSIZE;+ uint8_t iv_key[CP_IV_KEYSIZE];+ unsigned iv_key_len = CP_IV_KEYSIZE;+ int iswrapped = 0;+ cp_key_class_t key_class = CP_CLASS(*newclass_eff);++ /* Structures passed between HFS and AKS */+ struct aks_cred_s access_in;+ struct aks_wrapped_key_s wrapped_key_out;+ struct aks_raw_key_s key_out;++ /* Sanity check that it's a file or directory here */+ if (!(S_ISREG(cmode)) && !(S_ISDIR(cmode))) {+ return EPERM;+ }++ /*+ * Step 1: Generate Keys if needed.+ *+ * For class F files, the kernel provides the key.+ * PROTECTION_CLASS_F is in-use by VM swapfile; it represents a transient+ * key that is only good as long as the file is open. There is no+ * wrapped key, so there isn't anything to wrap.+ *+ * For class A->D files, the key store provides the key+ *+ * For Directories, we only give them a class ; no keys.+ */+ if (S_ISDIR (cmode)) {+ /* Directories */+ new_persistent_len = 0;+ new_key_len = 0;++ error = 0;+ }+ else {+ /* Must be a file */+ if (key_class == PROTECTION_CLASS_F) {+ /* class F files are not wrapped; they can still use the max key size */+ new_key_len = CP_MAX_KEYSIZE;+ read_random (&new_key[0], new_key_len);+ new_persistent_len = 0;++ error = 0;+ }+ else {+ /*+ * The keystore is provided the file ID so that it can associate+ * the wrapped backup blob with this key from userspace. This+ * lookup occurs after successful file creation. Beyond this, the+ * file ID is not used. Note that there is a potential race here if+ * the file ID is re-used.+ */+ cp_init_access(&access_in, cp);++ bzero(&key_out, sizeof(key_out));+ key_out.key = new_key;+ key_out.iv_key = iv_key;+ /*+ * AKS will override our key length fields, but we need to supply+ * the length of the buffer in those length fields so that+ * AKS knows hoa many bytes it has to work with.+ */+ key_out.key_len = new_key_len;+ key_out.iv_key_len = iv_key_len;++ bzero(&wrapped_key_out, sizeof(wrapped_key_out));+ wrapped_key_out.key = new_persistent_key;+ wrapped_key_out.key_len = new_persistent_len;++ access_in.key_revision = key_revision;++ error = hfs_new_key(&access_in,+ key_class,+ &key_out,+ &wrapped_key_out);++ if (error) {+ /* keybag returned failure */+ error = EPERM;+ goto cpnew_fail;+ }++ /* Now sanity-check the output from new_key */+ if (key_out.key_len == 0 || key_out.key_len > CP_MAX_CACHEBUFLEN) {+ panic ("cp_new: invalid key length! (%ul) \n", key_out.key_len);+ }++ if (key_out.iv_key_len != CP_IV_KEYSIZE) {+ panic ("cp_new: invalid iv key length! (%ul) \n", key_out.iv_key_len);+ }++ /*+ * AKS is allowed to override our preferences and wrap with a+ * different class key for policy reasons. If we were told that+ * any class other than the one specified is unacceptable then error out+ * if that occurred. Check that the effective class returned by+ * AKS is the same as our effective new class+ */+ if (CP_CLASS(wrapped_key_out.dp_class) != key_class) {+ if (!ISSET(keyflags, CP_KEYWRAP_DIFFCLASS)) {+ error = EPERM;+ /* TODO: When 12170074 fixed, release/invalidate the key! */+ goto cpnew_fail;+ }+ }++ *newclass_eff = wrapped_key_out.dp_class;+ new_key_len = key_out.key_len;+ iv_key_len = key_out.iv_key_len;+ new_persistent_len = wrapped_key_out.key_len;++ /* Is the key a SEP wrapped key? */+ if (key_out.flags & AKS_RAW_KEY_WRAPPEDKEY) {+ iswrapped = 1;+ }+ }+ }++ /*+ * Step 2: allocate cprotect and initialize it.+ */++ cp_key_pair_t *cpkp;+ *pholder = alloc_fn(NULL, new_persistent_len, new_key_len, &cpkp);+ if (*pholder == NULL) {+ return ENOMEM;+ }++ /* Copy the cache key & IV keys into place if needed. */+ if (new_key_len > 0) {+ cpx_t cpx = cpkp_cpx(cpkp);++ cpx_set_key_len(cpx, new_key_len);+ memcpy(cpx_key(cpx), new_key, new_key_len);++ /* Initialize the IV key */+ if (key_class != PROTECTION_CLASS_F)+ cpx_set_aes_iv_key(cpx, iv_key);++ cpx_set_is_sep_wrapped_key(cpx, iswrapped);+ }+ if (new_persistent_len > 0) {+ cpkp_set_pers_key_len(cpkp, new_persistent_len);+ memcpy(cpkp_pers_key(cpkp), new_persistent_key, new_persistent_len);+ }++cpnew_fail:++#if HFS_TMPDBG+#if !SECURE_KERNEL+ if ((hfsmp->hfs_cp_verbose) && (error == EPERM)) {+ /* Only introspect the data fork */+ cp_log_eperm (cp->c_vp, *newclass_eff, true);+ }+#endif+#endif++ return error;+}+++/* Initialize the aks_cred_t structure passed to AKS */+static void cp_init_access(aks_cred_t access, struct cnode *cp)+{+ vfs_context_t context = vfs_context_current();+ kauth_cred_t cred = vfs_context_ucred(context);+ proc_t proc = vfs_context_proc(context);+ struct hfsmount *hfsmp;+ struct vnode *vp;+ uuid_t hfs_uuid;++ bzero(access, sizeof(*access));++ vp = CTOV(cp, 0);+ if (vp == NULL) {+ /* is it a rsrc */+ vp = CTOV(cp,1);+ if (vp == NULL) {+ //leave the struct bzeroed.+ return;+ }+ }++ hfsmp = VTOHFS(vp);+ hfs_getvoluuid(hfsmp, hfs_uuid);++ /* Note: HFS uses 32-bit fileID, even though inode is a 64-bit value */+ access->inode = cp->c_fileid;+ access->pid = proc_pid(proc);+ access->uid = kauth_cred_getuid(cred);+ uuid_copy (access->volume_uuid, hfs_uuid);++ if (cp->c_cpentry)+ access->key_revision = cp->c_cpentry->cp_key_revision;++ return;+}++#if HFS_CONFIG_KEY_ROLL++errno_t cp_set_auto_roll(hfsmount_t *hfsmp,+ const hfs_key_auto_roll_args_t *args)+{+ // 64 bytes should be OK on the stack+ _Static_assert(sizeof(struct cp_root_xattr) < 64, "cp_root_xattr too big!");++ struct cp_root_xattr xattr;+ errno_t ret;++ ret = cp_getrootxattr(hfsmp, &xattr);+ if (ret)+ return ret;++ ret = hfs_start_transaction(hfsmp);+ if (ret)+ return ret;++ xattr.auto_roll_min_version = args->min_key_os_version;+ xattr.auto_roll_max_version = args->max_key_os_version;++ bool roll_old_class_gen = ISSET(args->flags, HFS_KEY_AUTO_ROLL_OLD_CLASS_GENERATION);++ if (roll_old_class_gen)+ SET(xattr.flags, CP_ROOT_AUTO_ROLL_OLD_CLASS_GENERATION);+ else+ CLR(xattr.flags, CP_ROOT_AUTO_ROLL_OLD_CLASS_GENERATION);++ ret = cp_setrootxattr(hfsmp, &xattr);++ errno_t ret2 = hfs_end_transaction(hfsmp);++ if (!ret)+ ret = ret2;++ if (ret)+ return ret;++ hfs_lock_mount(hfsmp);+ hfsmp->hfs_auto_roll_min_key_os_version = args->min_key_os_version;+ hfsmp->hfs_auto_roll_max_key_os_version = args->max_key_os_version;+ hfs_unlock_mount(hfsmp);++ return ret;+}++bool cp_should_auto_roll(hfsmount_t *hfsmp, cprotect_t cpr)+{+ if (cpr->cp_key_roll_ctx) {+ // Already rolling+ return false;+ }++ // Only automatically roll class A, B & C+ if (CP_CLASS(cpr->cp_pclass) < PROTECTION_CLASS_A+ || CP_CLASS(cpr->cp_pclass) > PROTECTION_CLASS_C) {+ return false;+ }++ if (!cpkp_has_pers_key(cpr->cp_keys))+ return false;++ /*+ * Remember, the class generation stored in HFS+ is updated at the *end*,+ * so it's old if it matches the generation we have stored.+ */+ if (ISSET(hfsmp->cproot_flags, CP_ROOT_AUTO_ROLL_OLD_CLASS_GENERATION)+ && cp_get_crypto_generation(cpr->cp_pclass) == hfsmp->cp_crypto_generation) {+ return true;+ }++ if (!hfsmp->hfs_auto_roll_min_key_os_version+ && !hfsmp->hfs_auto_roll_max_key_os_version) {+ // No minimum or maximum set+ return false;+ }++ if (hfsmp->hfs_auto_roll_min_key_os_version+ && cpr->cp_key_os_version < hfsmp->hfs_auto_roll_min_key_os_version) {+ // Before minimum+ return false;+ }++ if (hfsmp->hfs_auto_roll_max_key_os_version+ && cpr->cp_key_os_version >= hfsmp->hfs_auto_roll_max_key_os_version) {+ // Greater than maximum+ return false;+ }++ return true;+}++#endif // HFS_CONFIG_KEY_ROLL++errno_t cp_handle_strategy(buf_t bp)+{+ vnode_t vp = buf_vnode(bp);+ cnode_t *cp = NULL;++ if (bufattr_rawencrypted(buf_attr(bp))+ || !(cp = cp_get_protected_cnode(vp))+ || !cp->c_cpentry) {+ // Nothing to do+ return 0;+ }++ /*+ * For filesystem resize, we may not have access to the underlying+ * file's cache key for whatever reason (device may be locked).+ * However, we do not need it since we are going to use the+ * temporary HFS-wide resize key which is generated once we start+ * relocating file content. If this file's I/O should be done+ * using the resize key, it will have been supplied already, so do+ * not attach the file's cp blob to the buffer.+ */+ if (ISSET(cp->c_cpentry->cp_flags, CP_RELOCATION_INFLIGHT))+ return 0;++#if HFS_CONFIG_KEY_ROLL+ /*+ * We don't require any locks here. Pages will be locked so no+ * key rolling can take place until this I/O has completed.+ */+ if (!cp->c_cpentry->cp_key_roll_ctx)+#endif+ {+ // Fast path+ cpx_t cpx = cpkp_cpx(cp->c_cpentry->cp_keys);++ if (cpx_has_key(cpx)) {+ bufattr_setcpx(buf_attr(bp), cpx);+ return 0;+ }+ }++ /*+ * We rely mostly (see note below) upon the truncate lock to+ * protect the CP cache key from getting tossed prior to our IO+ * finishing here. Nearly all cluster io calls to manipulate file+ * payload from HFS take the truncate lock before calling into the+ * cluster layer to ensure the file size does not change, or that+ * they have exclusive right to change the EOF of the file. That+ * same guarantee protects us here since the code that deals with+ * CP lock events must now take the truncate lock before doing+ * anything.+ *+ * If you want to change content protection structures, then the+ * truncate lock is not sufficient; you must take the truncate+ * lock and then wait for outstanding writes to complete. This is+ * necessary because asynchronous I/O only holds the truncate lock+ * whilst I/O is being queued.+ *+ * One exception should be the VM swapfile IO, because HFS will+ * funnel the VNOP_PAGEOUT directly into a cluster_pageout call+ * for the swapfile code only without holding the truncate lock.+ * This is because individual swapfiles are maintained at+ * fixed-length sizes by the VM code. In non-swapfile IO we use+ * PAGEOUT_V2 semantics which allow us to create our own UPL and+ * thus take the truncate lock before calling into the cluster+ * layer. In that case, however, we are not concerned with the CP+ * blob being wiped out in the middle of the IO because there+ * isn't anything to toss; the VM swapfile key stays in-core as+ * long as the file is open.+ */++ off_rsrc_t off_rsrc = off_rsrc_make(buf_lblkno(bp) * GetLogicalBlockSize(vp),+ VNODE_IS_RSRC(vp));+ cp_io_params_t io_params;+++ /*+ * We want to take the cnode lock here and because the vnode write+ * count is a pseudo-lock, we need to do something to preserve+ * lock ordering; the cnode lock comes before the write count.+ * Ideally, the write count would be incremented after the+ * strategy routine returns, but that becomes complicated if the+ * strategy routine where to call buf_iodone before returning.+ * For now, we drop the write count here and then pick it up again+ * later.+ */+ if (!ISSET(buf_flags(bp), B_READ) && !ISSET(buf_flags(bp), B_RAW))+ vnode_writedone(vp);++ hfs_lock_always(cp, HFS_SHARED_LOCK);+ cp_io_params(VTOHFS(vp), cp->c_cpentry, off_rsrc,+ ISSET(buf_flags(bp), B_READ) ? VNODE_READ : VNODE_WRITE,+ &io_params);+ hfs_unlock(cp);++ /*+ * Last chance: If this data protected I/O does not have unwrapped+ * keys present, then try to get them. We already know that it+ * should, by this point.+ */+ if (!cpx_has_key(io_params.cpx)) {+ int io_op = ( (buf_flags(bp) & B_READ) ? CP_READ_ACCESS : CP_WRITE_ACCESS);+ errno_t error = cp_handle_vnop(vp, io_op, 0);+ if (error) {+ /*+ * We have to be careful here. By this point in the I/O+ * path, VM or the cluster engine has prepared a buf_t+ * with the proper file offsets and all the rest, so+ * simply erroring out will result in us leaking this+ * particular buf_t. We need to properly decorate the+ * buf_t just as buf_strategy would so as to make it+ * appear that the I/O errored out with the particular+ * error code.+ */+ if (!ISSET(buf_flags(bp), B_READ) && !ISSET(buf_flags(bp), B_RAW))+ vnode_startwrite(vp);+ buf_seterror (bp, error);+ buf_biodone(bp);+ return error;+ }++ hfs_lock_always(cp, HFS_SHARED_LOCK);+ cp_io_params(VTOHFS(vp), cp->c_cpentry, off_rsrc,+ ISSET(buf_flags(bp), B_READ) ? VNODE_READ : VNODE_WRITE,+ &io_params);+ hfs_unlock(cp);+ }++ hfs_assert(buf_count(bp) <= io_params.max_len);+ bufattr_setcpx(buf_attr(bp), io_params.cpx);++ if (!ISSET(buf_flags(bp), B_READ) && !ISSET(buf_flags(bp), B_RAW))+ vnode_startwrite(vp);++ return 0;+}++#endif /* CONFIG_PROTECT */diff --git a/xnu/files/bsd/hfs/hfs_cprotect.h b/xnu/files/bsd/hfs/hfs_cprotect.hnew file mode 100644index 0000000..e788448--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_cprotect.h@@ -0,0 +1,424 @@+/*+ * Copyright (c) 2009-2015 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@+ */++#ifndef HFS_CPROTECT_H_+#define HFS_CPROTECT_H_++#if CONFIG_PROTECT++#include <sys/cprotect.h>++#include <sys/cdefs.h>+#include <sys/content_protection.h>+#include <sys/kernel_types.h>+#include <crypto/aes.h>+#include <sys/kdebug.h>++#include "hfs.h"+#include "hfs_fsctl.h"++__BEGIN_DECLS++#define CP_IV_KEYSIZE 16 /* 16x8 = 128 */+#define CP_MAX_KEYSIZE 32 /* 8x4 = 32, 32x8 = 256 */+#define CP_MAX_CACHEBUFLEN 64 /* Maximum size of cp cache buffer/array */++#define CP_INITIAL_WRAPPEDKEYSIZE 40+#define CP_V2_WRAPPEDKEYSIZE 40 /* Size of the wrapped key in a v2 EA */+#define CP_V4_RESERVEDBYTES 16 /* Number of reserved bytes in EA still present */++#define CP_LOCKED_KEYCHAIN 0+#define CP_UNLOCKED_KEYCHAIN 1++#define CONTENT_PROTECTION_XATTR_NAME "com.apple.system.cprotect"+#define CONTENT_PROTECTION_XATTR_NAME_CHARS \+ { 'c', 'o', 'm', '.', 'a', 'p', 'p', 'l', 'e', \+ '.', 's', 'y', 's', 't', 'e', 'm', \+ '.', 'c', 'p', 'r', 'o', 't', 'e', 'c', 't' }+#define CP_CURRENT_VERS CP_VERS_5+#define CP_VERS_5 5 // iOS 8.1+#define CP_VERS_4 4 // iOS 5+#define CP_VERS_2 2 // iOS 4+#define CP_MINOR_VERS 0++/* the class occupies the lowest 5 bits, so there are 32 values (0-31) */+#define CP_EFFECTIVE_CLASSMASK 0x0000001f++/* macros for quick access/typing to mask out the classmask */+#define CP_CLASS(x) ((cp_key_class_t)(CP_EFFECTIVE_CLASSMASK & (x)))++#define CP_CRYPTO_G1 0x00000020++typedef struct cp_xattr *cp_xattr_t;+typedef struct cnode * cnode_ptr_t;+//forward declare the struct.+struct hfsmount;++/*+ * Flags for Key Generation Behavior+ *+ * These are passed to cp_generate_keys() and cp_new() in the+ * flags arguments+ */+#define CP_KEYWRAP_DIFFCLASS 0x00000001 /* wrapping with a different class bag is OK */++/*+ * off_rsrc_t: this structure represents an offset and whether or not it's+ * the resource fork. It's done this way so that we can easily do comparisons+ * i.e.+ *+ * { 0, data-fork } < { 100, rsrc-fork }+ */++enum {+ OFF_RSRC_BIT = 0x4000000000000000,+};++typedef int64_t off_rsrc_t;++static inline bool off_rsrc_is_rsrc(off_rsrc_t off_rsrc)+{+ return off_rsrc & OFF_RSRC_BIT;+}++static inline off_t off_rsrc_get_off(off_rsrc_t off_rsrc)+{+ return off_rsrc & (OFF_RSRC_BIT - 1);+}++static inline off_rsrc_t off_rsrc_make(off_t offset, bool is_rsrc)+{+ return offset | (is_rsrc ? OFF_RSRC_BIT : 0);+}++// -- struct cp_key_pair --++/*+ * This structure maintains the pair of keys; the persistent, wrapped key that+ * is written to disk, and the unwrapped key (cpx_t) that we pass to lower+ * layers.+ */++typedef struct cp_key_pair {+ uint16_t cpkp_max_pers_key_len;+ uint16_t cpkp_pers_key_len;+ uint8_t cpkp_cpx[];++ // cpkp_cpx is variable length so the location of the persistent key varies+ // uint8_t cpkp_persistent_key[];+} cp_key_pair_t;++// -- struct cprotect --++/*+ * Runtime-only structure containing the content protection status for+ * the given file. This is referenced by the cnode. It has the+ * variable length key pair at the end.+ */++typedef uint32_t cp_flags_t;+enum {+ CP_NO_XATTR = 0x01, /* Key info has not been saved as EA to the FS */+ CP_RELOCATION_INFLIGHT = 0x02, /* File with offset IVs is in the process of being relocated. */++#if HFS_CONFIG_KEY_ROLL+ // These flags are only set if you ask for basic info from read_xattr_v5+ CP_KEY_IS_ROLLING = 0x04, /* File is in the middle of key rolling */+#endif+ CP_HAS_A_KEY = 0x08, /* File has a non-zero length key */+};++typedef struct cprotect {+#if DEBUG+ uint32_t cp_magic1;+#endif+ cp_flags_t cp_flags;+ cp_key_class_t cp_pclass; /* persistent class stored on-disk */+ void* cp_backing_cnode;+ cp_key_os_version_t cp_key_os_version;+ cp_key_revision_t cp_key_revision;+ uint16_t cp_raw_open_count;+#if HFS_CONFIG_KEY_ROLL+ struct hfs_cp_key_roll_ctx *cp_key_roll_ctx;+#endif+ cp_key_pair_t *cp_keys; // Variable length+} *cprotect_t;++// -- On-Disk Structures --++typedef uint32_t cp_xattr_flags_t;+enum {+ /*+ * Be careful about using flags 0x02 to 0x20. Older code used to write+ * flags that were used for in-memory purposes to disk and therefore+ * they might be used in V4 structures. Here's what they were:+ *+ * CP_KEY_FLUSHED 0x02 Should never have made it to disk+ * CP_NO_XATTR 0x04 Should never have made it to disk+ * CP_OFF_IV_ENABLED 0x08 Probably made it to disk+ * CP_RELOCATION_INFLIGHT 0x10 Should never have made it to disk+ * CP_SEP_WRAPPEDKEY 0x20 Probably made it to disk+ *+ */++ CP_XAF_NEEDS_KEYS = 0x0001, /* V4 only: file needs persistent keys */++};++/*+ * V2 structure written as the per-file EA payload+ * All on-disk multi-byte fields for the CP XATTR must be stored+ * little-endian on-disk. This means they must be endian swapped to+ * L.E on getxattr() and converted to LE on setxattr().+ *+ * This structure is a fixed length and is tightly packed.+ * 56 bytes total.+ */+struct cp_xattr_v2 {+ u_int16_t xattr_major_version;+ u_int16_t xattr_minor_version;+ cp_xattr_flags_t flags;+ u_int32_t persistent_class;+ u_int32_t key_size;+ uint8_t persistent_key[CP_V2_WRAPPEDKEYSIZE];+} __attribute__((aligned(2), packed));+++/*+ * V4 Content Protection EA On-Disk Layout.+ *+ * This structure must be tightly packed, but the *size can vary*+ * depending on the length of the key. At MOST, the key length will be+ * CP_MAX_WRAPPEDKEYSIZE, but the length is defined by the key_size field.+ *+ * Either way, the packing must be applied to ensure that the key data is+ * retrievable in the right location relative to the start of the struct.+ *+ * Fully packed, this structure can range from :+ * MIN: 36 bytes (no key -- used with directories)+ * MAX: 164 bytes (with 128 byte key)+ *+ * During runtime we always allocate with the full 128 byte key, but only+ * use as much of the key buffer as needed. It must be tightly packed, though.+ */++struct cp_xattr_v4 {+ u_int16_t xattr_major_version;+ u_int16_t xattr_minor_version;+ cp_xattr_flags_t flags;+ cp_key_class_t persistent_class;+ u_int32_t key_size;+ // This field will be zero on older systems+ cp_key_os_version_t key_os_version;+ /* CP V4 Reserved Bytes == 16 */+ u_int8_t reserved[CP_V4_RESERVEDBYTES];+ /* All above fields are fixed regardless of key length (36 bytes) */+ /* Max Wrapped Size == 128 */+ uint8_t persistent_key[CP_MAX_WRAPPEDKEYSIZE];+} __attribute__((aligned(2), packed));++// -- Version 5 --++#if HFS_CONFIG_KEY_ROLL+struct cp_roll_info {+ off_rsrc_t off_rsrc;+ uint16_t key_len;+ uint8_t key[CP_MAX_WRAPPEDKEYSIZE];+} __attribute__((aligned(2), packed));+#endif++struct cp_xattr_v5 {+ uint16_t xattr_major_version;+ uint16_t xattr_minor_version;+ cp_xattr_flags_t flags;+ cp_key_class_t persistent_class;+ cp_key_os_version_t key_os_version;+ cp_key_revision_t key_revision;+ uint16_t key_len;++ // 20 bytes to here++ // Variable length from here+ uint8_t persistent_key[CP_MAX_WRAPPEDKEYSIZE];++#if HFS_CONFIG_KEY_ROLL+ // NOTE: data not necessarily here because preceding is variable+ uint8_t roll_key_[sizeof(struct cp_roll_info)];+#endif++ // Wouldn't be necessary if xattr routines returned just what we ask for+ uint8_t spare[512];+} __attribute__((aligned(2), packed));++enum {+ CP_XATTR_MIN_LEN = 20, // Minimum length for all versions+};++/*+ * The Root Directory's EA (fileid 1) is special; it defines information about+ * what capabilities the filesystem is using.+ *+ * The data is still stored little endian.+ */+struct cp_root_xattr {+ u_int16_t major_version;+ u_int16_t minor_version;+ u_int64_t flags;+#if HFS_CONFIG_KEY_ROLL+ cp_key_os_version_t auto_roll_min_version;+ cp_key_os_version_t auto_roll_max_version;+#endif+} __attribute__((aligned(2), packed));++enum {+ CP_ROOT_XATTR_MIN_LEN = 12,+};+++// -- Function Prototypes --++int cp_entry_init(cnode_ptr_t, struct mount *);+int cpx_gentempkeys(cpx_t *pcpx, struct hfsmount *hfsmp);+void cp_entry_destroy(struct hfsmount *hfsmp, struct cprotect *entry_ptr);+void cp_replace_entry (struct hfsmount *hfsmp, struct cnode *cp, struct cprotect *newentry);+cnode_ptr_t cp_get_protected_cnode(vnode_t);+int cp_fs_protected (mount_t);+int cp_getrootxattr (struct hfsmount *hfsmp, struct cp_root_xattr *outxattr);+int cp_setrootxattr (struct hfsmount *hfsmp, struct cp_root_xattr *newxattr);+int cp_generate_keys (struct hfsmount *hfsmp, struct cnode *cp,+ cp_key_class_t targetclass, uint32_t flags,+ struct cprotect **newentry);+int cp_setup_newentry (struct hfsmount *hfsmp, struct cnode *dcp,+ cp_key_class_t suppliedclass, mode_t cmode,+ struct cprotect **tmpentry);+int cp_is_valid_class (int isdir, int32_t protectionclass);+int cp_set_trimmed(struct hfsmount*);+int cp_set_rewrapped(struct hfsmount *);+int cp_flop_generation (struct hfsmount*);+bool cp_is_supported_version(uint16_t version);+int cp_vnode_getclass(struct vnode *vp, cp_key_class_t *class);+int cp_vnode_setclass(struct vnode *vp, cp_key_class_t newclass);+int cp_get_root_major_vers(vnode_t vp, uint32_t *level);+int cp_vnode_transcode(vnode_t vp, cp_key_t *k);+int cp_get_default_level (struct vnode *vp, uint32_t *level);+void cp_device_locked_callback(mount_t mp, cp_lock_state_t state);++#if HFS_CONFIG_KEY_ROLL+bool cp_should_auto_roll(struct hfsmount *hfsmp, cprotect_t cpr);+errno_t cp_set_auto_roll(struct hfsmount *hfsmp,+ const hfs_key_auto_roll_args_t *args);+#endif++typedef struct cp_io_params {+ // The key to use+ cpx_t cpx;++ /*+ * The physical offset for this I/O or -1 if unknown (i.e. caller must+ * do a regular look up).+ */+ off_t phys_offset;++ // The maximum length allowed for this I/O+ off_t max_len;+} cp_io_params_t;++// Return the I/O parameters for this I/O+void cp_io_params(struct hfsmount *hfsmp, cprotect_t cpr, off_rsrc_t off_rsrc,+ int direction, cp_io_params_t *io_params);++int cp_setxattr(struct cnode *cp, struct cprotect *entry, struct hfsmount *hfsmp,+ uint32_t fileid, int xattr_opts);++typedef void * (* cp_new_alloc_fn)(const void *old, uint16_t pers_key_len,+ uint16_t cached_key_len,+ cp_key_pair_t **pcpkp);++int cp_new(cp_key_class_t *newclass_eff, struct hfsmount *hfsmp,+ struct cnode *cp, mode_t cmode, int32_t keyflags,+ cp_key_revision_t key_revision,+ cp_new_alloc_fn alloc_fn, void **pholder);++int cp_rewrap(struct cnode *cp, __unused struct hfsmount *hfsmp,+ cp_key_class_t *newclass, cp_key_pair_t *cpkp, const void *old_holder,+ cp_new_alloc_fn alloc_fn, void **pholder);++cprotect_t cp_entry_alloc(cprotect_t old, uint16_t pers_keylen,+ uint16_t cached_key_len, cp_key_pair_t **pcpkp);++cp_key_os_version_t cp_os_version(void);++cp_key_revision_t cp_next_key_revision(cp_key_revision_t rev);++typedef uint32_t cp_getxattr_options_t;+enum {+ // Return just basic information (not the key)+ CP_GET_XATTR_BASIC_INFO = 1,+};++int cp_read_xattr_v5(struct hfsmount *hfsmp, struct cp_xattr_v5 *xattr,+ size_t xattr_len, cprotect_t *pcpr, cp_getxattr_options_t options);+++errno_t cp_handle_strategy(buf_t bp);++typedef enum {+ CP_READ_ACCESS = 0x1,+ CP_WRITE_ACCESS = 0x2+} cp_mode_t;++int cp_handle_open(struct vnode *vp, int mode);+int cp_handle_vnop(struct vnode *vp, int mode, int ioflag);++// -- cp_key_pair_t functions --++size_t cpkp_size(uint16_t pers_key_len, uint16_t cached_key_len);+size_t cpkp_sizex(const cp_key_pair_t *cpkp);+void cpkp_init(cp_key_pair_t *cpkp, uint16_t max_pers_key_len,+ uint16_t max_cached_key_len);+void cpkp_flush(cp_key_pair_t *cpkp);+void cpkp_copy(const cp_key_pair_t *src, cp_key_pair_t *dst);+uint16_t cpkp_max_pers_key_len(const cp_key_pair_t *cpkp);+uint16_t cpkp_pers_key_len(const cp_key_pair_t *cpkp);+bool cpkp_can_copy(const cp_key_pair_t *src, const cp_key_pair_t *dst);+cpx_t cpkp_cpx(const cp_key_pair_t *cpkp) __attribute__((pure));++// -- Helper Functions --++static inline int cp_get_crypto_generation (cp_key_class_t protclass) {+ if (protclass & CP_CRYPTO_G1) {+ return 1;+ }+ else return 0;+}++__END_DECLS++#endif // CONFIG_PROTECT++#endif /* !HFS_CPROTECT_H_ */diff --git a/xnu/files/bsd/hfs/hfs_dbg.h b/xnu/files/bsd/hfs/hfs_dbg.hnew file mode 100644index 0000000..eada538--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_dbg.h@@ -0,0 +1,92 @@+/*+ * Copyright (c) 2000, 2005 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@+ */++#ifndef HFS_DBG_H_+#define HFS_DBG_H_++#include <sys/cdefs.h>++__BEGIN_DECLS++#include <stdbool.h>++// So that the analyzer acknowledges assertions...+#if defined(__clang_analyzer__) || DEBUG+#define panic_on_assert true+#else+extern bool panic_on_assert;+#endif++#if DEBUG+extern bool hfs_corruption_panics;+#else+#define hfs_corruption_panics false+#endif++__attribute__((noreturn))+void hfs_assert_fail(const char *file, unsigned line, const char *expr);++#define hfs_assert(expr) \+ do { \+ if (__builtin_expect(panic_on_assert, false) \+ && __builtin_expect(!(expr), false)) { \+ hfs_assert_fail(__FILE__, __LINE__, #expr); \+ } \+ } while (0)++// On production, will printf rather than assert+#define hfs_warn(format, ...) \+ do { \+ if (__builtin_expect(panic_on_assert, false)) { \+ panic(format, ## __VA_ARGS__); \+ __builtin_unreachable(); \+ } else \+ printf(format, ## __VA_ARGS__); \+ } while (0)++// Quiet on production+#define hfs_debug(format, ...) \+ do { \+ if (__builtin_expect(panic_on_assert, false)) \+ printf(format, ## __VA_ARGS__); \+ } while (0)++// Panic on debug unless boot-arg tells us not to+#define hfs_corruption_debug(format, ...) \+ do { \+ if (__builtin_expect(hfs_corruption_panics, false)) { \+ panic(format, ## __VA_ARGS__); \+ __builtin_unreachable(); \+ } \+ else \+ printf(format, ## __VA_ARGS__); \+ } while (0)++__END_DECLS++#endif // HFS_DBG_H_diff --git a/xnu/files/bsd/hfs/hfs_endian.c b/xnu/files/bsd/hfs/hfs_endian.cnew file mode 100644index 0000000..391bc1c--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_endian.c@@ -0,0 +1,925 @@+/*+ * Copyright (c) 2000-2015 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@+ */++/*+ * hfs_endian.c+ *+ * This file implements endian swapping routines for the HFS/HFS Plus+ * volume format.+ */++#include "hfs_endian.h"+#include "hfs_dbg.h"+#include "BTreesPrivate.h"++#undef ENDIAN_DEBUG++/*+ * Internal swapping routines+ *+ * These routines handle swapping the records of leaf and index nodes. The+ * layout of the keys and records varies depending on the kind of B-tree+ * (determined by fileID).+ *+ * The direction parameter must be kSwapBTNodeBigToHost or kSwapBTNodeHostToBig.+ * The kSwapBTNodeHeaderRecordOnly "direction" is not valid for these routines.+ */+int hfs_swap_HFSPlusBTInternalNode (BlockDescriptor *src, HFSCatalogNodeID fileID, enum HFSBTSwapDirection direction);+void hfs_swap_HFSPlusForkData (HFSPlusForkData *src);++/*+ * hfs_swap_HFSPlusForkData+ */+void+hfs_swap_HFSPlusForkData (+ HFSPlusForkData *src+)+{+ int i;++ src->logicalSize = SWAP_BE64 (src->logicalSize);++ src->clumpSize = SWAP_BE32 (src->clumpSize);+ src->totalBlocks = SWAP_BE32 (src->totalBlocks);++ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ src->extents[i].startBlock = SWAP_BE32 (src->extents[i].startBlock);+ src->extents[i].blockCount = SWAP_BE32 (src->extents[i].blockCount);+ }+}++/*+ * hfs_swap_BTNode+ *+ * NOTE: This operation is not naturally symmetric.+ * We have to determine which way we're swapping things.+ */+int+hfs_swap_BTNode (+ BlockDescriptor *src,+ vnode_t vp,+ enum HFSBTSwapDirection direction,+ u_int8_t allow_empty_node+)+{+ BTNodeDescriptor *srcDesc = src->buffer;+ u_int16_t *srcOffs = NULL;+ BTreeControlBlockPtr btcb = (BTreeControlBlockPtr)VTOF(vp)->fcbBTCBPtr;+ u_int16_t i; /* index to match srcDesc->numRecords */+ int error = 0;++#ifdef ENDIAN_DEBUG+ if (direction == kSwapBTNodeBigToHost) {+ printf ("hfs: BE -> Native Swap\n");+ } else if (direction == kSwapBTNodeHostToBig) {+ printf ("hfs: Native -> BE Swap\n");+ } else if (direction == kSwapBTNodeHeaderRecordOnly) {+ printf ("hfs: Not swapping descriptors\n");+ } else {+ panic ("hfs_swap_BTNode: This is impossible");+ }+#endif++ /*+ * If we are doing a swap from on-disk to in-memory, then swap the node+ * descriptor and record offsets before we need to use them.+ */+ if (direction == kSwapBTNodeBigToHost) {+ srcDesc->fLink = SWAP_BE32 (srcDesc->fLink);+ srcDesc->bLink = SWAP_BE32 (srcDesc->bLink);++ /*+ * When first opening a BTree, we have to read the header node before the+ * control block is initialized. In this case, totalNodes will be zero,+ * so skip the bounds checking. Also, we should ignore the header node when+ * checking for invalid forwards and backwards links, since the header node's+ * links can point back to itself legitimately.+ */+ if (btcb->totalNodes != 0) {+ if (srcDesc->fLink >= btcb->totalNodes) {+ hfs_corruption_debug("hfs_swap_BTNode: invalid forward link (0x%08x >= 0x%08x)\n", srcDesc->fLink, btcb->totalNodes);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }+ if (srcDesc->bLink >= btcb->totalNodes) {+ hfs_corruption_debug("hfs_swap_BTNode: invalid backward link (0x%08x >= 0x%08x)\n", srcDesc->bLink, btcb->totalNodes);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }++ if ((src->blockNum != 0) && (srcDesc->fLink == (u_int32_t) src->blockNum)) {+ hfs_corruption_debug("hfs_swap_BTNode: invalid forward link (0x%08x == 0x%08x)\n", srcDesc->fLink, (u_int32_t) src->blockNum);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }+ if ((src->blockNum != 0) && (srcDesc->bLink == (u_int32_t) src->blockNum)) {+ hfs_corruption_debug("hfs_swap_BTNode: invalid backward link (0x%08x == 0x%08x)\n", srcDesc->bLink, (u_int32_t) src->blockNum);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }+++ }++ /*+ * Check srcDesc->kind. Don't swap it because it's only one byte.+ */+ if (srcDesc->kind < kBTLeafNode || srcDesc->kind > kBTMapNode) {+ printf("hfs_swap_BTNode: invalid node kind (%d)\n", srcDesc->kind);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }++ /*+ * Check srcDesc->height. Don't swap it because it's only one byte.+ */+ if (srcDesc->height > kMaxTreeDepth) {+ printf("hfs_swap_BTNode: invalid node height (%d)\n", srcDesc->height);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }++ /* Don't swap srcDesc->reserved */++ srcDesc->numRecords = SWAP_BE16 (srcDesc->numRecords);++ /*+ * Swap the node offsets (including the free space one!).+ */+ srcOffs = (u_int16_t *)((char *)src->buffer + (src->blockSize - ((srcDesc->numRecords + 1) * sizeof (u_int16_t))));++ /*+ * Sanity check that the record offsets are within the node itself.+ */+ if ((char *)srcOffs > ((char *)src->buffer + src->blockSize) ||+ (char *)srcOffs < ((char *)src->buffer + sizeof(BTNodeDescriptor))) {+ printf("hfs_swap_BTNode: invalid record count (0x%04X)\n", srcDesc->numRecords);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }++ /*+ * Swap and sanity check each of the record offsets.+ */+ for (i = 0; i <= srcDesc->numRecords; i++) {+ srcOffs[i] = SWAP_BE16 (srcOffs[i]);++ /*+ * Sanity check: must be even, and within the node itself.+ *+ * We may be called to swap an unused node, which contains all zeroes.+ * Unused nodes are expected only when allow_empty_node is true.+ * If it is false and record offset is zero, return error.+ */+ if ((srcOffs[i] & 1) || (+ (allow_empty_node == false) && (srcOffs[i] == 0)) ||+ (srcOffs[i] < sizeof(BTNodeDescriptor) && srcOffs[i] != 0) ||+ (srcOffs[i] > (src->blockSize - 2 * (srcDesc->numRecords + 1)))) {+ printf("hfs_swap_BTNode: offset #%d invalid (0x%04X) (blockSize 0x%x numRecords %d)\n",+ i, srcOffs[i], src->blockSize, srcDesc->numRecords);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }++ /*+ * Make sure the offsets are strictly increasing. Note that we're looping over+ * them backwards, hence the order in the comparison.+ */+ if ((i != 0) && (srcOffs[i] >= srcOffs[i-1])) {+ printf("hfs_swap_BTNode: offsets %d and %d out of order (0x%04X, 0x%04X)\n",+ i, i-1, srcOffs[i], srcOffs[i-1]);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }+ }+ }++ /*+ * Swap the records (ordered by frequency of access)+ */+ if ((srcDesc->kind == kBTIndexNode) ||+ (srcDesc-> kind == kBTLeafNode)) {++ if (VTOVCB(vp)->vcbSigWord == kHFSPlusSigWord) {+ error = hfs_swap_HFSPlusBTInternalNode (src, VTOC(vp)->c_fileid, direction);+ }++ if (error) goto fail;++ } else if (srcDesc-> kind == kBTMapNode) {+ /* Don't swap the bitmaps, they'll be done in the bitmap routines */++ } else if (srcDesc-> kind == kBTHeaderNode) {+ /* The header's offset is hard-wired because we cannot trust the offset pointers. */+ BTHeaderRec *srcHead = (BTHeaderRec *)((char *)src->buffer + sizeof(BTNodeDescriptor));++ srcHead->treeDepth = SWAP_BE16 (srcHead->treeDepth);++ srcHead->rootNode = SWAP_BE32 (srcHead->rootNode);+ srcHead->leafRecords = SWAP_BE32 (srcHead->leafRecords);+ srcHead->firstLeafNode = SWAP_BE32 (srcHead->firstLeafNode);+ srcHead->lastLeafNode = SWAP_BE32 (srcHead->lastLeafNode);++ srcHead->nodeSize = SWAP_BE16 (srcHead->nodeSize);+ srcHead->maxKeyLength = SWAP_BE16 (srcHead->maxKeyLength);++ srcHead->totalNodes = SWAP_BE32 (srcHead->totalNodes);+ srcHead->freeNodes = SWAP_BE32 (srcHead->freeNodes);++ srcHead->clumpSize = SWAP_BE32 (srcHead->clumpSize);+ srcHead->attributes = SWAP_BE32 (srcHead->attributes);++ /* Don't swap srcHead->reserved1 */+ /* Don't swap srcHead->btreeType; it's only one byte */+ /* Don't swap srcHead->reserved2 */+ /* Don't swap srcHead->reserved3 */+ /* Don't swap bitmap */+ }++ /*+ * If we are doing a swap from in-memory to on-disk, then swap the node+ * descriptor and record offsets after we're done using them.+ */+ if (direction == kSwapBTNodeHostToBig) {+ /*+ * Sanity check and swap the forward and backward links.+ * Ignore the header node since its forward and backwards links can legitimately+ * point to itself.+ */+ if (srcDesc->fLink >= btcb->totalNodes) {+ panic("hfs_UNswap_BTNode: invalid forward link (0x%08X)\n", srcDesc->fLink);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }+ if ((src->blockNum != 0) && (srcDesc->fLink == (u_int32_t) src->blockNum)) {+ panic ("hfs_UNswap_BTNode: invalid forward link (0x%08x == 0x%08x)\n",+ srcDesc->fLink, (u_int32_t) src->blockNum);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }++ if (srcDesc->bLink >= btcb->totalNodes) {+ panic("hfs_UNswap_BTNode: invalid backward link (0x%08X)\n", srcDesc->bLink);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }+ if ((src->blockNum != 0) && (srcDesc->bLink == (u_int32_t) src->blockNum)) {+ panic ("hfs_UNswap_BTNode: invalid backward link (0x%08x == 0x%08x)\n",+ srcDesc->bLink, (u_int32_t) src->blockNum);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }+++ srcDesc->fLink = SWAP_BE32 (srcDesc->fLink);+ srcDesc->bLink = SWAP_BE32 (srcDesc->bLink);++ /*+ * Check srcDesc->kind. Don't swap it because it's only one byte.+ */+ if (srcDesc->kind < kBTLeafNode || srcDesc->kind > kBTMapNode) {+ panic("hfs_UNswap_BTNode: invalid node kind (%d)\n", srcDesc->kind);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }++ /*+ * Check srcDesc->height. Don't swap it because it's only one byte.+ */+ if (srcDesc->height > kMaxTreeDepth) {+ panic("hfs_UNswap_BTNode: invalid node height (%d)\n", srcDesc->height);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }++ /* Don't swap srcDesc->reserved */++ /*+ * Swap the node offsets (including the free space one!).+ */+ srcOffs = (u_int16_t *)((char *)src->buffer + (src->blockSize - ((srcDesc->numRecords + 1) * sizeof (u_int16_t))));++ /*+ * Sanity check that the record offsets are within the node itself.+ */+ if ((char *)srcOffs > ((char *)src->buffer + src->blockSize) ||+ (char *)srcOffs < ((char *)src->buffer + sizeof(BTNodeDescriptor))) {+ panic("hfs_UNswap_BTNode: invalid record count (0x%04X)\n", srcDesc->numRecords);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }++ /*+ * Swap and sanity check each of the record offsets.+ */+ for (i = 0; i <= srcDesc->numRecords; i++) {+ /*+ * Sanity check: must be even, and within the node itself.+ *+ * We may be called to swap an unused node, which contains all zeroes.+ * This can happen when the last record from a node gets deleted.+ * This is why we allow the record offset to be zero.+ * Unused nodes are expected only when allow_empty_node is true+ * (the caller should set it to true for kSwapBTNodeBigToHost).+ */+ if ((srcOffs[i] & 1) ||+ ((allow_empty_node == false) && (srcOffs[i] == 0)) ||+ (srcOffs[i] < sizeof(BTNodeDescriptor) && srcOffs[i] != 0) ||+ (srcOffs[i] > (src->blockSize - 2 * (srcDesc->numRecords + 1)))) {+ panic("hfs_UNswap_BTNode: offset #%d invalid (0x%04X) (blockSize 0x%x numRecords %d)\n",+ i, srcOffs[i], src->blockSize, srcDesc->numRecords);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }++ /*+ * Make sure the offsets are strictly increasing. Note that we're looping over+ * them backwards, hence the order in the comparison.+ */+ if ((i < srcDesc->numRecords) && (srcOffs[i+1] >= srcOffs[i])) {+ panic("hfs_UNswap_BTNode: offsets %d and %d out of order (0x%04X, 0x%04X)\n",+ i+1, i, srcOffs[i+1], srcOffs[i]);+ error = fsBTInvalidHeaderErr;+ goto fail;+ }++ srcOffs[i] = SWAP_BE16 (srcOffs[i]);+ }++ srcDesc->numRecords = SWAP_BE16 (srcDesc->numRecords);+ }++fail:+ if (error) {+ /*+ * Log some useful information about where the corrupt node is.+ */+ printf("hfs: node=%lld fileID=%u volume=%s device=%s\n", src->blockNum, VTOC(vp)->c_fileid,+ VTOVCB(vp)->vcbVN, vfs_statfs(vnode_mount(vp))->f_mntfromname);+ hfs_mark_inconsistent(VTOVCB(vp), HFS_INCONSISTENCY_DETECTED);+ }++ return (error);+}++int+hfs_swap_HFSPlusBTInternalNode (+ BlockDescriptor *src,+ HFSCatalogNodeID fileID,+ enum HFSBTSwapDirection direction+)+{+ BTNodeDescriptor *srcDesc = src->buffer;+ u_int16_t *srcOffs = (u_int16_t *)((char *)src->buffer + (src->blockSize - (srcDesc->numRecords * sizeof (u_int16_t))));+ char *nextRecord; /* Points to start of record following current one */++ /*+ * i is an int32 because it needs to be negative to index the offset to free space.+ * srcDesc->numRecords is a u_int16_t and is unlikely to become 32-bit so this should be ok.+ */++ int32_t i;+ u_int32_t j;++ if (fileID == kHFSExtentsFileID) {+ HFSPlusExtentKey *srcKey;+ HFSPlusExtentDescriptor *srcRec;+ size_t recordSize; /* Size of the data part of the record, or node number for index nodes */++ if (srcDesc->kind == kBTIndexNode)+ recordSize = sizeof(u_int32_t);+ else+ recordSize = sizeof(HFSPlusExtentDescriptor);++ for (i = 0; i < srcDesc->numRecords; i++) {+ /* Point to the start of the record we're currently checking. */+ srcKey = (HFSPlusExtentKey *)((char *)src->buffer + srcOffs[i]);++ /*+ * Point to start of next (larger offset) record. We'll use this+ * to be sure the current record doesn't overflow into the next+ * record.+ */+ nextRecord = (char *)src->buffer + srcOffs[i-1];++ /*+ * Make sure the key and data are within the buffer. Since both key+ * and data are fixed size, this is relatively easy. Note that this+ * relies on the keyLength being a constant; we verify the keyLength+ * below.+ */+ if ((char *)srcKey + sizeof(HFSPlusExtentKey) + recordSize > nextRecord) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: extents key #%d offset too big (0x%04X)\n", srcDesc->numRecords-i-1, srcOffs[i]);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: extents key #%d offset too big (0x%04X)\n", srcDesc->numRecords-i-1, srcOffs[i]);+ }+ return fsBTInvalidNodeErr;+ }++ if (direction == kSwapBTNodeBigToHost)+ srcKey->keyLength = SWAP_BE16 (srcKey->keyLength);+ if (srcKey->keyLength != sizeof(*srcKey) - sizeof(srcKey->keyLength)) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: extents key #%d invalid length (%d)\n", srcDesc->numRecords-i-1, srcKey->keyLength);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: extents key #%d invalid length (%d)\n", srcDesc->numRecords-i-1, srcKey->keyLength);+ }+ return fsBTInvalidNodeErr;+ }+ srcRec = (HFSPlusExtentDescriptor *)((char *)srcKey + srcKey->keyLength + sizeof(srcKey->keyLength));+ if (direction == kSwapBTNodeHostToBig)+ srcKey->keyLength = SWAP_BE16 (srcKey->keyLength);++ /* Don't swap srcKey->forkType; it's only one byte */+ /* Don't swap srcKey->pad */++ srcKey->fileID = SWAP_BE32 (srcKey->fileID);+ srcKey->startBlock = SWAP_BE32 (srcKey->startBlock);++ if (srcDesc->kind == kBTIndexNode) {+ /* For index nodes, the record data is just a child node number. */+ *((u_int32_t *)srcRec) = SWAP_BE32 (*((u_int32_t *)srcRec));+ } else {+ /* Swap the extent data */+ for (j = 0; j < kHFSPlusExtentDensity; j++) {+ srcRec[j].startBlock = SWAP_BE32 (srcRec[j].startBlock);+ srcRec[j].blockCount = SWAP_BE32 (srcRec[j].blockCount);+ }+ }+ }++ } else if (fileID == kHFSCatalogFileID) {+ HFSPlusCatalogKey *srcKey;+ int16_t *srcPtr;+ u_int16_t keyLength;++ for (i = 0; i < srcDesc->numRecords; i++) {+ /* Point to the start of the record we're currently checking. */+ srcKey = (HFSPlusCatalogKey *)((char *)src->buffer + srcOffs[i]);++ /*+ * Point to start of next (larger offset) record. We'll use this+ * to be sure the current record doesn't overflow into the next+ * record.+ */+ nextRecord = (char *)src->buffer + (uintptr_t)(srcOffs[i-1]);++ /*+ * Make sure we can safely dereference the keyLength and parentID fields.+ */+ if ((char *)srcKey + offsetof(HFSPlusCatalogKey, nodeName.unicode[0]) > nextRecord) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: catalog key #%d offset too big (0x%04X)\n", srcDesc->numRecords-i-1, srcOffs[i]);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: catalog key #%d offset too big (0x%04X)\n", srcDesc->numRecords-i-1, srcOffs[i]);+ }+ return fsBTInvalidNodeErr;+ }++ /*+ * Swap and sanity check the key length+ */+ if (direction == kSwapBTNodeBigToHost)+ srcKey->keyLength = SWAP_BE16 (srcKey->keyLength);+ keyLength = srcKey->keyLength; /* Put it in a local (native order) because we use it several times */+ if (direction == kSwapBTNodeHostToBig)+ srcKey->keyLength = SWAP_BE16 (keyLength);++ /* Sanity check the key length */+ if (keyLength < kHFSPlusCatalogKeyMinimumLength || keyLength > kHFSPlusCatalogKeyMaximumLength) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: catalog key #%d invalid length (%d)\n", srcDesc->numRecords-i-1, keyLength);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: catalog key #%d invalid length (%d)\n", srcDesc->numRecords-i-1, keyLength);+ }+ return fsBTInvalidNodeErr;+ }++ /*+ * Make sure that we can safely dereference the record's type field or+ * an index node's child node number.+ */+ srcPtr = (int16_t *)((char *)srcKey + keyLength + sizeof(srcKey->keyLength));+ if ((char *)srcPtr + sizeof(u_int32_t) > nextRecord) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: catalog key #%d too big\n", srcDesc->numRecords-i-1);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: catalog key #%d too big\n", srcDesc->numRecords-i-1);+ }+ return fsBTInvalidNodeErr;+ }++ srcKey->parentID = SWAP_BE32 (srcKey->parentID);++ /*+ * Swap and sanity check the key's node name+ */+ if (direction == kSwapBTNodeBigToHost)+ srcKey->nodeName.length = SWAP_BE16 (srcKey->nodeName.length);+ /* Make sure name length is consistent with key length */+ if (keyLength < sizeof(srcKey->parentID) + sizeof(srcKey->nodeName.length) ++ srcKey->nodeName.length*sizeof(srcKey->nodeName.unicode[0])) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: catalog record #%d keyLength=%d expected=%lu\n",+ srcDesc->numRecords-i, keyLength, sizeof(srcKey->parentID) + sizeof(srcKey->nodeName.length) ++ srcKey->nodeName.length*sizeof(srcKey->nodeName.unicode[0]));+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: catalog record #%d keyLength=%d expected=%lu\n",+ srcDesc->numRecords-i, keyLength, sizeof(srcKey->parentID) + sizeof(srcKey->nodeName.length) ++ srcKey->nodeName.length*sizeof(srcKey->nodeName.unicode[0]));+ }+ return fsBTInvalidNodeErr;+ }+ for (j = 0; j < srcKey->nodeName.length; j++) {+ srcKey->nodeName.unicode[j] = SWAP_BE16 (srcKey->nodeName.unicode[j]);+ }+ if (direction == kSwapBTNodeHostToBig)+ srcKey->nodeName.length = SWAP_BE16 (srcKey->nodeName.length);++ /*+ * For index nodes, the record data is just the child's node number.+ * Skip over swapping the various types of catalog record.+ */+ if (srcDesc->kind == kBTIndexNode) {+ *((u_int32_t *)srcPtr) = SWAP_BE32 (*((u_int32_t *)srcPtr));+ continue;+ }++ /* Make sure the recordType is in native order before using it. */+ if (direction == kSwapBTNodeBigToHost)+ srcPtr[0] = SWAP_BE16 (srcPtr[0]);++ if (srcPtr[0] == kHFSPlusFolderRecord) {+ HFSPlusCatalogFolder *srcRec = (HFSPlusCatalogFolder *)srcPtr;+ if ((char *)srcRec + sizeof(*srcRec) > nextRecord) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: catalog folder record #%d too big\n", srcDesc->numRecords-i-1);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: catalog folder record #%d too big\n", srcDesc->numRecords-i-1);+ }+ return fsBTInvalidNodeErr;+ }++ srcRec->flags = SWAP_BE16 (srcRec->flags);+ srcRec->valence = SWAP_BE32 (srcRec->valence);+ srcRec->folderID = SWAP_BE32 (srcRec->folderID);+ srcRec->createDate = SWAP_BE32 (srcRec->createDate);+ srcRec->contentModDate = SWAP_BE32 (srcRec->contentModDate);+ srcRec->attributeModDate = SWAP_BE32 (srcRec->attributeModDate);+ srcRec->accessDate = SWAP_BE32 (srcRec->accessDate);+ srcRec->backupDate = SWAP_BE32 (srcRec->backupDate);++ srcRec->bsdInfo.ownerID = SWAP_BE32 (srcRec->bsdInfo.ownerID);+ srcRec->bsdInfo.groupID = SWAP_BE32 (srcRec->bsdInfo.groupID);++ /* Don't swap srcRec->bsdInfo.adminFlags; it's only one byte */+ /* Don't swap srcRec->bsdInfo.ownerFlags; it's only one byte */++ srcRec->bsdInfo.fileMode = SWAP_BE16 (srcRec->bsdInfo.fileMode);+ srcRec->bsdInfo.special.iNodeNum = SWAP_BE32 (srcRec->bsdInfo.special.iNodeNum);++ srcRec->textEncoding = SWAP_BE32 (srcRec->textEncoding);++ /* Don't swap srcRec->userInfo */+ /* Don't swap srcRec->finderInfo */+ srcRec->folderCount = SWAP_BE32 (srcRec->folderCount);++ } else if (srcPtr[0] == kHFSPlusFileRecord) {+ HFSPlusCatalogFile *srcRec = (HFSPlusCatalogFile *)srcPtr;+ if ((char *)srcRec + sizeof(*srcRec) > nextRecord) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: catalog file record #%d too big\n", srcDesc->numRecords-i-1);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: catalog file record #%d too big\n", srcDesc->numRecords-i-1);+ }+ return fsBTInvalidNodeErr;+ }++ srcRec->flags = SWAP_BE16 (srcRec->flags);++ srcRec->fileID = SWAP_BE32 (srcRec->fileID);++ srcRec->createDate = SWAP_BE32 (srcRec->createDate);+ srcRec->contentModDate = SWAP_BE32 (srcRec->contentModDate);+ srcRec->attributeModDate = SWAP_BE32 (srcRec->attributeModDate);+ srcRec->accessDate = SWAP_BE32 (srcRec->accessDate);+ srcRec->backupDate = SWAP_BE32 (srcRec->backupDate);++ srcRec->bsdInfo.ownerID = SWAP_BE32 (srcRec->bsdInfo.ownerID);+ srcRec->bsdInfo.groupID = SWAP_BE32 (srcRec->bsdInfo.groupID);++ /* Don't swap srcRec->bsdInfo.adminFlags; it's only one byte */+ /* Don't swap srcRec->bsdInfo.ownerFlags; it's only one byte */++ srcRec->bsdInfo.fileMode = SWAP_BE16 (srcRec->bsdInfo.fileMode);+ srcRec->bsdInfo.special.iNodeNum = SWAP_BE32 (srcRec->bsdInfo.special.iNodeNum);++ srcRec->textEncoding = SWAP_BE32 (srcRec->textEncoding);++ /* If kHFSHasLinkChainBit is set, reserved1 is hl_FirstLinkID.+ * In all other context, it is expected to be zero.+ */+ srcRec->reserved1 = SWAP_BE32 (srcRec->reserved1);++ /* Don't swap srcRec->userInfo */+ /* Don't swap srcRec->finderInfo */+ /* Don't swap srcRec->reserved2 */++ hfs_swap_HFSPlusForkData (&srcRec->dataFork);+ hfs_swap_HFSPlusForkData (&srcRec->resourceFork);++ } else if ((srcPtr[0] == kHFSPlusFolderThreadRecord) ||+ (srcPtr[0] == kHFSPlusFileThreadRecord)) {++ /*+ * Make sure there is room for parentID and name length.+ */+ HFSPlusCatalogThread *srcRec = (HFSPlusCatalogThread *)srcPtr;+ if ((char *) &srcRec->nodeName.unicode[0] > nextRecord) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: catalog thread record #%d too big\n", srcDesc->numRecords-i-1);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: catalog thread record #%d too big\n", srcDesc->numRecords-i-1);+ }+ return fsBTInvalidNodeErr;+ }++ /* Don't swap srcRec->reserved */++ srcRec->parentID = SWAP_BE32 (srcRec->parentID);++ if (direction == kSwapBTNodeBigToHost)+ srcRec->nodeName.length = SWAP_BE16 (srcRec->nodeName.length);++ /*+ * Make sure there is room for the name in the buffer.+ * Then swap the characters of the name itself.+ */+ if ((char *) &srcRec->nodeName.unicode[srcRec->nodeName.length] > nextRecord) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: catalog thread record #%d name too big\n", srcDesc->numRecords-i-1);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: catalog thread record #%d name too big\n", srcDesc->numRecords-i-1);+ }+ return fsBTInvalidNodeErr;+ }+ for (j = 0; j < srcRec->nodeName.length; j++) {+ srcRec->nodeName.unicode[j] = SWAP_BE16 (srcRec->nodeName.unicode[j]);+ }++ if (direction == kSwapBTNodeHostToBig)+ srcRec->nodeName.length = SWAP_BE16 (srcRec->nodeName.length);++ } else {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: unrecognized catalog record type (0x%04X; record #%d)\n", srcPtr[0], srcDesc->numRecords-i-1);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: unrecognized catalog record type (0x%04X; record #%d)\n", srcPtr[0], srcDesc->numRecords-i-1);+ }+ return fsBTInvalidNodeErr;+ }++ /* We can swap the record type now that we're done using it. */+ if (direction == kSwapBTNodeHostToBig)+ srcPtr[0] = SWAP_BE16 (srcPtr[0]);+ }++ } else if (fileID == kHFSAttributesFileID) {+ HFSPlusAttrKey *srcKey;+ HFSPlusAttrRecord *srcRec;+ u_int16_t keyLength;+ u_int32_t attrSize = 0;++ for (i = 0; i < srcDesc->numRecords; i++) {+ /* Point to the start of the record we're currently checking. */+ srcKey = (HFSPlusAttrKey *)((char *)src->buffer + srcOffs[i]);++ /*+ * Point to start of next (larger offset) record. We'll use this+ * to be sure the current record doesn't overflow into the next+ * record.+ */+ nextRecord = (char *)src->buffer + srcOffs[i-1];++ /* Make sure there is room in the buffer for a minimal key */+ if ((char *) &srcKey->attrName[1] > nextRecord) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: attr key #%d offset too big (0x%04X)\n", srcDesc->numRecords-i-1, srcOffs[i]);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: attr key #%d offset too big (0x%04X)\n", srcDesc->numRecords-i-1, srcOffs[i]);+ }+ return fsBTInvalidNodeErr;+ }++ /* Swap the key length field */+ if (direction == kSwapBTNodeBigToHost)+ srcKey->keyLength = SWAP_BE16(srcKey->keyLength);+ keyLength = srcKey->keyLength; /* Keep a copy in native order */+ if (direction == kSwapBTNodeHostToBig)+ srcKey->keyLength = SWAP_BE16(srcKey->keyLength);++ /*+ * Make sure that we can safely dereference the record's type field or+ * an index node's child node number.+ */+ srcRec = (HFSPlusAttrRecord *)((char *)srcKey + keyLength + sizeof(srcKey->keyLength));+ if ((char *)srcRec + sizeof(u_int32_t) > nextRecord) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: attr key #%d too big (%d)\n", srcDesc->numRecords-i-1, keyLength);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: attr key #%d too big (%d)\n", srcDesc->numRecords-i-1, keyLength);+ }+ return fsBTInvalidNodeErr;+ }++ srcKey->fileID = SWAP_BE32(srcKey->fileID);+ srcKey->startBlock = SWAP_BE32(srcKey->startBlock);++ /*+ * Swap and check the attribute name+ */+ if (direction == kSwapBTNodeBigToHost)+ srcKey->attrNameLen = SWAP_BE16(srcKey->attrNameLen);+ /* Sanity check the attribute name length */+ if (srcKey->attrNameLen > kHFSMaxAttrNameLen || keyLength < (kHFSPlusAttrKeyMinimumLength + sizeof(u_int16_t)*srcKey->attrNameLen)) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: attr key #%d keyLength=%d attrNameLen=%d\n", srcDesc->numRecords-i-1, keyLength, srcKey->attrNameLen);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: attr key #%d keyLength=%d attrNameLen=%d\n", srcDesc->numRecords-i-1, keyLength, srcKey->attrNameLen);+ }+ return fsBTInvalidNodeErr;+ }+ for (j = 0; j < srcKey->attrNameLen; j++)+ srcKey->attrName[j] = SWAP_BE16(srcKey->attrName[j]);+ if (direction == kSwapBTNodeHostToBig)+ srcKey->attrNameLen = SWAP_BE16(srcKey->attrNameLen);++ /*+ * For index nodes, the record data is just the child's node number.+ * Skip over swapping the various types of attribute record.+ */+ if (srcDesc->kind == kBTIndexNode) {+ *((u_int32_t *)srcRec) = SWAP_BE32 (*((u_int32_t *)srcRec));+ continue;+ }++ /* Swap the record data */+ if (direction == kSwapBTNodeBigToHost)+ srcRec->recordType = SWAP_BE32(srcRec->recordType);+ switch (srcRec->recordType) {+ case kHFSPlusAttrInlineData:+ /* Is there room for the inline data header? */+ if ((char *) &srcRec->attrData.attrData[0] > nextRecord) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: attr inline #%d too big\n", srcDesc->numRecords-i-1);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: attr inline #%d too big\n", srcDesc->numRecords-i-1);+ }+ return fsBTInvalidNodeErr;+ }++ /* We're not swapping the reserved fields */++ /* Swap the attribute size */+ if (direction == kSwapBTNodeHostToBig)+ attrSize = srcRec->attrData.attrSize;+ srcRec->attrData.attrSize = SWAP_BE32(srcRec->attrData.attrSize);+ if (direction == kSwapBTNodeBigToHost)+ attrSize = srcRec->attrData.attrSize;++ /* Is there room for the inline attribute data? */+ if ((char *) &srcRec->attrData.attrData[attrSize] > nextRecord) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: attr inline #%d too big (attrSize=%u)\n", srcDesc->numRecords-i-1, attrSize);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: attr inline #%d too big (attrSize=%u)\n", srcDesc->numRecords-i-1, attrSize);+ }+ return fsBTInvalidNodeErr;+ }++ /* Not swapping the attribute data itself */+ break;++ case kHFSPlusAttrForkData:+ /* Is there room for the fork data record? */+ if ((char *)srcRec + sizeof(HFSPlusAttrForkData) > nextRecord) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: attr fork data #%d too big\n", srcDesc->numRecords-i-1);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: attr fork data #%d too big\n", srcDesc->numRecords-i-1);+ }+ return fsBTInvalidNodeErr;+ }++ /* We're not swapping the reserved field */++ hfs_swap_HFSPlusForkData(&srcRec->forkData.theFork);+ break;++ case kHFSPlusAttrExtents:+ /* Is there room for an extent record? */+ if ((char *)srcRec + sizeof(HFSPlusAttrExtents) > nextRecord) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: attr extents #%d too big\n", srcDesc->numRecords-i-1);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: attr extents #%d too big\n", srcDesc->numRecords-i-1);+ }+ return fsBTInvalidNodeErr;+ }++ /* We're not swapping the reserved field */++ for (j = 0; j < kHFSPlusExtentDensity; j++) {+ srcRec->overflowExtents.extents[j].startBlock =+ SWAP_BE32(srcRec->overflowExtents.extents[j].startBlock);+ srcRec->overflowExtents.extents[j].blockCount =+ SWAP_BE32(srcRec->overflowExtents.extents[j].blockCount);+ }+ break;+ }+ if (direction == kSwapBTNodeHostToBig)+ srcRec->recordType = SWAP_BE32(srcRec->recordType);+ }+ } else if (fileID > kHFSFirstUserCatalogNodeID) {+ /* The only B-tree with a non-system CNID that we use is the hotfile B-tree */+ HotFileKey *srcKey;+ u_int32_t *srcRec;++ for (i = 0; i < srcDesc->numRecords; i++) {+ /* Point to the start of the record we're currently checking. */+ srcKey = (HotFileKey *)((char *)src->buffer + srcOffs[i]);++ /*+ * Point to start of next (larger offset) record. We'll use this+ * to be sure the current record doesn't overflow into the next+ * record.+ */+ nextRecord = (char *)src->buffer + srcOffs[i-1];++ /* Make sure there is room for the key (HotFileKey) and data (u_int32_t) */+ if ((char *)srcKey + sizeof(HotFileKey) + sizeof(u_int32_t) > nextRecord) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: hotfile #%d offset too big (0x%04X)\n", srcDesc->numRecords-i-1, srcOffs[i]);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: hotfile #%d offset too big (0x%04X)\n", srcDesc->numRecords-i-1, srcOffs[i]);+ }+ return fsBTInvalidNodeErr;+ }++ /* Swap and sanity check the key length field */+ if (direction == kSwapBTNodeBigToHost)+ srcKey->keyLength = SWAP_BE16 (srcKey->keyLength);+ if (srcKey->keyLength != sizeof(*srcKey) - sizeof(srcKey->keyLength)) {+ if (direction == kSwapBTNodeHostToBig) {+ panic("hfs_swap_HFSPlusBTInternalNode: hotfile #%d incorrect keyLength %d\n", srcDesc->numRecords-i-1, srcKey->keyLength);+ } else {+ printf("hfs_swap_HFSPlusBTInternalNode: hotfile #%d incorrect keyLength %d\n", srcDesc->numRecords-i-1, srcKey->keyLength);+ }+ return fsBTInvalidNodeErr;+ }+ srcRec = (u_int32_t *)((char *)srcKey + srcKey->keyLength + sizeof(srcKey->keyLength));+ if (direction == kSwapBTNodeHostToBig)+ srcKey->keyLength = SWAP_BE16 (srcKey->keyLength);++ /* Don't swap srcKey->forkType */+ /* Don't swap srcKey->pad */++ srcKey->temperature = SWAP_BE32 (srcKey->temperature);+ srcKey->fileID = SWAP_BE32 (srcKey->fileID);++ *((u_int32_t *)srcRec) = SWAP_BE32 (*((u_int32_t *)srcRec));+ }+ } else {+ panic ("hfs_swap_HFSPlusBTInternalNode: fileID %u is not a system B-tree\n", fileID);+ }+++ return (0);+}+diff --git a/xnu/files/bsd/hfs/hfs_endian.h b/xnu/files/bsd/hfs/hfs_endian.hnew file mode 100644index 0000000..a916319--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_endian.h@@ -0,0 +1,105 @@+/*+ * Copyright (c) 2000, 2002-2003, 2005-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@+ */+#ifndef __HFS_ENDIAN_H__+#define __HFS_ENDIAN_H__++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE+/*+ * hfs_endian.h+ *+ * This file prototypes endian swapping routines for the HFS/HFS Plus+ * volume format.+ */+#include "hfs.h"+#include "BTreesInternal.h"+#include <libkern/OSByteOrder.h>++/*********************/+/* BIG ENDIAN Macros */+/*********************/+#define SWAP_BE16(__a) OSSwapBigToHostInt16 (__a)+#define SWAP_BE32(__a) OSSwapBigToHostInt32 (__a)+#define SWAP_BE64(__a) OSSwapBigToHostInt64 (__a)++#if BYTE_ORDER == BIG_ENDIAN++ /* HFS is always big endian, no swapping needed */+ #define SWAP_HFS_PLUS_FORK_DATA(__a)++/************************/+/* LITTLE ENDIAN Macros */+/************************/+#elif BYTE_ORDER == LITTLE_ENDIAN++ #define SWAP_HFS_PLUS_FORK_DATA(__a) hfs_swap_HFSPlusForkData ((__a))++#else+#warning Unknown byte order+#error+#endif++#ifdef __cplusplus+extern "C" {+#endif++/*+ * Constants for the "unswap" argument to hfs_swap_BTNode:+ */+enum HFSBTSwapDirection {+ kSwapBTNodeBigToHost = 0,+ kSwapBTNodeHostToBig = 1,++ /*+ * kSwapBTNodeHeaderRecordOnly is used to swap just the header record+ * of a header node from big endian (on disk) to host endian (in memory).+ * It does not swap the node descriptor (forward/backward links, record+ * count, etc.). It assumes the header record is at offset 0x000E.+ *+ * Since HFS Plus doesn't have fixed B-tree node sizes, we have to read+ * the header record to determine the actual node size for that tree+ * before we can set up the B-tree control block. We read it initially+ * as 512 bytes, then re-read it once we know the correct node size. Since+ * we may not have read the entire header node the first time, we can't+ * swap the record offsets, other records, or do most sanity checks.+ */+ kSwapBTNodeHeaderRecordOnly = 3+};++int hfs_swap_BTNode (BlockDescriptor *src, vnode_t vp, enum HFSBTSwapDirection direction,+ u_int8_t allow_empty_node);++#ifdef __cplusplus+}+#endif++#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */+#endif /* __HFS_FORMAT__ */diff --git a/xnu/files/bsd/hfs/hfs_extents.c b/xnu/files/bsd/hfs/hfs_extents.cnew file mode 100644index 0000000..b9cb133--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_extents.c@@ -0,0 +1,769 @@+/*+ * Copyright (c) 2014-2015 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_EXTENTS_TEST++#include "../tests/hfs_extents_test.h"+#include "hfs_extents.h"++#else++#include "hfs_extents.h"++// In this file, group refers to a set of 8 extents++static uint32_t hfs_total_blocks(const HFSPlusExtentDescriptor *ext, int count);+static errno_t hfs_ext_iter_next_group(struct hfs_ext_iter *iter);+static errno_t hfs_ext_iter_update(struct hfs_ext_iter *iter,+ HFSPlusExtentDescriptor *extents,+ int count,+ HFSPlusExtentRecord cat_extents);+static errno_t hfs_ext_iter_check_group(hfs_ext_iter_t *iter);++#endif++#define CHECK(x, var, goto_label) \+ do { \+ var = (x); \+ if (var) { \+ printf("%s:%u error: %d\n", __func__, __LINE__, var); \+ goto goto_label; \+ } \+ } while (0)++#define hfs_min(a,b) \+ ({ typeof (a) _a = (a); typeof (b) _b = (b); _a < _b ? _a : _b; })++static __attribute__((pure))+const HFSPlusExtentKey *hfs_ext_iter_key(const hfs_ext_iter_t *iter)+{+ return (const HFSPlusExtentKey *)&iter->bt_iter.key;+}++static __attribute__((pure))+HFSPlusExtentKey *hfs_ext_iter_key_mut(hfs_ext_iter_t *iter)+{+ return (HFSPlusExtentKey *)&iter->bt_iter.key;+}++// Returns the total number of blocks for the @count extents provided+uint32_t hfs_total_blocks(const HFSPlusExtentDescriptor *extents, int count)+{+ uint32_t block_count = 0;+ for (int i = 0; i < count; ++i)+ block_count += extents[i].blockCount;+ return block_count;+}++/*+ * Checks a group of extents: makes sure that if it's the last group+ * for a fork, that all the remaining extents are properly zeroed and+ * if it's not then checks that all extents are set. This also sets+ * @group_block_count and @last_in_fork. Returns ESTALE if+ * inconsistent.+ */+errno_t hfs_ext_iter_check_group(hfs_ext_iter_t *iter)+{+ filefork_t *ff = VTOF(iter->vp);+ const HFSPlusExtentKey *key = hfs_ext_iter_key(iter);+ uint32_t count = 0;+ int i;++ for (i = 0; i < kHFSPlusExtentDensity; ++i) {+ if (!iter->group[i].blockCount)+ break;+ count += iter->group[i].blockCount;+ }++ if (i < kHFSPlusExtentDensity) {+ iter->last_in_fork = true;+ if (key->startBlock + count != ff_allocblocks(ff))+ goto bad;++ // Check remainder of extents+ for (++i; i < kHFSPlusExtentDensity; ++i) {+ if (iter->group[i].blockCount)+ goto bad;+ }+ } else {+ if (key->startBlock + count > ff_allocblocks(ff))+ goto bad;++ iter->last_in_fork = (key->startBlock + count == ff_allocblocks(ff));+ }++ iter->group_block_count = count;++ return 0;++bad:++#if DEBUG+ printf("hfs_ext_iter_check_group: bad group; start: %u, total blocks: %u\n",+ key->startBlock, ff_allocblocks(ff));++ for (int j = 0; j < kHFSPlusExtentDensity; ++j) {+ printf("%s<%u, %u>", j ? ", " : "",+ iter->group[j].startBlock, iter->group[j].blockCount);+ }++ printf("\n");+#endif++ return ESTALE;+}++// NOTE: doesn't copy group data+static void hfs_ext_iter_copy(const hfs_ext_iter_t *src, hfs_ext_iter_t *dst)+{+ dst->vp = src->vp;+ memcpy(&dst->bt_iter.key, &src->bt_iter.key, sizeof(HFSPlusExtentKey));++ dst->file_block = src->file_block;+ dst->ndx = src->ndx;++ dst->bt_iter.hint = src->bt_iter.hint;+ dst->bt_iter.version = 0;+ dst->bt_iter.reserved = 0;+ dst->bt_iter.hitCount = 0;+ dst->bt_iter.maxLeafRecs = 0;+}++bool hfs_ext_iter_is_catalog_extents(hfs_ext_iter_t *iter)+{+ return hfs_ext_iter_key(iter)->startBlock == 0;+}++#if !HFS_EXTENTS_TEST++/*+ * Finds the extent for offset. It might be in the catalog or the extents+ * file.+ */+errno_t hfs_ext_find(vnode_t vp, off_t offset, hfs_ext_iter_t *iter)+{+ errno_t ret;+ hfsmount_t *hfsmp = VTOHFS(vp);++ iter->vp = vp;++ uint32_t end_block, index;+ HFSPlusExtentKey *key = hfs_ext_iter_key_mut(iter);++ filefork_t *ff = VTOF(vp);++ CHECK(SearchExtentFile(hfsmp, ff, offset,+ key, iter->group, &index,+ &iter->bt_iter.hint.nodeNum, &end_block), ret, exit);++ iter->ndx = index;+ iter->file_block = end_block - iter->group[index].blockCount;++ if (!key->keyLength) {+ // We're pointing at the catalog record extents so fix up the key+ key->keyLength = kHFSPlusExtentKeyMaximumLength;+ key->forkType = (VNODE_IS_RSRC(iter->vp)+ ? kHFSResourceForkType : kHFSDataForkType);+ key->pad = 0;+ key->fileID = VTOC(iter->vp)->c_fileid;+ key->startBlock = 0;+ }++ CHECK(hfs_ext_iter_check_group(iter), ret, exit);++ ret = 0;++exit:++ return MacToVFSError(ret);+}++static uint32_t hfs_ext_iter_next_group_block(const hfs_ext_iter_t *iter)+{+ const HFSPlusExtentKey *key = hfs_ext_iter_key(iter);++ return key->startBlock + iter->group_block_count;+}++/*+ * Move the iterator to the next group. Don't call if there's a chance+ * there is no entry; the caller should check last_in_fork instead.+ */+static errno_t hfs_ext_iter_next_group(hfs_ext_iter_t *iter)+{+ errno_t ret;+ hfsmount_t *hfsmp = VTOHFS(iter->vp);+ filefork_t * const tree = hfsmp->hfs_extents_cp->c_datafork;+ HFSPlusExtentKey *key = hfs_ext_iter_key_mut(iter);+ const bool catalog_extents = hfs_ext_iter_is_catalog_extents(iter);+ const uint32_t next_block = hfs_ext_iter_next_group_block(iter);++ FSBufferDescriptor fbd = {+ .bufferAddress = &iter->group,+ .itemCount = 1,+ .itemSize = sizeof(iter->group)+ };++ if (catalog_extents) {+ key->startBlock = next_block;++ CHECK(BTSearchRecord(tree, &iter->bt_iter, &fbd, NULL,+ &iter->bt_iter), ret, exit);+ } else {+ const uint32_t file_id = key->fileID;+ const uint8_t fork_type = key->forkType;++ CHECK(BTIterateRecord(tree, kBTreeNextRecord, &iter->bt_iter,+ &fbd, NULL), ret, exit);++ if (key->fileID != file_id+ || key->forkType != fork_type+ || key->startBlock != next_block) {+ // This indicates an inconsistency+ ret = ESTALE;+ goto exit;+ }+ }++ iter->file_block = key->startBlock;+ iter->ndx = 0;++ CHECK(hfs_ext_iter_check_group(iter), ret, exit);++ ret = 0;++exit:++ return MacToVFSError(ret);+}++/*+ * Updates with the extents provided and sets the key up for the next group.+ * It is assumed that any previous record that might collide has been deleted.+ * NOTE: @extents must point to a buffer that can be zero padded to multiple+ * of 8 extents.+ */+errno_t hfs_ext_iter_update(hfs_ext_iter_t *iter,+ HFSPlusExtentDescriptor *extents,+ int count,+ HFSPlusExtentRecord cat_extents)+{+ errno_t ret;+ hfsmount_t *hfsmp = VTOHFS(iter->vp);+ cnode_t *cp = VTOC(iter->vp);+ HFSPlusExtentKey *key = hfs_ext_iter_key_mut(iter);+ int ndx = 0;++ if (!extents)+ extents = iter->group;++ if (count % kHFSPlusExtentDensity) {+ // Zero out last group+ bzero(&extents[count], (kHFSPlusExtentDensity+ - (count % 8)) * sizeof(*extents));+ }++ if (hfs_ext_iter_is_catalog_extents(iter)) {+ // Caller is responsible for in-memory updates++ if (cat_extents)+ hfs_ext_copy_rec(extents, cat_extents);++ struct cat_fork fork;++ hfs_fork_copy(&fork, &VTOF(iter->vp)->ff_data, extents);+ hfs_prepare_fork_for_update(VTOF(iter->vp), &fork, &fork, hfsmp->blockSize);++ bool is_rsrc = VNODE_IS_RSRC(iter->vp);+ CHECK(cat_update(hfsmp, &cp->c_desc, &cp->c_attr,+ is_rsrc ? NULL : &fork,+ is_rsrc ? &fork : NULL), ret, exit);++ // Set the key to the next group+ key->startBlock = hfs_total_blocks(extents, kHFSPlusExtentDensity);++ ndx += 8;+ }++ // Deal with the remainder which must be overflow extents+ for (; ndx < count; ndx += 8) {+ filefork_t * const tree = hfsmp->hfs_extents_cp->c_datafork;++ FSBufferDescriptor fbd = {+ .bufferAddress = &extents[ndx],+ .itemCount = 1,+ .itemSize = sizeof(HFSPlusExtentRecord)+ };++ CHECK(BTInsertRecord(tree, &iter->bt_iter, &fbd,+ sizeof(HFSPlusExtentRecord)), ret, exit);++ // Set the key to the next group+ key->startBlock += hfs_total_blocks(&extents[ndx], kHFSPlusExtentDensity);+ }++ ret = 0;++exit:++ return ret;+}++#endif // !HFS_EXTENTS_TEST++static void push_ext(HFSPlusExtentDescriptor *extents, int *count,+ const HFSPlusExtentDescriptor *ext)+{+ if (!ext->blockCount)+ return;++ if (*count && hfs_ext_end(&extents[*count - 1]) == ext->startBlock)+ extents[*count - 1].blockCount += ext->blockCount;+ else+ extents[(*count)++] = *ext;+}++/*+ * NOTE: Here we rely on the replacement extents not being too big as+ * otherwise the number of BTree records that we have to delete could be+ * too large.+ */+errno_t hfs_ext_replace(hfsmount_t *hfsmp, vnode_t vp,+ uint32_t file_block,+ const HFSPlusExtentDescriptor *repl,+ int repl_count,+ HFSPlusExtentRecord catalog_extents)+{+ errno_t ret;+ filefork_t * const tree = hfsmp->hfs_extents_cp->c_datafork;+ hfs_ext_iter_t *iter_in = NULL, *iter_out;+ HFSPlusExtentDescriptor *extents = NULL;+ int buffered_extents = 0;+ const int max_roll_back_extents = 16384; // 128k+ HFSPlusExtentDescriptor *roll_back_extents = NULL;+ int roll_back_count = 0;+ const uint32_t end_file_block = file_block + hfs_total_blocks(repl, repl_count);+ filefork_t *ff = VTOF(vp);+ uint32_t start_group_block = 0, block = 0;++ // Indicate we haven't touched catalog extents+ catalog_extents[0].blockCount = 0;++ if (end_file_block > ff_allocblocks(ff))+ return EINVAL;++ iter_in = hfs_new(hfs_ext_iter_t, 2);+ iter_out = iter_in + 1;+ HFSPlusExtentKey *key_in = hfs_ext_iter_key_mut(iter_in);++ // Get to where we want to start+ off_t offset = hfs_blk_to_bytes(file_block, hfsmp->blockSize);++ /*+ * If the replacement is at the start of a group, we want to pull in the+ * group before so that we tidy up any padding that we might have done+ * in a prior hfs_ext_replace call.+ */+ if (offset > 0)+ --offset;++ CHECK(hfs_ext_find(vp, offset, iter_in), ret, exit);++ start_group_block = key_in->startBlock;++ roll_back_extents = hfs_new_data(HFSPlusExtentDescriptor, max_roll_back_extents);++ // Move to the first extent in this group+ iter_in->ndx = 0;++ hfs_ext_iter_copy(iter_in, iter_out);++ // Create a buffer for our extents+ buffered_extents = roundup(3 * kHFSPlusExtentDensity + repl_count,+ kHFSPlusExtentDensity);+ extents = hfs_new_data(HFSPlusExtentDescriptor, buffered_extents);+ int count = 0;++ /*+ * Iterate through the extents that are affected by this replace operation.+ * We cannot push more than 16 + repl_count extents here; 8 for the group+ * containing the replacement start, repl_count for the replacements and 8+ * for the group containing the end. If we went back a group due to+ * decrementing the offset above, it's still the same because we know in+ * that case the replacement starts at the beginning of the next group.+ */+ block = start_group_block;+ for (;;) {+ if (!iter_in->ndx) {+ hfs_ext_copy_rec(iter_in->group, &roll_back_extents[roll_back_count]);+ roll_back_count += kHFSPlusExtentDensity;++ if (!hfs_ext_iter_is_catalog_extents(iter_in)) {+ // Delete this extent group; we're going to replace it+ CHECK(BTDeleteRecord(tree, &iter_in->bt_iter), ret, exit);+ }+ }++ HFSPlusExtentDescriptor *ext = &iter_in->group[iter_in->ndx];+ if (!ext->blockCount) {+ /*+ * We ran out of existing extents so we just write the+ * extents and we're done.+ */+ goto finish;+ }++ // If the current extent does not overlap replacement...+ if (block + ext->blockCount <= file_block || block >= end_file_block) {+ // Keep the current extent exactly as it is+ push_ext(extents, &count, ext);+ } else {+ HFSPlusExtentDescriptor dealloc_ext = *ext;++ if (block <= file_block) {+ /*+ * The middle or tail of the current extent overlaps+ * the replacement extents. Keep the non-overlapping+ * head of the current extent.+ */+ uint32_t trimmed_len = file_block - block;++ if (trimmed_len) {+ // Push (keep) non-overlapping head of current extent+ push_ext(extents, &count,+ &(HFSPlusExtentDescriptor){ ext->startBlock,+ trimmed_len });++ /*+ * Deallocate the part of the current extent that+ * overlaps the replacement extents. That starts+ * at @file_block. For now, assume it goes+ * through the end of the current extent. (If the+ * current extent extends beyond the end of the+ * replacement extents, we'll update the+ * blockCount below.)+ */+ dealloc_ext.startBlock += trimmed_len;+ dealloc_ext.blockCount -= trimmed_len;+ }++ // Insert the replacements+ for (int i = 0; i < repl_count; ++i)+ push_ext(extents, &count, &repl[i]);+ }++ if (block + ext->blockCount > end_file_block) {+ /*+ * The head or middle of the current extent overlaps+ * the replacement extents. Keep the non-overlapping+ * tail of the current extent.+ */+ uint32_t overlap = end_file_block - block;++ // Push (keep) non-overlapping tail of current extent+ push_ext(extents, &count,+ &(HFSPlusExtentDescriptor){ ext->startBlock + overlap,+ ext->blockCount - overlap });++ /*+ * Deallocate the part of current extent that overlaps+ * the replacements.+ */+ dealloc_ext.blockCount = (ext->startBlock + overlap+ - dealloc_ext.startBlock);+ }++ CHECK(BlockDeallocate(hfsmp, dealloc_ext.startBlock,+ dealloc_ext.blockCount, 0), ret, exit);+ }++ // Move to next (existing) extent from iterator+ block += ext->blockCount;++ if (++iter_in->ndx >= kHFSPlusExtentDensity) {+ if (block >= end_file_block) {+ if (iter_in->last_in_fork || !(count % kHFSPlusExtentDensity)) {+ /*+ * This is the easy case. We've hit the end or we have a+ * multiple of 8, so we can just write out the extents we+ * have and it should all fit within a transaction.+ */++ goto finish;+ }++ if (count + kHFSPlusExtentDensity > buffered_extents+ || (roll_back_count+ + kHFSPlusExtentDensity > max_roll_back_extents)) {+ /*+ * We've run out of room for the next group, so drop out+ * and take a different strategy.+ */+ break;+ }+ }++ CHECK(hfs_ext_iter_next_group(iter_in), ret, exit);+ }+ } // for (;;)++ /*+ * We're not at the end so we need to try and pad to a multiple of 8+ * so that we don't have to touch all the subsequent records. We pad+ * by stealing single blocks.+ */++ int stop_at = 0;++ for (;;) {+ // @in points to the record we're stealing from+ int in = count - 1;++ count = roundup(count, kHFSPlusExtentDensity);++ // @out is where we put the stolen single blocks+ int out = count - 1;++ do {+ if (out <= in) {+ // We suceeded in padding; we're done+ goto finish;+ }++ /*+ * "Steal" a block, or move a one-block extent within the+ * @extents array.+ *+ * If the extent we're "stealing" from (@in) is only one+ * block long, we'll end up copying it to @out, setting+ * @in's blockCount to zero, and decrementing @in. So, we+ * either split a multi-block extent; or move it within+ * the @extents array.+ */+ extents[out].blockCount = 1;+ extents[out].startBlock = (extents[in].startBlock+ + extents[in].blockCount - 1);+ --out;+ } while (--extents[in].blockCount || --in >= stop_at);++ // We ran out of extents+ if (roll_back_count + kHFSPlusExtentDensity > max_roll_back_extents) {+ ret = ENOSPC;+ goto exit;+ }++ // Need to shift extents starting at out + 1+ ++out;+ memmove(&extents[stop_at], &extents[out],+ (count - out) * sizeof(*extents));+ count -= out - stop_at;++ // Pull in the next group+ CHECK(hfs_ext_iter_next_group(iter_in), ret, exit);++ // Take a copy of these extents for roll back purposes+ hfs_ext_copy_rec(iter_in->group, &roll_back_extents[roll_back_count]);+ roll_back_count += kHFSPlusExtentDensity;++ // Delete this group; we're going to replace it+ CHECK(BTDeleteRecord(tree, &iter_in->bt_iter), ret, exit);++ if (iter_in->last_in_fork) {+ // Great! We've hit the end. Coalesce and write out.+ int old_count = count;+ count = 0;++ /*+ * First coalesce the extents we already have. Takes+ * advantage of push_ext coalescing the input extent with+ * the last extent in @extents. If the extents are not+ * contiguous, then this just copies the extents over+ * themselves and sets @count back to @old_count.+ */+ for (int i = 0; i < old_count; ++i)+ push_ext(extents, &count, &extents[i]);++ // Make room if necessary+ const int flush_count = buffered_extents - kHFSPlusExtentDensity;+ if (count > flush_count) {+ CHECK(hfs_ext_iter_update(iter_out, extents,+ flush_count, catalog_extents), ret, exit);++ memmove(&extents[0], &extents[flush_count],+ (count - flush_count) * sizeof(*extents));++ count -= flush_count;+ }++ // Add in the extents we just read in+ for (int i = 0; i < kHFSPlusExtentDensity; ++i) {+ HFSPlusExtentDescriptor *ext = &iter_in->group[i];+ if (!ext->blockCount)+ break;+ push_ext(extents, &count, ext);+ }++ goto finish;+ } // if (iter_in->last_in_fork)++ /*+ * Otherwise, we're not at the end, so we add these extents and then+ * try and pad out again to a multiple of 8. We start by making room.+ */+ if (count > buffered_extents - kHFSPlusExtentDensity) {+ // Only write out one group here+ CHECK(hfs_ext_iter_update(iter_out, extents,+ kHFSPlusExtentDensity,+ catalog_extents), ret, exit);++ memmove(&extents[0], &extents[kHFSPlusExtentDensity],+ (count - kHFSPlusExtentDensity) * sizeof(*extents));++ count -= kHFSPlusExtentDensity;+ }++ // Record where to stop when padding above+ stop_at = count;++ // Copy in the new extents+ hfs_ext_copy_rec(iter_in->group, &extents[count]);+ count += kHFSPlusExtentDensity;+ } // for (;;)++finish:++ // Write the remaining extents+ CHECK(hfs_ext_iter_update(iter_out, extents, count,+ catalog_extents), ret, exit);++ CHECK(BTFlushPath(hfsmp->hfs_catalog_cp->c_datafork), ret, exit);+ CHECK(BTFlushPath(hfsmp->hfs_extents_cp->c_datafork), ret, exit);++exit:++ if (ret && roll_back_count) {++#define RB_FAILED \+ do { \+ printf("hfs_ext_replace:%u: roll back failed\n", __LINE__); \+ hfs_mark_inconsistent(hfsmp, HFS_ROLLBACK_FAILED); \+ goto roll_back_failed; \+ } while (0)++ // First delete any groups we inserted+ HFSPlusExtentKey *key_out = hfs_ext_iter_key_mut(iter_out);++ key_in->startBlock = start_group_block;+ if (!key_in->startBlock && key_out->startBlock > key_in->startBlock) {+ key_in->startBlock += hfs_total_blocks(catalog_extents,+ kHFSPlusExtentDensity);+ }++ if (key_out->startBlock > key_in->startBlock) {+ FSBufferDescriptor fbd = {+ .bufferAddress = &iter_in->group,+ .itemCount = 1,+ .itemSize = sizeof(iter_in->group)+ };++ if (BTSearchRecord(tree, &iter_in->bt_iter, &fbd, NULL,+ &iter_in->bt_iter)) {+ RB_FAILED;+ }++ for (;;) {+ if (BTDeleteRecord(tree, &iter_in->bt_iter))+ RB_FAILED;++ key_in->startBlock += hfs_total_blocks(iter_in->group,+ kHFSPlusExtentDensity);++ if (key_in->startBlock >= key_out->startBlock)+ break;++ if (BTSearchRecord(tree, &iter_in->bt_iter, &fbd, NULL,+ &iter_in->bt_iter)) {+ RB_FAILED;+ }+ }+ }++ // Position iter_out+ key_out->startBlock = start_group_block;++ // Roll back all the extents+ if (hfs_ext_iter_update(iter_out, roll_back_extents, roll_back_count,+ catalog_extents)) {+ RB_FAILED;+ }++ // And we need to reallocate the blocks we deallocated+ const uint32_t end_block = hfs_min(block, end_file_block);+ block = start_group_block;+ for (int i = 0; i < roll_back_count && block < end_block; ++i) {+ HFSPlusExtentDescriptor *ext = &roll_back_extents[i];++ if (block + ext->blockCount <= file_block)+ continue;++ HFSPlusExtentDescriptor alloc_ext = *ext;++ if (block <= file_block) {+ uint32_t trimmed_len = file_block - block;++ alloc_ext.startBlock += trimmed_len;+ alloc_ext.blockCount -= trimmed_len;+ }++ if (block + ext->blockCount > end_file_block) {+ uint32_t overlap = end_file_block - block;++ alloc_ext.blockCount = (ext->startBlock + overlap+ - alloc_ext.startBlock);+ }++ if (hfs_block_alloc(hfsmp, &alloc_ext, HFS_ALLOC_ROLL_BACK, NULL))+ RB_FAILED;++ block += ext->blockCount;+ }++ if (BTFlushPath(hfsmp->hfs_catalog_cp->c_datafork)+ || BTFlushPath(hfsmp->hfs_extents_cp->c_datafork)) {+ RB_FAILED;+ }+ } // if (ret && roll_back_count)++roll_back_failed:++ hfs_delete(iter_in, hfs_ext_iter_t, 2);+ hfs_delete_data(extents, HFSPlusExtentDescriptor, buffered_extents);+ hfs_delete_data(roll_back_extents, HFSPlusExtentDescriptor, max_roll_back_extents);++ return MacToVFSError(ret);+}diff --git a/xnu/files/bsd/hfs/hfs_extents.h b/xnu/files/bsd/hfs/hfs_extents.hnew file mode 100644index 0000000..fce2e49--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_extents.h@@ -0,0 +1,74 @@+/*+ * Copyright (c) 2014-2015 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@+ */++#ifndef HFS_EXTENTS_H_+#define HFS_EXTENTS_H_++#include <stdint.h>+#include <stdbool.h>++#include "hfs_format.h"++#if !HFS_EXTENTS_TEST && !HFS_ALLOC_TEST+#include "hfs_cnode.h"+#include "hfs.h"+#include "BTreesInternal.h"+#endif++typedef struct hfs_ext_iter {+ struct vnode *vp; // If NULL, this is an xattr extent+ BTreeIterator bt_iter;+ uint8_t ndx; // Index in group+ bool last_in_fork;+ uint32_t file_block;+ uint32_t group_block_count;+ HFSPlusExtentRecord group;+} hfs_ext_iter_t;++errno_t hfs_ext_find(vnode_t vp, off_t offset, hfs_ext_iter_t *iter);++errno_t hfs_ext_replace(hfsmount_t *hfsmp, vnode_t vp,+ uint32_t file_block,+ const HFSPlusExtentDescriptor *repl,+ int count,+ HFSPlusExtentRecord catalog_extents);++bool hfs_ext_iter_is_catalog_extents(hfs_ext_iter_t *iter);++static inline void hfs_ext_copy_rec(const HFSPlusExtentRecord src,+ HFSPlusExtentRecord dst)+{+ memcpy(dst, src, sizeof(HFSPlusExtentRecord));+}++static inline uint32_t hfs_ext_end(const HFSPlusExtentDescriptor *ext)+{+ return ext->startBlock + ext->blockCount;+}++#endif // HFS_EXTENTS_H_diff --git a/xnu/files/bsd/hfs/hfs_format.h b/xnu/files/bsd/hfs/hfs_format.hnew file mode 100644index 0000000..89df0dc--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_format.h@@ -0,0 +1,818 @@+/*+ * Copyright (c) 2000-2015 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@+ */+#ifndef __HFS_FORMAT__+#define __HFS_FORMAT__++#include <sys/types.h>+#include <sys/appleapiopts.h>+#include "hfs_unistr.h"++/*+ * hfs_format.h+ *+ * This file describes the on-disk format for HFS and HFS Plus volumes.+ *+ * Note: Starting 10.9, definition of struct HFSUniStr255 exists in hfs_unitstr.h+ *+ */++#ifdef __cplusplus+extern "C" {+#endif++/* some on-disk hfs structures have 68K alignment (misaligned) */++/* Signatures used to differentiate between HFS and HFS Plus volumes */+enum {+ kHFSSigWord = 0x4244, /* 'BD' in ASCII */+ kHFSPlusSigWord = 0x482B, /* 'H+' in ASCII */+ kHFSXSigWord = 0x4858, /* 'HX' in ASCII */++ kHFSPlusVersion = 0x0004, /* 'H+' volumes are version 4 only */+ kHFSXVersion = 0x0005, /* 'HX' volumes start with version 5 */++ kHFSPlusMountVersion = 0x31302E30, /* '10.0' for Mac OS X */+ kHFSJMountVersion = 0x4846534a, /* 'HFSJ' for journaled HFS+ on OS X */+ kFSKMountVersion = 0x46534b21 /* 'FSK!' for failed journal replay */+};+++#ifdef __APPLE_API_PRIVATE+/*+ * Mac OS X has two special directories on HFS+ volumes for hardlinked files+ * and hardlinked directories as well as for open-unlinked files.+ *+ * These directories and their contents are not exported from the filesystem+ * under Mac OS X.+ */+#define HFSPLUSMETADATAFOLDER "\xE2\x90\x80\xE2\x90\x80\xE2\x90\x80\xE2\x90\x80HFS+ Private Data"+#define HFSPLUS_DIR_METADATA_FOLDER ".HFS+ Private Directory Data\xd"++/*+ * Files in the "HFS+ Private Data" folder have one of the following prefixes+ * followed by a decimal number (no leading zeros) for the file ID.+ *+ * Note: Earlier version of Mac OS X used a 32 bit random number for the link+ * ref number instead of the file id.+ *+ * e.g. iNode7182000 and temp3296+ */+#define HFS_INODE_PREFIX "iNode"+#define HFS_DELETE_PREFIX "temp"++/*+ * Files in the ".HFS+ Private Directory Data" folder have the following+ * prefix followed by a decimal number (no leading zeros) for the file ID.+ *+ * e.g. dir_555+ */+#define HFS_DIRINODE_PREFIX "dir_"++/*+ * Hardlink inodes save the head of the link chain in+ * an extended attribute named FIRST_LINK_XATTR_NAME.+ * The attribute data is the decimal value in ASCII+ * of the cnid for the first link in the chain.+ *+ * This extended attribute is private (i.e. its not+ * exported in the getxattr/listxattr POSIX APIs).+ */+#define FIRST_LINK_XATTR_NAME "com.apple.system.hfs.firstlink"+#define FIRST_LINK_XATTR_REC_SIZE (sizeof(HFSPlusAttrData) - 2 + 12)++/*+ * The name space ID for generating an HFS volume UUID+ *+ * B3E20F39-F292-11D6-97A4-00306543ECAC+ */+#define HFS_UUID_NAMESPACE_ID "\xB3\xE2\x0F\x39\xF2\x92\x11\xD6\x97\xA4\x00\x30\x65\x43\xEC\xAC"++#endif /* __APPLE_API_PRIVATE */++/*+ * Indirect link files (hard links) have the following type/creator.+ */+enum {+ kHardLinkFileType = 0x686C6E6B, /* 'hlnk' */+ kHFSPlusCreator = 0x6866732B /* 'hfs+' */+};+++/*+ * File type and creator for symbolic links+ */+enum {+ kSymLinkFileType = 0x736C6E6B, /* 'slnk' */+ kSymLinkCreator = 0x72686170 /* 'rhap' */+};+++enum {+ kHFSMaxVolumeNameChars = 27,+ kHFSMaxFileNameChars = 31,+ kHFSPlusMaxFileNameChars = 255+};+++/* Extent overflow file data structures */++/* HFS Extent key */+struct HFSExtentKey {+ u_int8_t keyLength; /* length of key, excluding this field */+ u_int8_t forkType; /* 0 = data fork, FF = resource fork */+ u_int32_t fileID; /* file ID */+ u_int16_t startBlock; /* first file allocation block number in this extent */+} __attribute__((aligned(2), packed));+typedef struct HFSExtentKey HFSExtentKey;++/* HFS Plus Extent key */+struct HFSPlusExtentKey {+ u_int16_t keyLength; /* length of key, excluding this field */+ u_int8_t forkType; /* 0 = data fork, FF = resource fork */+ u_int8_t pad; /* make the other fields align on 32-bit boundary */+ u_int32_t fileID; /* file ID */+ u_int32_t startBlock; /* first file allocation block number in this extent */+} __attribute__((aligned(2), packed));+typedef struct HFSPlusExtentKey HFSPlusExtentKey;++/* Number of extent descriptors per extent record */+enum {+ kHFSExtentDensity = 3,+ kHFSPlusExtentDensity = 8+};++/* HFS extent descriptor */+struct HFSExtentDescriptor {+ u_int16_t startBlock; /* first allocation block */+ u_int16_t blockCount; /* number of allocation blocks */+} __attribute__((aligned(2), packed));+typedef struct HFSExtentDescriptor HFSExtentDescriptor;++/* HFS Plus extent descriptor */+struct HFSPlusExtentDescriptor {+ u_int32_t startBlock; /* first allocation block */+ u_int32_t blockCount; /* number of allocation blocks */+} __attribute__((aligned(2), packed));+typedef struct HFSPlusExtentDescriptor HFSPlusExtentDescriptor;++/* HFS extent record */+typedef HFSExtentDescriptor HFSExtentRecord[3];++/* HFS Plus extent record */+typedef HFSPlusExtentDescriptor HFSPlusExtentRecord[8];+++/* Finder information */+struct FndrFileInfo {+ u_int32_t fdType; /* file type */+ u_int32_t fdCreator; /* file creator */+ u_int16_t fdFlags; /* Finder flags */+ struct {+ int16_t v; /* file's location */+ int16_t h;+ } fdLocation;+ int16_t opaque;+} __attribute__((aligned(2), packed));+typedef struct FndrFileInfo FndrFileInfo;++struct FndrDirInfo {+ struct { /* folder's window rectangle */+ int16_t top;+ int16_t left;+ int16_t bottom;+ int16_t right;+ } frRect;+ unsigned short frFlags; /* Finder flags */+ struct {+ u_int16_t v; /* folder's location */+ u_int16_t h;+ } frLocation;+ int16_t opaque;+} __attribute__((aligned(2), packed));+typedef struct FndrDirInfo FndrDirInfo;++struct FndrOpaqueInfo {+ int8_t opaque[16];+} __attribute__((aligned(2), packed));+typedef struct FndrOpaqueInfo FndrOpaqueInfo;++struct FndrExtendedDirInfo {+ u_int32_t document_id;+ u_int32_t date_added;+ u_int16_t extended_flags;+ u_int16_t reserved3;+ u_int32_t write_gen_counter;+} __attribute__((aligned(2), packed));++struct FndrExtendedFileInfo {+ u_int32_t document_id;+ u_int32_t date_added;+ u_int16_t extended_flags;+ u_int16_t reserved2;+ u_int32_t write_gen_counter;+} __attribute__((aligned(2), packed));++/* HFS Plus Fork data info - 80 bytes */+struct HFSPlusForkData {+ u_int64_t logicalSize; /* fork's logical size in bytes */+ u_int32_t clumpSize; /* fork's clump size in bytes */+ u_int32_t totalBlocks; /* total blocks used by this fork */+ HFSPlusExtentRecord extents; /* initial set of extents */+} __attribute__((aligned(2), packed));+typedef struct HFSPlusForkData HFSPlusForkData;+++/* Mac OS X has 16 bytes worth of "BSD" info.+ *+ * Note: Mac OS 9 implementations and applications+ * should preserve, but not change, this information.+ */+struct HFSPlusBSDInfo {+ u_int32_t ownerID; /* user-id of owner or hard link chain previous link */+ u_int32_t groupID; /* group-id of owner or hard link chain next link */+ u_int8_t adminFlags; /* super-user changeable flags */+ u_int8_t ownerFlags; /* owner changeable flags */+ u_int16_t fileMode; /* file type and permission bits */+ union {+ u_int32_t iNodeNum; /* indirect node number (hard links only) */+ u_int32_t linkCount; /* links that refer to this indirect node */+ u_int32_t rawDevice; /* special file device (FBLK and FCHR only) */+ } special;+} __attribute__((aligned(2), packed));+typedef struct HFSPlusBSDInfo HFSPlusBSDInfo;++/*+ * Hardlink "links" resolve to an inode+ * and the actual uid/gid comes from that+ * inode.+ *+ * We repurpose the links's uid/gid fields+ * for the hardlink link chain. The chain+ * consists of a doubly linked list of file+ * ids.+ */++#define hl_firstLinkID reserved1 /* Valid only if HasLinkChain flag is set (indirect nodes only) */++#define hl_prevLinkID bsdInfo.ownerID /* Valid only if HasLinkChain flag is set */+#define hl_nextLinkID bsdInfo.groupID /* Valid only if HasLinkChain flag is set */++#define hl_linkReference bsdInfo.special.iNodeNum+#define hl_linkCount bsdInfo.special.linkCount+++/* Catalog file data structures */++enum {+ kHFSRootParentID = 1, /* Parent ID of the root folder */+ kHFSRootFolderID = 2, /* Folder ID of the root folder */+ kHFSExtentsFileID = 3, /* File ID of the extents file */+ kHFSCatalogFileID = 4, /* File ID of the catalog file */+ kHFSBadBlockFileID = 5, /* File ID of the bad allocation block file */+ kHFSAllocationFileID = 6, /* File ID of the allocation file (HFS Plus only) */+ kHFSStartupFileID = 7, /* File ID of the startup file (HFS Plus only) */+ kHFSAttributesFileID = 8, /* File ID of the attribute file (HFS Plus only) */+ kHFSAttributeDataFileID = 13, /* Used in Mac OS X runtime for extent based attributes */+ /* kHFSAttributeDataFileID is never stored on disk. */+ kHFSRepairCatalogFileID = 14, /* Used when rebuilding Catalog B-tree */+ kHFSBogusExtentFileID = 15, /* Used for exchanging extents in extents file */+ kHFSFirstUserCatalogNodeID = 16+};++/* HFS catalog key */+struct HFSCatalogKey {+ u_int8_t keyLength; /* key length (in bytes) */+ u_int8_t reserved; /* reserved (set to zero) */+ u_int32_t parentID; /* parent folder ID */+ u_int8_t nodeName[kHFSMaxFileNameChars + 1]; /* catalog node name */+} __attribute__((aligned(2), packed));+typedef struct HFSCatalogKey HFSCatalogKey;++/* HFS Plus catalog key */+struct HFSPlusCatalogKey {+ u_int16_t keyLength; /* key length (in bytes) */+ u_int32_t parentID; /* parent folder ID */+ HFSUniStr255 nodeName; /* catalog node name */+} __attribute__((aligned(2), packed));+typedef struct HFSPlusCatalogKey HFSPlusCatalogKey;++/* Catalog record types */+enum {+ /* HFS Catalog Records */+ kHFSFolderRecord = 0x0100, /* Folder record */+ kHFSFileRecord = 0x0200, /* File record */+ kHFSFolderThreadRecord = 0x0300, /* Folder thread record */+ kHFSFileThreadRecord = 0x0400, /* File thread record */++ /* HFS Plus Catalog Records */+ kHFSPlusFolderRecord = 1, /* Folder record */+ kHFSPlusFileRecord = 2, /* File record */+ kHFSPlusFolderThreadRecord = 3, /* Folder thread record */+ kHFSPlusFileThreadRecord = 4 /* File thread record */+};+++/* Catalog file record flags */+enum {+ kHFSFileLockedBit = 0x0000, /* file is locked and cannot be written to */+ kHFSFileLockedMask = 0x0001,++ kHFSThreadExistsBit = 0x0001, /* a file thread record exists for this file */+ kHFSThreadExistsMask = 0x0002,++ kHFSHasAttributesBit = 0x0002, /* object has extended attributes */+ kHFSHasAttributesMask = 0x0004,++ kHFSHasSecurityBit = 0x0003, /* object has security data (ACLs) */+ kHFSHasSecurityMask = 0x0008,++ kHFSHasFolderCountBit = 0x0004, /* only for HFSX, folder maintains a separate sub-folder count */+ kHFSHasFolderCountMask = 0x0010, /* (sum of folder records and directory hard links) */++ kHFSHasLinkChainBit = 0x0005, /* has hardlink chain (inode or link) */+ kHFSHasLinkChainMask = 0x0020,++ kHFSHasChildLinkBit = 0x0006, /* folder has a child that's a dir link */+ kHFSHasChildLinkMask = 0x0040,++ kHFSHasDateAddedBit = 0x0007, /* File/Folder has the date-added stored in the finder info. */+ kHFSHasDateAddedMask = 0x0080,++ kHFSFastDevPinnedBit = 0x0008, /* this file has been pinned to the fast-device by the hot-file code on cooperative fusion */+ kHFSFastDevPinnedMask = 0x0100,++ kHFSDoNotFastDevPinBit = 0x0009, /* this file can not be pinned to the fast-device */+ kHFSDoNotFastDevPinMask = 0x0200,++ kHFSFastDevCandidateBit = 0x000a, /* this item is a potential candidate for fast-dev pinning (as are any of its descendents */+ kHFSFastDevCandidateMask = 0x0400,++ kHFSAutoCandidateBit = 0x000b, /* this item was automatically marked as a fast-dev candidate by the kernel */+ kHFSAutoCandidateMask = 0x0800++ // There are only 4 flag bits remaining: 0x1000, 0x2000, 0x4000, 0x8000++};+++/* HFS catalog folder record - 70 bytes */+struct HFSCatalogFolder {+ int16_t recordType; /* == kHFSFolderRecord */+ u_int16_t flags; /* folder flags */+ u_int16_t valence; /* folder valence */+ u_int32_t folderID; /* folder ID */+ u_int32_t createDate; /* date and time of creation */+ u_int32_t modifyDate; /* date and time of last modification */+ u_int32_t backupDate; /* date and time of last backup */+ FndrDirInfo userInfo; /* Finder information */+ FndrOpaqueInfo finderInfo; /* additional Finder information */+ u_int32_t reserved[4]; /* reserved - initialized as zero */+} __attribute__((aligned(2), packed));+typedef struct HFSCatalogFolder HFSCatalogFolder;++/* HFS Plus catalog folder record - 88 bytes */+struct HFSPlusCatalogFolder {+ int16_t recordType; /* == kHFSPlusFolderRecord */+ u_int16_t flags; /* file flags */+ u_int32_t valence; /* folder's item count */+ u_int32_t folderID; /* folder ID */+ u_int32_t createDate; /* date and time of creation */+ u_int32_t contentModDate; /* date and time of last content modification */+ u_int32_t attributeModDate; /* date and time of last attribute modification */+ u_int32_t accessDate; /* date and time of last access (MacOS X only) */+ u_int32_t backupDate; /* date and time of last backup */+ HFSPlusBSDInfo bsdInfo; /* permissions (for MacOS X) */+ FndrDirInfo userInfo; /* Finder information */+ FndrOpaqueInfo finderInfo; /* additional Finder information */+ u_int32_t textEncoding; /* hint for name conversions */+ u_int32_t folderCount; /* number of enclosed folders, active when HasFolderCount is set */+} __attribute__((aligned(2), packed));+typedef struct HFSPlusCatalogFolder HFSPlusCatalogFolder;++/* HFS catalog file record - 102 bytes */+struct HFSCatalogFile {+ int16_t recordType; /* == kHFSFileRecord */+ u_int8_t flags; /* file flags */+ int8_t fileType; /* file type (unused ?) */+ FndrFileInfo userInfo; /* Finder information */+ u_int32_t fileID; /* file ID */+ u_int16_t dataStartBlock; /* not used - set to zero */+ int32_t dataLogicalSize; /* logical EOF of data fork */+ int32_t dataPhysicalSize; /* physical EOF of data fork */+ u_int16_t rsrcStartBlock; /* not used - set to zero */+ int32_t rsrcLogicalSize; /* logical EOF of resource fork */+ int32_t rsrcPhysicalSize; /* physical EOF of resource fork */+ u_int32_t createDate; /* date and time of creation */+ u_int32_t modifyDate; /* date and time of last modification */+ u_int32_t backupDate; /* date and time of last backup */+ FndrOpaqueInfo finderInfo; /* additional Finder information */+ u_int16_t clumpSize; /* file clump size (not used) */+ HFSExtentRecord dataExtents; /* first data fork extent record */+ HFSExtentRecord rsrcExtents; /* first resource fork extent record */+ u_int32_t reserved; /* reserved - initialized as zero */+} __attribute__((aligned(2), packed));+typedef struct HFSCatalogFile HFSCatalogFile;++/* HFS Plus catalog file record - 248 bytes */+struct HFSPlusCatalogFile {+ int16_t recordType; /* == kHFSPlusFileRecord */+ u_int16_t flags; /* file flags */+ u_int32_t reserved1; /* reserved - initialized as zero */+ u_int32_t fileID; /* file ID */+ u_int32_t createDate; /* date and time of creation */+ u_int32_t contentModDate; /* date and time of last content modification */+ u_int32_t attributeModDate; /* date and time of last attribute modification */+ u_int32_t accessDate; /* date and time of last access (MacOS X only) */+ u_int32_t backupDate; /* date and time of last backup */+ HFSPlusBSDInfo bsdInfo; /* permissions (for MacOS X) */+ FndrFileInfo userInfo; /* Finder information */+ FndrOpaqueInfo finderInfo; /* additional Finder information */+ u_int32_t textEncoding; /* hint for name conversions */+ u_int32_t reserved2; /* reserved - initialized as zero */++ /* Note: these start on double long (64 bit) boundary */+ HFSPlusForkData dataFork; /* size and block data for data fork */+ HFSPlusForkData resourceFork; /* size and block data for resource fork */+} __attribute__((aligned(2), packed));+typedef struct HFSPlusCatalogFile HFSPlusCatalogFile;++/* HFS catalog thread record - 46 bytes */+struct HFSCatalogThread {+ int16_t recordType; /* == kHFSFolderThreadRecord or kHFSFileThreadRecord */+ int32_t reserved[2]; /* reserved - initialized as zero */+ u_int32_t parentID; /* parent ID for this catalog node */+ u_int8_t nodeName[kHFSMaxFileNameChars + 1]; /* name of this catalog node */+} __attribute__((aligned(2), packed));+typedef struct HFSCatalogThread HFSCatalogThread;++/* HFS Plus catalog thread record -- 264 bytes */+struct HFSPlusCatalogThread {+ int16_t recordType; /* == kHFSPlusFolderThreadRecord or kHFSPlusFileThreadRecord */+ int16_t reserved; /* reserved - initialized as zero */+ u_int32_t parentID; /* parent ID for this catalog node */+ HFSUniStr255 nodeName; /* name of this catalog node (variable length) */+} __attribute__((aligned(2), packed));+typedef struct HFSPlusCatalogThread HFSPlusCatalogThread;++#ifdef __APPLE_API_UNSTABLE+/*+ * These are the types of records in the attribute B-tree. The values were+ * chosen so that they wouldn't conflict with the catalog record types.+ */+enum {+ kHFSPlusAttrInlineData = 0x10, /* attributes whose data fits in a b-tree node */+ kHFSPlusAttrForkData = 0x20, /* extent based attributes (data lives in extents) */+ kHFSPlusAttrExtents = 0x30 /* overflow extents for large attributes */+};+++/*+ * HFSPlusAttrForkData+ * For larger attributes, whose value is stored in allocation blocks.+ * If the attribute has more than 8 extents, there will be additional+ * records (of type HFSPlusAttrExtents) for this attribute.+ */+struct HFSPlusAttrForkData {+ u_int32_t recordType; /* == kHFSPlusAttrForkData*/+ u_int32_t reserved;+ HFSPlusForkData theFork; /* size and first extents of value*/+} __attribute__((aligned(2), packed));+typedef struct HFSPlusAttrForkData HFSPlusAttrForkData;++/*+ * HFSPlusAttrExtents+ * This record contains information about overflow extents for large,+ * fragmented attributes.+ */+struct HFSPlusAttrExtents {+ u_int32_t recordType; /* == kHFSPlusAttrExtents*/+ u_int32_t reserved;+ HFSPlusExtentRecord extents; /* additional extents*/+} __attribute__((aligned(2), packed));+typedef struct HFSPlusAttrExtents HFSPlusAttrExtents;++/*+ * Atrributes B-tree Data Record+ *+ * For small attributes, whose entire value is stored+ * within a single B-tree record.+ */+struct HFSPlusAttrData {+ u_int32_t recordType; /* == kHFSPlusAttrInlineData */+ u_int32_t reserved[2];+ u_int32_t attrSize; /* size of attribute data in bytes */+ u_int8_t attrData[2]; /* variable length */+} __attribute__((aligned(2), packed));+typedef struct HFSPlusAttrData HFSPlusAttrData;+++/* HFSPlusAttrInlineData is obsolete use HFSPlusAttrData instead */+struct HFSPlusAttrInlineData {+ u_int32_t recordType;+ u_int32_t reserved;+ u_int32_t logicalSize;+ u_int8_t userData[2];+} __attribute__((aligned(2), packed));+typedef struct HFSPlusAttrInlineData HFSPlusAttrInlineData;+++/* A generic Attribute Record */+union HFSPlusAttrRecord {+ u_int32_t recordType;+ HFSPlusAttrInlineData inlineData; /* NOT USED */+ HFSPlusAttrData attrData;+ HFSPlusAttrForkData forkData;+ HFSPlusAttrExtents overflowExtents;+};+typedef union HFSPlusAttrRecord HFSPlusAttrRecord;++/* Attribute key */+enum { kHFSMaxAttrNameLen = 127 };+struct HFSPlusAttrKey {+ u_int16_t keyLength; /* key length (in bytes) */+ u_int16_t pad; /* set to zero */+ u_int32_t fileID; /* file associated with attribute */+ u_int32_t startBlock; /* first allocation block number for extents */+ u_int16_t attrNameLen; /* number of unicode characters */+ u_int16_t attrName[kHFSMaxAttrNameLen]; /* attribute name (Unicode) */+} __attribute__((aligned(2), packed));+typedef struct HFSPlusAttrKey HFSPlusAttrKey;++#define kHFSPlusAttrKeyMaximumLength (sizeof(HFSPlusAttrKey) - sizeof(u_int16_t))+#define kHFSPlusAttrKeyMinimumLength (kHFSPlusAttrKeyMaximumLength - kHFSMaxAttrNameLen*sizeof(u_int16_t))++#endif /* __APPLE_API_UNSTABLE */+++/* Key and node lengths */+enum {+ kHFSPlusExtentKeyMaximumLength = sizeof(HFSPlusExtentKey) - sizeof(u_int16_t),+ kHFSExtentKeyMaximumLength = sizeof(HFSExtentKey) - sizeof(u_int8_t),+ kHFSPlusCatalogKeyMaximumLength = sizeof(HFSPlusCatalogKey) - sizeof(u_int16_t),+ kHFSPlusCatalogKeyMinimumLength = kHFSPlusCatalogKeyMaximumLength - sizeof(HFSUniStr255) + sizeof(u_int16_t),+ kHFSCatalogKeyMaximumLength = sizeof(HFSCatalogKey) - sizeof(u_int8_t),+ kHFSCatalogKeyMinimumLength = kHFSCatalogKeyMaximumLength - (kHFSMaxFileNameChars + 1) + sizeof(u_int8_t),+ kHFSPlusCatalogMinNodeSize = 4096,+ kHFSPlusExtentMinNodeSize = 512,+ kHFSPlusAttrMinNodeSize = 4096+};++/* HFS and HFS Plus volume attribute bits */+enum {+ /* Bits 0-6 are reserved (always cleared by MountVol call) */+ kHFSVolumeHardwareLockBit = 7, /* volume is locked by hardware */+ kHFSVolumeUnmountedBit = 8, /* volume was successfully unmounted */+ kHFSVolumeSparedBlocksBit = 9, /* volume has bad blocks spared */+ kHFSVolumeNoCacheRequiredBit = 10, /* don't cache volume blocks (i.e. RAM or ROM disk) */+ kHFSBootVolumeInconsistentBit = 11, /* boot volume is inconsistent (System 7.6 and later) */+ kHFSCatalogNodeIDsReusedBit = 12,+ kHFSVolumeJournaledBit = 13, /* this volume has a journal on it */+ kHFSVolumeInconsistentBit = 14, /* serious inconsistencies detected at runtime */+ kHFSVolumeSoftwareLockBit = 15, /* volume is locked by software */+ /*+ * HFS only has 16 bits of attributes in the MDB, but HFS Plus has 32 bits.+ * Therefore, bits 16-31 can only be used on HFS Plus.+ */+ kHFSUnusedNodeFixBit = 31, /* Unused nodes in the Catalog B-tree have been zero-filled. See Radar #6947811. */+ kHFSContentProtectionBit = 30, /* Volume has per-file content protection */++ /*** Keep these in sync with the bits above ! ****/+ kHFSVolumeHardwareLockMask = 0x00000080,+ kHFSVolumeUnmountedMask = 0x00000100,+ kHFSVolumeSparedBlocksMask = 0x00000200,+ kHFSVolumeNoCacheRequiredMask = 0x00000400,+ kHFSBootVolumeInconsistentMask = 0x00000800,+ kHFSCatalogNodeIDsReusedMask = 0x00001000,+ kHFSVolumeJournaledMask = 0x00002000,+ kHFSVolumeInconsistentMask = 0x00004000,+ kHFSVolumeSoftwareLockMask = 0x00008000,++ /* Bits 16-31 are allocated from high to low */++ kHFSContentProtectionMask = 0x40000000,+ kHFSUnusedNodeFixMask = 0x80000000,++ kHFSMDBAttributesMask = 0x8380+};++enum {+ kHFSUnusedNodesFixDate = 0xc5ef2480 /* March 25, 2009 */+};++/* HFS Master Directory Block - 162 bytes */+/* Stored at sector #2 (3rd sector) and second-to-last sector. */+struct HFSMasterDirectoryBlock {+ u_int16_t drSigWord; /* == kHFSSigWord */+ u_int32_t drCrDate; /* date and time of volume creation */+ u_int32_t drLsMod; /* date and time of last modification */+ u_int16_t drAtrb; /* volume attributes */+ u_int16_t drNmFls; /* number of files in root folder */+ u_int16_t drVBMSt; /* first block of volume bitmap */+ u_int16_t drAllocPtr; /* start of next allocation search */+ u_int16_t drNmAlBlks; /* number of allocation blocks in volume */+ u_int32_t drAlBlkSiz; /* size (in bytes) of allocation blocks */+ u_int32_t drClpSiz; /* default clump size */+ u_int16_t drAlBlSt; /* first allocation block in volume */+ u_int32_t drNxtCNID; /* next unused catalog node ID */+ u_int16_t drFreeBks; /* number of unused allocation blocks */+ u_int8_t drVN[kHFSMaxVolumeNameChars + 1]; /* volume name */+ u_int32_t drVolBkUp; /* date and time of last backup */+ u_int16_t drVSeqNum; /* volume backup sequence number */+ u_int32_t drWrCnt; /* volume write count */+ u_int32_t drXTClpSiz; /* clump size for extents overflow file */+ u_int32_t drCTClpSiz; /* clump size for catalog file */+ u_int16_t drNmRtDirs; /* number of directories in root folder */+ u_int32_t drFilCnt; /* number of files in volume */+ u_int32_t drDirCnt; /* number of directories in volume */+ u_int32_t drFndrInfo[8]; /* information used by the Finder */+ u_int16_t drEmbedSigWord; /* embedded volume signature (formerly drVCSize) */+ HFSExtentDescriptor drEmbedExtent; /* embedded volume location and size (formerly drVBMCSize and drCtlCSize) */+ u_int32_t drXTFlSize; /* size of extents overflow file */+ HFSExtentRecord drXTExtRec; /* extent record for extents overflow file */+ u_int32_t drCTFlSize; /* size of catalog file */+ HFSExtentRecord drCTExtRec; /* extent record for catalog file */+} __attribute__((aligned(2), packed));+typedef struct HFSMasterDirectoryBlock HFSMasterDirectoryBlock;+++#ifdef __APPLE_API_UNSTABLE+#define SET_HFS_TEXT_ENCODING(hint) \+ (0x656e6300 | ((hint) & 0xff))+#define GET_HFS_TEXT_ENCODING(hint) \+ (((hint) & 0xffffff00) == 0x656e6300 ? (hint) & 0x000000ff : 0xffffffffU)+#endif /* __APPLE_API_UNSTABLE */+++/* HFS Plus Volume Header - 512 bytes */+/* Stored at sector #2 (3rd sector) and second-to-last sector. */+struct HFSPlusVolumeHeader {+ u_int16_t signature; /* == kHFSPlusSigWord */+ u_int16_t version; /* == kHFSPlusVersion */+ u_int32_t attributes; /* volume attributes */+ u_int32_t lastMountedVersion; /* implementation version which last mounted volume */+ u_int32_t journalInfoBlock; /* block addr of journal info (if volume is journaled, zero otherwise) */++ u_int32_t createDate; /* date and time of volume creation */+ u_int32_t modifyDate; /* date and time of last modification */+ u_int32_t backupDate; /* date and time of last backup */+ u_int32_t checkedDate; /* date and time of last disk check */++ u_int32_t fileCount; /* number of files in volume */+ u_int32_t folderCount; /* number of directories in volume */++ u_int32_t blockSize; /* size (in bytes) of allocation blocks */+ u_int32_t totalBlocks; /* number of allocation blocks in volume (includes this header and VBM*/+ u_int32_t freeBlocks; /* number of unused allocation blocks */++ u_int32_t nextAllocation; /* start of next allocation search */+ u_int32_t rsrcClumpSize; /* default resource fork clump size */+ u_int32_t dataClumpSize; /* default data fork clump size */+ u_int32_t nextCatalogID; /* next unused catalog node ID */++ u_int32_t writeCount; /* volume write count */+ u_int64_t encodingsBitmap; /* which encodings have been use on this volume */++ u_int8_t finderInfo[32]; /* information used by the Finder */++ HFSPlusForkData allocationFile; /* allocation bitmap file */+ HFSPlusForkData extentsFile; /* extents B-tree file */+ HFSPlusForkData catalogFile; /* catalog B-tree file */+ HFSPlusForkData attributesFile; /* extended attributes B-tree file */+ HFSPlusForkData startupFile; /* boot file (secondary loader) */+} __attribute__((aligned(2), packed));+typedef struct HFSPlusVolumeHeader HFSPlusVolumeHeader;+++/* B-tree structures */++enum BTreeKeyLimits{+ kMaxKeyLength = 520+};++union BTreeKey{+ u_int8_t length8;+ u_int16_t length16;+ u_int8_t rawData [kMaxKeyLength+2];+};+typedef union BTreeKey BTreeKey;++/* BTNodeDescriptor -- Every B-tree node starts with these fields. */+struct BTNodeDescriptor {+ u_int32_t fLink; /* next node at this level*/+ u_int32_t bLink; /* previous node at this level*/+ int8_t kind; /* kind of node (leaf, index, header, map)*/+ u_int8_t height; /* zero for header, map; child is one more than parent*/+ u_int16_t numRecords; /* number of records in this node*/+ u_int16_t reserved; /* reserved - initialized as zero */+} __attribute__((aligned(2), packed));+typedef struct BTNodeDescriptor BTNodeDescriptor;++/* Constants for BTNodeDescriptor kind */+enum {+ kBTLeafNode = -1,+ kBTIndexNode = 0,+ kBTHeaderNode = 1,+ kBTMapNode = 2+};++/* BTHeaderRec -- The first record of a B-tree header node */+struct BTHeaderRec {+ u_int16_t treeDepth; /* maximum height (usually leaf nodes) */+ u_int32_t rootNode; /* node number of root node */+ u_int32_t leafRecords; /* number of leaf records in all leaf nodes */+ u_int32_t firstLeafNode; /* node number of first leaf node */+ u_int32_t lastLeafNode; /* node number of last leaf node */+ u_int16_t nodeSize; /* size of a node, in bytes */+ u_int16_t maxKeyLength; /* reserved */+ u_int32_t totalNodes; /* total number of nodes in tree */+ u_int32_t freeNodes; /* number of unused (free) nodes in tree */+ u_int16_t reserved1; /* unused */+ u_int32_t clumpSize; /* reserved */+ u_int8_t btreeType; /* reserved */+ u_int8_t keyCompareType; /* Key string Comparison Type */+ u_int32_t attributes; /* persistent attributes about the tree */+ u_int32_t reserved3[16]; /* reserved */+} __attribute__((aligned(2), packed));+typedef struct BTHeaderRec BTHeaderRec;++/* Constants for BTHeaderRec attributes */+enum {+ kBTBadCloseMask = 0x00000001, /* reserved */+ kBTBigKeysMask = 0x00000002, /* key length field is 16 bits */+ kBTVariableIndexKeysMask = 0x00000004 /* keys in index nodes are variable length */+};+++/* Catalog Key Name Comparison Type */+enum {+ kHFSCaseFolding = 0xCF, /* case folding (case-insensitive) */+ kHFSBinaryCompare = 0xBC /* binary compare (case-sensitive) */+};++#include <uuid/uuid.h>++/* JournalInfoBlock - Structure that describes where our journal lives */++// the original size of the reserved field in the JournalInfoBlock was+// 32*sizeof(u_int32_t). To keep the total size of the structure the+// same we subtract the size of new fields (currently: ext_jnl_uuid and+// machine_uuid). If you add additional fields, place them before the+// reserved field and subtract their size in this macro.+//+#define JIB_RESERVED_SIZE ((32*sizeof(u_int32_t)) - sizeof(uuid_string_t) - 48)++struct JournalInfoBlock {+ u_int32_t flags;+ u_int32_t device_signature[8]; // signature used to locate our device.+ u_int64_t offset; // byte offset to the journal on the device+ u_int64_t size; // size in bytes of the journal+ uuid_string_t ext_jnl_uuid;+ char machine_serial_num[48];+ char reserved[JIB_RESERVED_SIZE];+} __attribute__((aligned(2), packed));+typedef struct JournalInfoBlock JournalInfoBlock;++enum {+ kJIJournalInFSMask = 0x00000001,+ kJIJournalOnOtherDeviceMask = 0x00000002,+ kJIJournalNeedInitMask = 0x00000004+};++//+// This the content type uuid for "external journal" GPT+// partitions. Each instance of a partition also has a+// uuid that uniquely identifies that instance.+//+#define EXTJNL_CONTENT_TYPE_UUID "4A6F7572-6E61-11AA-AA11-00306543ECAC"+++#ifdef __cplusplus+}+#endif++#endif /* __HFS_FORMAT__ */diff --git a/xnu/files/bsd/hfs/hfs_fsctl.h b/xnu/files/bsd/hfs/hfs_fsctl.hnew file mode 100644index 0000000..ba11524--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_fsctl.h@@ -0,0 +1,390 @@+/*+ * Copyright (c) 2004-2015 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@+ */++#ifndef _HFS_FSCTL_H_+#define _HFS_FSCTL_H_++#include <sys/appleapiopts.h>++#include <sys/param.h>+#include <sys/ioccom.h>+#include <sys/time.h>+#include <stdint.h>++#ifdef __APPLE_API_UNSTABLE++struct hfs_backingstoreinfo {+ int signature; /* == 3419115 */+ int version; /* version of this struct (1) */+ int backingfd; /* disk image file (on backing fs) */+ int bandsize; /* sparse disk image band size */+};+++typedef char pathname_t[MAXPATHLEN];++struct hfs_journal_info {+ off_t jstart;+ off_t jsize;+};+++// Will be deprecated and replaced by hfs_fsinfo+struct hfsinfo_metadata {+ uint32_t total;+ uint32_t extents;+ uint32_t catalog;+ uint32_t allocation;+ uint32_t attribute;+ uint32_t journal;+ uint32_t reserved[4];+};++/*+ * Flags for hfs_fsinfo_data structure+ */+#define HFS_FSINFO_CLASS_A 0x0001 /* Information for class A files requested */+#define HFS_FSINFO_CLASS_B 0x0002 /* Information for class B files requested */+#define HFS_FSINFO_CLASS_C 0x0004 /* Information for class C files requested */+#define HFS_FSINFO_CLASS_D 0x0008 /* Information for class D files requested */++/*+ * Maximum number of buckets to represent range from 0 to 1TB (2^40) in+ * increments of power of 2, and one catch-all bucket for anything that+ * is greater than 1TB+ */+#define HFS_FSINFO_DATA_MAX_BUCKETS 42++/*+ * Maximum number of buckets to represents percentage range from 0 to 100+ * in increments of 10.+ */+#define HFS_FSINFO_PERCENT_MAX_BUCKETS 10++/*+ * Maximum number of buckets to represent number of file/directory name characters+ * in increments of 5. Last bucket is used for names larger than or equal to 255.+ */+#define HFS_FSINFO_NAME_MAX_BUCKETS 51++/*+ * Version number to ensure that the caller and the kernel have same understanding+ * of the hfs_fsinfo_data structure. This version needs to be bumped whenever the+ * number of buckets is changed.+ */+#define HFS_FSINFO_VERSION 1++/*+ * hfs_fsinfo_data is generic data structure to aggregate information like sizes+ * or counts in buckets of power of 2. Each bucket represents a range of values+ * that is determined based on its index in the array. Specifically, buckets[i]+ * represents values that are greater than or equal to 2^(i-1) and less than 2^i,+ * except the last bucket which represents range greater than or equal to 2^(i-1)+ *+ * The current maximum number of buckets is 41, so we can represent range from+ * 0 up to 1TB in increments of power of 2, and then a catch-all bucket of+ * anything that is greater than or equal to 1TB.+ *+ * For example,+ * bucket[0] -> greater than or equal to 0 and less than 1+ * bucket[1] -> greater than or equal to 1 and less than 2+ * bucket[10] -> greater than or equal to 2^(10-1) = 512 and less than 2^10 = 1024+ * bucket[20] -> greater than or equal to 2^(20-1) = 512KB and less than 2^20 = 1MB+ * bucket[41] -> greater than or equal to 2^(41-1) = 1TB+ *+ * Note that fsctls that populate this data structure can take long time to+ * execute as this operation can be I/O intensive (traversing btrees) and compute+ * intensive.+ *+ * WARNING: Any changes to this structure should also update version number to+ * ensure that the clients and kernel are reading/writing correctly.+ */++/*+ * The header includes the user input fields.+ */+typedef struct hfs_fsinfo_header {+ uint32_t request_type;+ uint16_t version;+ uint16_t flags;+} hfs_fsinfo_header_t;++struct hfs_fsinfo_data {+ hfs_fsinfo_header_t header;+ uint32_t bucket[HFS_FSINFO_DATA_MAX_BUCKETS];+};++/*+ * Structure to represent information about metadata files+ *+ * WARNING: Any changes to this structure should also update version number to+ * ensure that the clients and kernel are reading/writing correctly.+ */+struct hfs_fsinfo_metadata {+ hfs_fsinfo_header_t header;+ uint32_t extents;+ uint32_t catalog;+ uint32_t allocation;+ uint32_t attribute;+ uint32_t journal;+};++/*+ * Structure to represent distribution of number of file name characters+ * in increments of 5s. Each bucket represents a range of values that is+ * determined based on its index in the array. So bucket[i] represents values+ * that are greater than or equal to (i*5) and less than ((i+1)*10).+ *+ * Since this structure represents range of file name characters and the+ * maximum number of unicode characters in HFS+ is 255, the maximum number+ * of buckets will be 52 [0..51].+ *+ * For example,+ * bucket[4] -> greater than or equal to 20 and less than 25 characters+ * bucket[51] -> equal to 255 characters+ *+ * WARNING: Any changes to this structure should also update version number to+ * ensure that the clients and kernel are reading/writing correctly.+ */+struct hfs_fsinfo_name {+ hfs_fsinfo_header_t header;+ uint32_t bucket[HFS_FSINFO_NAME_MAX_BUCKETS];+};++/*+ * Structure to represent information about content protection classes+ *+ * WARNING: Any changes to this structure should also update version number to+ * ensure that the clients and kernel are reading/writing correctly.+ */+struct hfs_fsinfo_cprotect {+ hfs_fsinfo_header_t header;+ uint32_t class_A;+ uint32_t class_B;+ uint32_t class_C;+ uint32_t class_D;+ uint32_t class_E;+ uint32_t class_F;+};++/*+ * Union of all the different values returned by HFSIOC_FSINFO fsctl+ */+union hfs_fsinfo {+ hfs_fsinfo_header_t header;+ struct hfs_fsinfo_data data;+ struct hfs_fsinfo_metadata metadata;+ struct hfs_fsinfo_name name;+ struct hfs_fsinfo_cprotect cprotect;+};+typedef union hfs_fsinfo hfs_fsinfo;++/*+ * Type of FSINFO requested, specified by the caller in request_type field+ */+enum {+ /* Information about number of allocation blocks for each metadata file, returns struct hfs_fsinfo_metadata */+ HFS_FSINFO_METADATA_BLOCKS_INFO = 1,++ /* Information about number of extents for each metadata file, returns struct hfs_fsinfo_metadata */+ HFS_FSINFO_METADATA_EXTENTS = 2,++ /* Information about percentage of free nodes vs used nodes in metadata btrees, returns struct hfs_fsinfo_metadata */+ HFS_FSINFO_METADATA_PERCENTFREE = 3,++ /* Distribution of number of extents for data files (data fork, no rsrc fork, no xattr), returns struct hfs_fsinfo_data */+ HFS_FSINFO_FILE_EXTENT_COUNT = 4,++ /* Distribution of extent sizes for data files (data fork, no rsrc fork, no xattr), returns struct hfs_fsinfo_data */+ HFS_FSINFO_FILE_EXTENT_SIZE = 5,++ /* Distribution of file sizes for data files (data fork, no rsrc fork, no xattr), returns struct hfs_fsinfo_data */+ HFS_FSINFO_FILE_SIZE = 6,++ /* Distribution of valence for all directories, returns struct hfs_fsinfo_data */+ HFS_FSINFO_DIR_VALENCE = 7,++ /* Distribution of file/directory name size in unicode characters, returns struct hfs_fsinfo_name */+ HFS_FSINFO_NAME_SIZE = 8,++ /* Distribution of extended attribute sizes, returns hfs_fsinfo_data */+ HFS_FSINFO_XATTR_SIZE = 9,++ /* Distribution of free space for the entire file system, returns struct hfs_fsinfo_data */+ HFS_FSINFO_FREE_EXTENTS = 10,++ /* Information about number of files belonging to each class, returns hfs_fsinfo_cprotect */+ HFS_FSINFO_FILE_CPROTECT_COUNT = 11,++ /*+ * Distribution of symbolic link sizes for data files (data fork, no rsrc fork, no xattr),+ * returns struct hfs_fsinfo_data+ */+ HFS_FSINFO_SYMLINK_SIZE = 12,+};+++/* HFS FS CONTROL COMMANDS */++#define HFSIOC_RESIZE_PROGRESS _IOR('h', 1, u_int32_t)++#define HFSIOC_RESIZE_VOLUME _IOW('h', 2, u_int64_t)++#define HFSIOC_CHANGE_NEXT_ALLOCATION _IOWR('h', 3, u_int32_t)+/* Magic value for next allocation to use with fcntl to set next allocation+ * to zero and never update it again on new block allocation.+ */+#define HFS_NO_UPDATE_NEXT_ALLOCATION 0xffffFFFF++#if defined(KERNEL)+#define HFSIOC_GET_VOL_CREATE_TIME_32 _IOR('h', 4, int32_t)+#define HFSIOC_GET_VOL_CREATE_TIME_64 _IOR('h', 4, int64_t)+#else+#define HFSIOC_GET_VOL_CREATE_TIME _IOR('h', 4, time_t)+#endif /* KERNEL */++#define HFSIOC_SETBACKINGSTOREINFO _IOW('h', 7, struct hfs_backingstoreinfo)++#define HFSIOC_CLRBACKINGSTOREINFO _IO('h', 8)++// 'h', 9 used to be HFSIOC_BULKACCESS which is now deprecated++/* Unsupported - Previously used to enable/disable ACLs */+#define HFSIOC_UNSUPPORTED _IOW('h', 10, int32_t)++#define HFSIOC_PREV_LINK _IOWR('h', 11, u_int32_t)++#define HFSIOC_NEXT_LINK _IOWR('h', 12, u_int32_t)++#define HFSIOC_GETPATH _IOWR('h', 13, pathname_t)+/* By default, the path returned by HFS_GETPATH is an absolute path,+ * i.e. it also contains the mount point of the volume on which the+ * fileID exists. If the following bit is set, the path returned is+ * relative to the root of the volume.+ */+#define HFS_GETPATH_VOLUME_RELATIVE 0x1++/* Enable/disable extent-based extended attributes */+#define HFSIOC_SET_XATTREXTENTS_STATE _IOW('h', 14, u_int32_t)++#if defined(KERNEL)+#define HFSIOC_EXT_BULKACCESS32 _IOW('h', 15, struct user32_ext_access_t)+#define HFSIOC_EXT_BULKACCESS64 _IOW('h', 15, struct user64_ext_access_t)+#else+#define HFSIOC_EXT_BULKACCESS _IOW('h', 15, struct ext_access_t)+#endif /* KERNEL */++#define HFSIOC_MARK_BOOT_CORRUPT _IO('h', 16)++#define HFSIOC_GET_JOURNAL_INFO _IOR('h', 17, struct hfs_journal_info)++#define HFSIOC_SET_VERY_LOW_DISK _IOW('h', 20, u_int32_t)++#define HFSIOC_SET_LOW_DISK _IOW('h', 21, u_int32_t)++#define HFSIOC_SET_DESIRED_DISK _IOW('h', 22, u_int32_t)++#define HFSIOC_SET_ALWAYS_ZEROFILL _IOW('h', 23, int32_t)+ /* XXXJRT Keep until 31866920 is resolved. */+#define HFS_SET_ALWAYS_ZEROFILL IOCBASECMD(HFSIOC_SET_ALWAYS_ZEROFILL)++#define HFSIOC_VOLUME_STATUS _IOR('h', 24, u_int32_t)++/* Disable metadata zone for given volume */+#define HFSIOC_DISABLE_METAZONE _IO('h', 25)++/* Change the next CNID value */+#define HFSIOC_CHANGE_NEXTCNID _IOWR('h', 26, u_int32_t)+ /* XXXJRT Keep until 31866920 is resolved. */+#define HFS_CHANGE_NEXTCNID IOCBASECMD(HFSIOC_CHANGE_NEXTCNID)++/* Get the low disk space values */+#define HFSIOC_GET_VERY_LOW_DISK _IOR('h', 27, u_int32_t)++#define HFSIOC_GET_LOW_DISK _IOR('h', 28, u_int32_t)++#define HFSIOC_GET_DESIRED_DISK _IOR('h', 29, u_int32_t)++/* 30 was HFSIOC_GET_WRITE_GEN_COUNTER and is now deprecated */++/* 31 was HFSIOC_GET_DOCUMENT_ID and is now deprecated */++/* revisiond only uses this when something transforms in a way the kernel can't track such as "foo.rtf" -> "foo.rtfd" */+#define HFSIOC_TRANSFER_DOCUMENT_ID _IOW('h', 32, u_int32_t)+++/*+ * XXX: Will be deprecated and replaced by HFSIOC_GET_FSINFO+ *+ * Get information about number of file system allocation blocks used by metadata+ * files on the volume, including individual btrees and journal file. The caller+ * can determine the size of file system allocation block using value returned as+ * f_bsize by statfs(2).+ */+#define HFSIOC_FSINFO_METADATA_BLOCKS _IOWR('h', 38, struct hfsinfo_metadata)++/* Send TRIMs for all free blocks to the underlying device */+#define HFSIOC_CS_FREESPACE_TRIM _IOWR('h', 39, u_int32_t)+++/* Get file system information for the given volume */+#define HFSIOC_GET_FSINFO _IOWR('h', 45, hfs_fsinfo)++/* Re-pin hotfile data; argument controls what state gets repinned */+#define HFSIOC_REPIN_HOTFILE_STATE _IOWR('h', 46, u_int32_t)++#define HFS_REPIN_METADATA 0x0001+#define HFS_REPIN_USERDATA 0x0002++/* Mark a directory or file as worth caching on any underlying "fast" device */+#define HFSIOC_SET_HOTFILE_STATE _IOWR('h', 47, u_int32_t)++/* flags to pass to SET_HOTFILE_STATE */+#define HFS_MARK_FASTDEVCANDIDATE 0x0001+#define HFS_UNMARK_FASTDEVCANDIDATE 0x0002+#define HFS_NEVER_FASTDEVCANDIDATE 0x0004++#define HFSIOC_SET_MAX_DEFRAG_SIZE _IOWR('h', 48, u_int32_t)++#define HFSIOC_FORCE_ENABLE_DEFRAG _IOWR('h', 49, u_int32_t)++/* NOTE: fsctl selector 'h' 50 is defined in XNU */+++/* These fsctls are ported from apfs. */+#ifndef APFSIOC_SET_NEAR_LOW_DISK+#define APFSIOC_SET_NEAR_LOW_DISK _IOW('J', 17, u_int32_t)+#endif /* APFSIOC_SET_NEAR_LOW_DISK */++#ifndef APFSIOC_GET_NEAR_LOW_DISK+#define APFSIOC_GET_NEAR_LOW_DISK _IOR('J', 18, u_int32_t)+#endif /* APFSIOC_GET_NEAR_LOW_DISK */++#endif /* __APPLE_API_UNSTABLE */++#endif /* ! _HFS_FSCTL_H_ */diff --git a/xnu/files/bsd/hfs/hfs_fsinfo.c b/xnu/files/bsd/hfs/hfs_fsinfo.cnew file mode 100644index 0000000..eda2c4b--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_fsinfo.c@@ -0,0 +1,890 @@+/*+ * Copyright (c) 2014-2015 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@+ */++#include <sys/xattr.h>+#include <sys/utfconv.h>+#include <libkern/OSByteOrder.h>+#include <sys/stat.h>++#include "hfs.h"+#include "hfs_fsctl.h"+#include "hfs_endian.h"+#include "BTreesInternal.h"+#include "BTreesPrivate.h"+#include "FileMgrInternal.h"++#include "hfs_cprotect.h"+++union HFSPlusRecord {+ HFSPlusCatalogFolder folder_record;+ HFSPlusCatalogFile file_record;+ HFSPlusCatalogThread thread_record;+ HFSPlusExtentRecord extent_record;+ HFSPlusAttrRecord attr_record;+};+typedef union HFSPlusRecord HFSPlusRecord;++union HFSPlusKey {+ HFSPlusExtentKey extent_key;+ HFSPlusAttrKey attr_key;+};+typedef union HFSPlusKey HFSPlusKey;++typedef enum traverse_btree_flag {++ //If set, extents btree will also be traversed along with catalog btree, so grab correct locks upfront+ TRAVERSE_BTREE_EXTENTS = 1,++ // Getting content-protection attributes, allocate enough space to accomodate the records.+ TRAVERSE_BTREE_XATTR_CPROTECT = 2,++} traverse_btree_flag_t;++++static errno_t hfs_fsinfo_metadata_blocks(struct hfsmount *hfsmp, struct hfs_fsinfo_metadata *fsinfo);+static errno_t hfs_fsinfo_metadata_extents(struct hfsmount *hfsmp, struct hfs_fsinfo_metadata *fsinfo);+static errno_t hfs_fsinfo_metadata_percentfree(struct hfsmount *hfsmp, struct hfs_fsinfo_metadata *fsinfo);+static errno_t fsinfo_file_extent_count_callback(struct hfsmount *hfsmp, HFSPlusKey *key, HFSPlusRecord *record, void *data);+static errno_t fsinfo_file_extent_size_catalog_callback(struct hfsmount *hfsmp, HFSPlusKey *key, HFSPlusRecord *record, void *data);+static errno_t fsinfo_file_extent_size_overflow_callback(struct hfsmount *hfsmp, HFSPlusKey *key, HFSPlusRecord *record, void *data);+static errno_t fsinfo_file_size_callback(struct hfsmount *hfsmp, HFSPlusKey *key, HFSPlusRecord *record, void *data);+static errno_t fsinfo_dir_valence_callback(struct hfsmount *hfsmp, HFSPlusKey *key, HFSPlusRecord *record, void *data);+static errno_t fsinfo_name_size_callback(struct hfsmount *hfsmp, HFSPlusKey *key, HFSPlusRecord *record, void *data);+static errno_t fsinfo_xattr_size_callback(struct hfsmount *hfsmp, HFSPlusKey *key, HFSPlusRecord *record, void *data);+static errno_t traverse_btree(struct hfsmount *hfsmp, uint32_t btree_fileID, int flags, void *fsinfo,+ int (*callback)(struct hfsmount *, HFSPlusKey *, HFSPlusRecord *, void *));+static errno_t hfs_fsinfo_free_extents(struct hfsmount *hfsmp, struct hfs_fsinfo_data *fsinfo);+static void fsinfo_free_extents_callback(void *data, off_t free_extent_size);+#if CONFIG_PROTECT+static errno_t fsinfo_cprotect_count_callback(struct hfsmount *hfsmp, HFSPlusKey *key, HFSPlusRecord *record, void *data);+#endif+static errno_t fsinfo_symlink_size_callback(struct hfsmount *hfsmp, HFSPlusKey *key, HFSPlusRecord *record, void *data);++/*+ * Entry function for all the fsinfo requests from hfs_vnop_ioctl()+ * Depending on the type of request, this function will call the+ * appropriate sub-function and return success or failure back to+ * the caller.+ */+errno_t hfs_get_fsinfo(struct hfsmount *hfsmp, void *a_data)+{+ int error = 0;+ hfs_fsinfo *fsinfo_union;+ uint32_t request_type;+ uint32_t header_len = sizeof(hfs_fsinfo_header_t);++ fsinfo_union = (hfs_fsinfo *)a_data;+ request_type = fsinfo_union->header.request_type;++ // Zero out output fields to fsinfo_union, keep the user input fields intact.+ bzero((char *)fsinfo_union + header_len, sizeof(hfs_fsinfo) - header_len);++ switch (request_type) {+ case HFS_FSINFO_METADATA_BLOCKS_INFO:+ error = hfs_fsinfo_metadata_blocks(hfsmp, &(fsinfo_union->metadata));+ break;++ case HFS_FSINFO_METADATA_EXTENTS:+ error = hfs_fsinfo_metadata_extents(hfsmp, &(fsinfo_union->metadata));+ break;++ case HFS_FSINFO_METADATA_PERCENTFREE:+ error = hfs_fsinfo_metadata_percentfree(hfsmp, &(fsinfo_union->metadata));+ break;++ case HFS_FSINFO_FILE_EXTENT_COUNT:+ /* Traverse catalog btree and invoke callback for all records */+ error = traverse_btree(hfsmp, kHFSCatalogFileID, TRAVERSE_BTREE_EXTENTS, &(fsinfo_union->data), fsinfo_file_extent_count_callback);+ break;++ case HFS_FSINFO_FILE_EXTENT_SIZE:+ /* Traverse the catalog btree first */+ error = traverse_btree(hfsmp, kHFSCatalogFileID, 0, &(fsinfo_union->data), &fsinfo_file_extent_size_catalog_callback);+ if (error) {+ break;+ }+ /* Traverse the overflow extents btree now */+ error = traverse_btree(hfsmp, kHFSExtentsFileID, 0, &(fsinfo_union->data), &fsinfo_file_extent_size_overflow_callback);+ break;++ case HFS_FSINFO_FILE_SIZE:+ /* Traverse catalog btree and invoke callback for all records */+ error = traverse_btree(hfsmp, kHFSCatalogFileID, 0, &(fsinfo_union->data), &fsinfo_file_size_callback);+ break;++ case HFS_FSINFO_DIR_VALENCE:+ /* Traverse catalog btree and invoke callback for all records */+ error = traverse_btree(hfsmp, kHFSCatalogFileID, 0, &(fsinfo_union->data), &fsinfo_dir_valence_callback);+ break;++ case HFS_FSINFO_NAME_SIZE:+ /* Traverse catalog btree and invoke callback for all records */+ error = traverse_btree(hfsmp, kHFSCatalogFileID, 0, &(fsinfo_union->name), &fsinfo_name_size_callback);+ break;++ case HFS_FSINFO_XATTR_SIZE:+ /* Traverse attribute btree and invoke callback for all records */+ error = traverse_btree(hfsmp, kHFSAttributesFileID, 0, &(fsinfo_union->data), &fsinfo_xattr_size_callback);+ break;++ case HFS_FSINFO_FREE_EXTENTS:+ error = hfs_fsinfo_free_extents(hfsmp, &(fsinfo_union->data));+ break;++ case HFS_FSINFO_SYMLINK_SIZE:+ /* Traverse catalog btree and invoke callback for all records */+ error = traverse_btree(hfsmp, kHFSCatalogFileID, 0, &(fsinfo_union->data), &fsinfo_symlink_size_callback);+ break;++#if CONFIG_PROTECT+ case HFS_FSINFO_FILE_CPROTECT_COUNT:+ /* Traverse attribute btree and invoke callback for all records */+ error = traverse_btree(hfsmp, kHFSAttributesFileID, TRAVERSE_BTREE_XATTR_CPROTECT, &(fsinfo_union->cprotect), &fsinfo_cprotect_count_callback);+ break;+#endif++ default:+ return ENOTSUP;+ };++ return error;+}++/*+ * This function provides information about total number of allocation blocks+ * for each individual metadata file.+ */+static errno_t+hfs_fsinfo_metadata_blocks(struct hfsmount *hfsmp, struct hfs_fsinfo_metadata *fsinfo)+{+ int lockflags = 0;+ int ret_lockflags = 0;++ /*+ * Getting number of allocation blocks for all metadata files+ * should be a relatively quick operation, so we grab locks for all+ * the btrees at the same time+ */+ lockflags = SFL_CATALOG | SFL_EXTENTS | SFL_BITMAP | SFL_ATTRIBUTE;+ ret_lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_SHARED_LOCK);++ /* Get information about all the btrees */+ fsinfo->extents = hfsmp->hfs_extents_cp->c_datafork->ff_blocks;+ fsinfo->catalog = hfsmp->hfs_catalog_cp->c_datafork->ff_blocks;+ fsinfo->allocation = hfsmp->hfs_allocation_cp->c_datafork->ff_blocks;+ if (hfsmp->hfs_attribute_cp)+ fsinfo->attribute = hfsmp->hfs_attribute_cp->c_datafork->ff_blocks;+ else+ fsinfo->attribute = 0;++ /* Done with btrees, give up the locks */+ hfs_systemfile_unlock(hfsmp, ret_lockflags);++ /* Get information about journal file */+ fsinfo->journal = howmany(hfsmp->jnl_size, hfsmp->blockSize);++ return 0;+}++/*+ * Helper function to count the number of valid extents in a file fork structure+ */+static uint32_t+hfs_count_extents_fp(struct filefork *ff)+{+ int i;+ uint32_t count = 0;+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ if (ff->ff_data.cf_extents[i].blockCount == 0) {+ break;+ }+ count++;+ }+ return count;+}+++/*+ * This is a helper function that counts the total number of valid+ * extents in all the overflow extent records for given fileID+ * in overflow extents btree+ */+static errno_t+hfs_count_overflow_extents(struct hfsmount *hfsmp, uint32_t fileID, uint32_t *num_extents)+{+ int error;+ FCB *fcb;+ struct BTreeIterator *iterator = NULL;+ FSBufferDescriptor btdata;+ HFSPlusExtentKey *extentKey;+ HFSPlusExtentRecord extentData;+ uint32_t extent_count = 0;+ int i;++ fcb = VTOF(hfsmp->hfs_extents_vp);+ iterator = hfs_malloc_type(struct BTreeIterator);++ extentKey = (HFSPlusExtentKey *) &iterator->key;+ extentKey->keyLength = kHFSPlusExtentKeyMaximumLength;+ extentKey->forkType = kHFSDataForkType;+ extentKey->fileID = fileID;+ extentKey->startBlock = 0;++ btdata.bufferAddress = &extentData;+ btdata.itemSize = sizeof(HFSPlusExtentRecord);+ btdata.itemCount = 1;++ /* Search for overflow extent record */+ error = BTSearchRecord(fcb, iterator, &btdata, NULL, iterator);++ /*+ * We used startBlock of zero, so we will not find any records and errors+ * are expected. It will also position the iterator just before the first+ * overflow extent record for given fileID (if any).+ */+ if (error && error != fsBTRecordNotFoundErr && error != fsBTEndOfIterationErr)+ goto out;+ error = 0;++ for (;;) {++ if (msleep(NULL, NULL, PINOD | PCATCH,+ "hfs_fsinfo", NULL) == EINTR) {+ error = EINTR;+ break;+ }++ error = BTIterateRecord(fcb, kBTreeNextRecord, iterator, &btdata, NULL);+ if (error != 0) {+ /* These are expected errors, so mask them */+ if (error == fsBTRecordNotFoundErr || error == fsBTEndOfIterationErr) {+ error = 0;+ }+ break;+ }++ /* If we encounter different fileID, stop the iteration */+ if (extentKey->fileID != fileID) {+ break;+ }++ if (extentKey->forkType != kHFSDataForkType)+ break;++ /* This is our record of interest; only count the datafork extents. */+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ if (extentData[i].blockCount == 0) {+ break;+ }+ extent_count++;+ }+ }++out:+ hfs_free_type(iterator, struct BTreeIterator);++ if (error == 0) {+ *num_extents = extent_count;+ }+ return MacToVFSError(error);+}++/*+ * This function provides information about total number of extents (including+ * extents from overflow extents btree, if any) for each individual metadata+ * file.+ */+static errno_t+hfs_fsinfo_metadata_extents(struct hfsmount *hfsmp, struct hfs_fsinfo_metadata *fsinfo)+{+ int error = 0;+ int lockflags = 0;+ int ret_lockflags = 0;+ uint32_t overflow_count;++ /*+ * Counting the number of extents for all metadata files should+ * be a relatively quick operation, so we grab locks for all the+ * btrees at the same time+ */+ lockflags = SFL_CATALOG | SFL_EXTENTS | SFL_BITMAP | SFL_ATTRIBUTE;+ ret_lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_SHARED_LOCK);++ /* Get number of extents for extents overflow btree */+ fsinfo->extents = hfs_count_extents_fp(hfsmp->hfs_extents_cp->c_datafork);++ /* Get number of extents for catalog btree */+ fsinfo->catalog = hfs_count_extents_fp(hfsmp->hfs_catalog_cp->c_datafork);+ if (fsinfo->catalog >= kHFSPlusExtentDensity) {+ error = hfs_count_overflow_extents(hfsmp, kHFSCatalogFileID, &overflow_count);+ if (error) {+ goto out;+ }+ fsinfo->catalog += overflow_count;+ }++ /* Get number of extents for allocation file */+ fsinfo->allocation = hfs_count_extents_fp(hfsmp->hfs_allocation_cp->c_datafork);+ if (fsinfo->allocation >= kHFSPlusExtentDensity) {+ error = hfs_count_overflow_extents(hfsmp, kHFSAllocationFileID, &overflow_count);+ if (error) {+ goto out;+ }+ fsinfo->allocation += overflow_count;+ }++ /*+ * Get number of extents for attribute btree.+ * hfs_attribute_cp might be NULL.+ */+ if (hfsmp->hfs_attribute_cp) {+ fsinfo->attribute = hfs_count_extents_fp(hfsmp->hfs_attribute_cp->c_datafork);+ if (fsinfo->attribute >= kHFSPlusExtentDensity) {+ error = hfs_count_overflow_extents(hfsmp, kHFSAttributesFileID, &overflow_count);+ if (error) {+ goto out;+ }+ fsinfo->attribute += overflow_count;+ }+ }+ /* Journal always has one extent */+ fsinfo->journal = 1;+out:+ hfs_systemfile_unlock(hfsmp, ret_lockflags);+ return error;+}++/*+ * Helper function to calculate percentage i.e. X is what percent of Y?+ */+static inline uint32_t+hfs_percent(uint32_t X, uint32_t Y)+{+ return (X * 100ll) / Y;+}++/*+ * This function provides percentage of free nodes vs total nodes for each+ * individual metadata btrees, i.e. for catalog, overflow extents and+ * attributes btree. This information is not applicable for allocation+ * file and journal file.+ */+static errno_t+hfs_fsinfo_metadata_percentfree(struct hfsmount *hfsmp, struct hfs_fsinfo_metadata *fsinfo)+{+ int lockflags = 0;+ int ret_lockflags = 0;+ BTreeControlBlockPtr btreePtr;+ uint32_t free_nodes, total_nodes;++ /*+ * Getting total and used nodes for all metadata btrees should+ * be a relatively quick operation, so we grab locks for all the+ * btrees at the same time+ */+ lockflags = SFL_CATALOG | SFL_EXTENTS | SFL_BITMAP | SFL_ATTRIBUTE;+ ret_lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_SHARED_LOCK);++ /* Overflow extents btree */+ btreePtr = VTOF(hfsmp->hfs_extents_vp)->fcbBTCBPtr;+ total_nodes = btreePtr->totalNodes;+ free_nodes = btreePtr->freeNodes;+ fsinfo->extents = hfs_percent(free_nodes, total_nodes);++ /* Catalog btree */+ btreePtr = VTOF(hfsmp->hfs_catalog_vp)->fcbBTCBPtr;+ total_nodes = btreePtr->totalNodes;+ free_nodes = btreePtr->freeNodes;+ fsinfo->catalog = hfs_percent(free_nodes, total_nodes);++ /* Attributes btree */+ if (hfsmp->hfs_attribute_vp) {+ btreePtr = VTOF(hfsmp->hfs_attribute_vp)->fcbBTCBPtr;+ total_nodes = btreePtr->totalNodes;+ free_nodes = btreePtr->freeNodes;+ fsinfo->attribute = hfs_percent(free_nodes, total_nodes);+ }++ hfs_systemfile_unlock(hfsmp, ret_lockflags);+ return 0;+}++/*+ * Helper function to calculate log base 2 for given number+ */+static inline int+hfs_log2(uint64_t entry)+{+ return (63 - __builtin_clzll(entry|1));+}++/*+ * Helper function to account for input entry into the data+ * array based on its log base 2 value+ */+void hfs_fsinfo_data_add(struct hfs_fsinfo_data *fsinfo, uint64_t entry)+{+ /*+ * From hfs_fsctl.h -+ *+ * hfs_fsinfo_data is generic data structure to aggregate information like sizes+ * or counts in buckets of power of 2. Each bucket represents a range of values+ * that is determined based on its index in the array. Specifically, buckets[i]+ * represents values that are greater than or equal to 2^(i-1) and less than 2^i,+ * except the last bucket which represents range greater than or equal to 2^(i-1)+ *+ * The current maximum number of buckets is 41, so we can represent range from+ * 0 up to 1TB in increments of power of 2, and then a catch-all bucket of+ * anything that is greater than or equal to 1TB.+ *+ * For example,+ * bucket[0] -> greater than or equal to 0 and less than 1+ * bucket[1] -> greater than or equal to 1 and less than 2+ * bucket[10] -> greater than or equal to 2^(10-1) = 512 and less than 2^10 = 1024+ * bucket[20] -> greater than or equal to 2^(20-1) = 512KB and less than 2^20 = 1MB+ * bucket[41] -> greater than or equal to 2^(41-1) = 1TB+ */+ uint32_t bucket;++ if (entry) {+ /*+ * Calculate log base 2 value for the entry.+ * Account for this value in the appropriate bucket.+ * The last bucket is a catch-all bucket of+ * anything that is greater than or equal to 1TB+ */+ bucket = MIN(hfs_log2(entry) + 1, HFS_FSINFO_DATA_MAX_BUCKETS-1);+ ++fsinfo->bucket[bucket];+ } else {+ /* Entry is zero, so account it in 0th offset */+ fsinfo->bucket[0]++;+ }+}++/*+ * Function to traverse all the records of a btree and then call caller-provided+ * callback function for every record found. The type of btree is chosen based+ * on the fileID provided by the caller. This fuction grabs the correct locks+ * depending on the type of btree it will be traversing and flags provided+ * by the caller.+ *+ * Note: It might drop and reacquire the locks during execution.+ */+static errno_t+traverse_btree(struct hfsmount *hfsmp, uint32_t btree_fileID, int flags,+ void *fsinfo, int (*callback)(struct hfsmount *, HFSPlusKey *, HFSPlusRecord *, void *))+{+ int error = 0;+ int lockflags = 0;+ int ret_lockflags = 0;+ FCB *fcb;+ struct BTreeIterator *iterator = NULL;+ struct FSBufferDescriptor btdata;+ int btree_operation;+ HFSPlusRecord record;+ HFSPlusKey *key;+ uint64_t start, timeout_abs;++ switch(btree_fileID) {+ case kHFSExtentsFileID:+ fcb = VTOF(hfsmp->hfs_extents_vp);+ lockflags = SFL_EXTENTS;+ break;+ case kHFSCatalogFileID:+ fcb = VTOF(hfsmp->hfs_catalog_vp);+ lockflags = SFL_CATALOG;+ break;+ case kHFSAttributesFileID:+ // Attributes file doesn’t exist, There are no records to iterate.+ if (hfsmp->hfs_attribute_vp == NULL)+ return error;+ fcb = VTOF(hfsmp->hfs_attribute_vp);+ lockflags = SFL_ATTRIBUTE;+ break;++ default:+ return EINVAL;+ }++ iterator = hfs_malloc_type(struct BTreeIterator);++ /* The key is initialized to zero because we are traversing entire btree */+ key = (HFSPlusKey *)&iterator->key;++ if (flags & TRAVERSE_BTREE_EXTENTS) {+ lockflags |= SFL_EXTENTS;+ }++ btdata.bufferAddress = &record;+ btdata.itemSize = sizeof(HFSPlusRecord);+ btdata.itemCount = 1;++ /* Lock btree for duration of traversal */+ ret_lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_SHARED_LOCK);+ btree_operation = kBTreeFirstRecord;++ nanoseconds_to_absolutetime(HFS_FSINFO_MAX_LOCKHELD_TIME, &timeout_abs);+ start = mach_absolute_time();++ while (1) {++ if (msleep(NULL, NULL, PINOD | PCATCH,+ "hfs_fsinfo", NULL) == EINTR) {+ error = EINTR;+ break;+ }++ error = BTIterateRecord(fcb, btree_operation, iterator, &btdata, NULL);+ if (error != 0) {+ if (error == fsBTRecordNotFoundErr || error == fsBTEndOfIterationErr) {+ error = 0;+ }+ break;+ }+ /* Lookup next btree record on next call to BTIterateRecord() */+ btree_operation = kBTreeNextRecord;++ /* Call our callback function and stop iteration if there are any errors */+ error = callback(hfsmp, key, &record, fsinfo);+ if (error) {+ break;+ }++ /* let someone else use the tree after we've processed over HFS_FSINFO_MAX_LOCKHELD_TIME */+ if ((mach_absolute_time() - start) >= timeout_abs) {++ /* release b-tree locks and let someone else get the lock */+ hfs_systemfile_unlock (hfsmp, ret_lockflags);++ /* add tsleep here to force context switch and fairness */+ tsleep((caddr_t)hfsmp, PRIBIO, "hfs_fsinfo", 1);++ /*+ * re-acquire the locks in the same way that we wanted them originally.+ * note: it is subtle but worth pointing out that in between the time that we+ * released and now want to re-acquire these locks that the b-trees may have shifted+ * slightly but significantly. For example, the catalog or other b-tree could have grown+ * past 8 extents and now requires the extents lock to be held in order to be safely+ * manipulated. We can't be sure of the state of the b-tree from where we last left off.+ */++ ret_lockflags = hfs_systemfile_lock (hfsmp, lockflags, HFS_SHARED_LOCK);++ /*+ * It's highly likely that the search key we stashed away before dropping lock+ * no longer points to an existing item. Iterator's IterateRecord is able to+ * re-position itself and process the next record correctly. With lock dropped,+ * there might be records missed for statistic gathering, which is ok. The+ * point is to get aggregate values.+ */++ start = mach_absolute_time();++ /* loop back around and get another record */+ }+ }++ hfs_systemfile_unlock(hfsmp, ret_lockflags);+ hfs_free_type(iterator, struct BTreeIterator);+ return MacToVFSError(error);+}++/*+ * Callback function to get distribution of number of extents+ * for all user files in given file system. Note that this only+ * accounts for data fork, no resource fork.+ */+static errno_t+fsinfo_file_extent_count_callback(struct hfsmount *hfsmp,+ __unused HFSPlusKey *key, HFSPlusRecord *record, void *data)+{+ int i;+ int error = 0;+ uint32_t num_extents = 0;+ uint32_t num_overflow = 0;+ uint32_t blockCount;++ if (record->file_record.recordType == kHFSPlusFileRecord) {+ /* Count total number of extents for this file */+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ blockCount = record->file_record.dataFork.extents[i].blockCount;+ if (blockCount == 0) {+ break;+ }+ num_extents++;+ }+ /* This file has overflow extent records, so search overflow btree */+ if (num_extents >= kHFSPlusExtentDensity) {+ /* The caller also hold extents overflow btree lock */+ error = hfs_count_overflow_extents(hfsmp, record->file_record.fileID, &num_overflow);+ if (error) {+ goto out;+ }+ num_extents += num_overflow;+ }+ hfs_fsinfo_data_add(data, num_extents);+ }+out:+ return error;+}++/*+ * Callback function to get distribution of individual extent sizes+ * (in bytes) for all user files in given file system from catalog+ * btree only. Note that this only accounts for data fork, no resource+ * fork.+ */+static errno_t fsinfo_file_extent_size_catalog_callback(struct hfsmount *hfsmp,+ __unused HFSPlusKey *key, HFSPlusRecord *record, void *data)+{+ int i;+ uint32_t blockCount;+ uint64_t extent_size;++ if (record->file_record.recordType == kHFSPlusFileRecord) {+ /* Traverse through all valid extents */+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ blockCount = record->file_record.dataFork.extents[i].blockCount;+ if (blockCount == 0) {+ break;+ }+ extent_size = hfs_blk_to_bytes(blockCount, hfsmp->blockSize);+ hfs_fsinfo_data_add(data, extent_size);+ }+ }+ return 0;+}++/*+ * Callback function to get distribution of individual extent sizes+ * (in bytes) for all user files in given file system from overflow+ * extents btree only. Note that this only accounts for data fork,+ * no resource fork.+ */+static errno_t fsinfo_file_extent_size_overflow_callback(struct hfsmount *hfsmp,+ HFSPlusKey *key, HFSPlusRecord *record, void *data)+{+ int i;+ uint32_t blockCount;+ uint64_t extent_size;++ if (key->extent_key.fileID >= kHFSFirstUserCatalogNodeID) {+ // Only count the data fork extents.+ if (key->extent_key.forkType == kHFSDataForkType) {+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ blockCount = record->extent_record[i].blockCount;+ if (blockCount == 0) {+ break;+ }+ extent_size = hfs_blk_to_bytes(blockCount, hfsmp->blockSize);+ hfs_fsinfo_data_add(data, extent_size);+ }+ }+ }+ return 0;+}++/*+ * Callback function to get distribution of file sizes (in bytes)+ * for all user files in given file system. Note that this only+ * accounts for data fork, no resource fork.+ */+static errno_t fsinfo_file_size_callback(__unused struct hfsmount *hfsmp,+ __unused HFSPlusKey *key, HFSPlusRecord *record, void *data)+{+ if (record->file_record.recordType == kHFSPlusFileRecord) {+ /* Record of interest, account for the size in the bucket */+ hfs_fsinfo_data_add(data, record->file_record.dataFork.logicalSize);+ }+ return 0;+}++/*+ * Callback function to get distribution of directory valence+ * for all directories in the given file system.+ */+static errno_t fsinfo_dir_valence_callback(__unused struct hfsmount *hfsmp,+ __unused HFSPlusKey *key, HFSPlusRecord *record, void *data)+{+ if (record->folder_record.recordType == kHFSPlusFolderRecord) {+ hfs_fsinfo_data_add(data, record->folder_record.valence);+ }+ return 0;+}++/*+ * Callback function to get distribution of number of unicode+ * characters in name for all files and directories for a given+ * file system.+ */+static errno_t fsinfo_name_size_callback(__unused struct hfsmount *hfsmp,+ __unused HFSPlusKey *key, HFSPlusRecord *record, void *data)+{+ struct hfs_fsinfo_name *fsinfo = (struct hfs_fsinfo_name *)data;+ uint32_t length;++ if ((record->folder_record.recordType == kHFSPlusFolderThreadRecord) ||+ (record->folder_record.recordType == kHFSPlusFileThreadRecord)) {+ length = record->thread_record.nodeName.length;++ // sanity check for a name length of zero, which isn't valid on disk.+ if (length == 0)+ return EIO;++ /* Round it down to nearest multiple of 5 to match our buckets granularity */+ length = (length - 1)/ 5;++ /* Use the last bucket for any file name which is larger */+ if (length > (HFS_FSINFO_NAME_MAX_BUCKETS - 1))+ length = HFS_FSINFO_NAME_MAX_BUCKETS - 1;++ /* Account this value into our bucket */+ fsinfo->bucket[length]++;+ }+ return 0;+}++/*+ * Callback function to get distribution of size of all extended+ * attributes for a given file system.+ */+static errno_t fsinfo_xattr_size_callback(__unused struct hfsmount *hfsmp,+ __unused HFSPlusKey *key, HFSPlusRecord *record, void *data)+{+ if (record->attr_record.recordType == kHFSPlusAttrInlineData) {+ /* Inline attribute */+ hfs_fsinfo_data_add(data, record->attr_record.attrData.attrSize);+ } else if (record->attr_record.recordType == kHFSPlusAttrForkData) {+ /* Larger attributes with extents information */+ hfs_fsinfo_data_add(data, record->attr_record.forkData.theFork.logicalSize);+ }+ return 0;+}+++/*+ * Callback function to get distribution of free space extents for a given file system.+ */+static void fsinfo_free_extents_callback(void *data, off_t free_extent_size)+{+ // Assume a minimum of 4 KB block size+ hfs_fsinfo_data_add(data, free_extent_size / 4096);+}++/*+ * Function to get distribution of free space extents for a given file system.+ */+static errno_t hfs_fsinfo_free_extents(struct hfsmount *hfsmp, struct hfs_fsinfo_data *fsinfo)+{+ return hfs_find_free_extents(hfsmp, &fsinfo_free_extents_callback, fsinfo);+}++/*+ * Callback function to get distribution of symblock link sizes (in bytes)+ * for all user files in given file system. Note that this only+ * accounts for data fork, no resource fork.+ */+static errno_t fsinfo_symlink_size_callback(__unused struct hfsmount *hfsmp,+ __unused HFSPlusKey *key, HFSPlusRecord *record, void *data)+{+ if (record->file_record.recordType == kHFSPlusFileRecord) {+ /* Record of interest, account for the size in the bucket */+ if (S_ISLNK(record->file_record.bsdInfo.fileMode))+ hfs_fsinfo_data_add((struct hfs_fsinfo_data *)data, record->file_record.dataFork.logicalSize);+ }+ return 0;+}++#if CONFIG_PROTECT+/*+ * Callback function to get total number of files/directories+ * for each content protection class+ */+static int fsinfo_cprotect_count_callback(struct hfsmount *hfsmp, HFSPlusKey *key,+ HFSPlusRecord *record, void *data)+{+ struct hfs_fsinfo_cprotect *fsinfo = (struct hfs_fsinfo_cprotect *)data;+ static const uint16_t cp_xattrname_utf16[] = CONTENT_PROTECTION_XATTR_NAME_CHARS;+ /*+ * NOTE: cp_xattrname_utf16_len is the number of UTF-16 code units in+ * the EA name string.+ */+ static const size_t cp_xattrname_utf16_len = sizeof(cp_xattrname_utf16)/2;+ struct cp_xattr_v5 *xattr;+ size_t xattr_len = sizeof(struct cp_xattr_v5);+ struct cprotect cp_entry;+ struct cprotect *cp_entryp = &cp_entry;+ int error = 0;++ /* Content protect xattrs are inline attributes only, so skip all others */+ if (record->attr_record.recordType != kHFSPlusAttrInlineData)+ return 0;++ /* We only look at content protection xattrs */+ if ((key->attr_key.attrNameLen != cp_xattrname_utf16_len) ||+ (bcmp(key->attr_key.attrName, cp_xattrname_utf16, 2 * cp_xattrname_utf16_len))) {+ return 0;+ }++ xattr = (struct cp_xattr_v5 *)((void *)(record->attr_record.attrData.attrData));+ error = cp_read_xattr_v5(hfsmp, xattr, xattr_len, (cprotect_t *)&cp_entryp,+ CP_GET_XATTR_BASIC_INFO);+ if (error)+ return 0;++ /* No key present, skip this record */+ if (!ISSET(cp_entry.cp_flags, CP_HAS_A_KEY))+ return 0;++ /* Now account for the persistent class */+ switch (CP_CLASS(cp_entry.cp_pclass)) {+ case PROTECTION_CLASS_A:+ fsinfo->class_A++;+ break;+ case PROTECTION_CLASS_B:+ fsinfo->class_B++;+ break;+ case PROTECTION_CLASS_C:+ fsinfo->class_C++;+ break;+ case PROTECTION_CLASS_D:+ fsinfo->class_D++;+ break;+ case PROTECTION_CLASS_E:+ fsinfo->class_E++;+ break;+ case PROTECTION_CLASS_F:+ fsinfo->class_F++;+ break;+ };++ return 0;+}+#endifdiff --git a/xnu/files/bsd/hfs/hfs_hotfiles.c b/xnu/files/bsd/hfs/hfs_hotfiles.cnew file mode 100644index 0000000..800816e--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_hotfiles.c@@ -0,0 +1,3926 @@+/*+ * Copyright (c) 2003-2015 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@+ */++#include <libkern/OSAtomic.h>++#include <sys/param.h>+#include <sys/systm.h>+#include <sys/fcntl.h>+#include <sys/kernel.h>+#include <sys/malloc.h>+#include <sys/ubc.h>+#include <sys/vnode.h>+#include <sys/kauth.h>+#include <sys/vm.h>++#include "hfs.h"+#include "hfs_endian.h"+#include "hfs_format.h"+#include "hfs_mount.h"+#include "hfs_hotfiles.h"++#include "BTreeScanner.h"+++#define HFC_DEBUG 0+#define HFC_VERBOSE 0+++/*+ * Minimum post Tiger base time.+ * Thu Mar 31 17:00:00 2005+ */+#define HFC_MIN_BASE_TIME 0x424c8f00L++/*+ * Hot File List (runtime).+ */+typedef struct hotfileinfo {+ u_int32_t hf_fileid;+ u_int32_t hf_temperature;+ u_int32_t hf_blocks;+} hotfileinfo_t;++typedef struct hotfilelist {+ size_t hfl_size;+ u_int32_t hfl_magic;+ u_int32_t hfl_version;+ time_t hfl_duration; /* duration of sample period */+ int hfl_count; /* count of hot files recorded */+ int hfl_next; /* next file to move */+ int hfl_totalblocks; /* total hot file blocks */+ int hfl_reclaimblks; /* blocks to reclaim in HFV */+ u_int32_t hfl_spare[2];+ hotfileinfo_t hfl_hotfile[1]; /* array of hot files */+} hotfilelist_t;+++/*+ * Hot File Entry (runtime).+ */+typedef struct hotfile_entry {+ struct hotfile_entry *left;+ struct hotfile_entry *right;+ u_int32_t fileid;+ u_int32_t temperature;+ u_int32_t blocks;+} hotfile_entry_t;+++//+// We cap the max temperature for non-system files to "MAX_NORMAL_TEMP"+// so that they will always have a lower temperature than system (aka+// "auto-cached") files. System files have MAX_NORMAL_TEMP added to+// their temperature which produces two bands of files (all non-system+// files will have a temp less than MAX_NORMAL_TEMP and all system+// files will have a temp greatern than MAX_NORMAL_TEMP).+//+// This puts non-system files on the left side of the hotfile btree+// (and we start evicting from the left-side of the tree). The idea is+// that we will evict non-system files more aggressively since their+// working set changes much more dynamically than system files (which+// are for the most part, static).+//+// NOTE: these values have to fit into a 32-bit int. We use a+// value of 1-billion which gives a pretty broad range+// and yet should not run afoul of any sign issues.+//+#define MAX_NORMAL_TEMP 1000000000+#define HF_TEMP_RANGE MAX_NORMAL_TEMP+++//+// These used to be defines of the hard coded values. But if+// we're on an cooperative fusion (CF) system we need to change+// the values (which happens in hfs_recording_init()+//+uint32_t hfc_default_file_count = 1000;+uint32_t hfc_default_duration = (3600 * 60);+uint32_t hfc_max_file_count = 5000;+uint64_t hfc_max_file_size = (10 * 1024 * 1024);+++/*+ * Hot File Recording Data (runtime).+ */+typedef struct hotfile_data {+ size_t maxentries;+ struct hfsmount *hfsmp;+ long refcount;+ u_int32_t activefiles; /* active number of hot files */+ u_int32_t threshold;+ u_int32_t maxblocks;+ hotfile_entry_t *rootentry;+ hotfile_entry_t *freelist;+ hotfile_entry_t *coldest;+ hotfile_entry_t entries[];+} hotfile_data_t;++static int hfs_recording_start (struct hfsmount *);+static int hfs_recording_stop (struct hfsmount *);++/* Hotfiles pinning routines */+static int hfs_getvnode_and_pin (struct hfsmount *hfsmp, uint32_t fileid, uint32_t *pinned);+static int hfs_pin_extent_record (struct hfsmount *hfsmp, HFSPlusExtentRecord extents, uint32_t *pinned);+static int hfs_pin_catalog_rec (struct hfsmount *hfsmp, HFSPlusCatalogFile *cfp, int rsrc);++/*+ * Hot File Data recording functions (in-memory binary tree).+ */+static int hf_insert (hotfile_data_t *, hotfile_entry_t *);+static void hf_delete (hotfile_data_t *, u_int32_t, u_int32_t);+static hotfile_entry_t * hf_coldest (hotfile_data_t *);+static hotfile_entry_t * hf_getnewentry (hotfile_data_t *);+static void hf_getsortedlist (hotfile_data_t *, hotfilelist_t *);++#if HFC_DEBUG+static hotfile_entry_t * hf_lookup (hotfile_data_t *, u_int32_t, u_int32_t);+static void hf_maxdepth(hotfile_entry_t *, int, int *);+static void hf_printtree (hotfile_entry_t *);+#endif++/*+ * Hot File misc support functions.+ */+static int hotfiles_collect (struct hfsmount *);+static int hotfiles_age (struct hfsmount *);+static int hotfiles_adopt (struct hfsmount *);+static int hotfiles_evict (struct hfsmount *, vfs_context_t);+static int hotfiles_refine (struct hfsmount *);+static int hotextents(struct hfsmount *, HFSPlusExtentDescriptor *);+static int hfs_addhotfile_internal(struct vnode *);+static int hfs_hotfile_cur_freeblks(hfsmount_t *hfsmp);+++/*+ * Hot File Cluster B-tree (on disk) functions.+ */+static int hfc_btree_create (struct hfsmount *, unsigned int, unsigned int);+static int hfc_btree_open (struct hfsmount *, struct vnode **);+static int hfc_btree_open_ext(struct hfsmount *hfsmp, struct vnode **vpp, int ignore_btree_errs);+static int hfc_btree_close (struct hfsmount *, struct vnode *);+static int hfc_btree_delete_record(struct hfsmount *hfsmp, BTreeIterator *iterator, HotFileKey *key);+static int hfc_btree_delete(struct hfsmount *hfsmp);+static int hfc_comparekeys (HotFileKey *, HotFileKey *);+++char hfc_tag[] = "CLUSTERED HOT FILES B-TREE ";+++/*+ *========================================================================+ * HOT FILE INTERFACE ROUTINES+ *========================================================================+ */++/*+ * Start recording the hottest files on a file system.+ *+ * Requires that the hfc_mutex be held.+ */+static int+hfs_recording_start(struct hfsmount *hfsmp)+{+ hotfile_data_t *hotdata;+ struct timeval tv;+ int maxentries;+ int i;+ int error;++ if ((hfsmp->hfs_flags & HFS_READ_ONLY) ||+ (hfsmp->jnl == NULL) ||+ (hfsmp->hfs_flags & HFS_METADATA_ZONE) == 0) {+ return (EPERM);+ }+ if (HFSTOVCB(hfsmp)->freeBlocks < (2 * (u_int32_t)hfsmp->hfs_hotfile_maxblks)) {+ return (ENOSPC);+ }+ if (hfsmp->hfc_stage != HFC_IDLE) {+ return (EBUSY);+ }+ hfsmp->hfc_stage = HFC_BUSY;++ if (hfsmp->hfc_recdata) {+ hfs_delete_with_hdr(hfsmp->hfc_recdata, hotfile_data_t, hotfile_entry_t, hfsmp->hfc_recdata->maxentries);+ hfsmp->hfc_recdata = NULL;+ }+ if (hfsmp->hfc_filelist) {+ hfs_free_data(hfsmp->hfc_filelist, hfsmp->hfc_filelist->hfl_size);+ hfsmp->hfc_filelist = NULL;+ }++ microtime(&tv); /* Times are base on GMT time. */++ /*+ * On first startup check for suspended recording.+ */+ if (hfsmp->hfc_timebase == 0 &&+ hfc_btree_open(hfsmp, &hfsmp->hfc_filevp) == 0) {+ HotFilesInfo hotfileinfo;++ if ((BTGetUserData(VTOF(hfsmp->hfc_filevp), &hotfileinfo,+ sizeof(hotfileinfo)) == 0) &&+ (SWAP_BE32 (hotfileinfo.magic) == HFC_MAGIC) &&+ (SWAP_BE32 (hotfileinfo.timeleft) > 0) &&+ (SWAP_BE32 (hotfileinfo.timebase) > 0)) {+ if (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) {+ if (hfsmp->hfs_hotfile_freeblks == 0) {+ hfsmp->hfs_hotfile_freeblks = hfsmp->hfs_hotfile_maxblks - SWAP_BE32 (hotfileinfo.usedblocks);+ }+ hfsmp->hfc_maxfiles = 0x7fffffff;+ printf("hfs: %s: %s: hotfile freeblocks: %d, max: %d\n", hfsmp->vcbVN, __FUNCTION__,+ hfsmp->hfs_hotfile_freeblks, hfsmp->hfs_hotfile_maxblks);+ } else {+ hfsmp->hfc_maxfiles = SWAP_BE32 (hotfileinfo.maxfilecnt);+ }+ hfsmp->hfc_timebase = SWAP_BE32 (hotfileinfo.timebase);+ int timeleft = (int)SWAP_BE32(hotfileinfo.timeleft);+ if (timeleft < 0 || timeleft > (int)(HFC_DEFAULT_DURATION*2)) {+ // in case this field got botched, don't let it screw things up+ // printf("hfs: hotfiles: bogus looking timeleft: %d\n", timeleft);+ timeleft = HFC_DEFAULT_DURATION;+ }+ hfsmp->hfc_timeout = timeleft + tv.tv_sec ;+ /* Fix up any bogus timebase values. */+ if (hfsmp->hfc_timebase < HFC_MIN_BASE_TIME) {+ hfsmp->hfc_timebase = hfsmp->hfc_timeout - HFC_DEFAULT_DURATION;+ }+#if HFC_VERBOSE+ printf("hfs: Resume recording hot files on %s (%d secs left (%d); timeout %ld)\n",+ hfsmp->vcbVN, SWAP_BE32 (hotfileinfo.timeleft), timeleft, hfsmp->hfc_timeout - tv.tv_sec);+#endif+ } else {+ hfsmp->hfc_maxfiles = HFC_DEFAULT_FILE_COUNT;+ hfsmp->hfc_timebase = tv.tv_sec + 1;+ hfsmp->hfc_timeout = hfsmp->hfc_timebase + HFC_DEFAULT_DURATION;+ }+ (void) hfc_btree_close(hfsmp, hfsmp->hfc_filevp);+ hfsmp->hfc_filevp = NULL;+ } else {+ struct cat_attr cattr;+ u_int32_t cnid;++ /*+ * Make sure a btree file exists.+ */+ cnid = GetFileInfo(HFSTOVCB(hfsmp), kRootDirID, HFC_FILENAME, &cattr, NULL);+ if ((cnid == 0) &&+ !S_ISREG(cattr.ca_mode) &&+ (error = hfc_btree_create(hfsmp, HFSTOVCB(hfsmp)->blockSize, HFC_DEFAULT_FILE_COUNT))) {+ hfsmp->hfc_stage = HFC_IDLE;+ wakeup((caddr_t)&hfsmp->hfc_stage);+ return (error);+ }+#if HFC_VERBOSE+ printf("hfs: begin recording hot files on %s (hotfile start/end block: %d - %d; max/free: %d/%d; maxfiles: %d)\n",+ hfsmp->vcbVN,+ hfsmp->hfs_hotfile_start, hfsmp->hfs_hotfile_end,+ hfsmp->hfs_hotfile_maxblks, hfsmp->hfs_hotfile_freeblks, hfsmp->hfc_maxfiles);+#endif+ hfsmp->hfc_maxfiles = HFC_DEFAULT_FILE_COUNT;+ hfsmp->hfc_timeout = tv.tv_sec + HFC_DEFAULT_DURATION;++ /* Reset time base. */+ if (hfsmp->hfc_timebase == 0) {+ hfsmp->hfc_timebase = tv.tv_sec + 1;+ } else {+ time_t cumulativebase;++ cumulativebase = hfsmp->hfc_timeout - (HFC_CUMULATIVE_CYCLES * HFC_DEFAULT_DURATION);+ hfsmp->hfc_timebase = MAX(hfsmp->hfc_timebase, cumulativebase);+ }+ }++ if ((hfsmp->hfc_maxfiles == 0) ||+ (hfsmp->hfc_maxfiles > HFC_MAXIMUM_FILE_COUNT)) {+ hfsmp->hfc_maxfiles = HFC_DEFAULT_FILE_COUNT;+ }+ maxentries = hfsmp->hfc_maxfiles;++ hotdata = hfs_new_with_hdr(hotfile_data_t, hotfile_entry_t, maxentries);+ hotdata->maxentries = maxentries;++ for (i = 1; i < maxentries ; i++)+ hotdata->entries[i-1].right = &hotdata->entries[i];++ hotdata->freelist = &hotdata->entries[0];+ /*+ * Establish minimum temperature and maximum file size.+ */+ hotdata->threshold = HFC_MINIMUM_TEMPERATURE;+ hotdata->maxblocks = HFC_MAXIMUM_FILESIZE / HFSTOVCB(hfsmp)->blockSize;+ hotdata->hfsmp = hfsmp;++ hfsmp->hfc_recdata = hotdata;+ hfsmp->hfc_stage = HFC_RECORDING;+ wakeup((caddr_t)&hfsmp->hfc_stage);+ return (0);+}++/*+ * Stop recording the hotest files on a file system.+ *+ * Requires that the hfc_mutex be held.+ */+static int+hfs_recording_stop(struct hfsmount *hfsmp)+{+ hotfile_data_t *hotdata;+ hotfilelist_t *listp;+ struct timeval tv;+ size_t size;+ enum hfc_stage newstage = HFC_IDLE;+ int error;++ if (hfsmp->hfc_stage != HFC_RECORDING)+ return (EPERM);++ hfsmp->hfc_stage = HFC_BUSY;++ hotfiles_collect(hfsmp);+++ /*+ * Convert hot file data into a simple file id list....+ *+ * then dump the sample data+ */+#if HFC_VERBOSE+ printf("hfs: end of hot file recording on %s\n", hfsmp->vcbVN);+#endif+ hotdata = hfsmp->hfc_recdata;+ if (hotdata == NULL)+ return (0);+ hfsmp->hfc_recdata = NULL;+ hfsmp->hfc_stage = HFC_EVALUATION;+ wakeup((caddr_t)&hfsmp->hfc_stage);++#if HFC_VERBOSE+ printf("hfs: curentries: %d\n", hotdata->activefiles);+#endif+ /*+ * If no hot files recorded then we're done.+ */+ if (hotdata->rootentry == NULL) {+ error = 0;+ goto out;+ }++ /* Open the B-tree file for writing... */+ if (hfsmp->hfc_filevp)+ panic("hfs_recording_stop: hfc_filevp exists (vp = %p)", hfsmp->hfc_filevp);++ error = hfc_btree_open(hfsmp, &hfsmp->hfc_filevp);+ if (error) {+ goto out;+ }++ /*+ * Age the previous set of clustered hot files.+ */+ error = hotfiles_age(hfsmp);+ if (error) {+ (void) hfc_btree_close(hfsmp, hfsmp->hfc_filevp);+ hfsmp->hfc_filevp = NULL;+ goto out;+ }++ /*+ * Create a sorted list of hotest files.+ */+ size = sizeof(hotfilelist_t);+ size += sizeof(hotfileinfo_t) * (hotdata->activefiles - 1);+ listp = hfs_malloc_zero_data(size);+ listp->hfl_size = size;++ hf_getsortedlist(hotdata, listp); /* NOTE: destroys hot file tree! */+ microtime(&tv);+ listp->hfl_duration = tv.tv_sec - hfsmp->hfc_timebase;+ hfs_assert(!hfsmp->hfc_filelist);+ hfsmp->hfc_filelist = listp;++ /*+ * Account for duplicates.+ */+ error = hotfiles_refine(hfsmp);+ if (error) {+ (void) hfc_btree_close(hfsmp, hfsmp->hfc_filevp);+ hfsmp->hfc_filevp = NULL;+ goto out;+ }++ /*+ * Compute the amount of space to reclaim...+ */+ if (listp->hfl_totalblocks > hfs_hotfile_cur_freeblks(hfsmp)) {+ listp->hfl_reclaimblks =+ MIN(listp->hfl_totalblocks, hfsmp->hfs_hotfile_maxblks) -+ hfsmp->hfs_hotfile_freeblks;+#if HFC_VERBOSE+ printf("hfs_recording_stop: need to reclaim %d blocks\n", listp->hfl_reclaimblks);+#endif+ if (listp->hfl_reclaimblks)+ newstage = HFC_EVICTION;+ else+ newstage = HFC_ADOPTION;+ } else {+ newstage = HFC_ADOPTION;+ }++ if (newstage == HFC_ADOPTION && listp->hfl_totalblocks == 0) {+ (void) hfc_btree_close(hfsmp, hfsmp->hfc_filevp);+ hfsmp->hfc_filevp = NULL;+ newstage = HFC_IDLE;+ }+out:+#if HFC_VERBOSE+ if (newstage == HFC_EVICTION)+ printf("hfs: evicting coldest files\n");+ else if (newstage == HFC_ADOPTION)+ printf("hfs: adopting hotest files\n");+#endif+ hfs_delete_with_hdr(hotdata, hotfile_data_t, hotfile_entry_t, hotdata->maxentries);++ hfsmp->hfc_stage = newstage;+ wakeup((caddr_t)&hfsmp->hfc_stage);+ return (error);+}++static void+save_btree_user_info(struct hfsmount *hfsmp)+{+ HotFilesInfo hotfileinfo;+ struct timeval tv;++ microtime(&tv);+ hotfileinfo.magic = SWAP_BE32 (HFC_MAGIC);+ hotfileinfo.version = SWAP_BE32 (HFC_VERSION);+ hotfileinfo.duration = SWAP_BE32 (HFC_DEFAULT_DURATION);+ hotfileinfo.timebase = SWAP_BE32 (hfsmp->hfc_timebase);+ hotfileinfo.timeleft = SWAP_BE32 (hfsmp->hfc_timeout - tv.tv_sec);+ hotfileinfo.threshold = SWAP_BE32 (HFC_MINIMUM_TEMPERATURE);+ hotfileinfo.maxfileblks = SWAP_BE32 (HFC_MAXIMUM_FILESIZE / HFSTOVCB(hfsmp)->blockSize);+ if (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) {+ hotfileinfo.usedblocks = SWAP_BE32 (hfsmp->hfs_hotfile_maxblks - hfs_hotfile_cur_freeblks(hfsmp));+#if HFC_VERBOSE+ printf("hfs: %s: saving usedblocks = %d (timeleft: %d; timeout %ld)\n", hfsmp->vcbVN, (hfsmp->hfs_hotfile_maxblks - hfsmp->hfs_hotfile_freeblks),+ SWAP_BE32(hotfileinfo.timeleft), hfsmp->hfc_timeout);+#endif+ } else {+ hotfileinfo.maxfilecnt = SWAP_BE32 (HFC_DEFAULT_FILE_COUNT);+ }+ strlcpy((char *)hotfileinfo.tag, hfc_tag, sizeof hotfileinfo.tag);+ (void) BTSetUserData(VTOF(hfsmp->hfc_filevp), &hotfileinfo, sizeof(hotfileinfo));+}++/*+ * Suspend recording the hotest files on a file system.+ */+int+hfs_recording_suspend(struct hfsmount *hfsmp)+{+ hotfile_data_t *hotdata = NULL;+ int error;++ if (hfsmp->hfc_stage == HFC_DISABLED)+ return (0);++ lck_mtx_lock(&hfsmp->hfc_mutex);++ /*+ * XXX NOTE+ * A suspend can occur during eval/evict/adopt stage.+ * In that case we would need to write out info and+ * flush our HFBT vnode. Currently we just bail.+ */++ hotdata = hfsmp->hfc_recdata;+ if (hotdata == NULL || hfsmp->hfc_stage != HFC_RECORDING) {+ error = 0;+ goto out;+ }+ hfsmp->hfc_stage = HFC_BUSY;++#if HFC_VERBOSE+ printf("hfs: suspend hot file recording on %s\n", hfsmp->vcbVN);+#endif+ error = hfc_btree_open(hfsmp, &hfsmp->hfc_filevp);+ if (error) {+ printf("hfs_recording_suspend: err %d opening btree\n", error);+ goto out;+ }++ if (hfs_start_transaction(hfsmp) != 0) {+ goto out;+ }+ if (hfs_lock(VTOC(hfsmp->hfc_filevp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0) {+ goto end_transaction;+ }++ save_btree_user_info(hfsmp);++ hfs_unlock(VTOC(hfsmp->hfc_filevp));++end_transaction:+ hfs_end_transaction(hfsmp);++out:+ if (hfsmp->hfc_filevp) {+ (void) hfc_btree_close(hfsmp, hfsmp->hfc_filevp);+ hfsmp->hfc_filevp = NULL;+ }+ if (hotdata) {+ hfs_delete_with_hdr(hotdata, hotfile_data_t, hotfile_entry_t, hotdata->maxentries);+ hfsmp->hfc_recdata = NULL;+ }+ hfsmp->hfc_stage = HFC_DISABLED;+ wakeup((caddr_t)&hfsmp->hfc_stage);++ lck_mtx_unlock(&hfsmp->hfc_mutex);+ return (error);+}+++static void+reset_file_ids(struct hfsmount *hfsmp, uint32_t *fileid_table, int num_ids)+{+ int i, error;++ for(i=0; i < num_ids; i++) {+ struct vnode *vp;++ error = hfs_vget(hfsmp, fileid_table[i], &vp, 0, 0);+ if (error) {+ if (error == ENOENT) {+ error = 0;+ continue; /* stale entry, go to next */+ }+ continue;+ }++ // hfs_vget returns a locked cnode so no need to lock here++ if ((hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) && (VTOC(vp)->c_attr.ca_recflags & kHFSFastDevPinnedMask)) {+ error = hfs_pin_vnode(hfsmp, vp, HFS_UNPIN_IT, NULL);+ }++ /*+ * The updates to the catalog must be journaled+ */+ hfs_start_transaction(hfsmp);++ //+ // turn off _all_ the hotfile related bits since we're resetting state+ //+ if (VTOC(vp)->c_attr.ca_recflags & kHFSFastDevCandidateMask) {+ vnode_clearfastdevicecandidate(vp);+ }++ VTOC(vp)->c_attr.ca_recflags &= ~(kHFSFastDevPinnedMask|kHFSDoNotFastDevPinMask|kHFSFastDevCandidateMask|kHFSAutoCandidateMask);+ VTOC(vp)->c_flag |= C_MODIFIED;++ hfs_update(vp, 0);++ hfs_end_transaction(hfsmp);++ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ }+}++static int+flag_hotfile(struct hfsmount *hfsmp, const char *filename)+{+ struct vnode *dvp = NULL, *fvp = NULL;+ vfs_context_t ctx = vfs_context_kernel();+ int error=0;+ size_t fname_len;+ const char *orig_fname = filename;++ if (filename == NULL) {+ return EINVAL;+ }++ fname_len = strlen(filename); // do NOT include the trailing '\0' so that we break out of the loop below++ error = hfs_vfs_root(HFSTOVFS(hfsmp), &dvp, ctx);+ if (error) {+ return (error);+ }++ /* At this point, 'dvp' must be considered iocounted */+ const char *ptr;+ ptr = filename;++ while (ptr < (orig_fname + fname_len - 1)) {+ for(; ptr < (orig_fname + fname_len) && *ptr && *ptr != '/'; ptr++) {+ /* just keep advancing till we reach the end of the string or a slash */+ }++ struct componentname cname = {+ .cn_nameiop = LOOKUP,+ .cn_flags = ISLASTCN,+ .cn_pnbuf = __DECONST(char *, orig_fname),+ .cn_nameptr = __DECONST(char *, filename),+ .cn_pnlen = fname_len,+ .cn_namelen = ptr - filename+ };++ struct vnop_lookup_args ap = {+ .a_dvp = dvp,+ .a_vpp = &fvp,+ .a_cnp = &cname,+ .a_context = ctx+ };++ error = hfs_vnop_lookup(&ap);+ if (error) {+ /*+ * If 'dvp' is non-NULL, then it has an iocount. Make sure to release it+ * before bailing out. VNOP_LOOKUP could legitimately return ENOENT+ * if the item didn't exist or if we raced with a delete.+ */+ if (dvp) {+ vnode_put(dvp);+ dvp = NULL;+ }+ return error;+ }++ if (ptr < orig_fname + fname_len - 1) {+ //+ // we've got a multi-part pathname so drop the ref on the dir,+ // make dvp become what we just looked up, and advance over+ // the slash character in the pathname to get to the next part+ // of the component+ //+ vnode_put(dvp);+ dvp = fvp;+ fvp = NULL;++ filename = ++ptr; // skip the slash character+ }+ }++ if (fvp == NULL) {+ error = ENOENT;+ goto out;+ }++ struct cnode *cp = VTOC(fvp);+ if ((error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT)) != 0) {+ goto out;+ }++ hfs_start_transaction(hfsmp);++ cp->c_attr.ca_recflags |= (kHFSFastDevCandidateMask|kHFSAutoCandidateMask);+ cp->c_flag |= C_MODIFIED;++ hfs_update(fvp, 0);++ hfs_end_transaction(hfsmp);++ hfs_unlock(cp);+ //printf("hfs: flagged /%s with the fast-dev-candidate|auto-candidate flags\n", filename);+++out:+ if (fvp) {+ vnode_put(fvp);+ fvp = NULL;+ }++ if (dvp) {+ vnode_put(dvp);+ dvp = NULL;+ }++ return error;+}+++static void+hfs_setup_default_cf_hotfiles(struct hfsmount *hfsmp)+{+ const char *system_default_hotfiles[] = {+ "usr",+ "System",+ "Applications",+ "private/var/db/dyld"+ };+ int i;++ for(i=0; i < (int)(sizeof(system_default_hotfiles)/sizeof(char *)); i++) {+ flag_hotfile(hfsmp, system_default_hotfiles[i]);+ }+}+++#define NUM_FILE_RESET_IDS 4096 // so we allocate 16k to hold file-ids++static void+hfs_hotfile_reset(struct hfsmount *hfsmp)+{+ CatalogKey * keyp;+ CatalogRecord * datap;+ u_int32_t dataSize;+ BTScanState scanstate;+ BTreeIterator * iterator = NULL;+ FSBufferDescriptor record;+ u_int32_t data;+ u_int32_t cnid;+ int error = 0;+ uint32_t *fileids=NULL;+ int cur_id_index = 0;++ int cleared = 0; /* debug variables */+ int filecount = 0;+ int dircount = 0;++#if HFC_VERBOSE+ printf("hfs: %s: %s\n", hfsmp->vcbVN, __FUNCTION__);+#endif++ iterator = hfs_malloc_type(BTreeIterator);++ fileids = hfs_new_data(uint32_t, NUM_FILE_RESET_IDS);++ record.bufferAddress = &data;+ record.itemSize = sizeof(u_int32_t);+ record.itemCount = 1;++ /*+ * Get ready to scan the Catalog file.+ */+ error = BTScanInitialize(VTOF(HFSTOVCB(hfsmp)->catalogRefNum), 0, 0, 0,+ kCatSearchBufferSize, &scanstate);+ if (error) {+ printf("hfs_hotfile_reset: err %d BTScanInit\n", error);+ goto out;+ }++ /*+ * Visit all the catalog btree leaf records, clearing any that have the+ * HotFileCached bit set.+ */+ for (;;) {+ error = BTScanNextRecord(&scanstate, 0, (void **)&keyp, (void **)&datap, &dataSize);+ if (error) {+ if (error == btNotFound)+ error = 0;+ else+ printf("hfs_hotfile_reset: err %d BTScanNext\n", error);+ break;+ }++ if (datap->recordType == kHFSPlusFolderRecord && (dataSize == sizeof(HFSPlusCatalogFolder))) {+ HFSPlusCatalogFolder *dirp = (HFSPlusCatalogFolder *)datap;++ dircount++;++ if ((dirp->flags & (kHFSFastDevPinnedMask|kHFSDoNotFastDevPinMask|kHFSFastDevCandidateMask|kHFSAutoCandidateMask)) == 0) {+ continue;+ }++ cnid = dirp->folderID;+ } else if ((datap->recordType == kHFSPlusFileRecord) && (dataSize == sizeof(HFSPlusCatalogFile))) {+ HFSPlusCatalogFile *filep = (HFSPlusCatalogFile *)datap;++ filecount++;++ /*+ * If the file doesn't have any of the HotFileCached bits set, ignore it.+ */+ if ((filep->flags & (kHFSFastDevPinnedMask|kHFSDoNotFastDevPinMask|kHFSFastDevCandidateMask|kHFSAutoCandidateMask)) == 0) {+ continue;+ }++ cnid = filep->fileID;+ } else {+ continue;+ }++ /* Skip over journal files. */+ if (cnid == hfsmp->hfs_jnlfileid || cnid == hfsmp->hfs_jnlinfoblkid) {+ continue;+ }++ //+ // Just record the cnid of the file for now. We will modify it separately+ // because we can't modify the catalog while we're scanning it.+ //+ fileids[cur_id_index++] = cnid;+ if (cur_id_index >= NUM_FILE_RESET_IDS) {+ //+ // We're over the limit of file-ids so we have to terminate this+ // scan, go modify all the catalog records, then restart the scan.+ // This is required because it's not permissible to modify the+ // catalog while scanning it.+ //+ (void) BTScanTerminate(&scanstate, &data, &data, &data);++ reset_file_ids(hfsmp, fileids, cur_id_index);+ cleared += cur_id_index;+ cur_id_index = 0;++ // restart the scan+ error = BTScanInitialize(VTOF(HFSTOVCB(hfsmp)->catalogRefNum), 0, 0, 0,+ kCatSearchBufferSize, &scanstate);+ if (error) {+ printf("hfs_hotfile_reset: err %d BTScanInit\n", error);+ goto out;+ }+ continue;+ }+ }++ if (cur_id_index) {+ reset_file_ids(hfsmp, fileids, cur_id_index);+ cleared += cur_id_index;+ cur_id_index = 0;+ }++ printf("hfs: cleared HotFileCache related bits on %d files out of %d (dircount %d)\n", cleared, filecount, dircount);++ (void) BTScanTerminate(&scanstate, &data, &data, &data);++out:+ hfs_delete_data(fileids, uint32_t, NUM_FILE_RESET_IDS);+ hfs_free_type(iterator, BTreeIterator);++ //+ // If the hotfile btree exists, delete it. We need to open+ // it to be able to delete it because we need the hfc_filevp+ // for deletion.+ //+ error = hfc_btree_open_ext(hfsmp, &hfsmp->hfc_filevp, 1);+ if (!error) {+ printf("hfs: hotfile_reset: deleting existing hotfile btree\n");+ hfc_btree_delete(hfsmp);+ }++ if (hfsmp->hfc_filevp) {+ (void) hfc_btree_close(hfsmp, hfsmp->hfc_filevp);+ hfsmp->hfc_filevp = NULL;+ }++ hfsmp->hfs_hotfile_blk_adjust = 0;+ hfsmp->hfs_hotfile_freeblks = hfsmp->hfs_hotfile_maxblks;+}+++//+// This should ONLY be called by hfs_recording_init() and the special fsctl.+//+// We assume that the hotfile btree is already opened.+//+static int+hfs_hotfile_repin_files(struct hfsmount *hfsmp)+{+ BTreeIterator * iterator = NULL;+ HotFileKey * key;+ filefork_t * filefork;+ int error = 0;+ int bt_op;+ enum hfc_stage stage;+ uint32_t pinned_blocks;+ uint32_t num_files=0, nrsrc=0;+ uint32_t total_pinned=0;++ if (!(hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) || !hfsmp->hfc_filevp) {+ //+ // this is only meaningful if we're pinning hotfiles+ // (as opposed to the regular form of hotfiles that+ // get relocated to the hotfile zone)+ //+ return 0;+ }++#if HFC_VERBOSE+ printf("hfs: %s: %s\n", hfsmp->vcbVN, __FUNCTION__);+#endif++ if (hfs_lock(VTOC(hfsmp->hfc_filevp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0) {+ return (EPERM);+ }+++ iterator = hfs_malloc_type(BTreeIterator);++ stage = hfsmp->hfc_stage;+ hfsmp->hfc_stage = HFC_BUSY;++ bt_op = kBTreeFirstRecord;++ key = (HotFileKey*) &iterator->key;++ filefork = VTOF(hfsmp->hfc_filevp);+ int lockflags;++ while (1) {++ lockflags = 0;+ /*+ * Obtain the first record (ie the coldest one).+ */+ if (BTIterateRecord(filefork, bt_op, iterator, NULL, NULL) != 0) {+ // no more records+ error = 0;+ break;+ }+ if (key->keyLength != HFC_KEYLENGTH) {+ // printf("hfs: hotfiles_repin_files: invalid key length %d\n", key->keyLength);+ error = EFTYPE;+ break;+ }+ if (key->temperature == HFC_LOOKUPTAG) {+ // ran into thread records in the hotfile btree+ error = 0;+ break;+ }++ //+ // Just lookup the records in the catalog and pin the direct+ // mapped extents. Faster than instantiating full vnodes+ // (and thereby thrashing the system vnode cache).+ //+ struct cat_desc fdesc;+ struct cat_attr attr;+ struct cat_fork fork;+ uint8_t forktype = 0;++ lockflags = hfs_systemfile_lock(hfsmp, (SFL_CATALOG | SFL_EXTENTS), HFS_SHARED_LOCK);+ /*+ * Snoop the cnode hash to find out if the item we want is in-core already.+ *+ * We largely expect this function to fail (the items we want are probably not in the hash).+ * we use the special variant which bails out as soon as it finds a vnode (even if it is+ * marked as open-unlinked or actually removed on-disk. If we find a vnode, then we+ * release the systemfile locks and go through the pin-vnode path instead.+ */+ if (hfs_chash_snoop (hfsmp, key->fileID, 1, NULL, NULL) == 0) {+ pinned_blocks = 0;++ /* unlock immediately and go through the in-core path */+ hfs_systemfile_unlock(hfsmp, lockflags);+ lockflags = 0;++ error = hfs_getvnode_and_pin (hfsmp, key->fileID, &pinned_blocks);+ if (error) {+ /* if ENOENT, then it was deleted in the catalog. Remove from our hotfiles tracking */+ if (error == ENOENT) {+ hfc_btree_delete_record(hfsmp, iterator, key);+ }+ /* other errors, just ignore and move on with life */+ }+ else { //!error+ total_pinned += pinned_blocks;+ num_files++;+ }++ goto next;+ }++ /* If we get here, we're still holding the systemfile locks */+ error = cat_idlookup(hfsmp, key->fileID, 1, 0, &fdesc, &attr, &fork);+ if (error) {+ //+ // this file system could have been mounted while booted from a+ // different partition and thus the hotfile btree would not have+ // been maintained. thus a file that was hotfile cached could+ // have been deleted while booted from a different partition which+ // means we need to delete it from the hotfile btree.+ //+ // block accounting is taken care of at the end: we re-assign+ // hfsmp->hfs_hotfile_freeblks based on how many blocks we actually+ // pinned.+ //+ hfc_btree_delete_record(hfsmp, iterator, key);++ goto next;+ }++ if (fork.cf_size == 0) {+ // hmmm, the data is probably in the resource fork (aka a compressed file)+ error = cat_idlookup(hfsmp, key->fileID, 1, 1, &fdesc, &attr, &fork);+ if (error) {+ hfc_btree_delete_record(hfsmp, iterator, key);+ goto next;+ }+ forktype = 0xff;+ nrsrc++;+ }++ pinned_blocks = 0;++ /* Can't release the catalog /extents lock yet, we may need to go find the overflow blocks */+ error = hfs_pin_extent_record (hfsmp, fork.cf_extents, &pinned_blocks);+ if (error) {+ goto next; //skip to next+ }+ /* add in the blocks from the inline 8 */+ total_pinned += pinned_blocks;+ pinned_blocks = 0;++ /* Could this file have overflow extents? */+ if (fork.cf_extents[kHFSPlusExtentDensity-1].startBlock) {+ /* better pin them, too */+ error = hfs_pin_overflow_extents (hfsmp, key->fileID, forktype, &pinned_blocks);+ if (error) {+ /* If we fail to pin all of the overflow extents, then just skip to the next file */+ goto next;+ }+ }++ num_files++;+ if (pinned_blocks) {+ /* now add in any overflow also */+ total_pinned += pinned_blocks;+ }++ next:+ if (lockflags) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ lockflags = 0;+ }+ bt_op = kBTreeNextRecord;++ } /* end while */++#if HFC_VERBOSE+ printf("hfs: hotfiles_repin_files: re-pinned %d files (nrsrc %d, total pinned %d blks; freeblock %d, maxblocks %d, calculated free: %d)\n",+ num_files, nrsrc, total_pinned, hfsmp->hfs_hotfile_freeblks, hfsmp->hfs_hotfile_maxblks,+ hfsmp->hfs_hotfile_maxblks - total_pinned);+#endif+ //+ // make sure this is accurate based on how many blocks we actually pinned+ //+ hfsmp->hfs_hotfile_freeblks = hfsmp->hfs_hotfile_maxblks - total_pinned;++ hfs_unlock(VTOC(hfsmp->hfc_filevp));++ hfs_free_type(iterator, BTreeIterator);+ hfsmp->hfc_stage = stage;+ wakeup((caddr_t)&hfsmp->hfc_stage);+ return (error);+}++void+hfs_repin_hotfiles(struct hfsmount *hfsmp)+{+ int error, need_close;++ lck_mtx_lock(&hfsmp->hfc_mutex);++ if (hfsmp->hfc_filevp == NULL) {+ error = hfc_btree_open(hfsmp, &hfsmp->hfc_filevp);+ if (!error) {+ need_close = 1;+ } else {+ printf("hfs: failed to open the btree err=%d. Unable to re-pin hotfiles.\n", error);+ lck_mtx_unlock(&hfsmp->hfc_mutex);+ return;+ }+ } else {+ need_close = 0;+ }++ hfs_pin_vnode(hfsmp, hfsmp->hfc_filevp, HFS_PIN_IT, NULL);++ hfs_hotfile_repin_files(hfsmp);++ if (need_close) {+ (void) hfc_btree_close(hfsmp, hfsmp->hfc_filevp);+ hfsmp->hfc_filevp = NULL;+ }++ lck_mtx_unlock(&hfsmp->hfc_mutex);+}++/*+ * For a given file ID, find and pin all of its overflow extents to the underlying CS+ * device. Assumes that the extents overflow b-tree is locked for the duration of this call.+ *+ * Emit the number of blocks pinned in output argument 'pinned'+ *+ * Return success or failure (errno) in return value.+ *+ */+int hfs_pin_overflow_extents (struct hfsmount *hfsmp, uint32_t fileid,+ uint8_t forktype, uint32_t *pinned) {++ struct BTreeIterator *ext_iter = NULL;+ ExtentKey *ext_key_ptr = NULL;+ ExtentRecord ext_data;+ FSBufferDescriptor btRecord;+ uint16_t btRecordSize;+ int error = 0;++ uint32_t pinned_blocks = 0;+++ ext_iter = hfs_malloc_type(struct BTreeIterator);++ BTInvalidateHint (ext_iter);+ ext_key_ptr = (ExtentKey*)&ext_iter->key;+ btRecord.bufferAddress = &ext_data;+ btRecord.itemCount = 1;++ /*+ * This is like when you delete a file; we don't actually need most of the search machinery because+ * we are going to need all of the extent records that belong to this file (for a given fork type),+ * so we might as well use a straight-up iterator.+ *+ * Position the B-Tree iterator at the first record with this file ID+ */+ btRecord.itemSize = sizeof (HFSPlusExtentRecord);+ ext_key_ptr->hfsPlus.keyLength = kHFSPlusExtentKeyMaximumLength;+ ext_key_ptr->hfsPlus.forkType = forktype;+ ext_key_ptr->hfsPlus.pad = 0;+ ext_key_ptr->hfsPlus.fileID = fileid;+ ext_key_ptr->hfsPlus.startBlock = 0;++ error = BTSearchRecord (VTOF(hfsmp->hfs_extents_vp), ext_iter, &btRecord, &btRecordSize, ext_iter);+ if (error == btNotFound) {+ /* empty b-tree, so that's ok. we'll fall out during error check below. */+ error = 0;+ }++ while (1) {+ uint32_t found_fileid;+ uint32_t pblocks;++ error = BTIterateRecord (VTOF(hfsmp->hfs_extents_vp), kBTreeNextRecord, ext_iter, &btRecord, &btRecordSize);+ if (error) {+ /* swallow it if it's btNotFound, otherwise just bail out */+ if (error == btNotFound)+ error = 0;+ break;+ }++ found_fileid = ext_key_ptr->hfsPlus.fileID;+ /*+ * We only do one fork type at a time. So if either the fork-type doesn't+ * match what we are looking for (resource or data), OR the file id doesn't match+ * which indicates that there's nothing more with this file ID as the key, then bail out+ */+ if ((found_fileid != fileid) || (ext_key_ptr->hfsPlus.forkType != forktype)) {+ error = 0;+ break;+ }++ /* Otherwise, we now have an extent record. Process and pin all of the file extents. */+ pblocks = 0;+ error = hfs_pin_extent_record (hfsmp, ext_data.hfsPlus, &pblocks);++ if (error) {+ break;+ }+ pinned_blocks += pblocks;++ /* if 8th extent is empty, then bail out */+ if (ext_data.hfsPlus[kHFSPlusExtentDensity-1].startBlock == 0) {+ error = 0;+ break;+ }++ } // end extent-getting loop++ /* dump the iterator */+ hfs_free_type(ext_iter, struct BTreeIterator);++ if (error == 0) {+ /*+ * In the event that the file has no overflow extents, pinned_blocks+ * will never be updated, so we'll properly export 0 pinned blocks to caller+ */+ *pinned = pinned_blocks;+ }++ return error;++}+++static int+hfs_getvnode_and_pin (struct hfsmount *hfsmp, uint32_t fileid, uint32_t *pinned) {+ struct vnode *vp;+ int error = 0;+ *pinned = 0;+ uint32_t pblocks;++ /*+ * Acquire the vnode for this file. This returns a locked cnode on success+ */+ error = hfs_vget(hfsmp, fileid, &vp, 0, 0);+ if (error) {+ /* It's possible the file was open-unlinked. In this case, we'll get ENOENT back. */+ return error;+ }++ /*+ * Symlinks that may have been inserted into the hotfile zone during a previous OS are now stuck+ * here. We do not want to move them.+ */+ if (!vnode_isreg(vp)) {+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ return EPERM;+ }++ if (!(VTOC(vp)->c_attr.ca_recflags & kHFSFastDevPinnedMask)) {+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ return EINVAL;+ }++ error = hfs_pin_vnode(hfsmp, vp, HFS_PIN_IT, &pblocks);+ if (error == 0) {+ *pinned = pblocks;+ }++ hfs_unlock(VTOC(vp));+ vnode_put(vp);++ return error;++}++/*+ * Pins an HFS Extent record to the underlying CoreStorage. Assumes that Catalog & Extents overflow+ * B-trees are held locked, as needed.+ *+ * Returns the number of blocks pinned in the output argument 'pinned'+ *+ * Returns error status (0 || errno) in return value.+ */+static int hfs_pin_extent_record (struct hfsmount *hfsmp, HFSPlusExtentRecord extents, uint32_t *pinned) {+ uint32_t pb = 0;+ int i;+ int error = 0;++ if (pinned == NULL) {+ return EINVAL;+ }+ *pinned = 0;++++ /* iterate through the extents */+ for ( i = 0; i < kHFSPlusExtentDensity; i++) {+ if (extents[i].startBlock == 0) {+ break;+ }++ error = hfs_pin_block_range (hfsmp, HFS_PIN_IT, extents[i].startBlock,+ extents[i].blockCount);++ if (error) {+ break;+ }+ pb += extents[i].blockCount;+ }++ *pinned = pb;++ return error;+}++/*+ * Consume an HFS Plus on-disk catalog record and pin its blocks+ * to the underlying CS devnode.+ *+ * NOTE: This is an important distinction!+ * This function takes in an HFSPlusCatalogFile* which is the actual+ * 200-some-odd-byte on-disk representation in the Catalog B-Tree (not+ * one of the run-time structs that we normally use.+ *+ * This assumes that the catalog and extents-overflow btrees+ * are locked, at least in shared mode+ */+static int hfs_pin_catalog_rec (struct hfsmount *hfsmp, HFSPlusCatalogFile *cfp, int rsrc) {+ uint32_t pinned_blocks = 0;+ HFSPlusForkData *forkdata;+ int error = 0;+ uint8_t forktype = 0;++ if (rsrc) {+ forkdata = &cfp->resourceFork;+ forktype = 0xff;+ }+ else {+ forkdata = &cfp->dataFork;+ }++ uint32_t pblocks = 0;++ /* iterate through the inline extents */+ error = hfs_pin_extent_record (hfsmp, forkdata->extents, &pblocks);+ if (error) {+ return error;+ }++ pinned_blocks += pblocks;+ pblocks = 0;++ /* it may have overflow extents */+ if (forkdata->extents[kHFSPlusExtentDensity-1].startBlock != 0) {+ error = hfs_pin_overflow_extents (hfsmp, cfp->fileID, forktype, &pblocks);+ }+ pinned_blocks += pblocks;++ hfsmp->hfs_hotfile_freeblks -= pinned_blocks;++ return error;+}+++/*+ *+ */+int+hfs_recording_init(struct hfsmount *hfsmp)+{+ CatalogKey * keyp;+ CatalogRecord * datap;+ u_int32_t dataSize;+ HFSPlusCatalogFile *filep;+ BTScanState scanstate;+ BTreeIterator * iterator = NULL;+ FSBufferDescriptor record;+ HotFileKey * key;+ filefork_t * filefork;+ u_int32_t data;+ struct cat_attr cattr;+ u_int32_t cnid;+ int error = 0;+ long starting_temp;++ int started_tr = 0;+ int started_scan = 0;++ int inserted = 0; /* debug variables */+ int filecount = 0;+ int uncacheable = 0;++ /*+ * For now, only the boot volume is supported.+ */+ if ((vfs_flags(HFSTOVFS(hfsmp)) & MNT_ROOTFS) == 0) {+ hfsmp->hfc_stage = HFC_DISABLED;+ return (EPERM);+ }++ /* We grab the HFC mutex even though we're not fully mounted yet, just for orderliness */+ lck_mtx_lock (&hfsmp->hfc_mutex);++ /*+ * Tracking of hot files requires up-to-date access times.+ * So if access time updates are disabled, then we disable+ * hot files, too.+ */+ if (vfs_flags(HFSTOVFS(hfsmp)) & MNT_NOATIME) {+ hfsmp->hfc_stage = HFC_DISABLED;+ lck_mtx_unlock (&hfsmp->hfc_mutex);+ return EPERM;+ }++ //+ // Check if we've been asked to suspend operation+ //+ cnid = GetFileInfo(HFSTOVCB(hfsmp), kRootDirID, ".hotfile-suspend", &cattr, NULL);+ if (cnid != 0) {+ printf("hfs: %s: %s: hotfiles explicitly disabled! remove /.hotfiles-suspend to re-enable\n", hfsmp->vcbVN, __FUNCTION__);+ hfsmp->hfc_stage = HFC_DISABLED;+ lck_mtx_unlock (&hfsmp->hfc_mutex);+ return EPERM;+ }++ //+ // Check if we've been asked to reset our state.+ //+ cnid = GetFileInfo(HFSTOVCB(hfsmp), kRootDirID, ".hotfile-reset", &cattr, NULL);+ if (cnid != 0) {+ hfs_hotfile_reset(hfsmp);+ }++ if (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) {+ //+ // Cooperative Fusion (CF) systems use different constants+ // than traditional hotfile systems. These were picked after a bit of+ // experimentation - we can cache many more files on the+ // ssd in an CF system and we can do so more rapidly+ // so bump the limits considerably (and turn down the+ // duration so that it doesn't take weeks to adopt all+ // the files).+ //+ hfc_default_file_count = 20000;+ hfc_default_duration = 300; // 5min+ hfc_max_file_count = 50000;+ hfc_max_file_size = (512ULL * 1024ULL * 1024ULL);+ }++ /*+ * If the Hot File btree exists then metadata zone is ready.+ */+ cnid = GetFileInfo(HFSTOVCB(hfsmp), kRootDirID, HFC_FILENAME, &cattr, NULL);+ if (cnid != 0 && S_ISREG(cattr.ca_mode)) {+ int recreate = 0;++ if (hfsmp->hfc_stage == HFC_DISABLED)+ hfsmp->hfc_stage = HFC_IDLE;+ hfsmp->hfs_hotfile_freeblks = 0;++ if ((hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) && cattr.ca_blocks > 0) {+ //+ // make sure the hotfile btree is pinned+ //+ error = hfc_btree_open(hfsmp, &hfsmp->hfc_filevp);+ if (!error) {+ /* XXX: must fix hfs_pin_vnode too */+ hfs_pin_vnode(hfsmp, hfsmp->hfc_filevp, HFS_PIN_IT, NULL);++ } else {+ printf("hfs: failed to open the btree err=%d. Recreating hotfile btree.\n", error);+ recreate = 1;+ }++ hfs_hotfile_repin_files(hfsmp);++ if (hfsmp->hfc_filevp) {+ (void) hfc_btree_close(hfsmp, hfsmp->hfc_filevp);+ hfsmp->hfc_filevp = NULL;+ }++ } else if (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) {+ // hmmm, the hotfile btree is zero bytes long? how odd. let's recreate it.+ printf("hfs: hotfile btree is zero bytes long?! recreating it.\n");+ recreate = 1;+ }++ if (!recreate) {+ /* don't forget to unlock the mutex */+ lck_mtx_unlock (&hfsmp->hfc_mutex);+ return (0);+ } else {+ //+ // open the hotfile btree file ignoring errors because+ // we need the vnode pointer for hfc_btree_delete() to+ // be able to do its work+ //+ error = hfc_btree_open_ext(hfsmp, &hfsmp->hfc_filevp, 1);+ if (!error) {+ // and delete it!+ error = hfc_btree_delete(hfsmp);+ (void) hfc_btree_close(hfsmp, hfsmp->hfc_filevp);+ hfsmp->hfc_filevp = NULL;+ }+ }+ }++ printf("hfs: %s: %s: creating the hotfile btree\n", hfsmp->vcbVN, __FUNCTION__);+ if (hfs_start_transaction(hfsmp) != 0) {+ lck_mtx_unlock (&hfsmp->hfc_mutex);+ return EINVAL;+ }++ /* B-tree creation must be journaled */+ started_tr = 1;++ error = hfc_btree_create(hfsmp, HFSTOVCB(hfsmp)->blockSize, HFC_DEFAULT_FILE_COUNT);+ if (error) {+#if HFC_VERBOSE+ printf("hfs: Error %d creating hot file b-tree on %s \n", error, hfsmp->vcbVN);+#endif+ goto recording_init_out;+ }++ hfs_end_transaction (hfsmp);+ started_tr = 0;+ /*+ * Do a journal flush + flush track cache. We have to ensure that the async I/Os have been issued to the media+ * before proceeding.+ */+ hfs_flush (hfsmp, HFS_FLUSH_FULL);++ /* now re-start a new transaction */+ if (hfs_start_transaction (hfsmp) != 0) {+ lck_mtx_unlock (&hfsmp->hfc_mutex);+ return EINVAL;+ }+ started_tr = 1;++ /*+ * Open the Hot File B-tree file for writing.+ */+ if (hfsmp->hfc_filevp)+ panic("hfs_recording_init: hfc_filevp exists (vp = %p)", hfsmp->hfc_filevp);++ error = hfc_btree_open(hfsmp, &hfsmp->hfc_filevp);+ if (error) {+#if HFC_VERBOSE+ printf("hfs: Error %d opening hot file b-tree on %s \n", error, hfsmp->vcbVN);+#endif+ goto recording_init_out;+ }++ /*+ * This function performs work similar to namei; we must NOT hold the catalog lock while+ * calling it. This will decorate catalog records as being pinning candidates. (no hotfiles work)+ */+ hfs_setup_default_cf_hotfiles(hfsmp);++ /*+ * now grab the hotfiles b-tree vnode/cnode lock first, as it is not classified as a systemfile.+ */+ if (hfs_lock(VTOC(hfsmp->hfc_filevp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0) {+ error = EPERM;+ (void) hfc_btree_close(hfsmp, hfsmp->hfc_filevp);+ /* zero it out to avoid pinning later on */+ hfsmp->hfc_filevp = NULL;+ goto recording_init_out;+ }++ iterator = hfs_malloc_type(BTreeIterator);++ key = (HotFileKey*) &iterator->key;+ key->keyLength = HFC_KEYLENGTH;++ record.bufferAddress = &data;+ record.itemSize = sizeof(u_int32_t);+ record.itemCount = 1;++#if HFC_VERBOSE+ printf("hfs: Evaluating space for \"%s\" metadata zone... (freeblks %d)\n", HFSTOVCB(hfsmp)->vcbVN,+ hfsmp->hfs_hotfile_freeblks);+#endif++ /*+ * Get ready to scan the Catalog file. We explicitly do NOT grab the catalog lock because+ * we're fully single-threaded at the moment (by virtue of being called during mount()),+ * and if we have to grow the hotfile btree, then we would need to grab the catalog lock+ * and if we take a shared lock here, it would deadlock (see <rdar://problem/21486585>)+ *+ * We already started a transaction so we should already be holding the journal lock at this point.+ * Note that we have to hold the journal lock / start a txn BEFORE the systemfile locks.+ */++ error = BTScanInitialize(VTOF(HFSTOVCB(hfsmp)->catalogRefNum), 0, 0, 0,+ kCatSearchBufferSize, &scanstate);+ if (error) {+ printf("hfs_recording_init: err %d BTScanInit\n", error);++ /* drop the systemfile locks */+ hfs_unlock(VTOC(hfsmp->hfc_filevp));++ (void) hfc_btree_close(hfsmp, hfsmp->hfc_filevp);++ /* zero it out to avoid pinning */+ hfsmp->hfc_filevp = NULL;+ goto recording_init_out;+ }++ started_scan = 1;++ filefork = VTOF(hfsmp->hfc_filevp);++ starting_temp = random() % HF_TEMP_RANGE;++ /*+ * Visit all the catalog btree leaf records. We have to hold the catalog lock to do this.+ *+ * NOTE: The B-Tree scanner reads from the media itself. Under normal circumstances it would be+ * fine to simply use b-tree routines to read blocks that correspond to b-tree nodes, because the+ * block cache is going to ensure you always get the cached copy of a block (even if a journal+ * txn has modified one of those blocks). That is NOT true when+ * using the scanner. In particular, it will always read whatever is on-disk. So we have to ensure+ * that the journal has flushed and that the async I/Os to the metadata files have been issued.+ */+ for (;;) {+ error = BTScanNextRecord(&scanstate, 0, (void **)&keyp, (void **)&datap, &dataSize);+ if (error) {+ if (error == btNotFound)+ error = 0;+ else+ printf("hfs_recording_init: err %d BTScanNext\n", error);+ break;+ }+ if ((datap->recordType != kHFSPlusFileRecord) ||+ (dataSize != sizeof(HFSPlusCatalogFile))) {+ continue;+ }+ filep = (HFSPlusCatalogFile *)datap;+ filecount++;++ if (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) {+ if (filep->flags & kHFSDoNotFastDevPinMask) {+ uncacheable++;+ }++ //+ // If the file does not have the FastDevPinnedMask set, we+ // can ignore it and just go to the next record.+ //+ if ((filep->flags & kHFSFastDevPinnedMask) == 0) {+ continue;+ }+ } else if (filep->dataFork.totalBlocks == 0) {+ continue;+ }++ /*+ * On a regular hdd, any file that has blocks inside+ * the hot file space is recorded for later eviction.+ *+ * For now, resource forks are ignored.+ *+ * We don't do this on CF systems as there is no real+ * hotfile area - we just pin/unpin blocks belonging to+ * interesting files.+ */+ if (!(hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) && !hotextents(hfsmp, &filep->dataFork.extents[0])) {+ continue;+ }+ cnid = filep->fileID;++ /* Skip over journal files and the hotfiles B-Tree file. */+ if (cnid == hfsmp->hfs_jnlfileid+ || cnid == hfsmp->hfs_jnlinfoblkid+ || cnid == VTOC(hfsmp->hfc_filevp)->c_fileid) {+ continue;+ }+ /*+ * XXX - need to skip quota files as well.+ */++ uint32_t temp;++ if (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) {+ int rsrc = 0;++ temp = (uint32_t)starting_temp++;+ if (filep->flags & kHFSAutoCandidateMask) {+ temp += MAX_NORMAL_TEMP;+ }++ /* use the data fork by default */+ if (filep->dataFork.totalBlocks == 0) {+ /*+ * but if empty, switch to rsrc as its likely+ * a compressed file+ */+ rsrc = 1;+ }++ error = hfs_pin_catalog_rec (hfsmp, filep, rsrc);+ if (error)+ break;++ } else {+ temp = HFC_MINIMUM_TEMPERATURE;+ }++ /* Insert a hot file entry. */+ key->keyLength = HFC_KEYLENGTH;+ key->temperature = temp;+ key->fileID = cnid;+ key->forkType = 0;+ data = 0x3f3f3f3f;+ error = BTInsertRecord(filefork, iterator, &record, record.itemSize);+ if (error) {+ printf("hfs_recording_init: BTInsertRecord failed %d (fileid %d)\n", error, key->fileID);+ error = MacToVFSError(error);+ break;+ }++ /* Insert the corresponding thread record. */+ key->keyLength = HFC_KEYLENGTH;+ key->temperature = HFC_LOOKUPTAG;+ key->fileID = cnid;+ key->forkType = 0;+ data = temp;+ error = BTInsertRecord(filefork, iterator, &record, record.itemSize);+ if (error) {+ printf("hfs_recording_init: BTInsertRecord failed %d (fileid %d)\n", error, key->fileID);+ error = MacToVFSError(error);+ break;+ }+ inserted++;+ } // end catalog iteration loop++ save_btree_user_info(hfsmp);+ (void) BTFlushPath(filefork);++recording_init_out:++ /* Unlock first, then pin after releasing everything else */+ if (hfsmp->hfc_filevp) {+ hfs_unlock (VTOC(hfsmp->hfc_filevp));+ }++ if (started_scan) {+ (void) BTScanTerminate (&scanstate, &data, &data, &data);+ }++ if (started_tr) {+ hfs_end_transaction(hfsmp);+ }++#if HFC_VERBOSE+ printf("hfs: %d files identified out of %d (freeblocks is now: %d)\n", inserted, filecount, hfsmp->hfs_hotfile_freeblks);+ if (uncacheable) {+ printf("hfs: %d files were marked as uncacheable\n", uncacheable);+ }+#endif++ if (iterator)+ hfs_free_type(iterator, BTreeIterator);++ if (hfsmp->hfc_filevp) {+ if (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) {+ hfs_pin_vnode(hfsmp, hfsmp->hfc_filevp, HFS_PIN_IT, NULL);+ }+ (void) hfc_btree_close(hfsmp, hfsmp->hfc_filevp);+ hfsmp->hfc_filevp = NULL;+ }++ if (error == 0)+ hfsmp->hfc_stage = HFC_IDLE;++ /* Finally, unlock the HFC mutex */+ lck_mtx_unlock (&hfsmp->hfc_mutex);++ return (error);+}++/*+ * Use sync to perform ocassional background work.+ */+int+hfs_hotfilesync(struct hfsmount *hfsmp, vfs_context_t ctx)+{+ if (hfsmp->hfc_stage) {+ struct timeval tv;++ lck_mtx_lock(&hfsmp->hfc_mutex);++ switch (hfsmp->hfc_stage) {+ case HFC_IDLE:+ (void) hfs_recording_start(hfsmp);+ break;++ case HFC_RECORDING:+ microtime(&tv);+ if (tv.tv_sec > hfsmp->hfc_timeout)+ (void) hfs_recording_stop(hfsmp);+ break;++ case HFC_EVICTION:+ (void) hotfiles_evict(hfsmp, ctx);+ break;++ case HFC_ADOPTION:+ (void) hotfiles_adopt(hfsmp);+ break;+ default:+ break;+ }++ lck_mtx_unlock(&hfsmp->hfc_mutex);+ }+ return (0);+}++/*+ * Add a hot file to the recording list.+ *+ * This can happen when a hot file gets reclaimed or at the+ * end of the recording period for any active hot file.+ *+ * NOTE: Since both the data and resource fork can be hot,+ * there can be two entries for the same file id.+ *+ * Note: the cnode is locked on entry.+ */+int+hfs_addhotfile(struct vnode *vp)+{+ hfsmount_t *hfsmp;+ int error;++ hfsmp = VTOHFS(vp);+ if (hfsmp->hfc_stage != HFC_RECORDING)+ return (0);++ lck_mtx_lock(&hfsmp->hfc_mutex);+ error = hfs_addhotfile_internal(vp);+ lck_mtx_unlock(&hfsmp->hfc_mutex);+ return (error);+}++static int+hf_ignore_process(const char *pname, size_t maxlen)+{+ if ( strncmp(pname, "mds", maxlen) == 0+ || strncmp(pname, "mdworker", maxlen) == 0+ || strncmp(pname, "mds_stores", maxlen) == 0+ || strncmp(pname, "makewhatis", maxlen) == 0) {+ return 1;+ }++ return 0;++}++static int+hfs_addhotfile_internal(struct vnode *vp)+{+ hotfile_data_t *hotdata;+ hotfile_entry_t *entry;+ hfsmount_t *hfsmp;+ cnode_t *cp;+ filefork_t *ffp;+ u_int32_t temperature;++ hfsmp = VTOHFS(vp);+ if (hfsmp->hfc_stage != HFC_RECORDING)+ return (0);++ /*+ * Only regular files are eligible for hotfiles addition.+ *+ * Symlinks were previously added to the list and may exist in+ * extant hotfiles regions, but no new ones will be added, and no+ * symlinks will now be relocated/evicted from the hotfiles region.+ */+ if (!vnode_isreg(vp) || vnode_issystem(vp)) {+ return (0);+ }++ /* Skip resource forks for now. */+ if (VNODE_IS_RSRC(vp)) {+ return (0);+ }+ if ((hotdata = hfsmp->hfc_recdata) == NULL) {+ return (0);+ }+ ffp = VTOF(vp);+ cp = VTOC(vp);++ if (cp->c_attr.ca_recflags & (kHFSFastDevPinnedMask|kHFSDoNotFastDevPinMask)) {+ // it's already a hotfile or can't be a hotfile...+ return 0;+ }++ if (vnode_isdir(vp) || vnode_issystem(vp) || (cp->c_flag & (C_DELETED | C_NOEXISTS))) {+ return 0;+ }++ if ((hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) && vnode_isfastdevicecandidate(vp)) {+ //+ // On cooperative fusion (CF) systems we have different criteria for whether something+ // can be pinned to the ssd.+ //+ if (cp->c_flag & (C_DELETED|C_NOEXISTS)) {+ //+ // dead files are definitely not worth caching+ //+ return 0;+ } else if (ffp->ff_blocks == 0 && !(cp->c_bsdflags & UF_COMPRESSED) && !(cp->c_attr.ca_recflags & kHFSFastDevCandidateMask)) {+ //+ // empty files aren't worth caching but compressed ones might be, as are+ // newly created files that live in WorthCaching directories...+ //+ return 0;+ }++ char pname[256];+ pname[0] = '\0';+ proc_selfname(pname, sizeof(pname));+ if (hf_ignore_process(pname, sizeof(pname))) {+ // ignore i/o's from certain system daemons+ return 0;+ }++ temperature = cp->c_fileid; // in memory we just keep it sorted by file-id+ } else {+ // the normal hard drive based hotfile checks+ if ((ffp->ff_bytesread == 0) ||+ (ffp->ff_blocks == 0) ||+ (ffp->ff_size == 0) ||+ (ffp->ff_blocks > hotdata->maxblocks) ||+ (cp->c_bsdflags & (UF_NODUMP | UF_COMPRESSED)) ||+ (cp->c_atime < hfsmp->hfc_timebase)) {+ return (0);+ }++ temperature = ffp->ff_bytesread / ffp->ff_size;+ if (temperature < hotdata->threshold) {+ return (0);+ }+ }++ /*+ * If there is room or this file is hotter than+ * the coldest one then add it to the list.+ *+ */+ if ((hotdata->activefiles < hfsmp->hfc_maxfiles) ||+ (hotdata->coldest == NULL) ||+ (temperature >= hotdata->coldest->temperature)) {+ ++hotdata->refcount;+ entry = hf_getnewentry(hotdata);+ entry->temperature = temperature;+ entry->fileid = cp->c_fileid;+ //+ // if ffp->ff_blocks is zero, it might be compressed so make sure we record+ // that there's at least one block.+ //+ entry->blocks = ffp->ff_blocks ? ffp->ff_blocks : 1;+ if (hf_insert(hotdata, entry) == EEXIST) {+ // entry is already present, don't need to add it again+ entry->right = hotdata->freelist;+ hotdata->freelist = entry;+ }+ --hotdata->refcount;+ }++ return (0);+}++/*+ * Remove a hot file from the recording list.+ *+ * This can happen when a hot file becomes+ * an active vnode (active hot files are+ * not kept in the recording list until the+ * end of the recording period).+ *+ * Note: the cnode is locked on entry.+ */+int+hfs_removehotfile(struct vnode *vp)+{+ hotfile_data_t *hotdata;+ hfsmount_t *hfsmp;+ cnode_t *cp;+ filefork_t *ffp;+ u_int32_t temperature;++ hfsmp = VTOHFS(vp);+ if (hfsmp->hfc_stage != HFC_RECORDING)+ return (0);++ if ((!vnode_isreg(vp)) || vnode_issystem(vp)) {+ return (0);+ }++ ffp = VTOF(vp);+ cp = VTOC(vp);++ if ((ffp->ff_bytesread == 0) || (ffp->ff_blocks == 0) ||+ (ffp->ff_size == 0) || (cp->c_atime < hfsmp->hfc_timebase)) {+ return (0);+ }++ lck_mtx_lock(&hfsmp->hfc_mutex);+ if (hfsmp->hfc_stage != HFC_RECORDING)+ goto out;+ if ((hotdata = hfsmp->hfc_recdata) == NULL)+ goto out;++ temperature = ffp->ff_bytesread / ffp->ff_size;+ if (temperature < hotdata->threshold)+ goto out;++ if (hotdata->coldest && (temperature >= hotdata->coldest->temperature)) {+ ++hotdata->refcount;+ hf_delete(hotdata, VTOC(vp)->c_fileid, temperature);+ --hotdata->refcount;+ }+out:+ lck_mtx_unlock(&hfsmp->hfc_mutex);+ return (0);+}++int+hfs_hotfile_deleted(__unused struct vnode *vp)+{+#if 1+ return 0;+#else+ //+ // XXXdbg - this code, while it would work, would introduce a huge inefficiency+ // to deleting files as the way it's written would require us to open+ // the hotfile btree on every open, delete two records in it and then+ // close the hotfile btree (which involves more writes).+ //+ // We actually can be lazy about deleting hotfile records for files+ // that get deleted. When it's time to evict things, if we encounter+ // a record that references a dead file (i.e. a fileid which no+ // longer exists), the eviction code will remove the records. Likewise+ // the code that scans the HotFile B-Tree at boot time to re-pin files+ // will remove dead records.+ //++ hotfile_data_t *hotdata;+ hfsmount_t *hfsmp;+ cnode_t *cp;+ filefork_t *filefork;+ u_int32_t temperature;+ BTreeIterator * iterator = NULL;+ FSBufferDescriptor record;+ HotFileKey *key;+ u_int32_t data;+ int error=0;++ cp = VTOC(vp);+ if (cp == NULL || !(cp->c_attr.ca_recflags & kHFSFastDevPinnedMask)) {+ return 0;+ }++ hfsmp = VTOHFS(vp);+ if (!(hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN)) {+ return 0;+ }++ if (hfc_btree_open(hfsmp, &hfsmp->hfc_filevp) != 0 || hfsmp->hfc_filevp == NULL) {+ // either there is no hotfile info or it's damaged+ return EINVAL;+ }++ filefork = VTOF(hfsmp->hfc_filevp);+ if (filefork == NULL) {+ return 0;+ }++ iterator = hfs_malloc_type(BTreeIterator);++ key = (HotFileKey*) &iterator->key;++ record.bufferAddress = &data;+ record.itemSize = sizeof(u_int32_t);+ record.itemCount = 1;++ key->keyLength = HFC_KEYLENGTH;+ key->temperature = HFC_LOOKUPTAG;+ key->fileID = cp->c_fileid;+ key->forkType = 0;++ lck_mtx_lock(&hfsmp->hfc_mutex);+ (void) BTInvalidateHint(iterator);+ if (BTSearchRecord(filefork, iterator, &record, NULL, iterator) == 0) {+ temperature = key->temperature;+ hfc_btree_delete_record(hfsmp, iterator, key);+ } else {+ //printf("hfs: hotfile_deleted: did not find fileid %d\n", cp->c_fileid);+ error = ENOENT;+ }++ if ((hotdata = hfsmp->hfc_recdata) != NULL) {+ // just in case, also make sure it's removed from the in-memory list as well+ ++hotdata->refcount;+ hf_delete(hotdata, cp->c_fileid, cp->c_fileid);+ --hotdata->refcount;+ }++ lck_mtx_unlock(&hfsmp->hfc_mutex);+ hfs_free_type(iterator, BTreeIterator);++ hfc_btree_close(hfsmp, hfsmp->hfc_filevp);++ return error;+#endif+}++int+hfs_hotfile_adjust_blocks(struct vnode *vp, int64_t num_blocks)+{+ hfsmount_t *hfsmp;++ if (vp == NULL) {+ return 0;+ }++ hfsmp = VTOHFS(vp);++ if (!(hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) || num_blocks == 0 || vp == NULL) {+ return 0;+ }++ //+ // if file is not HotFileCached or it has the CanNotHotFile cache+ // bit set then there is nothing to do+ //+ if (!(VTOC(vp)->c_attr.ca_recflags & kHFSFastDevPinnedMask) || (VTOC(vp)->c_attr.ca_recflags & kHFSDoNotFastDevPinMask)) {+ // it's not a hot file or can't be one so don't bother tracking+ return 0;+ }++ OSAddAtomic(num_blocks, &hfsmp->hfs_hotfile_blk_adjust);++ return (0);+}++//+// Assumes hfsmp->hfc_mutex is LOCKED+//+static int+hfs_hotfile_cur_freeblks(hfsmount_t *hfsmp)+{+ if (hfsmp->hfc_stage < HFC_IDLE) {+ return 0;+ }++ int cur_blk_adjust = hfsmp->hfs_hotfile_blk_adjust; // snap a copy of this value++ if (cur_blk_adjust) {+ OSAddAtomic(-cur_blk_adjust, &hfsmp->hfs_hotfile_blk_adjust);+ hfsmp->hfs_hotfile_freeblks += cur_blk_adjust;+ }++ return hfsmp->hfs_hotfile_freeblks;+}+++/*+ *========================================================================+ * HOT FILE MAINTENANCE ROUTINES+ *========================================================================+ */++static int+hotfiles_collect_callback(struct vnode *vp, __unused void *cargs)+{+ if ((vnode_isreg(vp)) && !vnode_issystem(vp))+ (void) hfs_addhotfile_internal(vp);++ return (VNODE_RETURNED);+}++/*+ * Add all active hot files to the recording list.+ */+static int+hotfiles_collect(struct hfsmount *hfsmp)+{+ struct mount *mp = HFSTOVFS(hfsmp);++ if (vfs_busy(mp, LK_NOWAIT))+ return (0);++ /*+ * hotfiles_collect_callback will be called for each vnode+ * hung off of this mount point+ * the vnode will be+ * properly referenced and unreferenced around the callback+ */+ vnode_iterate(mp, 0, hotfiles_collect_callback, (void *)NULL);++ vfs_unbusy(mp);++ return (0);+}+++/*+ * Update the data of a btree record+ * This is called from within BTUpdateRecord.+ */+static int+update_callback(const HotFileKey *key, u_int32_t *data, u_int32_t *state)+{+ if (key->temperature == HFC_LOOKUPTAG)+ *data = *state;+ return (0);+}++/*+ * Identify files already in hot area.+ */+static int+hotfiles_refine(struct hfsmount *hfsmp)+{+ BTreeIterator * iterator = NULL;+ struct mount *mp;+ filefork_t * filefork;+ hotfilelist_t *listp;+ FSBufferDescriptor record;+ HotFileKey * key;+ u_int32_t data;+ int i;+ int error = 0;++ if ((listp = hfsmp->hfc_filelist) == NULL)+ return (0);++ if (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) {+ // on ssd's we don't refine the temperature since the+ // replacement algorithm is simply random+ return 0;+ }++ mp = HFSTOVFS(hfsmp);++ iterator = hfs_malloc_type(BTreeIterator);++ key = (HotFileKey*) &iterator->key;++ record.bufferAddress = &data;+ record.itemSize = sizeof(u_int32_t);+ record.itemCount = 1;++ if (hfs_start_transaction(hfsmp) != 0) {+ error = EINVAL;+ goto out;+ }+ if (hfs_lock(VTOC(hfsmp->hfc_filevp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0) {+ error = EPERM;+ goto out1;+ }+ filefork = VTOF(hfsmp->hfc_filevp);++ for (i = 0; i < listp->hfl_count; ++i) {+ /*+ * Check if entry (thread) is already in hot area.+ */+ key->keyLength = HFC_KEYLENGTH;+ key->temperature = HFC_LOOKUPTAG;+ key->fileID = listp->hfl_hotfile[i].hf_fileid;+ key->forkType = 0;+ (void) BTInvalidateHint(iterator);+ if (BTSearchRecord(filefork, iterator, &record, NULL, iterator) != 0) {+ continue; /* not in hot area, so skip */+ }++ /*+ * Update thread entry with latest temperature.+ */+ error = BTUpdateRecord(filefork, iterator,+ (IterateCallBackProcPtr)update_callback,+ &listp->hfl_hotfile[i].hf_temperature);+ if (error) {+ printf("hfs: hotfiles_refine: BTUpdateRecord failed %d (file %d)\n", error, key->fileID);+ error = MacToVFSError(error);+ // break;+ }+ /*+ * Re-key entry with latest temperature.+ */+ key->keyLength = HFC_KEYLENGTH;+ key->temperature = data;+ key->fileID = listp->hfl_hotfile[i].hf_fileid;+ key->forkType = 0;+ /* Pick up record data. */+ (void) BTInvalidateHint(iterator);+ (void) BTSearchRecord(filefork, iterator, &record, NULL, iterator);+ error = BTDeleteRecord(filefork, iterator);+ if (error) {+ printf("hfs: hotfiles_refine: BTDeleteRecord failed %d (file %d)\n", error, key->fileID);+ error = MacToVFSError(error);+ break;+ }+ key->keyLength = HFC_KEYLENGTH;+ key->temperature = listp->hfl_hotfile[i].hf_temperature;+ key->fileID = listp->hfl_hotfile[i].hf_fileid;+ key->forkType = 0;+ error = BTInsertRecord(filefork, iterator, &record, record.itemSize);+ if (error) {+ printf("hfs: hotfiles_refine: BTInsertRecord failed %d (file %d)\n", error, key->fileID);+ error = MacToVFSError(error);+ break;+ }+ /*+ * Invalidate this entry in the list.+ */+ listp->hfl_hotfile[i].hf_temperature = 0;+ listp->hfl_totalblocks -= listp->hfl_hotfile[i].hf_blocks;++ } /* end for */++ (void) BTFlushPath(filefork);+ hfs_unlock(VTOC(hfsmp->hfc_filevp));++out1:+ hfs_end_transaction(hfsmp);+out:+ if (iterator)+ hfs_free_type(iterator, BTreeIterator);+ return (error);+}++/*+ * Move new hot files into hot area.+ *+ * Requires that the hfc_mutex be held.+ */+static int+hotfiles_adopt(struct hfsmount *hfsmp)+{+ BTreeIterator * iterator = NULL;+ struct vnode *vp;+ filefork_t * filefork;+ hotfilelist_t *listp;+ FSBufferDescriptor record;+ HotFileKey * key;+ u_int32_t data;+ enum hfc_stage stage;+ int fileblocks;+ int blksmoved;+ int i;+ int last;+ int error = 0;+ int startedtrans = 0;+ //+ // all files in a given adoption phase have a temperature+ // that starts at a random value and then increases linearly.+ // the idea is that during eviction, files that were adopted+ // together will be evicted together+ //+ long starting_temp = random() % HF_TEMP_RANGE;+ long temp_adjust = 0;++ if ((listp = hfsmp->hfc_filelist) == NULL)+ return (0);++ if (hfsmp->hfc_stage != HFC_ADOPTION) {+ return (EBUSY);+ }+ if (hfs_lock(VTOC(hfsmp->hfc_filevp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0) {+ return (EPERM);+ }++ iterator = hfs_malloc_type(BTreeIterator);++#if HFC_VERBOSE+ printf("hfs:%s: hotfiles_adopt: (hfl_next: %d, hotfile start/end block: %d - %d; max/free: %d/%d; maxfiles: %d)\n",+ hfsmp->vcbVN,+ listp->hfl_next,+ hfsmp->hfs_hotfile_start, hfsmp->hfs_hotfile_end,+ hfsmp->hfs_hotfile_maxblks, hfsmp->hfs_hotfile_freeblks, hfsmp->hfc_maxfiles);+#endif++ stage = hfsmp->hfc_stage;+ hfsmp->hfc_stage = HFC_BUSY;++ blksmoved = 0;+ last = listp->hfl_next + HFC_FILESPERSYNC;+ if (last > listp->hfl_count)+ last = listp->hfl_count;++ key = (HotFileKey*) &iterator->key;+ key->keyLength = HFC_KEYLENGTH;++ record.bufferAddress = &data;+ record.itemSize = sizeof(u_int32_t);+ record.itemCount = 1;++ filefork = VTOF(hfsmp->hfc_filevp);++ for (i = listp->hfl_next; (i < last) && (blksmoved < HFC_BLKSPERSYNC); ++i) {+ /*+ * Skip entries that aren't going to work.+ */+ if (listp->hfl_hotfile[i].hf_temperature == 0) {+ //printf("hfs: zero temp on file-id %d\n", listp->hfl_hotfile[i].hf_fileid);+ listp->hfl_next++;+ continue;+ }+ if (listp->hfl_hotfile[i].hf_fileid == VTOC(hfsmp->hfc_filevp)->c_fileid) {+ //printf("hfs: cannot adopt the hotfile b-tree itself! (file-id %d)\n", listp->hfl_hotfile[i].hf_fileid);+ listp->hfl_next++;+ continue;+ }+ if (listp->hfl_hotfile[i].hf_fileid < kHFSFirstUserCatalogNodeID) {+ //printf("hfs: cannot adopt system files (file-id %d)\n", listp->hfl_hotfile[i].hf_fileid);+ listp->hfl_next++;+ continue;+ }++ /*+ * Acquire a vnode for this file.+ */+ error = hfs_vget(hfsmp, listp->hfl_hotfile[i].hf_fileid, &vp, 0, 0);+ if (error) {+ //printf("failed to get fileid %d (err %d)\n", listp->hfl_hotfile[i].hf_fileid, error);+ if (error == ENOENT) {+ error = 0;+ listp->hfl_next++;+ continue; /* stale entry, go to next */+ }+ break;+ }++ //printf("hfs: examining hotfile entry w/fileid %d, temp %d, blocks %d (HotFileCached: %s)\n",+ // listp->hfl_hotfile[i].hf_fileid, listp->hfl_hotfile[i].hf_temperature,+ // listp->hfl_hotfile[i].hf_blocks,+ // (VTOC(vp)->c_attr.ca_recflags & kHFSFastDevPinnedMask) ? "YES" : "NO");++ if (!vnode_isreg(vp)) {+ /* Symlinks are ineligible for adoption into the hotfile zone. */+ //printf("hfs: hotfiles_adopt: huh, not a file %d (%d)\n", listp->hfl_hotfile[i].hf_fileid, VTOC(vp)->c_cnid);+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ listp->hfl_hotfile[i].hf_temperature = 0;+ listp->hfl_next++;+ continue; /* stale entry, go to next */+ }+ if ( (VTOC(vp)->c_flag & (C_DELETED | C_NOEXISTS))+ || (!(hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) && hotextents(hfsmp, &VTOF(vp)->ff_extents[0]))+ || (VTOC(vp)->c_attr.ca_recflags & (kHFSFastDevPinnedMask|kHFSDoNotFastDevPinMask))) {+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ listp->hfl_hotfile[i].hf_temperature = 0;+ listp->hfl_next++;+ listp->hfl_totalblocks -= listp->hfl_hotfile[i].hf_blocks;+ continue; /* stale entry, go to next */+ }++ fileblocks = VTOF(vp)->ff_blocks;++ //+ // for CF, if the file is empty (and not compressed) or it is too large,+ // do not try to pin it. (note: if fileblocks == 0 but the file is marked+ // as compressed, we may still be able to cache it).+ //+ if ((hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) &&+ ((fileblocks == 0 && !(VTOC(vp)->c_bsdflags & UF_COMPRESSED)) ||+ (unsigned int)fileblocks > (HFC_MAXIMUM_FILESIZE / (uint64_t)HFSTOVCB(hfsmp)->blockSize))) {+ // don't try to cache something too large or that's zero-bytes++ vnode_clearfastdevicecandidate(vp); // turn off the fast-dev-candidate flag so we don't keep trying to cache it.++ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ listp->hfl_hotfile[i].hf_temperature = 0;+ listp->hfl_next++;+ listp->hfl_totalblocks -= listp->hfl_hotfile[i].hf_blocks;+ continue; /* entry is too big, just carry on with the next guy */+ }++ //+ // If a file is not an autocandidate (i.e. it's a user-tagged file desirous of+ // being hotfile cached) but it is already bigger than 4 megs, don't bother+ // hotfile caching it. Note that if a user tagged file starts small, gets+ // adopted and then grows over time we will allow it to grow bigger than 4 megs+ // which is intentional for things like the Mail or Photos database files which+ // grow slowly over time and benefit from being on the FastDevice.+ //+ if ((hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) &&+ !(VTOC(vp)->c_attr.ca_recflags & kHFSAutoCandidateMask) &&+ (VTOC(vp)->c_attr.ca_recflags & kHFSFastDevCandidateMask) &&+ (unsigned int)fileblocks > ((4*1024*1024) / (uint64_t)HFSTOVCB(hfsmp)->blockSize)) {++ vnode_clearfastdevicecandidate(vp); // turn off the fast-dev-candidate flag so we don't keep trying to cache it.++ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ listp->hfl_hotfile[i].hf_temperature = 0;+ listp->hfl_next++;+ listp->hfl_totalblocks -= listp->hfl_hotfile[i].hf_blocks;+ continue; /* entry is too big, just carry on with the next guy */+ }++ if (fileblocks > hfs_hotfile_cur_freeblks(hfsmp)) {+ //+ // No room for this file. Although eviction should have made space+ // it's best that we check here as well since writes to existing+ // hotfiles may have eaten up space since we performed eviction+ //+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ listp->hfl_next++;+ listp->hfl_totalblocks -= fileblocks;+ continue; /* entry too big, go to next */+ }++ if ((blksmoved > 0) &&+ (blksmoved + fileblocks) > HFC_BLKSPERSYNC) {+ //+ // we've done enough work, let's be nice to the system and+ // stop until the next iteration+ //+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ break; /* adopt this entry the next time around */+ }++ //+ // The size of data for a hot file record is 4 bytes. The data+ // stored in hot file record is not really meaningful. However+ // to aid debugging, we store first four bytes of the file name+ // or the ASCII text "????"+ //+ if (VTOC(vp)->c_desc.cd_nameptr && (VTOC(vp)->c_desc.cd_namelen > 0)) {+ size_t max_len;++ max_len = sizeof(u_int32_t);+ if (max_len > (unsigned)VTOC(vp)->c_desc.cd_namelen)+ max_len = VTOC(vp)->c_desc.cd_namelen;++ memcpy(&data, VTOC(vp)->c_desc.cd_nameptr, max_len);+ } else+ data = 0x3f3f3f3f;+++ if (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) {+ //+ // For CF we pin the blocks belonging to the file+ // to the "fast" (aka ssd) media+ //+ uint32_t pinned_blocks;++ if (vnode_isautocandidate(vp)) {+ VTOC(vp)->c_attr.ca_recflags |= kHFSAutoCandidateMask;+ }+ if (VTOC(vp)->c_attr.ca_recflags & kHFSAutoCandidateMask) {+ //+ // this moves auto-cached files to the higher tier+ // of "temperatures" which means they are less likely+ // to get evicted (user selected hotfiles will get+ // evicted first in the theory that they change more+ // frequently compared to system files)+ //+ temp_adjust = MAX_NORMAL_TEMP;+ } else {+ temp_adjust = 0;+ }++ hfs_unlock(VTOC(vp)); // don't need an exclusive lock for this+ hfs_lock(VTOC(vp), HFS_SHARED_LOCK, HFS_LOCK_ALLOW_NOEXISTS);++ error = hfs_pin_vnode(hfsmp, vp, HFS_PIN_IT, &pinned_blocks);++ fileblocks = pinned_blocks;++ // go back to an exclusive lock since we're going to modify the cnode again+ hfs_unlock(VTOC(vp));+ hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ } else {+ //+ // Old style hotfiles moves the data to the center (aka "hot")+ // region of the disk+ //+ error = hfs_relocate(vp, hfsmp->hfs_hotfile_start, kauth_cred_get(), current_proc());+ }++ if (!error) {+ VTOC(vp)->c_attr.ca_recflags |= kHFSFastDevPinnedMask;+ VTOC(vp)->c_flag |= C_MODIFIED;+ } else if ((hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) && error == EALREADY) {+ //+ // If hfs_pin_vnode() returned EALREADY then this file is not+ // ever able to be hotfile cached the normal way. This can+ // happen with compressed files which have their data stored+ // in an extended attribute. We flag them so that we won't+ // bother to try and hotfile cache them again the next time+ // they're read.+ //+ VTOC(vp)->c_attr.ca_recflags |= kHFSDoNotFastDevPinMask;+ VTOC(vp)->c_flag |= C_MODIFIED;+ }++ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ if (error) {+#if HFC_VERBOSE+ if (error != EALREADY) {+ printf("hfs: hotfiles_adopt: could not relocate file %d (err %d)\n", listp->hfl_hotfile[i].hf_fileid, error);+ }+#endif++ if (last < listp->hfl_count) {+ last++;+ }+ /* Move on to next item. */+ listp->hfl_next++;+ continue;+ }+ /* Keep hot file free space current. */+ hfsmp->hfs_hotfile_freeblks -= fileblocks;+ listp->hfl_totalblocks -= fileblocks;++ /* Insert hot file entry */+ key->keyLength = HFC_KEYLENGTH;++ if (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) {+ //+ // The "temperature" for a CF hotfile is simply a random+ // number that we sequentially increment for each file in+ // the set of files we're currently adopting. This has the+ // nice property that all of the files we pin to the ssd+ // in the current phase will sort together in the hotfile+ // btree. When eviction time comes we will evict them+ // together as well. This gives the eviction phase temporal+ // locality - things written together get evicted together+ // which is what ssd's like.+ //+ listp->hfl_hotfile[i].hf_temperature = (uint32_t)temp_adjust + starting_temp++;+ }++ key->temperature = listp->hfl_hotfile[i].hf_temperature;+ key->fileID = listp->hfl_hotfile[i].hf_fileid;+ key->forkType = 0;++ /* Start a new transaction before calling BTree code. */+ if (hfs_start_transaction(hfsmp) != 0) {+ error = EINVAL;+ break;+ }+ startedtrans = 1;++ error = BTInsertRecord(filefork, iterator, &record, record.itemSize);+ if (error) {+ int orig_error = error;+ error = MacToVFSError(error);+ printf("hfs: hotfiles_adopt:1: BTInsertRecord failed %d/%d (fileid %d)\n", error, orig_error, key->fileID);+ stage = HFC_IDLE;+ break;+ }++ /* Insert thread record */+ key->keyLength = HFC_KEYLENGTH;+ key->temperature = HFC_LOOKUPTAG;+ key->fileID = listp->hfl_hotfile[i].hf_fileid;+ key->forkType = 0;+ data = listp->hfl_hotfile[i].hf_temperature;+ error = BTInsertRecord(filefork, iterator, &record, record.itemSize);+ if (error) {+ int orig_error = error;+ error = MacToVFSError(error);+ printf("hfs: hotfiles_adopt:2: BTInsertRecord failed %d/%d (fileid %d)\n", error, orig_error, key->fileID);+ stage = HFC_IDLE;+ break;+ } else {+ (void) BTFlushPath(filefork);+ blksmoved += fileblocks;+ }++ listp->hfl_next++;+ if (listp->hfl_next >= listp->hfl_count) {+ break;+ }++ /* Transaction complete. */+ if (startedtrans) {+ hfs_end_transaction(hfsmp);+ startedtrans = 0;+ }++ if (hfs_hotfile_cur_freeblks(hfsmp) <= 0) {+#if HFC_VERBOSE+ printf("hfs: hotfiles_adopt: free space exhausted (%d)\n", hfsmp->hfs_hotfile_freeblks);+#endif+ break;+ }+ } /* end for */++#if HFC_VERBOSE+ printf("hfs: hotfiles_adopt: [%d] adopted %d blocks (%d files left)\n", listp->hfl_next, blksmoved, listp->hfl_count - i);+#endif+ if (!startedtrans) {+ // start a txn so we'll save the btree summary info+ if (hfs_start_transaction(hfsmp) == 0) {+ startedtrans = 1;+ }+ }++ /* Finish any outstanding transactions. */+ if (startedtrans) {+ save_btree_user_info(hfsmp);++ (void) BTFlushPath(filefork);+ hfs_end_transaction(hfsmp);+ startedtrans = 0;+ }+ hfs_unlock(VTOC(hfsmp->hfc_filevp));++ if ((listp->hfl_next >= listp->hfl_count) || (hfsmp->hfs_hotfile_freeblks <= 0)) {+#if HFC_VERBOSE+ printf("hfs: hotfiles_adopt: all done relocating %d files\n", listp->hfl_count);+ printf("hfs: hotfiles_adopt: %d blocks free in hot file band\n", hfsmp->hfs_hotfile_freeblks);+#endif+ stage = HFC_IDLE;+ }+ hfs_free_type(iterator, BTreeIterator);++ if (stage != HFC_ADOPTION && hfsmp->hfc_filevp) {+ (void) hfc_btree_close(hfsmp, hfsmp->hfc_filevp);+ hfsmp->hfc_filevp = NULL;+ }+ hfsmp->hfc_stage = stage;+ wakeup((caddr_t)&hfsmp->hfc_stage);+ return (error);+}++/*+ * Reclaim space by evicting the coldest files.+ *+ * Requires that the hfc_mutex be held.+ */+static int+hotfiles_evict(struct hfsmount *hfsmp, vfs_context_t ctx)+{+ BTreeIterator * iterator = NULL;+ struct vnode *vp;+ HotFileKey * key;+ filefork_t * filefork;+ hotfilelist_t *listp;+ enum hfc_stage stage;+ u_int32_t savedtemp;+ int blksmoved;+ int filesmoved;+ int fileblocks;+ int error = 0;+ int startedtrans = 0;+ int bt_op;++ if (hfsmp->hfc_stage != HFC_EVICTION) {+ return (EBUSY);+ }++ if ((listp = hfsmp->hfc_filelist) == NULL)+ return (0);++ if (hfs_lock(VTOC(hfsmp->hfc_filevp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0) {+ return (EPERM);+ }++#if HFC_VERBOSE+ printf("hfs:%s: hotfiles_evict (hotfile start/end block: %d - %d; max/free: %d/%d; maxfiles: %d)\n",+ hfsmp->vcbVN,+ hfsmp->hfs_hotfile_start, hfsmp->hfs_hotfile_end,+ hfsmp->hfs_hotfile_maxblks, hfsmp->hfs_hotfile_freeblks, hfsmp->hfc_maxfiles);+#endif++ iterator = hfs_malloc_type(BTreeIterator);++ stage = hfsmp->hfc_stage;+ hfsmp->hfc_stage = HFC_BUSY;++ filesmoved = blksmoved = 0;+ bt_op = kBTreeFirstRecord;++ key = (HotFileKey*) &iterator->key;++ filefork = VTOF(hfsmp->hfc_filevp);++#if HFC_VERBOSE+ printf("hfs: hotfiles_evict: reclaim blks %d\n", listp->hfl_reclaimblks);+#endif++ while (listp->hfl_reclaimblks > 0 &&+ blksmoved < HFC_BLKSPERSYNC &&+ filesmoved < HFC_FILESPERSYNC) {++ /*+ * Obtain the first record (ie the coldest one).+ */+ if (BTIterateRecord(filefork, bt_op, iterator, NULL, NULL) != 0) {+#if HFC_VERBOSE+ printf("hfs: hotfiles_evict: no more records\n");+#endif+ error = 0;+ stage = HFC_ADOPTION;+ break;+ }+ if (key->keyLength != HFC_KEYLENGTH) {+ printf("hfs: hotfiles_evict: invalid key length %d\n", key->keyLength);+ error = EFTYPE;+ break;+ }+ if (key->temperature == HFC_LOOKUPTAG) {+#if HFC_VERBOSE+ printf("hfs: hotfiles_evict: ran into thread records\n");+#endif+ error = 0;+ stage = HFC_ADOPTION;+ break;+ }++ // Jump straight to delete for some files...+ if (key->fileID == VTOC(hfsmp->hfc_filevp)->c_fileid+ || key->fileID == hfsmp->hfs_jnlfileid+ || key->fileID == hfsmp->hfs_jnlinfoblkid+ || key->fileID < kHFSFirstUserCatalogNodeID) {+ goto delete;+ }++ /*+ * Aquire the vnode for this file.+ */+ error = hfs_vget(hfsmp, key->fileID, &vp, 0, 0);+ if (error) {+ if (error == ENOENT) {+ goto delete; /* stale entry, go to next */+ } else {+ printf("hfs: hotfiles_evict: err %d getting file %d\n",+ error, key->fileID);+ }+ break;+ }++ /*+ * Symlinks that may have been inserted into the hotfile zone during a previous OS are now stuck+ * here. We do not want to move them.+ */+ if (!vnode_isreg(vp)) {+ //printf("hfs: hotfiles_evict: huh, not a file %d\n", key->fileID);+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ goto delete; /* invalid entry, go to next */+ }++ fileblocks = VTOF(vp)->ff_blocks;+ if ((blksmoved > 0) &&+ (blksmoved + fileblocks) > HFC_BLKSPERSYNC) {+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ break;+ }+ /*+ * Make sure file is in the hot area.+ */+ if (!hotextents(hfsmp, &VTOF(vp)->ff_extents[0]) && !(VTOC(vp)->c_attr.ca_recflags & kHFSFastDevPinnedMask)) {+#if HFC_VERBOSE+ printf("hfs: hotfiles_evict: file %d isn't hot!\n", key->fileID);+#endif+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ goto delete; /* stale entry, go to next */+ }++ /*+ * Relocate file out of hot area. On cooperative fusion (CF) that just+ * means un-pinning the data from the ssd. For traditional hotfiles that means moving+ * the file data out of the hot region of the disk.+ */+ if (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) {+ uint32_t pinned_blocks;++ hfs_unlock(VTOC(vp)); // don't need an exclusive lock for this+ hfs_lock(VTOC(vp), HFS_SHARED_LOCK, HFS_LOCK_ALLOW_NOEXISTS);++ error = hfs_pin_vnode(hfsmp, vp, HFS_UNPIN_IT, &pinned_blocks);+ fileblocks = pinned_blocks;++ if (!error) {+ // go back to an exclusive lock since we're going to modify the cnode again+ hfs_unlock(VTOC(vp));+ hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ }+ } else {+ error = hfs_relocate(vp, HFSTOVCB(hfsmp)->nextAllocation, vfs_context_ucred(ctx), vfs_context_proc(ctx));+ }+ if (error) {+#if HFC_VERBOSE+ printf("hfs: hotfiles_evict: err %d relocating file %d\n", error, key->fileID);+#endif+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ bt_op = kBTreeNextRecord;+ goto next; /* go to next */+ } else {+ VTOC(vp)->c_attr.ca_recflags &= ~kHFSFastDevPinnedMask;+ VTOC(vp)->c_flag |= C_MODIFIED;+ }++ //+ // We do not believe that this call to hfs_fsync() is+ // necessary and it causes a journal transaction+ // deadlock so we are removing it.+ //+ // (void) hfs_fsync(vp, MNT_WAIT, 0, p);++ hfs_unlock(VTOC(vp));+ vnode_put(vp);++ hfsmp->hfs_hotfile_freeblks += fileblocks;+ listp->hfl_reclaimblks -= fileblocks;+ if (listp->hfl_reclaimblks < 0)+ listp->hfl_reclaimblks = 0;+ blksmoved += fileblocks;+ filesmoved++;+delete:+ /* Start a new transaction before calling BTree code. */+ if (hfs_start_transaction(hfsmp) != 0) {+ error = EINVAL;+ break;+ }+ startedtrans = 1;++ error = BTDeleteRecord(filefork, iterator);+ if (error) {+ error = MacToVFSError(error);+ break;+ }+ savedtemp = key->temperature;+ key->temperature = HFC_LOOKUPTAG;+ error = BTDeleteRecord(filefork, iterator);+ if (error) {+ error = MacToVFSError(error);+ break;+ }+ key->temperature = savedtemp;+next:+ (void) BTFlushPath(filefork);++ /* Transaction complete. */+ if (startedtrans) {+ hfs_end_transaction(hfsmp);+ startedtrans = 0;+ }++ } /* end while */++#if HFC_VERBOSE+ printf("hfs: hotfiles_evict: moved %d files (%d blks, %d to go)\n", filesmoved, blksmoved, listp->hfl_reclaimblks);+#endif+ /* Finish any outstanding transactions. */+ if (startedtrans) {+ save_btree_user_info(hfsmp);++ (void) BTFlushPath(filefork);+ hfs_end_transaction(hfsmp);+ startedtrans = 0;+ }+ hfs_unlock(VTOC(hfsmp->hfc_filevp));++ /*+ * Move to next stage when finished.+ */+ if (listp->hfl_reclaimblks <= 0) {+ stage = HFC_ADOPTION;+#if HFC_VERBOSE+ printf("hfs: hotfiles_evict: %d blocks free in hot file band\n", hfsmp->hfs_hotfile_freeblks);+#endif+ }+ hfs_free_type(iterator, BTreeIterator);+ hfsmp->hfc_stage = stage;+ wakeup((caddr_t)&hfsmp->hfc_stage);+ return (error);+}++/*+ * Age the existing records in the hot files b-tree.+ */+static int+hotfiles_age(struct hfsmount *hfsmp)+{+ BTreeInfoRec btinfo;+ BTreeIterator * iterator = NULL;+ BTreeIterator * prev_iterator;+ FSBufferDescriptor record;+ FSBufferDescriptor prev_record;+ HotFileKey * key;+ HotFileKey * prev_key;+ filefork_t * filefork;+ u_int32_t data;+ u_int32_t prev_data;+ u_int32_t newtemp;+ int error;+ int i;+ int numrecs;+ int aged = 0;+ u_int16_t reclen;+++ if (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) {+ //+ // hotfiles don't age on CF+ //+ return 0;+ }++ iterator = hfs_new(BTreeIterator, 2);+ key = (HotFileKey*) &iterator->key;++ prev_iterator = &iterator[1];+ prev_key = (HotFileKey*) &prev_iterator->key;++ record.bufferAddress = &data;+ record.itemSize = sizeof(data);+ record.itemCount = 1;+ prev_record.bufferAddress = &prev_data;+ prev_record.itemSize = sizeof(prev_data);+ prev_record.itemCount = 1;++ /*+ * Capture b-tree changes inside a transaction+ */+ if (hfs_start_transaction(hfsmp) != 0) {+ error = EINVAL;+ goto out2;+ }+ if (hfs_lock(VTOC(hfsmp->hfc_filevp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0) {+ error = EPERM;+ goto out1;+ }+ filefork = VTOF(hfsmp->hfc_filevp);++ error = BTGetInformation(filefork, 0, &btinfo);+ if (error) {+ error = MacToVFSError(error);+ goto out;+ }+ if (btinfo.numRecords < 2) {+ error = 0;+ goto out;+ }++ /* Only want 1st half of leaf records */+ numrecs = (btinfo.numRecords /= 2) - 1;++ error = BTIterateRecord(filefork, kBTreeFirstRecord, iterator, &record, &reclen);+ if (error) {+ printf("hfs_agehotfiles: BTIterateRecord: %d\n", error);+ error = MacToVFSError(error);+ goto out;+ }+ bcopy(iterator, prev_iterator, sizeof(BTreeIterator));+ prev_data = data;++ for (i = 0; i < numrecs; ++i) {+ error = BTIterateRecord(filefork, kBTreeNextRecord, iterator, &record, &reclen);+ if (error == 0) {+ if (key->temperature < prev_key->temperature) {+ printf("hfs_agehotfiles: out of order keys!\n");+ error = EFTYPE;+ break;+ }+ if (reclen != sizeof(data)) {+ printf("hfs_agehotfiles: invalid record length %d\n", reclen);+ error = EFTYPE;+ break;+ }+ if (key->keyLength != HFC_KEYLENGTH) {+ printf("hfs_agehotfiles: invalid key length %d\n", key->keyLength);+ error = EFTYPE;+ break;+ }+ } else if ((error == fsBTEndOfIterationErr || error == fsBTRecordNotFoundErr) &&+ (i == (numrecs - 1))) {+ error = 0;+ } else if (error) {+ printf("hfs_agehotfiles: %d of %d BTIterateRecord: %d\n", i, numrecs, error);+ error = MacToVFSError(error);+ break;+ }+ if (prev_key->temperature == HFC_LOOKUPTAG) {+#if HFC_VERBOSE+ printf("hfs_agehotfiles: ran into thread record\n");+#endif+ error = 0;+ break;+ }+ error = BTDeleteRecord(filefork, prev_iterator);+ if (error) {+ printf("hfs_agehotfiles: BTDeleteRecord failed %d (file %d)\n", error, prev_key->fileID);+ error = MacToVFSError(error);+ break;+ }++ /* Age by halving the temperature (floor = 4) */+ newtemp = MAX(prev_key->temperature >> 1, 4);+ prev_key->temperature = newtemp;++ error = BTInsertRecord(filefork, prev_iterator, &prev_record, prev_record.itemSize);+ if (error) {+ printf("hfs_agehotfiles: BTInsertRecord failed %d (file %d)\n", error, prev_key->fileID);+ error = MacToVFSError(error);+ break;+ }+ ++aged;+ /*+ * Update thread entry with latest temperature.+ */+ prev_key->temperature = HFC_LOOKUPTAG;+ error = BTUpdateRecord(filefork, prev_iterator,+ (IterateCallBackProcPtr)update_callback,+ &newtemp);+ if (error) {+ printf("hfs_agehotfiles: %d of %d BTUpdateRecord failed %d (file %d, %d)\n",+ i, numrecs, error, prev_key->fileID, newtemp);+ error = MacToVFSError(error);+ // break;+ }++ bcopy(iterator, prev_iterator, sizeof(BTreeIterator));+ prev_data = data;++ } /* end for */++#if HFC_VERBOSE+ if (error == 0)+ printf("hfs_agehotfiles: aged %d records out of %d\n", aged, btinfo.numRecords);+#endif+ (void) BTFlushPath(filefork);+out:+ hfs_unlock(VTOC(hfsmp->hfc_filevp));+out1:+ hfs_end_transaction(hfsmp);+out2:+ if (iterator)+ hfs_delete(iterator, BTreeIterator, 2);+ return (error);+}++/*+ * Return true if any blocks (or all blocks if all is true)+ * are contained in the hot file region.+ */+static int+hotextents(struct hfsmount *hfsmp, HFSPlusExtentDescriptor * extents)+{+ u_int32_t b1, b2;+ int i;+ int inside = 0;++ for (i = 0; i < kHFSPlusExtentDensity; ++i) {+ b1 = extents[i].startBlock;+ if (b1 == 0)+ break;+ b2 = b1 + extents[i].blockCount - 1;+ if ((b1 >= hfsmp->hfs_hotfile_start &&+ b2 <= hfsmp->hfs_hotfile_end) ||+ (b1 < hfsmp->hfs_hotfile_end &&+ b2 > hfsmp->hfs_hotfile_end)) {+ inside = 1;+ break;+ }+ }+ return (inside);+}+++/*+ *========================================================================+ * HOT FILE B-TREE ROUTINES+ *========================================================================+ */++/*+ * Open the hot files b-tree for writing.+ *+ * On successful exit the vnode has a reference but not an iocount.+ */+static int+hfc_btree_open(struct hfsmount *hfsmp, struct vnode **vpp)+{+ return hfc_btree_open_ext(hfsmp, vpp, 0);+}++static int+hfc_btree_open_ext(struct hfsmount *hfsmp, struct vnode **vpp, int ignore_btree_errs)+{+ proc_t p;+ struct vnode *vp;+ struct cat_desc cdesc;+ struct cat_attr cattr;+ struct cat_fork cfork;+ static char filename[] = HFC_FILENAME;+ int error;+ int retry = 0;+ int lockflags;+ int newvnode_flags = 0;++ *vpp = NULL;+ p = current_proc();++ bzero(&cdesc, sizeof(cdesc));+ cdesc.cd_parentcnid = kRootDirID;+ cdesc.cd_nameptr = (const u_int8_t *)filename;+ cdesc.cd_namelen = strlen(filename);++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);++ error = cat_lookup(hfsmp, &cdesc, 0, 0, &cdesc, &cattr, &cfork, NULL);++ hfs_systemfile_unlock(hfsmp, lockflags);++ if (error) {+ printf("hfs: hfc_btree_open: cat_lookup error %d\n", error);+ return (error);+ }+again:+ cdesc.cd_flags |= CD_ISMETA;+ error = hfs_getnewvnode(hfsmp, NULL, NULL, &cdesc, 0, &cattr,+ &cfork, &vp, &newvnode_flags);+ if (error) {+ printf("hfs: hfc_btree_open: hfs_getnewvnode error %d\n", error);+ cat_releasedesc(&cdesc);+ return (error);+ }+ if (!vnode_issystem(vp)) {+#if HFC_VERBOSE+ printf("hfs: hfc_btree_open: file has UBC, try again\n");+#endif+ hfs_unlock(VTOC(vp));+ vnode_recycle(vp);+ vnode_put(vp);+ if (retry++ == 0)+ goto again;+ else+ return (EBUSY);+ }++ /* Open the B-tree file for writing... */+ error = BTOpenPath(VTOF(vp), (KeyCompareProcPtr) hfc_comparekeys);+ if (error) {+ if (!ignore_btree_errs) {+ printf("hfs: hfc_btree_open: BTOpenPath error %d; filesize %lld\n", error, VTOF(vp)->ff_size);+ error = MacToVFSError(error);+ } else {+ error = 0;+ }+ }++ hfs_unlock(VTOC(vp));+ if (error == 0) {+ *vpp = vp;+ vnode_ref(vp); /* keep a reference while its open */+ }+ vnode_put(vp);++ if (!vnode_issystem(vp))+ panic("hfs: hfc_btree_open: not a system file (vp = %p)", vp);++ HotFilesInfo hotfileinfo;++ if (error == 0 && (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN)) {+ if ((BTGetUserData(VTOF(vp), &hotfileinfo, sizeof(hotfileinfo)) == 0) && (SWAP_BE32 (hotfileinfo.magic) == HFC_MAGIC)) {+ if (hfsmp->hfs_hotfile_freeblks == 0) {+ hfsmp->hfs_hotfile_freeblks = hfsmp->hfs_hotfile_maxblks - SWAP_BE32 (hotfileinfo.usedblocks);+ }++ hfs_hotfile_cur_freeblks(hfsmp); // factors in any adjustments that happened at run-time+ }+ }++ return (error);+}++/*+ * Close the hot files b-tree.+ *+ * On entry the vnode has a reference.+ */+static int+hfc_btree_close(struct hfsmount *hfsmp, struct vnode *vp)+{+ proc_t p = current_proc();+ int error = 0;+++ if (hfsmp->jnl) {+ hfs_flush(hfsmp, HFS_FLUSH_JOURNAL);+ }++ if (vnode_get(vp) == 0) {+ error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ if (error == 0) {+ (void) hfs_fsync(vp, MNT_WAIT, 0, p);+ error = BTClosePath(VTOF(vp));+ hfs_unlock(VTOC(vp));+ }+ vnode_rele(vp);+ vnode_recycle(vp);+ vnode_put(vp);+ }++ return (error);+}++//+// Assumes that hfsmp->hfc_filevp points to the hotfile btree vnode+// (i.e. you called hfc_btree_open() ahead of time)+//+static int+hfc_btree_delete_record(struct hfsmount *hfsmp, BTreeIterator *iterator, HotFileKey *key)+{+ int error;+ filefork_t *filefork=VTOF(hfsmp->hfc_filevp);++ /* Start a new transaction before calling BTree code. */+ if (hfs_start_transaction(hfsmp) != 0) {+ return EINVAL;+ }++ error = BTDeleteRecord(filefork, iterator);+ if (error) {+ error = MacToVFSError(error);+ printf("hfs: failed to delete record for file-id %d : err %d\n", key->fileID, error);+ goto out;+ }++ int savedtemp;+ savedtemp = key->temperature;+ key->temperature = HFC_LOOKUPTAG;+ error = BTDeleteRecord(filefork, iterator);+ if (error) {+ error = MacToVFSError(error);+ printf("hfs:2: failed to delete record for file-id %d : err %d\n", key->fileID, error);+ }+ key->temperature = savedtemp;++ (void) BTFlushPath(filefork);++out:+ /* Transaction complete. */+ hfs_end_transaction(hfsmp);++ return error;+}++//+// You have to have already opened the hotfile btree so+// that hfsmp->hfc_filevp is filled in.+//+static int+hfc_btree_delete(struct hfsmount *hfsmp)+{+ struct vnode *dvp = NULL;+ vfs_context_t ctx = vfs_context_current();+ struct vnode_attr va;+ static char filename[] = HFC_FILENAME;+ int error;++ error = hfs_vfs_root(HFSTOVFS(hfsmp), &dvp, ctx);+ if (error) {+ return (error);+ }++ struct componentname cname = {+ .cn_nameiop = DELETE,+ .cn_flags = ISLASTCN,+ .cn_pnbuf = filename,+ .cn_pnlen = sizeof(filename),+ .cn_nameptr = filename,+ .cn_namelen = strlen(filename),+ };++ VATTR_INIT(&va);+ VATTR_SET(&va, va_type, VREG);+ VATTR_SET(&va, va_mode, S_IFREG | S_IRUSR | S_IWUSR);+ VATTR_SET(&va, va_uid, 0);+ VATTR_SET(&va, va_gid, 0);++ if (hfs_start_transaction(hfsmp) != 0) {+ error = EINVAL;+ goto out;+ }++ struct vnop_remove_args ap = {+ .a_dvp = dvp,+ .a_vp = hfsmp->hfc_filevp,+ .a_cnp = &cname,+ };++ error = hfs_vnop_remove(&ap);+ if (error) {+ printf("hfs: error %d removing HFBT on %s\n", error, HFSTOVCB(hfsmp)->vcbVN);+ }++ hfs_end_transaction(hfsmp);++out:+ if (dvp) {+ vnode_put(dvp);+ dvp = NULL;+ }++ return 0;+}+++++/*+ * Create a hot files btree file.+ *+ */+static int+hfc_btree_create(struct hfsmount *hfsmp, unsigned int nodesize, unsigned int entries)+{+ struct vnode *dvp = NULL;+ struct vnode *vp = NULL;+ struct cnode *cp = NULL;+ vfs_context_t ctx = vfs_context_current();+ struct vnode_attr va;+ static char filename[] = HFC_FILENAME;+ int error;++ if (hfsmp->hfc_filevp)+ panic("hfs: hfc_btree_create: hfc_filevp exists (vp = %p)", hfsmp->hfc_filevp);++ error = hfs_vfs_root(HFSTOVFS(hfsmp), &dvp, ctx);+ if (error) {+ return (error);+ }++ struct componentname cname = {+ .cn_nameiop = CREATE,+ .cn_flags = ISLASTCN,+ .cn_pnbuf = filename,+ .cn_pnlen = sizeof(filename),+ .cn_nameptr = filename,+ .cn_namelen = strlen(filename)+ };++ VATTR_INIT(&va);+ VATTR_SET(&va, va_type, VREG);+ VATTR_SET(&va, va_mode, S_IFREG | S_IRUSR | S_IWUSR);+ VATTR_SET(&va, va_uid, 0);+ VATTR_SET(&va, va_gid, 0);++ if (hfs_start_transaction(hfsmp) != 0) {+ vnode_put(dvp);+ return EINVAL;+ }++ /* call ourselves directly, ignore the higher-level VFS file creation code */++ struct vnop_create_args ap = {+ .a_dvp = dvp,+ .a_vpp = &vp,+ .a_cnp = &cname,+ .a_vap = &va+ };++ error = hfs_vnop_create(&ap);+ if (error) {+ printf("hfs: error %d creating HFBT on %s\n", error, HFSTOVCB(hfsmp)->vcbVN);+ goto out;+ }+ if (dvp) {+ vnode_put(dvp);+ dvp = NULL;+ }+ if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ goto out;+ }+ cp = VTOC(vp);++ /* Don't use non-regular files or files with links. */+ if (!vnode_isreg(vp) || cp->c_linkcount != 1) {+ error = EFTYPE;+ goto out;+ }++ printf("hfs: created HFBT on %s\n", HFSTOVCB(hfsmp)->vcbVN);++ if (VTOF(vp)->ff_size < nodesize) {+ caddr_t buffer;+ u_int16_t *index;+ u_int16_t offset;+ BTNodeDescriptor *ndp;+ BTHeaderRec *bthp;+ HotFilesInfo *hotfileinfo;+ int nodecnt;+ int filesize;+ int entirespernode;++ /*+ * Mark it invisible (truncate will pull these changes).+ */+ ((FndrFileInfo *)&cp->c_finderinfo[0])->fdFlags |=+ SWAP_BE16 (kIsInvisible + kNameLocked);++ buffer = hfs_malloc_zero_data(nodesize);+ index = (u_int16_t *)buffer;++ entirespernode = (nodesize - sizeof(BTNodeDescriptor) - 2) /+ (sizeof(HotFileKey) + 6);+ nodecnt = 2 + howmany(entries * 2, entirespernode);+ nodecnt = roundup(nodecnt, 8);+ filesize = nodecnt * nodesize;++ /* FILL IN THE NODE DESCRIPTOR: */+ ndp = (BTNodeDescriptor *)buffer;+ ndp->kind = kBTHeaderNode;+ ndp->numRecords = SWAP_BE16 (3);+ offset = sizeof(BTNodeDescriptor);+ index[(nodesize / 2) - 1] = SWAP_BE16 (offset);++ /* FILL IN THE HEADER RECORD: */+ bthp = (BTHeaderRec *)((u_int8_t *)buffer + offset);+ bthp->nodeSize = SWAP_BE16 (nodesize);+ bthp->totalNodes = SWAP_BE32 (filesize / nodesize);+ bthp->freeNodes = SWAP_BE32 (nodecnt - 1);+ bthp->clumpSize = SWAP_BE32 (filesize);+ bthp->btreeType = kUserBTreeType; /* non-metadata */+ bthp->attributes |= SWAP_BE32 (kBTBigKeysMask);+ bthp->maxKeyLength = SWAP_BE16 (HFC_KEYLENGTH);+ offset += sizeof(BTHeaderRec);+ index[(nodesize / 2) - 2] = SWAP_BE16 (offset);++ /* FILL IN THE USER RECORD: */+ hotfileinfo = (HotFilesInfo *)((u_int8_t *)buffer + offset);+ hotfileinfo->magic = SWAP_BE32 (HFC_MAGIC);+ hotfileinfo->version = SWAP_BE32 (HFC_VERSION);+ hotfileinfo->duration = SWAP_BE32 (HFC_DEFAULT_DURATION);+ hotfileinfo->timebase = 0;+ hotfileinfo->timeleft = 0;+ hotfileinfo->threshold = SWAP_BE32 (HFC_MINIMUM_TEMPERATURE);+ hotfileinfo->maxfileblks = SWAP_BE32 (HFC_MAXIMUM_FILESIZE / HFSTOVCB(hfsmp)->blockSize);+ if (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) {+ if (hfsmp->hfs_hotfile_freeblks == 0) {+ hfsmp->hfs_hotfile_freeblks = hfsmp->hfs_hotfile_maxblks;+ }+ hotfileinfo->usedblocks = SWAP_BE32 (hfsmp->hfs_hotfile_maxblks - hfsmp->hfs_hotfile_freeblks);+ } else {+ hotfileinfo->maxfilecnt = SWAP_BE32 (HFC_DEFAULT_FILE_COUNT);+ }+ strlcpy((char *)hotfileinfo->tag, hfc_tag,+ sizeof hotfileinfo->tag);+ offset += kBTreeHeaderUserBytes;+ index[(nodesize / 2) - 3] = SWAP_BE16 (offset);++ /* FILL IN THE MAP RECORD (only one node in use). */+ *((u_int8_t *)buffer + offset) = 0x80;+ offset += nodesize - sizeof(BTNodeDescriptor) - sizeof(BTHeaderRec)+ - kBTreeHeaderUserBytes - (4 * sizeof(int16_t));+ index[(nodesize / 2) - 4] = SWAP_BE16 (offset);++ vnode_setnoflush(vp);+ error = hfs_truncate(vp, (off_t)filesize, IO_NDELAY, 0, ctx);+ if (error) {+ printf("hfs: error %d growing HFBT on %s\n", error, HFSTOVCB(hfsmp)->vcbVN);+ goto out;+ }+ cp->c_flag |= C_ZFWANTSYNC;+ cp->c_zftimeout = 1;++ if (error == 0) {+ struct vnop_write_args args;+ uio_t auio;++ auio = uio_create(1, 0, UIO_SYSSPACE, UIO_WRITE);+ uio_addiov(auio, (uintptr_t)buffer, nodesize);++ args.a_desc = &vnop_write_desc;+ args.a_vp = vp;+ args.a_uio = auio;+ args.a_ioflag = 0;+ args.a_context = ctx;++ hfs_unlock(cp);+ cp = NULL;++ error = hfs_vnop_write(&args);+ if (error)+ printf("hfs: error %d writing HFBT on %s\n", error, HFSTOVCB(hfsmp)->vcbVN);++ uio_free(auio);+ }+ hfs_free_data(buffer, nodesize);+ }+out:+ hfs_end_transaction(hfsmp);+ if (dvp) {+ vnode_put(dvp);+ }+ if (vp) {+ if (cp)+ hfs_unlock(cp);+ vnode_recycle(vp);+ vnode_put(vp);+ }+ return (error);+}++/*+ * Compare two hot file b-tree keys.+ *+ * Result: +n search key > trial key+ * 0 search key = trial key+ * -n search key < trial key+ */+static int+hfc_comparekeys(HotFileKey *searchKey, HotFileKey *trialKey)+{+ /*+ * Compared temperatures first.+ */+ if (searchKey->temperature == trialKey->temperature) {+ /*+ * Temperatures are equal so compare file ids.+ */+ if (searchKey->fileID == trialKey->fileID) {+ /*+ * File ids are equal so compare fork types.+ */+ if (searchKey->forkType == trialKey->forkType) {+ return (0);+ } else if (searchKey->forkType > trialKey->forkType) {+ return (1);+ }+ } else if (searchKey->fileID > trialKey->fileID) {+ return (1);+ }+ } else if (searchKey->temperature > trialKey->temperature) {+ return (1);+ }++ return (-1);+}+++/*+ *========================================================================+ * HOT FILE DATA COLLECTING ROUTINES+ *========================================================================+ */++/*+ * Lookup a hot file entry in the tree.+ */+#if HFC_DEBUG+static hotfile_entry_t *+hf_lookup(hotfile_data_t *hotdata, u_int32_t fileid, u_int32_t temperature)+{+ hotfile_entry_t *entry = hotdata->rootentry;++ while (entry &&+ entry->temperature != temperature &&+ entry->fileid != fileid) {++ if (temperature > entry->temperature)+ entry = entry->right;+ else if (temperature < entry->temperature)+ entry = entry->left;+ else if (fileid > entry->fileid)+ entry = entry->right;+ else+ entry = entry->left;+ }+ return (entry);+}+#endif++/*+ * Insert a hot file entry into the tree.+ */+static int+hf_insert(hotfile_data_t *hotdata, hotfile_entry_t *newentry)+{+ hotfile_entry_t *entry = hotdata->rootentry;+ u_int32_t fileid = newentry->fileid;+ u_int32_t temperature = newentry->temperature;++ if (entry == NULL) {+ hotdata->rootentry = newentry;+ hotdata->coldest = newentry;+ hotdata->activefiles++;+ return 0;+ }++ while (entry) {+ if (temperature > entry->temperature) {+ if (entry->right) {+ entry = entry->right;+ } else {+ entry->right = newentry;+ break;+ }+ } else if (temperature < entry->temperature) {+ if (entry->left) {+ entry = entry->left;+ } else {+ entry->left = newentry;+ break;+ }+ } else if (fileid > entry->fileid) {+ if (entry->right) {+ entry = entry->right;+ } else {+ if (entry->fileid != fileid)+ entry->right = newentry;+ break;+ }+ } else {+ if (entry->left) {+ entry = entry->left;+ } else {+ if (entry->fileid != fileid) {+ entry->left = newentry;+ } else {+ return EEXIST;+ }+ break;+ }+ }+ }++ hotdata->activefiles++;+ return 0;+}++/*+ * Find the coldest entry in the tree.+ */+static hotfile_entry_t *+hf_coldest(hotfile_data_t *hotdata)+{+ hotfile_entry_t *entry = hotdata->rootentry;++ if (entry) {+ while (entry->left)+ entry = entry->left;+ }+ return (entry);+}++/*+ * Find the hottest entry in the tree.+ */+static hotfile_entry_t *+hf_hottest(hotfile_data_t *hotdata)+{+ hotfile_entry_t *entry = hotdata->rootentry;++ if (entry) {+ while (entry->right)+ entry = entry->right;+ }+ return (entry);+}++/*+ * Delete a hot file entry from the tree.+ */+static void+hf_delete(hotfile_data_t *hotdata, u_int32_t fileid, u_int32_t temperature)+{+ hotfile_entry_t *entry, *parent, *next;++ parent = NULL;+ entry = hotdata->rootentry;++ while (entry &&+ entry->temperature != temperature &&+ entry->fileid != fileid) {++ parent = entry;+ if (temperature > entry->temperature)+ entry = entry->right;+ else if (temperature < entry->temperature)+ entry = entry->left;+ else if (fileid > entry->fileid)+ entry = entry->right;+ else+ entry = entry->left;+ }++ if (entry) {+ /*+ * Reorganize the sub-trees spanning from our entry.+ */+ if ((next = entry->right)) {+ hotfile_entry_t *pnextl, *psub;+ /*+ * Tree pruning: take the left branch of the+ * current entry and place it at the lowest+ * left branch of the current right branch+ */+ psub = next;++ /* Walk the Right/Left sub tree from current entry */+ while ((pnextl = psub->left))+ psub = pnextl;++ /* Plug the old left tree to the new ->Right leftmost entry */+ psub->left = entry->left;++ } else /* only left sub-tree, simple case */ {+ next = entry->left;+ }+ /*+ * Now, plug the current entry sub tree to+ * the good pointer of our parent entry.+ */+ if (parent == NULL)+ hotdata->rootentry = next;+ else if (parent->left == entry)+ parent->left = next;+ else+ parent->right = next;++ /* Place entry back on the free-list */+ entry->left = 0;+ entry->fileid = 0;+ entry->temperature = 0;++ entry->right = hotdata->freelist;+ hotdata->freelist = entry;+ hotdata->activefiles--;++ if (hotdata->coldest == entry || hotdata->coldest == NULL) {+ hotdata->coldest = hf_coldest(hotdata);+ }++ }+}++/*+ * Get a free hot file entry.+ */+static hotfile_entry_t *+hf_getnewentry(hotfile_data_t *hotdata)+{+ hotfile_entry_t * entry;++ /*+ * When the free list is empty then steal the coldest one+ */+ if (hotdata->freelist == NULL) {+ entry = hf_coldest(hotdata);+ hf_delete(hotdata, entry->fileid, entry->temperature);+ }+ entry = hotdata->freelist;+ hotdata->freelist = entry->right;+ entry->right = 0;++ return (entry);+}+++/*+ * Generate a sorted list of hot files (hottest to coldest).+ *+ * As a side effect, every node in the hot file tree will be+ * deleted (moved to the free list).+ */+static void+hf_getsortedlist(hotfile_data_t * hotdata, hotfilelist_t *sortedlist)+{+ int i = 0;+ hotfile_entry_t *entry;++ while ((entry = hf_hottest(hotdata)) != NULL) {+ sortedlist->hfl_hotfile[i].hf_fileid = entry->fileid;+ sortedlist->hfl_hotfile[i].hf_temperature = entry->temperature;+ sortedlist->hfl_hotfile[i].hf_blocks = entry->blocks;+ sortedlist->hfl_totalblocks += entry->blocks;+ ++i;++ hf_delete(hotdata, entry->fileid, entry->temperature);+ }++ sortedlist->hfl_count = i;++#if HFC_VERBOSE+ printf("hfs: hf_getsortedlist returning %d entries w/%d total blocks\n", i, sortedlist->hfl_totalblocks);+#endif+}+++#if HFC_DEBUG+static void+hf_maxdepth(hotfile_entry_t * root, int depth, int *maxdepth)+{+ if (root) {+ depth++;+ if (depth > *maxdepth)+ *maxdepth = depth;+ hf_maxdepth(root->left, depth, maxdepth);+ hf_maxdepth(root->right, depth, maxdepth);+ }+}++static void+hf_printtree(hotfile_entry_t * root)+{+ if (root) {+ hf_printtree(root->left);+ printf("hfs: temperature: % 8d, fileid %d\n", root->temperature, root->fileid);+ hf_printtree(root->right);+ }+}+#endifdiff --git a/xnu/files/bsd/hfs/hfs_hotfiles.h b/xnu/files/bsd/hfs/hfs_hotfiles.hnew file mode 100644index 0000000..0ce32da--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_hotfiles.h@@ -0,0 +1,136 @@+/*+ * Copyright (c) 2003-2015 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@+ */+#ifndef __HFS_HOTFILES__+#define __HFS_HOTFILES__++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE+++#define HFC_FILENAME ".hotfiles.btree"+++/*+ * Temperature measurement constraints.+ */+#define HFC_DEFAULT_FILE_COUNT hfc_default_file_count+#define HFC_DEFAULT_DURATION hfc_default_duration+#define HFC_CUMULATIVE_CYCLES 3+#define HFC_MAXIMUM_FILE_COUNT hfc_max_file_count+#define HFC_MAXIMUM_FILESIZE hfc_max_file_size+#define HFC_MINIMUM_TEMPERATURE 24+++/*+ * Sync constraints.+ */+#define HFC_BLKSPERSYNC 300+#define HFC_FILESPERSYNC 50+++/*+ * Hot file clustering stages.+ */+enum hfc_stage {+ HFC_DISABLED,+ HFC_IDLE,+ HFC_BUSY,+ HFC_RECORDING,+ HFC_EVALUATION,+ HFC_EVICTION,+ HFC_ADOPTION,+};+++/*+ * B-tree file key format (on-disk).+ */+struct HotFileKey {+ u_int16_t keyLength; /* length of key, excluding this field */+ u_int8_t forkType; /* 0 = data fork, FF = resource fork */+ u_int8_t pad; /* make the other fields align on 32-bit boundary */+ u_int32_t temperature; /* temperature recorded */+ u_int32_t fileID; /* file ID */+};+typedef struct HotFileKey HotFileKey;++#define HFC_LOOKUPTAG 0xFFFFFFFF+#define HFC_KEYLENGTH (sizeof(HotFileKey) - sizeof(u_int16_t))++/*+ * B-tree header node user info (on-disk).+ */+struct HotFilesInfo {+ u_int32_t magic;+ u_int32_t version;+ u_int32_t duration; /* duration of sample period (secs) */+ u_int32_t timebase; /* start of recording period (GMT time in secs) */+ u_int32_t timeleft; /* time remaining in recording period (secs) */+ u_int32_t threshold;+ u_int32_t maxfileblks;+ union {+ u_int32_t _maxfilecnt; // on hdd's we track the max # of files+ u_int32_t _usedblocks; // on ssd's we track how many blocks are used+ } _u;+ u_int8_t tag[32];+};++#define usedblocks _u._usedblocks+#define maxfilecnt _u._maxfilecnt++typedef struct HotFilesInfo HotFilesInfo;++#define HFC_MAGIC 0xFF28FF26+#define HFC_VERSION 1+++struct hfsmount;+struct proc;+struct vnode;++/*+ * Hot File interface functions.+ */+int hfs_hotfilesync (struct hfsmount *, vfs_context_t ctx);++int hfs_recording_init(struct hfsmount *);+int hfs_recording_suspend (struct hfsmount *);++int hfs_addhotfile (struct vnode *);+int hfs_removehotfile (struct vnode *);+int hfs_hotfile_deleted(struct vnode *vp); // called when a file is deleted+void hfs_repin_hotfiles(struct hfsmount *);++// call this to adjust the number of used hotfile blocks either up/down+int hfs_hotfile_adjust_blocks(struct vnode *vp, int64_t num_blocks);++#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */+#endif /* __HFS_HOTFILES__ */diff --git a/xnu/files/bsd/hfs/hfs_iokit.h b/xnu/files/bsd/hfs/hfs_iokit.hnew file mode 100644index 0000000..968730e--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_iokit.h@@ -0,0 +1,62 @@+/*+ * Copyright (c) 2015 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@+ */++#ifndef hfs_iokit_h+#define hfs_iokit_h++#include <sys/cdefs.h>+#if CONFIG_PROTECT+#include <AppleKeyStore/AppleKeyStoreFSServices.h>+#endif++__BEGIN_DECLS++int hfs_is_ejectable(const char *cdev_name);+void hfs_iterate_media_with_content(const char *content_uuid_cstring,+ int (*func)(const char *bsd_name,+ const char *uuid_str,+ void *arg),+ void *arg);+kern_return_t hfs_get_platform_serial_number(char *serial_number_str,+ uint32_t len);+#if CONFIG_PROTECT+int hfs_unwrap_key(aks_cred_t access, const aks_wrapped_key_t wrapped_key_in,+ aks_raw_key_t key_out);+int hfs_rewrap_key(aks_cred_t access, cp_key_class_t dp_class,+ const aks_wrapped_key_t wrapped_key_in,+ aks_wrapped_key_t wrapped_key_out);+int hfs_new_key(aks_cred_t access, cp_key_class_t dp_class,+ aks_raw_key_t key_out, aks_wrapped_key_t wrapped_key_out);+int hfs_backup_key(aks_cred_t access, const aks_wrapped_key_t wrapped_key_in,+ aks_wrapped_key_t wrapped_key_out);++#endif /* CONFIG_PROTECT */++__END_DECLS++#endif /* hfs_iokit_h */diff --git a/xnu/files/bsd/hfs/hfs_journal.c b/xnu/files/bsd/hfs/hfs_journal.cnew file mode 100644index 0000000..20dc624--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_journal.c@@ -0,0 +1,4946 @@+/*+ * Copyright (c) 2002-2015 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@+ */+//+// This file implements a simple write-ahead journaling layer.+// In theory any file system can make use of it by calling these+// functions when the fs wants to modify meta-data blocks. See+// hfs_journal.h for a more detailed description of the api and+// data structures.+//+// Dominic Giampaolo ([email protected])+//++#ifdef KERNEL++#include <sys/param.h>+#include <sys/systm.h>+#include <sys/kernel.h>+#include <sys/stat.h>+#include <sys/namei.h>+#include <sys/ioctl.h>+#include <sys/ubc.h>+#include <sys/malloc.h>+#include <kern/task.h>+#include <kern/thread.h>+#include <sys/disk.h>+#include <sys/kdebug.h>+#include <sys/kpi_private.h>+#include <sys/sysctl.h>+#include <sys/systm.h>+#include <miscfs/specfs/specdev.h>+#include <libkern/OSAtomic.h> /* OSAddAtomic */++#include "hfs.h"++kern_return_t thread_terminate(thread_t);++/*+ * Set sysctl vfs.generic.jnl.kdebug.trim=1 to enable KERNEL_DEBUG_CONSTANT+ * logging of trim-related calls within the journal. (They're+ * disabled by default because there can be a lot of these events,+ * and we don't want to overwhelm the kernel debug buffer. If you+ * want to watch these events in particular, just set the sysctl.)+ */+static int jnl_kdebug = 0;++HFS_SYSCTL(NODE, _vfs_generic_hfs, OID_AUTO, jnl, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "Journal")+HFS_SYSCTL(NODE, _vfs_generic_hfs_jnl, OID_AUTO, kdebug, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "Journal kdebug")+HFS_SYSCTL(INT, _vfs_generic_hfs_jnl_kdebug, OID_AUTO, trim, CTLFLAG_RW|CTLFLAG_LOCKED, &jnl_kdebug, 0, "Enable kdebug logging for journal TRIM")++#define DBG_JOURNAL_FLUSH FSDBG_CODE(DBG_JOURNAL, 1)+#define DBG_JOURNAL_TRIM_ADD FSDBG_CODE(DBG_JOURNAL, 2)+#define DBG_JOURNAL_TRIM_REMOVE FSDBG_CODE(DBG_JOURNAL, 3)+#define DBG_JOURNAL_TRIM_REMOVE_PENDING FSDBG_CODE(DBG_JOURNAL, 4)+#define DBG_JOURNAL_TRIM_REALLOC FSDBG_CODE(DBG_JOURNAL, 5)+#define DBG_JOURNAL_TRIM_FLUSH FSDBG_CODE(DBG_JOURNAL, 6)+#define DBG_JOURNAL_TRIM_UNMAP FSDBG_CODE(DBG_JOURNAL, 7)++/*+ * Cap the journal max size to 2GB. On HFS, it will attempt to occupy+ * a full allocation block if the current size is smaller than the allocation+ * block on which it resides. Once we hit the exabyte filesystem range, then+ * it will use 2GB allocation blocks. As a result, make the cap 2GB.+ */+#define MAX_JOURNAL_SIZE 0x80000000U++#include <mach/machine/sdt.h>+#else++#include <stdio.h>+#include <stdlib.h>+#include <string.h>+#include <limits.h>+#include <errno.h>+#include <fcntl.h>+#include <unistd.h>+#include <stdarg.h>+#include <sys/types.h>+#include "compat.h"++#endif /* KERNEL */++#include "hfs_journal.h"++#include <sys/kdebug.h>++//+// By default, we grow the list of extents to trim by 4K at a time.+// We'll opt to flush a transaction if it contains at least+// JOURNAL_FLUSH_TRIM_EXTENTS extents to be trimmed (even if the number+// of modified blocks is small).+//+enum {+ JOURNAL_DEFAULT_TRIM_BYTES = 4096,+ JOURNAL_DEFAULT_TRIM_EXTENTS = JOURNAL_DEFAULT_TRIM_BYTES / sizeof(dk_extent_t),+ JOURNAL_FLUSH_TRIM_EXTENTS = JOURNAL_DEFAULT_TRIM_EXTENTS * 15 / 16+};++unsigned int jnl_trim_flush_limit = JOURNAL_FLUSH_TRIM_EXTENTS;++HFS_SYSCTL(UINT, _vfs_generic_hfs_jnl, OID_AUTO, trim_flush, CTLFLAG_RW, &jnl_trim_flush_limit, 0, "number of trimmed extents to cause a journal flush")++// number of bytes to checksum in a block_list_header+// NOTE: this should be enough to clear out the header+// fields as well as the first entry of binfo[]+#define BLHDR_CHECKSUM_SIZE 32++static void lock_condition(journal *jnl, boolean_t *condition, const char *condition_name);+static void wait_condition(journal *jnl, boolean_t *condition, const char *condition_name);+static void unlock_condition(journal *jnl, boolean_t *condition);+static void finish_end_thread(transaction *tr);+static void write_header_thread(journal *jnl);+static int finish_end_transaction(transaction *tr, errno_t (*callback)(void*), void *callback_arg);+static int end_transaction(transaction *tr, int force_it, errno_t (*callback)(void*), void *callback_arg, boolean_t drop_lock, boolean_t must_wait);+static void abort_transaction(journal *jnl, transaction *tr);+static void dump_journal(journal *jnl);++static __inline__ void lock_oldstart(journal *jnl);+static __inline__ void unlock_oldstart(journal *jnl);+static __inline__ void lock_flush(journal *jnl);+static __inline__ void unlock_flush(journal *jnl);+++//+// 3105942 - Coalesce writes to the same block on journal replay+//++typedef struct bucket {+ off_t block_num;+ uint32_t jnl_offset;+ uint32_t block_size;+ int32_t cksum;+} bucket;++#define STARTING_BUCKETS 256++static int add_block(journal *jnl, struct bucket **buf_ptr, off_t block_num, size_t size, size_t offset, int32_t cksum, int *num_buckets_ptr, int *num_full_ptr);+static int grow_table(struct bucket **buf_ptr, int num_buckets, int new_size);+static int lookup_bucket(struct bucket **buf_ptr, off_t block_num, int num_full);+static int do_overlap(journal *jnl, struct bucket **buf_ptr, int blk_index, off_t block_num, size_t size, size_t offset, int32_t cksum, int *num_buckets_ptr, int *num_full_ptr);+static int insert_block(journal *jnl, struct bucket **buf_ptr, int blk_index, off_t num, size_t size, size_t offset, int32_t cksum, int *num_buckets_ptr, int *num_full_ptr, int overwriting);++#define CHECK_JOURNAL(jnl) \+ do { \+ if (jnl == NULL) { \+ panic("%s:%d: null journal ptr?\n", __FILE__, __LINE__); \+ } \+ if (jnl->jdev == NULL) { \+ panic("%s:%d: jdev is null!\n", __FILE__, __LINE__); \+ } \+ if (jnl->fsdev == NULL) { \+ panic("%s:%d: fsdev is null!\n", __FILE__, __LINE__); \+ } \+ if (jnl->jhdr->magic != JOURNAL_HEADER_MAGIC) { \+ panic("%s:%d: jhdr magic corrupted (0x%x != 0x%x)\n", \+ __FILE__, __LINE__, jnl->jhdr->magic, JOURNAL_HEADER_MAGIC); \+ } \+ if ( jnl->jhdr->start <= 0 \+ || jnl->jhdr->start > jnl->jhdr->size) { \+ panic("%s:%d: jhdr start looks bad (0x%llx max size 0x%llx)\n", \+ __FILE__, __LINE__, jnl->jhdr->start, jnl->jhdr->size); \+ } \+ if ( jnl->jhdr->end <= 0 \+ || jnl->jhdr->end > jnl->jhdr->size) { \+ panic("%s:%d: jhdr end looks bad (0x%llx max size 0x%llx)\n", \+ __FILE__, __LINE__, jnl->jhdr->end, jnl->jhdr->size); \+ } \+ } while(0)++#define CHECK_TRANSACTION(tr) \+ do { \+ if (tr == NULL) { \+ panic("%s:%d: null transaction ptr?\n", __FILE__, __LINE__); \+ } \+ if (tr->jnl == NULL) { \+ panic("%s:%d: null tr->jnl ptr?\n", __FILE__, __LINE__); \+ } \+ if (tr->blhdr != (block_list_header *)tr->tbuffer) { \+ panic("%s:%d: blhdr (%p) != tbuffer (%p)\n", __FILE__, __LINE__, tr->blhdr, tr->tbuffer); \+ } \+ if (tr->total_bytes < 0) { \+ panic("%s:%d: tr total_bytes looks bad: %d\n", __FILE__, __LINE__, tr->total_bytes); \+ } \+ if (tr->journal_start < 0) { \+ panic("%s:%d: tr journal start looks bad: 0x%llx\n", __FILE__, __LINE__, tr->journal_start); \+ } \+ if (tr->journal_end < 0) { \+ panic("%s:%d: tr journal end looks bad: 0x%llx\n", __FILE__, __LINE__, tr->journal_end); \+ } \+ if (tr->blhdr && (tr->blhdr->max_blocks <= 0 || tr->blhdr->max_blocks > (tr->jnl->jhdr->size/tr->jnl->jhdr->jhdr_size))) { \+ panic("%s:%d: tr blhdr max_blocks looks bad: %d\n", __FILE__, __LINE__, tr->blhdr->max_blocks); \+ } \+ } while(0)+++#define BLHDR_TO_BLHDRIM(hdr) (block_list_header_in_memory *)((char *)(hdr) - offsetof(block_list_header_in_memory, blhdr))++//+// this isn't a great checksum routine but it will do for now.+// we use it to checksum the journal header and the block list+// headers that are at the start of each transaction.+//+static unsigned int+calc_checksum(const char *ptr, int len)+{+ int i;+ unsigned int cksum=0;++ // this is a lame checksum but for now it'll do+ for(i = 0; i < len; i++, ptr++) {+ cksum = (cksum << 8) ^ (cksum + *(unsigned char *)ptr);+ }++ return (~cksum);+}++//+// Journal Locking+//+lck_grp_attr_t * jnl_group_attr;+lck_attr_t * jnl_lock_attr;+lck_grp_t * jnl_mutex_group;++void+journal_init(void)+{+ jnl_lock_attr = lck_attr_alloc_init();+ jnl_group_attr = lck_grp_attr_alloc_init();+ jnl_mutex_group = lck_grp_alloc_init("jnl-mutex", jnl_group_attr);+}++__inline__ void+journal_lock(journal *jnl)+{+ lck_mtx_lock(&jnl->jlock);+ if (jnl->owner) {+ panic ("jnl: owner is %p, expected NULL\n", jnl->owner);+ }+ jnl->owner = current_thread();+}++__inline__ void+journal_unlock(journal *jnl)+{+ jnl->owner = NULL;+ lck_mtx_unlock(&jnl->jlock);+}++static __inline__ void+lock_flush(journal *jnl)+{+ lck_mtx_lock(&jnl->flock);+}++static __inline__ void+unlock_flush(journal *jnl)+{+ lck_mtx_unlock(&jnl->flock);+}++static __inline__ void+lock_oldstart(journal *jnl)+{+ lck_mtx_lock(&jnl->old_start_lock);+}++static __inline__ void+unlock_oldstart(journal *jnl)+{+ lck_mtx_unlock(&jnl->old_start_lock);+}++++#define JNL_WRITE 0x0001+#define JNL_READ 0x0002+#define JNL_HEADER 0x8000++//+// This function sets up a fake buf and passes it directly to the+// journal device strategy routine (so that it won't get cached in+// the block cache.+//+// It also handles range checking the i/o so that we don't write+// outside the journal boundaries and it will wrap the i/o back+// to the beginning if necessary (skipping over the journal header)+//+static size_t+do_journal_io(journal *jnl, off_t *offset, void *data, size_t len, int direction)+{+ int err;+ off_t curlen = len;+ size_t io_sz = 0;+ buf_t bp;+ off_t max_iosize;+ bufattr_t bap;+ boolean_t was_vm_privileged = FALSE;+ boolean_t need_vm_privilege = FALSE;++ if (vfs_isswapmount(jnl->fsmount))+ need_vm_privilege = TRUE;++ if (*offset < 0 || *offset > jnl->jhdr->size) {+ panic("jnl: do_jnl_io: bad offset 0x%llx (max 0x%llx)\n", *offset, jnl->jhdr->size);+ }++ if (direction & JNL_WRITE)+ max_iosize = jnl->max_write_size;+ else if (direction & JNL_READ)+ max_iosize = jnl->max_read_size;+ else+ max_iosize = 128 * 1024;++again:+ bp = buf_alloc(jnl->jdev);++ if (*offset + curlen > jnl->jhdr->size && *offset != 0 && jnl->jhdr->size != 0) {+ if (*offset == jnl->jhdr->size) {+ *offset = jnl->jhdr->jhdr_size;+ } else {+ curlen = jnl->jhdr->size - *offset;+ }+ }++ if (curlen > max_iosize) {+ curlen = max_iosize;+ }++ if (curlen <= 0) {+ panic("jnl: do_jnl_io: curlen == %lld, offset 0x%llx len %zd\n", curlen, *offset, len);+ }++ if (*offset == 0 && (direction & JNL_HEADER) == 0) {+ panic("jnl: request for i/o to jnl-header without JNL_HEADER flag set! (len %lld, data %p)\n", curlen, data);+ }++ /*+ * As alluded to in the block comment at the top of the function, we use a "fake" iobuf+ * here and issue directly to the disk device that the journal protects since we don't+ * want this to enter the block cache. As a result, we lose the ability to mark it+ * as a metadata buf_t for the layers below us that may care. If we were to+ * simply attach the B_META flag into the b_flags this may confuse things further+ * since this is an iobuf, not a metadata buffer.+ *+ * To address this, we use the extended bufattr struct embedded in the bp.+ * Explicitly mark the buf here as a metadata buffer in its bufattr flags.+ */+ bap = buf_attr(bp);+ bufattr_markmeta(bap);++ if (direction & JNL_READ)+ buf_setflags(bp, B_READ);+ else {+ /*+ * don't have to set any flags+ */+ vnode_startwrite(jnl->jdev);+ }+ buf_setsize(bp, curlen);+ buf_setcount(bp, curlen);+ buf_setdataptr(bp, (uintptr_t)data);+ buf_setblkno(bp, (daddr64_t) ((jnl->jdev_offset + *offset) / (off_t)jnl->jhdr->jhdr_size));+ buf_setlblkno(bp, (daddr64_t) ((jnl->jdev_offset + *offset) / (off_t)jnl->jhdr->jhdr_size));++ if ((direction & JNL_WRITE) && (jnl->flags & JOURNAL_DO_FUA_WRITES)) {+ buf_markfua(bp);+ }++ if (need_vm_privilege == TRUE) {+ /*+ * if we block waiting for memory, and there is enough pressure to+ * cause us to try and create a new swap file, we may end up deadlocking+ * due to waiting for the journal on the swap file creation path...+ * by making ourselves vm_privileged, we give ourselves the best chance+ * of not blocking+ */+ was_vm_privileged = set_vm_privilege(TRUE);+ }+ DTRACE_IO1(journal__start, buf_t, bp);+ err = VNOP_STRATEGY(bp);+ if (!err) {+ err = (int)buf_biowait(bp);+ }+ DTRACE_IO1(journal__done, buf_t, bp);++ if (need_vm_privilege == TRUE && was_vm_privileged == FALSE)+ set_vm_privilege(FALSE);++ buf_free(bp);++ if (err) {+ printf("jnl: %s: do_jnl_io: strategy err 0x%x\n", jnl->jdev_name, err);+ return 0;+ }++ *offset += curlen;+ io_sz += curlen;++ if (io_sz != len) {+ // handle wrap-around+ data = (char *)data + curlen;+ curlen = len - io_sz;+ if (*offset >= jnl->jhdr->size) {+ *offset = jnl->jhdr->jhdr_size;+ }+ goto again;+ }++ return io_sz;+}++static size_t+read_journal_data(journal *jnl, off_t *offset, void *data, size_t len)+{+ return do_journal_io(jnl, offset, data, len, JNL_READ);+}++static size_t+write_journal_data(journal *jnl, off_t *offset, void *data, size_t len)+{+ return do_journal_io(jnl, offset, data, len, JNL_WRITE);+}+++static size_t+read_journal_header(journal *jnl, void *data, size_t len)+{+ off_t hdr_offset = 0;++ return do_journal_io(jnl, &hdr_offset, data, len, JNL_READ|JNL_HEADER);+}++static int+write_journal_header(journal *jnl, int updating_start, uint32_t sequence_num)+{+ static int num_err_prints = 0;+ int ret=0;+ off_t jhdr_offset = 0;+ //+ // Flush the track cache if we're not doing force-unit-access+ // writes.+ //+ if (!updating_start && (jnl->flags & JOURNAL_DO_FUA_WRITES) == 0) {++ dk_synchronize_t sync_request = {+ .options = DK_SYNCHRONIZE_OPTION_BARRIER,+ };++ /*+ * If device doesn't support barrier-only flush, or+ * the journal is on a different device, use full flush.+ */+ if (!(jnl->flags & JOURNAL_FEATURE_BARRIER) || (jnl->jdev != jnl->fsdev)) {+ sync_request.options = 0;+ jnl->flush_counter++;+ }++ ret = VNOP_IOCTL(jnl->jdev, DKIOCSYNCHRONIZE, (caddr_t)&sync_request, FWRITE, vfs_context_kernel());+ }+ if (ret != 0) {+ //+ // Only print this error if it's a different error than the+ // previous one, or if it's the first time for this device+ // or if the total number of printfs is less than 25. We+ // allow for up to 25 printfs to insure that some make it+ // into the on-disk syslog. Otherwise if we only printed+ // one, it's possible it would never make it to the syslog+ // for the root volume and that makes debugging hard.+ //+ if ( ret != jnl->last_flush_err+ || (jnl->flags & JOURNAL_FLUSHCACHE_ERR) == 0+ || num_err_prints++ < 25) {++ printf("jnl: %s: flushing fs disk buffer returned 0x%x\n", jnl->jdev_name, ret);++ jnl->flags |= JOURNAL_FLUSHCACHE_ERR;+ jnl->last_flush_err = ret;+ }+ }++ jnl->jhdr->sequence_num = sequence_num;+ jnl->jhdr->checksum = 0;+ jnl->jhdr->checksum = calc_checksum((char *)jnl->jhdr, JOURNAL_HEADER_CKSUM_SIZE);++ if (do_journal_io(jnl, &jhdr_offset, jnl->header_buf, jnl->jhdr->jhdr_size, JNL_WRITE|JNL_HEADER) != (size_t)jnl->jhdr->jhdr_size) {+ printf("jnl: %s: write_journal_header: error writing the journal header!\n", jnl->jdev_name);+ jnl->flags |= JOURNAL_INVALID;+ return -1;+ }++ // If we're not doing force-unit-access writes, then we+ // have to flush after writing the journal header so that+ // a future transaction doesn't sneak out to disk before+ // the header does and thus overwrite data that the old+ // journal header refers to. Saw this exact case happen+ // on an IDE bus analyzer with Larry Barras so while it+ // may seem obscure, it's not.+ //+ if (updating_start && (jnl->flags & JOURNAL_DO_FUA_WRITES) == 0) {++ dk_synchronize_t sync_request = {+ .options = DK_SYNCHRONIZE_OPTION_BARRIER,+ };++ /*+ * If device doesn't support barrier-only flush, or+ * the journal is on a different device, use full flush.+ */+ if (!(jnl->flags & JOURNAL_FEATURE_BARRIER) || (jnl->jdev != jnl->fsdev)) {+ sync_request.options = 0;+ jnl->flush_counter++;+ }++ VNOP_IOCTL(jnl->jdev, DKIOCSYNCHRONIZE, (caddr_t)&sync_request, FWRITE, vfs_context_kernel());+ }++ return 0;+}++static inline int32_t+journal_max_blocks(journal *jnl)+{+ return ((jnl->jhdr->blhdr_size / sizeof(block_info)) - 1);+}++//+// this is a work function used to free up transactions that+// completed. they can't be free'd from buffer_flushed_callback+// because it is called from deep with the disk driver stack+// and thus can't do something that would potentially cause+// paging. it gets called by each of the journal api entry+// points so stuff shouldn't hang around for too long.+//+static void+free_old_stuff(journal *jnl)+{+ transaction *tr, *next;+ block_list_header *blhdr=NULL, *next_blhdr=NULL;++ if (jnl->tr_freeme == NULL)+ return;++ lock_oldstart(jnl);+ tr = jnl->tr_freeme;+ jnl->tr_freeme = NULL;+ unlock_oldstart(jnl);++ for(; tr; tr=next) {+ for (blhdr = tr->blhdr; blhdr; blhdr = next_blhdr) {+ next_blhdr = (block_list_header *)((long)blhdr->binfo[0].bnum);+ blhdr->binfo[0].bnum = 0xdeadc0de;+ // get block_list_header_in_memory pointer, since this is what we really allocated in memory+ block_list_header_in_memory *blhdrim = BLHDR_TO_BLHDRIM(blhdr);+ hfs_free_data(blhdrim->buffers, tr->tbuffer_size - jnl->jhdr->blhdr_size);+ hfs_delete_with_hdr(blhdrim, block_list_header_in_memory, block_info, journal_max_blocks(jnl));++ KERNEL_DEBUG(0xbbbbc01c, jnl, tr, tr->tbuffer_size, 0, 0);+ }+ next = tr->next;+ hfs_free_type(tr, transaction);+ }+}++++//+// This is our callback that lets us know when a buffer has been+// flushed to disk. It's called from deep within the driver stack+// and thus is quite limited in what it can do. Notably, it can+// not initiate any new i/o's or allocate/free memory.+//+static void+buffer_flushed_callback(struct buf *bp, void *arg)+{+ transaction *tr;+ journal *jnl;+ transaction *ctr, *prev=NULL, *next;+ size_t i;+ int bufsize, amt_flushed, total_bytes;+++ //printf("jnl: buf flush: bp @ 0x%x l/blkno %qd/%qd vp 0x%x tr @ 0x%x\n",+ // bp, buf_lblkno(bp), buf_blkno(bp), buf_vnode(bp), arg);++ // snarf out the bits we want+ bufsize = buf_size(bp);+ tr = (transaction *)arg;++ // then we've already seen it+ if (tr == NULL) {+ return;+ }++ if (tr->total_bytes == (int)0xfbadc0de) {+ // then someone beat us to it...+ return;+ }++ CHECK_TRANSACTION(tr);++ jnl = tr->jnl;++ CHECK_JOURNAL(jnl);++ amt_flushed = tr->num_killed;+ total_bytes = tr->total_bytes;++ // update the number of blocks that have been flushed.+ // this buf may represent more than one block so take+ // that into account.+ //+ // OSAddAtomic() returns the value of tr->num_flushed before the add+ //+ amt_flushed += OSAddAtomic(bufsize, &tr->num_flushed);+++ // if this transaction isn't done yet, just return as+ // there is nothing to do.+ //+ // NOTE: we are careful to not reference anything through+ // the tr pointer after doing the OSAddAtomic(). if+ // this if statement fails then we are the last one+ // and then it's ok to dereference "tr".+ //+ if ((amt_flushed + bufsize) < total_bytes) {+ return;+ }++ // this will single thread checking the transaction+ lock_oldstart(jnl);++ // re-check this after acquiring the lock+ if (tr->total_bytes == (int)0xfbadc0de) {+ // then someone beat us to it...+ unlock_oldstart(jnl);+ return;+ }++ // mark this so that we're the owner of dealing with the+ // cleanup for this transaction+ tr->total_bytes = 0xfbadc0de;++ if (jnl->flags & JOURNAL_INVALID)+ goto transaction_done;++ //printf("jnl: tr 0x%x (0x%llx 0x%llx) in jnl 0x%x completed.\n",+ // tr, tr->journal_start, tr->journal_end, jnl);++ // find this entry in the old_start[] index and mark it completed+ for(i = 0; i < sizeof(jnl->old_start)/sizeof(jnl->old_start[0]); i++) {++ if ((off_t)(jnl->old_start[i] & ~(0x8000000000000000ULL)) == tr->journal_start) {+ jnl->old_start[i] &= ~(0x8000000000000000ULL);+ break;+ }+ }++ if (i >= sizeof(jnl->old_start)/sizeof(jnl->old_start[0])) {+ panic("jnl: buffer_flushed: did not find tr w/start @ %lld (tr %p, jnl %p)\n",+ tr->journal_start, tr, jnl);+ }+++ // if we are here then we need to update the journal header+ // to reflect that this transaction is complete+ if (tr->journal_start == jnl->active_start) {+ jnl->active_start = tr->journal_end;+ tr->journal_start = tr->journal_end = (off_t)0;+ }++ // go through the completed_trs list and try to coalesce+ // entries, restarting back at the beginning if we have to.+ for (ctr = jnl->completed_trs; ctr; prev=ctr, ctr=next) {+ if (ctr->journal_start == jnl->active_start) {+ jnl->active_start = ctr->journal_end;+ if (prev) {+ prev->next = ctr->next;+ }+ if (ctr == jnl->completed_trs) {+ jnl->completed_trs = ctr->next;+ }++ next = jnl->completed_trs; // this starts us over again+ ctr->next = jnl->tr_freeme;+ jnl->tr_freeme = ctr;+ ctr = NULL;+ } else if (tr->journal_end == ctr->journal_start) {+ ctr->journal_start = tr->journal_start;+ next = jnl->completed_trs; // this starts us over again+ ctr = NULL;+ tr->journal_start = tr->journal_end = (off_t)0;+ } else if (tr->journal_start == ctr->journal_end) {+ ctr->journal_end = tr->journal_end;+ next = ctr->next;+ tr->journal_start = tr->journal_end = (off_t)0;+ } else if (ctr->next && ctr->journal_end == ctr->next->journal_start) {+ // coalesce the next entry with this one and link the next+ // entry in at the head of the tr_freeme list+ next = ctr->next; // temporarily use the "next" variable+ ctr->journal_end = next->journal_end;+ ctr->next = next->next;+ next->next = jnl->tr_freeme; // link in the next guy at the head of the tr_freeme list+ jnl->tr_freeme = next;++ next = jnl->completed_trs; // this starts us over again+ ctr = NULL;+ } else {+ next = ctr->next;+ }+ }++ // if this is true then we didn't merge with anyone+ // so link ourselves in at the head of the completed+ // transaction list.+ if (tr->journal_start != 0) {+ // put this entry into the correct sorted place+ // in the list instead of just at the head.+ //++ prev = NULL;+ for (ctr = jnl->completed_trs; ctr && tr->journal_start > ctr->journal_start; prev=ctr, ctr=ctr->next) {+ // just keep looping+ }++ if (ctr == NULL && prev == NULL) {+ jnl->completed_trs = tr;+ tr->next = NULL;+ } else if (ctr == jnl->completed_trs) {+ tr->next = jnl->completed_trs;+ jnl->completed_trs = tr;+ } else {+ tr->next = prev->next;+ prev->next = tr;+ }+ } else {+ // if we're here this tr got merged with someone else so+ // put it on the list to be free'd+ tr->next = jnl->tr_freeme;+ jnl->tr_freeme = tr;+ }+transaction_done:+ unlock_oldstart(jnl);++ unlock_condition(jnl, &jnl->asyncIO);+}+++#include <libkern/OSByteOrder.h>++#define SWAP16(x) OSSwapInt16(x)+#define SWAP32(x) OSSwapInt32(x)+#define SWAP64(x) OSSwapInt64(x)+++static void+swap_journal_header(journal *jnl)+{+ jnl->jhdr->magic = SWAP32(jnl->jhdr->magic);+ jnl->jhdr->endian = SWAP32(jnl->jhdr->endian);+ jnl->jhdr->start = SWAP64(jnl->jhdr->start);+ jnl->jhdr->end = SWAP64(jnl->jhdr->end);+ jnl->jhdr->size = SWAP64(jnl->jhdr->size);+ jnl->jhdr->blhdr_size = SWAP32(jnl->jhdr->blhdr_size);+ jnl->jhdr->checksum = SWAP32(jnl->jhdr->checksum);+ jnl->jhdr->jhdr_size = SWAP32(jnl->jhdr->jhdr_size);+ jnl->jhdr->sequence_num = SWAP32(jnl->jhdr->sequence_num);+}++static void+swap_block_list_header(journal *jnl, block_list_header *blhdr)+{+ int i;++ blhdr->max_blocks = SWAP16(blhdr->max_blocks);+ blhdr->num_blocks = SWAP16(blhdr->num_blocks);+ blhdr->bytes_used = SWAP32(blhdr->bytes_used);+ blhdr->checksum = SWAP32(blhdr->checksum);+ blhdr->flags = SWAP32(blhdr->flags);++ if (blhdr->num_blocks >= journal_max_blocks(jnl)) {+ printf("jnl: %s: blhdr num blocks looks suspicious (%d / blhdr size %d). not swapping.\n", jnl->jdev_name, blhdr->num_blocks, jnl->jhdr->blhdr_size);+ return;+ }++ for(i = 0; i < blhdr->num_blocks; i++) {+ blhdr->binfo[i].bnum = SWAP64(blhdr->binfo[i].bnum);+ blhdr->binfo[i].u.bi.bsize = SWAP32(blhdr->binfo[i].u.bi.bsize);+ blhdr->binfo[i].u.bi.b.cksum = SWAP32(blhdr->binfo[i].u.bi.b.cksum);+ }+}+++static int+update_fs_block(journal *jnl, void *block_ptr, off_t fs_block, size_t bsize)+{+ int ret;+ struct buf *oblock_bp=NULL;+ boolean_t was_vm_privileged = FALSE;+++ // first read the block we want.+ ret = buf_meta_bread(jnl->fsdev, (daddr64_t)fs_block, bsize, NOCRED, &oblock_bp);+ if (ret != 0) {+ printf("jnl: %s: update_fs_block: error reading fs block # %lld! (ret %d)\n", jnl->jdev_name, fs_block, ret);++ if (oblock_bp) {+ buf_brelse(oblock_bp);+ oblock_bp = NULL;+ }++ // let's try to be aggressive here and just re-write the block+ oblock_bp = buf_getblk(jnl->fsdev, (daddr64_t)fs_block, bsize, 0, 0, BLK_META);+ if (oblock_bp == NULL) {+ printf("jnl: %s: update_fs_block: buf_getblk() for %lld failed! failing update.\n", jnl->jdev_name, fs_block);+ return -1;+ }+ }++ // make sure it's the correct size.+ if (buf_size(oblock_bp) != bsize) {+ buf_brelse(oblock_bp);+ return -1;+ }++ // copy the journal data over top of it+ memcpy((char *)buf_dataptr(oblock_bp), block_ptr, bsize);++ if (vfs_isswapmount(jnl->fsmount)) {+ /*+ * if we block waiting for memory, and there is enough pressure to+ * cause us to try and create a new swap file, we may end up deadlocking+ * due to waiting for the journal on the swap file creation path...+ * by making ourselves vm_privileged, we give ourselves the best chance+ * of not blocking+ */+ was_vm_privileged = set_vm_privilege(TRUE);+ }+ ret = VNOP_BWRITE(oblock_bp);++ if (vfs_isswapmount(jnl->fsmount) && (was_vm_privileged == FALSE))+ set_vm_privilege(FALSE);++ if (ret != 0) {+ printf("jnl: %s: update_fs_block: failed to update block %lld (ret %d)\n", jnl->jdev_name, fs_block,ret);+ return ret;+ }+ // and now invalidate it so that if someone else wants to read+ // it in a different size they'll be able to do it.+ ret = buf_meta_bread(jnl->fsdev, (daddr64_t)fs_block, bsize, NOCRED, &oblock_bp);+ if (oblock_bp) {+ buf_markinvalid(oblock_bp);+ buf_brelse(oblock_bp);+ }++ return 0;+}++static int+grow_table(struct bucket **buf_ptr, int num_buckets, int new_size)+{+ struct bucket *newBuf;+ int current_size = num_buckets, i;++ // return if newsize is less than the current size+ if (new_size < num_buckets) {+ return current_size;+ }++ newBuf = hfs_new_data(struct bucket, new_size);++ // printf("jnl: lookup_bucket: expanded co_buf to %d elems\n", new_size);++ // copy existing elements+ bcopy(*buf_ptr, newBuf, num_buckets*sizeof(struct bucket));++ // initialize the new ones+ for(i = num_buckets; i < new_size; i++) {+ newBuf[i].block_num = (off_t)-1;+ }++ // free the old container+ hfs_delete_data(*buf_ptr, struct bucket, num_buckets);++ // reset the buf_ptr+ *buf_ptr = newBuf;++ return new_size;+}++static int+lookup_bucket(struct bucket **buf_ptr, off_t block_num, int num_full)+{+ int lo, hi, index, matches, i;++ if (num_full == 0) {+ return 0; // table is empty, so insert at index=0+ }++ lo = 0;+ hi = num_full - 1;+ index = -1;++ // perform binary search for block_num+ do {+ int mid = (hi - lo)/2 + lo;+ off_t this_num = (*buf_ptr)[mid].block_num;++ if (block_num == this_num) {+ index = mid;+ break;+ }++ if (block_num < this_num) {+ hi = mid;+ continue;+ }++ if (block_num > this_num) {+ lo = mid + 1;+ continue;+ }+ } while (lo < hi);++ // check if lo and hi converged on the match+ if (block_num == (*buf_ptr)[hi].block_num) {+ index = hi;+ }++ // if no existing entry found, find index for new one+ if (index == -1) {+ index = (block_num < (*buf_ptr)[hi].block_num) ? hi : hi + 1;+ } else {+ // make sure that we return the right-most index in the case of multiple matches+ matches = 0;+ i = index + 1;+ while (i < num_full && block_num == (*buf_ptr)[i].block_num) {+ matches++;+ i++;+ }++ index += matches;+ }++ return index;+}++static int+insert_block(journal *jnl, struct bucket **buf_ptr, int blk_index, off_t num, size_t size, size_t offset, int32_t cksum, int *num_buckets_ptr, int *num_full_ptr, int overwriting)+{+ if (!overwriting) {+ // grow the table if we're out of space - we may index the table+ // with *num_full_ptr (lookup_bucket() can return a maximum value ==+ // *num_full_ptr), so we need to grow when we hit (*num_buckets_ptr - 1)+ // to prevent out-of-bounds indexing+ if (*num_full_ptr >= (*num_buckets_ptr - 1)) {+ int new_size = *num_buckets_ptr * 2;+ int grow_size = grow_table(buf_ptr, *num_buckets_ptr, new_size);++ if (grow_size < new_size) {+ printf("jnl: %s: add_block: grow_table returned an error!\n", jnl->jdev_name);+ return -1;+ }++ *num_buckets_ptr = grow_size; //update num_buckets to reflect the new size+ }++ // if we're not inserting at the end, we need to bcopy+ if (blk_index != *num_full_ptr) {+ bcopy( (*buf_ptr)+(blk_index), (*buf_ptr)+(blk_index+1), (*num_full_ptr-blk_index)*sizeof(struct bucket) );+ }++ (*num_full_ptr)++; // increment only if we're not overwriting+ }++ // sanity check the values we're about to add+ if ((off_t)offset >= jnl->jhdr->size) {+ offset = jnl->jhdr->jhdr_size + (offset - jnl->jhdr->size);+ }+ if (size <= 0) {+ panic("jnl: insert_block: bad size in insert_block (%zd)\n", size);+ }++ (*buf_ptr)[blk_index].block_num = num;+ (*buf_ptr)[blk_index].block_size = (uint32_t)size;+ (*buf_ptr)[blk_index].jnl_offset = (uint32_t)offset;+ (*buf_ptr)[blk_index].cksum = cksum;++ return blk_index;+}++static int+do_overlap(journal *jnl, struct bucket **buf_ptr, int blk_index, off_t block_num, size_t size, __unused size_t offset, int32_t cksum, int *num_buckets_ptr, int *num_full_ptr)+{+ int num_to_remove, index, i, overwrite, err;+ size_t jhdr_size = jnl->jhdr->jhdr_size, new_offset;+ off_t overlap, block_start, block_end;++ block_start = block_num*jhdr_size;+ block_end = block_start + size;+ overwrite = (block_num == (*buf_ptr)[blk_index].block_num && size >= (*buf_ptr)[blk_index].block_size);++ // first, eliminate any overlap with the previous entry+ if (blk_index != 0 && !overwrite) {+ off_t prev_block_start = (*buf_ptr)[blk_index-1].block_num*jhdr_size;+ off_t prev_block_end = prev_block_start + (*buf_ptr)[blk_index-1].block_size;+ overlap = prev_block_end - block_start;+ if (overlap > 0) {+ if (overlap % jhdr_size != 0) {+ panic("jnl: do_overlap: overlap with previous entry not a multiple of %zd\n", jhdr_size);+ }++ // if the previous entry completely overlaps this one, we need to break it into two pieces.+ if (prev_block_end > block_end) {+ off_t new_num = block_end / jhdr_size;+ size_t new_size = prev_block_end - block_end;++ new_offset = (*buf_ptr)[blk_index-1].jnl_offset + (block_end - prev_block_start);++ err = insert_block(jnl, buf_ptr, blk_index, new_num, new_size, new_offset, cksum, num_buckets_ptr, num_full_ptr, 0);+ if (err < 0) {+ panic("jnl: do_overlap: error inserting during pre-overlap\n");+ }+ }++ // Regardless, we need to truncate the previous entry to the beginning of the overlap+ (*buf_ptr)[blk_index-1].block_size = (uint32_t)(block_start - prev_block_start);+ (*buf_ptr)[blk_index-1].cksum = 0; // have to blow it away because there's no way to check it+ }+ }++ // then, bail out fast if there's no overlap with the entries that follow+ if (!overwrite && block_end <= (off_t)((*buf_ptr)[blk_index].block_num*jhdr_size)) {+ return 0; // no overlap, no overwrite+ } else if (overwrite && (blk_index + 1 >= *num_full_ptr || block_end <= (off_t)((*buf_ptr)[blk_index+1].block_num*jhdr_size))) {++ (*buf_ptr)[blk_index].cksum = cksum; // update this+ return 1; // simple overwrite+ }++ // Otherwise, find all cases of total and partial overlap. We use the special+ // block_num of -2 to designate entries that are completely overlapped and must+ // be eliminated. The block_num, size, and jnl_offset of partially overlapped+ // entries must be adjusted to keep the array consistent.+ index = blk_index;+ num_to_remove = 0;+ while (index < *num_full_ptr && block_end > (off_t)((*buf_ptr)[index].block_num*jhdr_size)) {+ if (block_end >= (off_t)(((*buf_ptr)[index].block_num*jhdr_size + (*buf_ptr)[index].block_size))) {+ (*buf_ptr)[index].block_num = -2; // mark this for deletion+ num_to_remove++;+ } else {+ overlap = block_end - (*buf_ptr)[index].block_num*jhdr_size;+ if (overlap > 0) {+ if (overlap % jhdr_size != 0) {+ panic("jnl: do_overlap: overlap of %lld is not multiple of %zd\n", overlap, jhdr_size);+ }++ // if we partially overlap this entry, adjust its block number, jnl offset, and size+ (*buf_ptr)[index].block_num += (overlap / jhdr_size); // make sure overlap is multiple of jhdr_size, or round up+ (*buf_ptr)[index].cksum = 0;++ new_offset = (*buf_ptr)[index].jnl_offset + overlap; // check for wrap-around+ if ((off_t)new_offset >= jnl->jhdr->size) {+ new_offset = jhdr_size + (new_offset - jnl->jhdr->size);+ }+ (*buf_ptr)[index].jnl_offset = (uint32_t)new_offset;++ (*buf_ptr)[index].block_size -= overlap; // sanity check for negative value+ if ((*buf_ptr)[index].block_size <= 0) {+ panic("jnl: do_overlap: after overlap, new block size is invalid (%u)\n", (*buf_ptr)[index].block_size);+ // return -1; // if above panic is removed, return -1 for error+ }+ }++ }++ index++;+ }++ // bcopy over any completely overlapped entries, starting at the right (where the above loop broke out)+ index--; // start with the last index used within the above loop+ while (index >= blk_index) {+ if ((*buf_ptr)[index].block_num == -2) {+ if (index == *num_full_ptr-1) {+ (*buf_ptr)[index].block_num = -1; // it's the last item in the table... just mark as free+ } else {+ bcopy( (*buf_ptr)+(index+1), (*buf_ptr)+(index), (*num_full_ptr - (index + 1)) * sizeof(struct bucket) );+ }+ (*num_full_ptr)--;+ }+ index--;+ }++ // eliminate any stale entries at the end of the table+ for(i = *num_full_ptr; i < (*num_full_ptr + num_to_remove); i++) {+ (*buf_ptr)[i].block_num = -1;+ }++ return 0; // if we got this far, we need to insert the entry into the table (rather than overwrite)+}++// PR-3105942: Coalesce writes to the same block in journal replay+// We coalesce writes by maintaining a dynamic sorted array of physical disk blocks+// to be replayed and the corresponding location in the journal which contains+// the most recent data for those blocks. The array is "played" once the all the+// blocks in the journal have been coalesced. The code for the case of conflicting/+// overlapping writes to a single block is the most dense. Because coalescing can+// disrupt the existing time-ordering of blocks in the journal playback, care+// is taken to catch any overlaps and keep the array consistent.+static int+add_block(journal *jnl, struct bucket **buf_ptr, off_t block_num, size_t size, size_t offset, int32_t cksum, int *num_buckets_ptr, int *num_full_ptr)+{+ int blk_index, overwriting;++ // on return from lookup_bucket(), blk_index is the index into the table where block_num should be+ // inserted (or the index of the elem to overwrite).+ blk_index = lookup_bucket( buf_ptr, block_num, *num_full_ptr);++ // check if the index is within bounds (if we're adding this block to the end of+ // the table, blk_index will be equal to num_full)+ if (blk_index < 0 || blk_index > *num_full_ptr) {+ //printf("jnl: add_block: trouble adding block to co_buf\n");+ return -1;+ } // else printf("jnl: add_block: adding block 0x%llx at i=%d\n", block_num, blk_index);++ // Determine whether we're overwriting an existing entry by checking for overlap+ overwriting = do_overlap(jnl, buf_ptr, blk_index, block_num, size, offset, cksum, num_buckets_ptr, num_full_ptr);+ if (overwriting < 0) {+ return -1; // if we got an error, pass it along+ }++ // returns the index, or -1 on error+ blk_index = insert_block(jnl, buf_ptr, blk_index, block_num, size, offset, cksum, num_buckets_ptr, num_full_ptr, overwriting);++ return blk_index;+}++static int+replay_journal(journal *jnl)+{+ int i, bad_blocks=0;+ unsigned int orig_checksum, checksum, check_block_checksums = 0;+ size_t ret;+ size_t max_bsize = 0; /* protected by block_ptr */+ block_list_header *blhdr;+ off_t offset, txn_start_offset=0, blhdr_offset, orig_jnl_start;+ char *buff, *block_ptr=NULL;+ struct bucket *co_buf;+ int num_buckets = STARTING_BUCKETS, num_full, check_past_jnl_end = 1, in_uncharted_territory=0;+ uint32_t last_sequence_num = 0;+ int replay_retry_count = 0;++ // wrap the start ptr if it points to the very end of the journal+ if (jnl->jhdr->start == jnl->jhdr->size) {+ jnl->jhdr->start = jnl->jhdr->jhdr_size;+ }+ if (jnl->jhdr->end == jnl->jhdr->size) {+ jnl->jhdr->end = jnl->jhdr->jhdr_size;+ }++ if (jnl->jhdr->start == jnl->jhdr->end) {+ return 0;+ }++ orig_jnl_start = jnl->jhdr->start;++ // allocate memory for the header_block. we'll read each blhdr into this+ // When replaying a journal, the in-memory representation is the same as on disk representation, so no need to use+ // block_list_header_in_memory structure when replaying+ buff = hfs_new_with_hdr(block_list_header, block_info, journal_max_blocks(jnl));++ // allocate memory for the coalesce buffer+ co_buf = hfs_new_data(struct bucket, num_buckets);++restart_replay:++ // initialize entries+ for(i = 0; i < num_buckets; i++) {+ co_buf[i].block_num = -1;+ }+ num_full = 0; // empty at first+++ printf("jnl: %s: replay_journal: from: %lld to: %lld (joffset 0x%llx)\n",+ jnl->jdev_name, jnl->jhdr->start, jnl->jhdr->end, jnl->jdev_offset);++ while (check_past_jnl_end || jnl->jhdr->start != jnl->jhdr->end) {+ offset = blhdr_offset = jnl->jhdr->start;+ ret = read_journal_data(jnl, &offset, buff, jnl->jhdr->blhdr_size);+ if (ret != (size_t)jnl->jhdr->blhdr_size) {+ printf("jnl: %s: replay_journal: Could not read block list header block @ 0x%llx!\n", jnl->jdev_name, offset);+ bad_blocks = 1;+ goto bad_txn_handling;+ }++ blhdr = (block_list_header *)buff;++ orig_checksum = blhdr->checksum;+ blhdr->checksum = 0;+ if (jnl->flags & JOURNAL_NEED_SWAP) {+ // calculate the checksum based on the unswapped data+ // because it is done byte-at-a-time.+ orig_checksum = (unsigned int)SWAP32(orig_checksum);+ checksum = calc_checksum((char *)blhdr, BLHDR_CHECKSUM_SIZE);+ swap_block_list_header(jnl, blhdr);+ } else {+ checksum = calc_checksum((char *)blhdr, BLHDR_CHECKSUM_SIZE);+ }+++ //+ // XXXdbg - if these checks fail, we should replay as much+ // we can in the hopes that it will still leave the+ // drive in a better state than if we didn't replay+ // anything+ //+ if (checksum != orig_checksum) {+ if (check_past_jnl_end && in_uncharted_territory) {++ if (blhdr_offset != jnl->jhdr->end) {+ printf("jnl: %s: Extra txn replay stopped @ %lld / 0x%llx\n", jnl->jdev_name, blhdr_offset, blhdr_offset);+ }++ check_past_jnl_end = 0;+ jnl->jhdr->end = blhdr_offset;+ continue;+ }++ printf("jnl: %s: replay_journal: bad block list header @ 0x%llx (checksum 0x%x != 0x%x)\n",+ jnl->jdev_name, blhdr_offset, orig_checksum, checksum);++ if (blhdr_offset == orig_jnl_start) {+ // if there's nothing in the journal at all, just bail out altogether.+ goto bad_replay;+ }++ bad_blocks = 1;+ goto bad_txn_handling;+ }++ if ( (last_sequence_num != 0)+ && (blhdr->binfo[0].u.bi.b.sequence_num != 0)+ && (blhdr->binfo[0].u.bi.b.sequence_num != last_sequence_num)+ && (blhdr->binfo[0].u.bi.b.sequence_num != last_sequence_num+1)) {++ txn_start_offset = jnl->jhdr->end = blhdr_offset;++ if (check_past_jnl_end) {+ check_past_jnl_end = 0;+ printf("jnl: %s: 2: extra replay stopped @ %lld / 0x%llx (seq %d < %d)\n",+ jnl->jdev_name, blhdr_offset, blhdr_offset, blhdr->binfo[0].u.bi.b.sequence_num, last_sequence_num);+ continue;+ }++ printf("jnl: %s: txn sequence numbers out of order in txn @ %lld / %llx! (%d < %d)\n",+ jnl->jdev_name, blhdr_offset, blhdr_offset, blhdr->binfo[0].u.bi.b.sequence_num, last_sequence_num);+ bad_blocks = 1;+ goto bad_txn_handling;+ }+ last_sequence_num = blhdr->binfo[0].u.bi.b.sequence_num;++ if (blhdr_offset >= jnl->jhdr->end && jnl->jhdr->start <= jnl->jhdr->end) {+ if (last_sequence_num == 0) {+ check_past_jnl_end = 0;+ printf("jnl: %s: pre-sequence-num-enabled txn's - can not go further than end (%lld %lld).\n",+ jnl->jdev_name, jnl->jhdr->start, jnl->jhdr->end);+ if (jnl->jhdr->start != jnl->jhdr->end) {+ jnl->jhdr->start = jnl->jhdr->end;+ }+ continue;+ }+ printf("jnl: %s: examining extra transactions starting @ %lld / 0x%llx\n", jnl->jdev_name, blhdr_offset, blhdr_offset);+ }++ if ( blhdr->max_blocks <= 0 || blhdr->max_blocks > (jnl->jhdr->size/jnl->jhdr->jhdr_size)+ || blhdr->num_blocks <= 0 || blhdr->num_blocks > blhdr->max_blocks) {+ printf("jnl: %s: replay_journal: bad looking journal entry: max: %d num: %d\n",+ jnl->jdev_name, blhdr->max_blocks, blhdr->num_blocks);+ bad_blocks = 1;+ goto bad_txn_handling;+ }++ max_bsize = 0;+ for (i = 1; i < blhdr->num_blocks; i++) {+ if (blhdr->binfo[i].bnum < 0 && blhdr->binfo[i].bnum != (off_t)-1) {+ printf("jnl: %s: replay_journal: bogus block number 0x%llx\n", jnl->jdev_name, blhdr->binfo[i].bnum);+ bad_blocks = 1;+ goto bad_txn_handling;+ }++ if ((size_t)blhdr->binfo[i].u.bi.bsize > max_bsize) {+ max_bsize = blhdr->binfo[i].u.bi.bsize;+ }+ }++ if (blhdr->flags & BLHDR_CHECK_CHECKSUMS) {+ check_block_checksums = 1;+ block_ptr = hfs_malloc_data(max_bsize);+ } else {+ block_ptr = NULL;+ }++ if (blhdr->flags & BLHDR_FIRST_HEADER) {+ txn_start_offset = blhdr_offset;+ }++ //printf("jnl: replay_journal: adding %d blocks in journal entry @ 0x%llx to co_buf\n",+ // blhdr->num_blocks-1, jnl->jhdr->start);+ bad_blocks = 0;+ for (i = 1; i < blhdr->num_blocks; i++) {+ int size, ret_val;+ off_t number;++ size = blhdr->binfo[i].u.bi.bsize;+ number = blhdr->binfo[i].bnum;++ // don't add "killed" blocks+ if (number == (off_t)-1) {+ //printf("jnl: replay_journal: skipping killed fs block (index %d)\n", i);+ } else {++ if (check_block_checksums) {+ int32_t disk_cksum;+ off_t block_offset;++ block_offset = offset;++ // read the block so we can check the checksum+ ret = read_journal_data(jnl, &block_offset, block_ptr, size);+ if (ret != (size_t)size) {+ printf("jnl: %s: replay_journal: Could not read journal entry data @ offset 0x%llx!\n", jnl->jdev_name, offset);+ bad_blocks = 1;+ goto bad_txn_handling;+ }++ disk_cksum = calc_checksum(block_ptr, size);++ // there is no need to swap the checksum from disk because+ // it got swapped when the blhdr was read in.+ if (blhdr->binfo[i].u.bi.b.cksum != 0 && disk_cksum != blhdr->binfo[i].u.bi.b.cksum) {+ printf("jnl: %s: txn starting at %lld (%lld) @ index %3d bnum %lld (%d) with disk cksum != blhdr cksum (0x%.8x 0x%.8x)\n",+ jnl->jdev_name, txn_start_offset, blhdr_offset, i, number, size, disk_cksum, blhdr->binfo[i].u.bi.b.cksum);+ printf("jnl: 0x%.8x 0x%.8x 0x%.8x 0x%.8x 0x%.8x 0x%.8x 0x%.8x 0x%.8x\n",+ *(int *)&block_ptr[0*sizeof(int)], *(int *)&block_ptr[1*sizeof(int)], *(int *)&block_ptr[2*sizeof(int)], *(int *)&block_ptr[3*sizeof(int)],+ *(int *)&block_ptr[4*sizeof(int)], *(int *)&block_ptr[5*sizeof(int)], *(int *)&block_ptr[6*sizeof(int)], *(int *)&block_ptr[7*sizeof(int)]);++ bad_blocks = 1;+ goto bad_txn_handling;+ }+ }+++ // add this bucket to co_buf, coalescing where possible+ // printf("jnl: replay_journal: adding block 0x%llx\n", number);+ ret_val = add_block(jnl, &co_buf, number, size, (size_t) offset, blhdr->binfo[i].u.bi.b.cksum, &num_buckets, &num_full);++ if (ret_val == -1) {+ printf("jnl: %s: replay_journal: trouble adding block to co_buf\n", jnl->jdev_name);+ goto bad_replay;+ } // else printf("jnl: replay_journal: added block 0x%llx at i=%d\n", number);+ }++ // increment offset+ offset += size;++ // check if the last block added puts us off the end of the jnl.+ // if so, we need to wrap to the beginning and take any remainder+ // into account+ //+ if (offset >= jnl->jhdr->size) {+ offset = jnl->jhdr->jhdr_size + (offset - jnl->jhdr->size);+ }+ }++ if (block_ptr) {+ hfs_free_data(block_ptr, max_bsize);+ block_ptr = NULL;+ }++ if (bad_blocks) {+ bad_txn_handling:+ /* Journal replay got error before it found any valid+ * transations, abort replay */+ if (txn_start_offset == 0) {+ printf("jnl: %s: no known good txn start offset! aborting journal replay.\n", jnl->jdev_name);+ goto bad_replay;+ }++ /* Repeated error during journal replay, abort replay */+ if (replay_retry_count == 3) {+ printf("jnl: %s: repeated errors replaying journal! aborting journal replay.\n", jnl->jdev_name);+ goto bad_replay;+ }+ replay_retry_count++;++ /* There was an error replaying the journal (possibly+ * EIO/ENXIO from the device). So retry replaying all+ * the good transactions that we found before getting+ * the error.+ */+ jnl->jhdr->start = orig_jnl_start;+ jnl->jhdr->end = txn_start_offset;+ check_past_jnl_end = 0;+ last_sequence_num = 0;+ printf("jnl: %s: restarting journal replay (%lld - %lld)!\n", jnl->jdev_name, jnl->jhdr->start, jnl->jhdr->end);+ goto restart_replay;+ }++ jnl->jhdr->start += blhdr->bytes_used;+ if (jnl->jhdr->start >= jnl->jhdr->size) {+ // wrap around and skip the journal header block+ jnl->jhdr->start = (jnl->jhdr->start % jnl->jhdr->size) + jnl->jhdr->jhdr_size;+ }++ if (jnl->jhdr->start == jnl->jhdr->end) {+ in_uncharted_territory = 1;+ }+ }++ if (jnl->jhdr->start != jnl->jhdr->end) {+ printf("jnl: %s: start %lld != end %lld. resetting end.\n", jnl->jdev_name, jnl->jhdr->start, jnl->jhdr->end);+ jnl->jhdr->end = jnl->jhdr->start;+ }++ //printf("jnl: replay_journal: replaying %d blocks\n", num_full);++ /*+ * make sure it's at least one page in size, so+ * start max_bsize at PAGE_SIZE+ */+ for (i = 0, max_bsize = PAGE_SIZE; i < num_full; i++) {++ if (co_buf[i].block_num == (off_t)-1)+ continue;++ if (co_buf[i].block_size > max_bsize)+ max_bsize = co_buf[i].block_size;+ }+ /*+ * round max_bsize up to the nearest PAGE_SIZE multiple+ */+ if (max_bsize & (PAGE_SIZE - 1)) {+ max_bsize = (max_bsize + PAGE_SIZE) & ~(PAGE_SIZE - 1);+ }++ block_ptr = hfs_malloc_data(max_bsize);++ // Replay the coalesced entries in the co-buf+ for(i = 0; i < num_full; i++) {+ size_t size = co_buf[i].block_size;+ off_t jnl_offset = (off_t) co_buf[i].jnl_offset;+ off_t number = co_buf[i].block_num;+++ // printf("replaying co_buf[%d]: block 0x%llx, size 0x%x, jnl_offset 0x%llx\n", i, co_buf[i].block_num,+ // co_buf[i].block_size, co_buf[i].jnl_offset);++ if (number == (off_t)-1) {+ // printf("jnl: replay_journal: skipping killed fs block\n");+ } else {++ // do journal read, and set the phys. block+ ret = read_journal_data(jnl, &jnl_offset, block_ptr, size);+ if (ret != size) {+ printf("jnl: %s: replay_journal: Could not read journal entry data @ offset 0x%llx!\n", jnl->jdev_name, jnl_offset);+ goto bad_replay;+ }++ if (update_fs_block(jnl, block_ptr, number, size) != 0) {+ goto bad_replay;+ }+ }+ }+++ // done replaying; update jnl header+ if (write_journal_header(jnl, 1, jnl->jhdr->sequence_num) != 0) {+ goto bad_replay;+ }++ printf("jnl: %s: journal replay done.\n", jnl->jdev_name);++ // free block_ptr+ if (block_ptr) {+ hfs_free_data(block_ptr, max_bsize);+ block_ptr = NULL;+ }++ // free the coalesce buffer+ hfs_delete_data(co_buf, struct bucket, num_buckets);+ co_buf = NULL;++ blhdr = (block_list_header *)buff;+ hfs_delete_with_hdr(blhdr, block_list_header, block_info, journal_max_blocks(jnl));+ return 0;++bad_replay:+ if (block_ptr) {+ hfs_free_data(block_ptr, max_bsize);+ }+ hfs_delete_data(co_buf, struct bucket, num_buckets);++ blhdr = (block_list_header *)buff;+ hfs_delete_with_hdr(blhdr, block_list_header, block_info, journal_max_blocks(jnl));++ return -1;+}+++#define DEFAULT_TRANSACTION_BUFFER_SIZE (128*1024)+#define MAX_TRANSACTION_BUFFER_SIZE (3072*1024)++// XXXdbg - so I can change it in the debugger+int def_tbuffer_size = 0;+++//+// This function sets the size of the tbuffer and the+// size of the blhdr. It assumes that jnl->jhdr->size+// and jnl->jhdr->jhdr_size are already valid.+//+static void+size_up_tbuffer(journal *jnl, int tbuffer_size, int phys_blksz)+{+ //+ // one-time initialization based on how much memory+ // there is in the machine.+ //+ if (def_tbuffer_size == 0) {+ uint64_t memsize = 0;+ size_t l = sizeof(memsize);+ sysctlbyname("hw.memsize", &memsize, &l, NULL, 0);++ if (memsize < (256*1024*1024)) {+ def_tbuffer_size = DEFAULT_TRANSACTION_BUFFER_SIZE;+ } else if (memsize < (512*1024*1024)) {+ def_tbuffer_size = DEFAULT_TRANSACTION_BUFFER_SIZE * 2;+ } else if (memsize < (1024*1024*1024)) {+ def_tbuffer_size = DEFAULT_TRANSACTION_BUFFER_SIZE * 3;+ } else {+ def_tbuffer_size = DEFAULT_TRANSACTION_BUFFER_SIZE * (memsize / (256*1024*1024));+ }+ }++ // For analyzer+ hfs_assert(jnl->jhdr->jhdr_size > 0);++ // size up the transaction buffer... can't be larger than the number+ // of blocks that can fit in a block_list_header block.+ if (tbuffer_size == 0) {+ jnl->tbuffer_size = def_tbuffer_size;+ } else {+ // make sure that the specified tbuffer_size isn't too small+ if (tbuffer_size < jnl->jhdr->blhdr_size * 2) {+ tbuffer_size = jnl->jhdr->blhdr_size * 2;+ }+ // and make sure it's an even multiple of the block size+ if ((tbuffer_size % jnl->jhdr->jhdr_size) != 0) {+ tbuffer_size -= (tbuffer_size % jnl->jhdr->jhdr_size);+ }++ jnl->tbuffer_size = tbuffer_size;+ }++ if (jnl->tbuffer_size > (jnl->jhdr->size / 2)) {+ jnl->tbuffer_size = (jnl->jhdr->size / 2);+ }++ if (jnl->tbuffer_size > MAX_TRANSACTION_BUFFER_SIZE) {+ jnl->tbuffer_size = MAX_TRANSACTION_BUFFER_SIZE;+ }++ jnl->jhdr->blhdr_size = (jnl->tbuffer_size / jnl->jhdr->jhdr_size) * sizeof(block_info);+ if (jnl->jhdr->blhdr_size < phys_blksz) {+ jnl->jhdr->blhdr_size = phys_blksz;+ } else if ((jnl->jhdr->blhdr_size % phys_blksz) != 0) {+ // have to round up so we're an even multiple of the physical block size+ jnl->jhdr->blhdr_size = (jnl->jhdr->blhdr_size + (phys_blksz - 1)) & ~(phys_blksz - 1);+ }+}++static void+get_io_info(struct vnode *devvp, size_t phys_blksz, journal *jnl, struct vfs_context *context)+{+ off_t readblockcnt;+ off_t writeblockcnt;+ off_t readmaxcnt=0, tmp_readmaxcnt;+ off_t writemaxcnt=0, tmp_writemaxcnt;+ off_t readsegcnt, writesegcnt;+ int32_t features;++ if (VNOP_IOCTL(devvp, DKIOCGETFEATURES, (caddr_t)&features, 0, context) == 0) {+ if (features & DK_FEATURE_FORCE_UNIT_ACCESS) {+ const char *name = vnode_getname_printable(devvp);+ jnl->flags |= JOURNAL_DO_FUA_WRITES;+ printf("jnl: %s: enabling FUA writes (features 0x%x)\n", name, features);+ vnode_putname_printable(name);+ }+ if (features & DK_FEATURE_UNMAP) {+ jnl->flags |= JOURNAL_USE_UNMAP;+ }++ if (features & DK_FEATURE_BARRIER) {+ jnl->flags |= JOURNAL_FEATURE_BARRIER;+ }+ }++ //+ // First check the max read size via several different mechanisms...+ //+ VNOP_IOCTL(devvp, DKIOCGETMAXBYTECOUNTREAD, (caddr_t)&readmaxcnt, 0, context);++ if (VNOP_IOCTL(devvp, DKIOCGETMAXBLOCKCOUNTREAD, (caddr_t)&readblockcnt, 0, context) == 0) {+ tmp_readmaxcnt = readblockcnt * phys_blksz;+ if (readmaxcnt == 0 || (readblockcnt > 0 && tmp_readmaxcnt < readmaxcnt)) {+ readmaxcnt = tmp_readmaxcnt;+ }+ }++ if (VNOP_IOCTL(devvp, DKIOCGETMAXSEGMENTCOUNTREAD, (caddr_t)&readsegcnt, 0, context)) {+ readsegcnt = 0;+ }++ if (readsegcnt > 0 && (readsegcnt * PAGE_SIZE) < readmaxcnt) {+ readmaxcnt = readsegcnt * PAGE_SIZE;+ }++ if (readmaxcnt == 0) {+ readmaxcnt = 128 * 1024;+ } else if (readmaxcnt > UINT32_MAX) {+ readmaxcnt = UINT32_MAX;+ }+++ //+ // Now check the max writes size via several different mechanisms...+ //+ VNOP_IOCTL(devvp, DKIOCGETMAXBYTECOUNTWRITE, (caddr_t)&writemaxcnt, 0, context);++ if (VNOP_IOCTL(devvp, DKIOCGETMAXBLOCKCOUNTWRITE, (caddr_t)&writeblockcnt, 0, context) == 0) {+ tmp_writemaxcnt = writeblockcnt * phys_blksz;+ if (writemaxcnt == 0 || (writeblockcnt > 0 && tmp_writemaxcnt < writemaxcnt)) {+ writemaxcnt = tmp_writemaxcnt;+ }+ }++ if (VNOP_IOCTL(devvp, DKIOCGETMAXSEGMENTCOUNTWRITE, (caddr_t)&writesegcnt, 0, context)) {+ writesegcnt = 0;+ }++ if (writesegcnt > 0 && (writesegcnt * PAGE_SIZE) < writemaxcnt) {+ writemaxcnt = writesegcnt * PAGE_SIZE;+ }++ if (writemaxcnt == 0) {+ writemaxcnt = 128 * 1024;+ } else if (writemaxcnt > UINT32_MAX) {+ writemaxcnt = UINT32_MAX;+ }++ jnl->max_read_size = readmaxcnt;+ jnl->max_write_size = writemaxcnt;+ // printf("jnl: %s: max read/write: %lld k / %lld k\n",+ // jnl->jdev_name ? jnl->jdev_name : "unknown",+ // jnl->max_read_size/1024, jnl->max_write_size/1024);+}+++journal *+journal_create(struct vnode *jvp,+ off_t offset,+ off_t journal_size,+ struct vnode *fsvp,+ size_t min_fs_blksz,+ int32_t flags,+ int32_t tbuffer_size,+ void (*flush)(void *arg),+ void *arg,+ struct mount *fsmount)+{+ journal *jnl;+ uint32_t phys_blksz, new_txn_base;+ u_int32_t min_size;+ const char *jdev_name;+ /*+ * Cap the journal max size to 2GB. On HFS, it will attempt to occupy+ * a full allocation block if the current size is smaller than the allocation+ * block on which it resides. Once we hit the exabyte filesystem range, then+ * it will use 2GB allocation blocks. As a result, make the cap 2GB.+ */++ jdev_name = vnode_getname_printable(jvp);++ /* Get the real physical block size. */+ if (VNOP_IOCTL(jvp, DKIOCGETBLOCKSIZE, (caddr_t)&phys_blksz, 0, vfs_context_kernel())) {+ goto cleanup_jdev_name;+ }++ if (journal_size < (256*1024) || journal_size > (MAX_JOURNAL_SIZE)) {+ printf("jnl: %s: create: journal size %lld looks bogus.\n", jdev_name, journal_size);+ goto cleanup_jdev_name;+ }++ min_size = phys_blksz * (phys_blksz / sizeof(block_info));+ /* Reject journals that are too small given the sector size of the device */+ if (journal_size < min_size) {+ printf("jnl: %s: create: journal size (%lld) too small given sector size of (%u)\n",+ jdev_name, journal_size, phys_blksz);+ goto cleanup_jdev_name;+ }++ if (phys_blksz > min_fs_blksz) {+ printf("jnl: %s: create: error: phys blksize %u bigger than min fs blksize %zd\n",+ jdev_name, phys_blksz, min_fs_blksz);+ goto cleanup_jdev_name;+ }++ if ((journal_size % phys_blksz) != 0) {+ printf("jnl: %s: create: journal size 0x%llx is not an even multiple of block size 0x%ux\n",+ jdev_name, journal_size, phys_blksz);+ goto cleanup_jdev_name;+ }+++ jnl = hfs_malloc_type(struct journal);++ jnl->jdev = jvp;+ jnl->jdev_offset = offset;+ jnl->fsdev = fsvp;+ jnl->flush = flush;+ jnl->flush_arg = arg;+ jnl->flags = (flags & JOURNAL_OPTION_FLAGS_MASK);+ jnl->jdev_name = jdev_name;+ lck_mtx_init(&jnl->old_start_lock, jnl_mutex_group, jnl_lock_attr);++ // Keep a point to the mount around for use in IO throttling.+ jnl->fsmount = fsmount;++ get_io_info(jvp, phys_blksz, jnl, vfs_context_kernel());++ jnl->header_buf = hfs_malloc_data(phys_blksz);+ jnl->header_buf_size = phys_blksz;++ jnl->jhdr = (journal_header *)jnl->header_buf;+ memset(jnl->jhdr, 0, sizeof(journal_header));++ // we have to set this up here so that do_journal_io() will work+ jnl->jhdr->jhdr_size = phys_blksz;++ //+ // We try and read the journal header to see if there is already one+ // out there. If there is, it's possible that it has transactions+ // in it that we might replay if we happen to pick a sequence number+ // that is a little less than the old one, there is a crash and the+ // last txn written ends right at the start of a txn from the previous+ // incarnation of this file system. If all that happens we would+ // replay the transactions from the old file system and that would+ // destroy your disk. Although it is extremely unlikely for all those+ // conditions to happen, the probability is non-zero and the result is+ // severe - you lose your file system. Therefore if we find a valid+ // journal header and the sequence number is non-zero we write junk+ // over the entire journal so that there is no way we will encounter+ // any old transactions. This is slow but should be a rare event+ // since most tools erase the journal.+ //+ if ( read_journal_header(jnl, jnl->jhdr, phys_blksz) == phys_blksz+ && jnl->jhdr->magic == JOURNAL_HEADER_MAGIC+ && jnl->jhdr->sequence_num != 0) {++ new_txn_base = (jnl->jhdr->sequence_num + (journal_size / phys_blksz) + (random() % 16384)) & 0x00ffffff;+ printf("jnl: %s: create: avoiding old sequence number 0x%x (0x%x)\n", jdev_name, jnl->jhdr->sequence_num, new_txn_base);++#if 0+ int i;+ off_t pos=0;++ for(i = 1; i < journal_size / phys_blksz; i++) {+ pos = i*phys_blksz;++ // we don't really care what data we write just so long+ // as it's not a valid transaction header. since we have+ // the header_buf sitting around we'll use that.+ write_journal_data(jnl, &pos, jnl->header_buf, phys_blksz);+ }+ printf("jnl: create: done clearing journal (i=%d)\n", i);+#endif+ } else {+ new_txn_base = random() & 0x00ffffff;+ }++ memset(jnl->header_buf, 0, phys_blksz);++ jnl->jhdr->magic = JOURNAL_HEADER_MAGIC;+ jnl->jhdr->endian = ENDIAN_MAGIC;+ jnl->jhdr->start = phys_blksz; // start at block #1, block #0 is for the jhdr itself+ jnl->jhdr->end = phys_blksz;+ jnl->jhdr->size = journal_size;+ jnl->jhdr->jhdr_size = phys_blksz;+ size_up_tbuffer(jnl, tbuffer_size, phys_blksz);++ jnl->active_start = jnl->jhdr->start;++ // XXXdbg - for testing you can force the journal to wrap around+ // jnl->jhdr->start = jnl->jhdr->size - (phys_blksz*3);+ // jnl->jhdr->end = jnl->jhdr->size - (phys_blksz*3);++ jnl->jhdr->sequence_num = new_txn_base;++ lck_mtx_init(&jnl->jlock, jnl_mutex_group, jnl_lock_attr);+ lck_mtx_init(&jnl->flock, jnl_mutex_group, jnl_lock_attr);+ lck_rw_init(&jnl->trim_lock, jnl_mutex_group, jnl_lock_attr);+++ jnl->flushing = FALSE;+ jnl->asyncIO = FALSE;+ jnl->flush_aborted = FALSE;+ jnl->writing_header = FALSE;+ jnl->async_trim = NULL;+ jnl->sequence_num = jnl->jhdr->sequence_num;++ if (write_journal_header(jnl, 1, jnl->jhdr->sequence_num) != 0) {+ printf("jnl: %s: journal_create: failed to write journal header.\n", jdev_name);+ goto bad_write;+ }++ goto journal_create_complete;+++bad_write:+ hfs_free_data(jnl->header_buf, phys_blksz);+ jnl->jhdr = NULL;+ hfs_free_type(jnl, struct journal);+cleanup_jdev_name:+ vnode_putname_printable(jdev_name);+ jnl = NULL;+journal_create_complete:+ return jnl;+}+++journal *+journal_open(struct vnode *jvp,+ off_t offset,+ off_t journal_size,+ struct vnode *fsvp,+ size_t min_fs_blksz,+ int32_t flags,+ int32_t tbuffer_size,+ void (*flush)(void *arg),+ void *arg,+ struct mount *fsmount)+{+ journal *jnl;+ uint32_t orig_blksz=0;+ uint32_t phys_blksz;+ u_int32_t min_size = 0;+ int orig_checksum, checksum;+ const char *jdev_name = vnode_getname_printable(jvp);++ /* Get the real physical block size. */+ if (VNOP_IOCTL(jvp, DKIOCGETBLOCKSIZE, (caddr_t)&phys_blksz, 0, vfs_context_kernel())) {+ goto cleanup_jdev_name;+ }++ if (phys_blksz > min_fs_blksz) {+ printf("jnl: %s: open: error: phys blksize %u bigger than min fs blksize %zd\n",+ jdev_name, phys_blksz, min_fs_blksz);+ goto cleanup_jdev_name;+ }++ if (journal_size < (256*1024) || journal_size > (1024*1024*1024)) {+ printf("jnl: %s: open: journal size %lld looks bogus.\n", jdev_name, journal_size);+ goto cleanup_jdev_name;+ }++ min_size = phys_blksz * (phys_blksz / sizeof(block_info));+ /* Reject journals that are too small given the sector size of the device */+ if (journal_size < min_size) {+ printf("jnl: %s: open: journal size (%lld) too small given sector size of (%u)\n",+ jdev_name, journal_size, phys_blksz);+ goto cleanup_jdev_name;+ }++ if ((journal_size % phys_blksz) != 0) {+ printf("jnl: %s: open: journal size 0x%llx is not an even multiple of block size 0x%x\n",+ jdev_name, journal_size, phys_blksz);+ goto cleanup_jdev_name;+ }++ jnl = hfs_malloc_type(struct journal);++ jnl->jdev = jvp;+ jnl->jdev_offset = offset;+ jnl->fsdev = fsvp;+ jnl->flush = flush;+ jnl->flush_arg = arg;+ jnl->flags = (flags & JOURNAL_OPTION_FLAGS_MASK);+ jnl->jdev_name = jdev_name;+ lck_mtx_init(&jnl->old_start_lock, jnl_mutex_group, jnl_lock_attr);++ /* We hold the mount to later pass to the throttling code for IO+ * accounting.+ */+ jnl->fsmount = fsmount;++ get_io_info(jvp, phys_blksz, jnl, vfs_context_kernel());++ jnl->header_buf = hfs_malloc_data(phys_blksz);+ jnl->header_buf_size = phys_blksz;++ jnl->jhdr = (journal_header *)jnl->header_buf;+ memset(jnl->jhdr, 0, sizeof(journal_header));++ // we have to set this up here so that do_journal_io() will work+ jnl->jhdr->jhdr_size = phys_blksz;++ if (read_journal_header(jnl, jnl->jhdr, phys_blksz) != phys_blksz) {+ printf("jnl: %s: open: could not read %u bytes for the journal header.\n",+ jdev_name, phys_blksz);+ goto bad_journal;+ }++ /*+ * Check for a bad jhdr size after reading in the journal header.+ * The journal header length cannot be zero+ */+ if (jnl->jhdr->jhdr_size == 0) {+ printf("jnl: %s: open: bad jhdr size (%d) \n", jdev_name, jnl->jhdr->jhdr_size);+ goto bad_journal;+ }++ orig_checksum = jnl->jhdr->checksum;+ jnl->jhdr->checksum = 0;++ if (jnl->jhdr->magic == SWAP32(JOURNAL_HEADER_MAGIC)) {+ // do this before the swap since it's done byte-at-a-time+ orig_checksum = SWAP32(orig_checksum);+ checksum = calc_checksum((char *)jnl->jhdr, JOURNAL_HEADER_CKSUM_SIZE);+ swap_journal_header(jnl);+ jnl->flags |= JOURNAL_NEED_SWAP;+ } else {+ checksum = calc_checksum((char *)jnl->jhdr, JOURNAL_HEADER_CKSUM_SIZE);+ }++ if (jnl->jhdr->magic != JOURNAL_HEADER_MAGIC && jnl->jhdr->magic != OLD_JOURNAL_HEADER_MAGIC) {+ printf("jnl: %s: open: journal magic is bad (0x%x != 0x%x)\n",+ jnl->jdev_name, jnl->jhdr->magic, JOURNAL_HEADER_MAGIC);+ goto bad_journal;+ }++ // only check if we're the current journal header magic value+ if (jnl->jhdr->magic == JOURNAL_HEADER_MAGIC) {++ if (orig_checksum != checksum) {+ printf("jnl: %s: open: journal checksum is bad (0x%x != 0x%x)\n",+ jdev_name, orig_checksum, checksum);++ //goto bad_journal;+ }+ }++ // XXXdbg - convert old style magic numbers to the new one+ if (jnl->jhdr->magic == OLD_JOURNAL_HEADER_MAGIC) {+ jnl->jhdr->magic = JOURNAL_HEADER_MAGIC;+ }++ if (phys_blksz != (size_t)jnl->jhdr->jhdr_size && jnl->jhdr->jhdr_size != 0) {+ /*+ * The volume has probably been resized (such that we had to adjust the+ * logical sector size), or copied to media with a different logical+ * sector size.+ *+ * Temporarily change the device's logical block size to match the+ * journal's header size. This will allow us to replay the journal+ * safely. If the replay succeeds, we will update the journal's header+ * size (later in this function).+ */+ orig_blksz = phys_blksz;+ phys_blksz = jnl->jhdr->jhdr_size;+ VNOP_IOCTL(jvp, DKIOCSETBLOCKSIZE, (caddr_t)&phys_blksz, FWRITE, vfs_context_kernel());+ printf("jnl: %s: open: temporarily switched block size from %u to %u\n",+ jdev_name, orig_blksz, phys_blksz);+ }++ if ( jnl->jhdr->start <= 0+ || jnl->jhdr->start > jnl->jhdr->size+ || jnl->jhdr->start > 1024*1024*1024) {+ printf("jnl: %s: open: jhdr start looks bad (0x%llx max size 0x%llx)\n",+ jdev_name, jnl->jhdr->start, jnl->jhdr->size);+ goto bad_journal;+ }++ if ( jnl->jhdr->end <= 0+ || jnl->jhdr->end > jnl->jhdr->size+ || jnl->jhdr->end > 1024*1024*1024) {+ printf("jnl: %s: open: jhdr end looks bad (0x%llx max size 0x%llx)\n",+ jdev_name, jnl->jhdr->end, jnl->jhdr->size);+ goto bad_journal;+ }++ if (jnl->jhdr->size < (256*1024) || jnl->jhdr->size > 1024*1024*1024) {+ printf("jnl: %s: open: jhdr size looks bad (0x%llx)\n", jdev_name, jnl->jhdr->size);+ goto bad_journal;+ }++// XXXdbg - can't do these checks because hfs writes all kinds of+// non-uniform sized blocks even on devices that have a block size+// that is larger than 512 bytes (i.e. optical media w/2k blocks).+// therefore these checks will fail and so we just have to punt and+// do more relaxed checking...+// XXXdbg if ((jnl->jhdr->start % jnl->jhdr->jhdr_size) != 0) {+ if ((jnl->jhdr->start % 512) != 0) {+ printf("jnl: %s: open: journal start (0x%llx) not a multiple of 512?\n",+ jdev_name, jnl->jhdr->start);+ goto bad_journal;+ }++//XXXdbg if ((jnl->jhdr->end % jnl->jhdr->jhdr_size) != 0) {+ if ((jnl->jhdr->end % 512) != 0) {+ printf("jnl: %s: open: journal end (0x%llx) not a multiple of block size (0x%x)?\n",+ jdev_name, jnl->jhdr->end, jnl->jhdr->jhdr_size);+ goto bad_journal;+ }++ if (jnl->jhdr->blhdr_size < 0) {+ //throw out invalid sizes+ printf("jnl %s: open: blhdr size looks bogus! (%d) \n",+ jdev_name, jnl->jhdr->blhdr_size);+ goto bad_journal;+ }++ // take care of replaying the journal if necessary+ if (flags & JOURNAL_RESET) {+ printf("jnl: %s: journal start/end pointers reset! (s 0x%llx e 0x%llx)\n",+ jdev_name, jnl->jhdr->start, jnl->jhdr->end);+ jnl->jhdr->start = jnl->jhdr->end;+ } else if (replay_journal(jnl) != 0) {+ printf("jnl: %s: journal_open: Error replaying the journal!\n", jdev_name);+ goto bad_journal;+ }++ /*+ * When we get here, we know that the journal is empty (jnl->jhdr->start ==+ * jnl->jhdr->end). If the device's logical block size was different from+ * the journal's header size, then we can now restore the device's logical+ * block size and update the journal's header size to match.+ *+ * Note that we also adjust the journal's start and end so that they will+ * be aligned on the new block size. We pick a new sequence number to+ * avoid any problems if a replay found previous transactions using the old+ * journal header size. (See the comments in journal_create(), above.)+ */++ if (orig_blksz != 0) {+ VNOP_IOCTL(jvp, DKIOCSETBLOCKSIZE, (caddr_t)&orig_blksz, FWRITE, vfs_context_kernel());+ phys_blksz = orig_blksz;++ orig_blksz = 0;++ jnl->jhdr->jhdr_size = phys_blksz;+ jnl->jhdr->start = phys_blksz;+ jnl->jhdr->end = phys_blksz;+ jnl->jhdr->sequence_num = (jnl->jhdr->sequence_num ++ (journal_size / phys_blksz) ++ (random() % 16384)) & 0x00ffffff;++ if (write_journal_header(jnl, 1, jnl->jhdr->sequence_num)) {+ printf("jnl: %s: open: failed to update journal header size\n", jdev_name);+ goto bad_journal;+ }+ }++ // make sure this is in sync!+ jnl->active_start = jnl->jhdr->start;+ jnl->sequence_num = jnl->jhdr->sequence_num;++ // set this now, after we've replayed the journal+ size_up_tbuffer(jnl, tbuffer_size, phys_blksz);++ // TODO: Does this need to change if the device's logical block size changed?+ if ((off_t)(jnl->jhdr->blhdr_size/sizeof(block_info)-1) > (jnl->jhdr->size/jnl->jhdr->jhdr_size)) {+ printf("jnl: %s: open: jhdr size and blhdr size are not compatible (0x%llx, %d, %d)\n", jdev_name, jnl->jhdr->size,+ jnl->jhdr->blhdr_size, jnl->jhdr->jhdr_size);+ goto bad_journal;+ }++ lck_mtx_init(&jnl->jlock, jnl_mutex_group, jnl_lock_attr);+ lck_mtx_init(&jnl->flock, jnl_mutex_group, jnl_lock_attr);+ lck_rw_init(&jnl->trim_lock, jnl_mutex_group, jnl_lock_attr);++ goto journal_open_complete;++bad_journal:+ if (orig_blksz != 0) {+ phys_blksz = orig_blksz;+ VNOP_IOCTL(jvp, DKIOCSETBLOCKSIZE, (caddr_t)&orig_blksz, FWRITE, vfs_context_kernel());+ printf("jnl: %s: open: restored block size after error\n", jdev_name);+ }+ hfs_free_data(jnl->header_buf, jnl->header_buf_size);+ hfs_free_type(jnl, struct journal);+cleanup_jdev_name:+ vnode_putname_printable(jdev_name);+ jnl = NULL;+journal_open_complete:+ return jnl;+}+++int+journal_is_clean(struct vnode *jvp,+ off_t offset,+ off_t journal_size,+ struct vnode *fsvp,+ size_t min_fs_block_size)+{+ journal jnl;+ uint32_t phys_blksz;+ int ret;+ int orig_checksum, checksum;+ const char *jdev_name = vnode_getname_printable(jvp);++ /* Get the real physical block size. */+ if (VNOP_IOCTL(jvp, DKIOCGETBLOCKSIZE, (caddr_t)&phys_blksz, 0, vfs_context_kernel())) {+ printf("jnl: %s: is_clean: failed to get device block size.\n", jdev_name);+ ret = EINVAL;+ goto cleanup_jdev_name;+ }++ if (phys_blksz > (uint32_t)min_fs_block_size) {+ printf("jnl: %s: is_clean: error: phys blksize %d bigger than min fs blksize %zd\n",+ jdev_name, phys_blksz, min_fs_block_size);+ ret = EINVAL;+ goto cleanup_jdev_name;+ }++ if (journal_size < (256*1024) || journal_size > (MAX_JOURNAL_SIZE)) {+ printf("jnl: %s: is_clean: journal size %lld looks bogus.\n", jdev_name, journal_size);+ ret = EINVAL;+ goto cleanup_jdev_name;+ }++ if ((journal_size % phys_blksz) != 0) {+ printf("jnl: %s: is_clean: journal size 0x%llx is not an even multiple of block size 0x%x\n",+ jdev_name, journal_size, phys_blksz);+ ret = EINVAL;+ goto cleanup_jdev_name;+ }++ memset(&jnl, 0, sizeof(jnl));++ jnl.header_buf = hfs_malloc_data(phys_blksz);+ jnl.header_buf_size = phys_blksz;++ get_io_info(jvp, phys_blksz, &jnl, vfs_context_kernel());++ jnl.jhdr = (journal_header *)jnl.header_buf;+ memset(jnl.jhdr, 0, sizeof(journal_header));++ jnl.jdev = jvp;+ jnl.jdev_offset = offset;+ jnl.fsdev = fsvp;++ // we have to set this up here so that do_journal_io() will work+ jnl.jhdr->jhdr_size = phys_blksz;++ if (read_journal_header(&jnl, jnl.jhdr, phys_blksz) != (unsigned)phys_blksz) {+ printf("jnl: %s: is_clean: could not read %d bytes for the journal header.\n",+ jdev_name, phys_blksz);+ ret = EINVAL;+ goto get_out;+ }++ orig_checksum = jnl.jhdr->checksum;+ jnl.jhdr->checksum = 0;++ if (jnl.jhdr->magic == SWAP32(JOURNAL_HEADER_MAGIC)) {+ // do this before the swap since it's done byte-at-a-time+ orig_checksum = SWAP32(orig_checksum);+ checksum = calc_checksum((char *)jnl.jhdr, JOURNAL_HEADER_CKSUM_SIZE);+ swap_journal_header(&jnl);+ jnl.flags |= JOURNAL_NEED_SWAP;+ } else {+ checksum = calc_checksum((char *)jnl.jhdr, JOURNAL_HEADER_CKSUM_SIZE);+ }++ if (jnl.jhdr->magic != JOURNAL_HEADER_MAGIC && jnl.jhdr->magic != OLD_JOURNAL_HEADER_MAGIC) {+ printf("jnl: %s: is_clean: journal magic is bad (0x%x != 0x%x)\n",+ jdev_name, jnl.jhdr->magic, JOURNAL_HEADER_MAGIC);+ ret = EINVAL;+ goto get_out;+ }++ if (orig_checksum != checksum) {+ printf("jnl: %s: is_clean: journal checksum is bad (0x%x != 0x%x)\n", jdev_name, orig_checksum, checksum);+ ret = EINVAL;+ goto get_out;+ }++ //+ // if the start and end are equal then the journal is clean.+ // otherwise it's not clean and therefore an error.+ //+ if (jnl.jhdr->start == jnl.jhdr->end) {+ ret = 0;+ } else {+ ret = EBUSY; // so the caller can differentiate an invalid journal from a "busy" one+ }++get_out:+ hfs_free_data(jnl.header_buf, jnl.header_buf_size);+cleanup_jdev_name:+ vnode_putname_printable(jdev_name);+ return ret;+}+++void+journal_close(journal *jnl)+{+ volatile off_t *start, *end;+ int counter=0;++ CHECK_JOURNAL(jnl);++ // set this before doing anything that would block so that+ // we start tearing things down properly.+ //+ jnl->flags |= JOURNAL_CLOSE_PENDING;++ if (jnl->owner != current_thread()) {+ journal_lock(jnl);+ }++ wait_condition(jnl, &jnl->flushing, "journal_close");++ //+ // only write stuff to disk if the journal is still valid+ //+ if ((jnl->flags & JOURNAL_INVALID) == 0) {++ if (jnl->active_tr) {+ /*+ * "journal_end_transaction" will fire the flush asynchronously+ */+ journal_end_transaction(jnl);+ }++ // flush any buffered transactions+ if (jnl->cur_tr) {+ transaction *tr = jnl->cur_tr;++ jnl->cur_tr = NULL;+ /*+ * "end_transaction" will wait for any in-progress flush to complete+ * before flushing "cur_tr" synchronously("must_wait" == TRUE)+ */+ end_transaction(tr, 1, NULL, NULL, FALSE, TRUE);+ }+ /*+ * if there was an "active_tr", make sure we wait for+ * it to flush if there was no "cur_tr" to process+ */+ wait_condition(jnl, &jnl->flushing, "journal_close");++ //start = &jnl->jhdr->start;+ start = &jnl->active_start;+ end = &jnl->jhdr->end;++ while (*start != *end && counter++ < 5000) {+ //printf("jnl: close: flushing the buffer cache (start 0x%llx end 0x%llx)\n", *start, *end);+ if (jnl->flush) {+ jnl->flush(jnl->flush_arg);+ }+ tsleep((caddr_t)jnl, PRIBIO, "jnl_close", 2);+ }++ if (*start != *end) {+ printf("jnl: %s: close: buffer flushing didn't seem to flush out all the transactions! (0x%llx - 0x%llx)\n",+ jnl->jdev_name, *start, *end);+ }++ // make sure this is in sync when we close the journal+ jnl->jhdr->start = jnl->active_start;++ // if this fails there's not much we can do at this point...+ write_journal_header(jnl, 1, jnl->sequence_num);+ } else {+ // if we're here the journal isn't valid any more.+ // so make sure we don't leave any locked blocks lying around+ printf("jnl: %s: close: journal is invalid. aborting outstanding transactions\n", jnl->jdev_name);+ if (jnl->active_tr || jnl->cur_tr) {+ transaction *tr;++ if (jnl->active_tr) {+ tr = jnl->active_tr;+ jnl->active_tr = NULL;+ } else {+ tr = jnl->cur_tr;+ jnl->cur_tr = NULL;+ }+ abort_transaction(jnl, tr);++ if (jnl->active_tr || jnl->cur_tr) {+ panic("jnl: %s: close: jnl @ %p had both an active and cur tr\n", jnl->jdev_name, jnl);+ }+ }+ }+ wait_condition(jnl, &jnl->asyncIO, "journal_close");++ free_old_stuff(jnl);++ hfs_free_data(jnl->header_buf, jnl->header_buf_size);+ jnl->jhdr = (void *)0xbeefbabe;++ vnode_putname_printable(jnl->jdev_name);++ journal_unlock(jnl);+ lck_mtx_destroy(&jnl->old_start_lock, jnl_mutex_group);+ lck_mtx_destroy(&jnl->jlock, jnl_mutex_group);+ lck_mtx_destroy(&jnl->flock, jnl_mutex_group);+ hfs_free_type(jnl, journal);+}++static void+dump_journal(journal *jnl)+{+ transaction *ctr;++ printf("journal for dev %s:", jnl->jdev_name);+ printf(" jdev_offset %.8llx\n", jnl->jdev_offset);+ printf(" magic: 0x%.8x\n", jnl->jhdr->magic);+ printf(" start: 0x%.8llx\n", jnl->jhdr->start);+ printf(" end: 0x%.8llx\n", jnl->jhdr->end);+ printf(" size: 0x%.8llx\n", jnl->jhdr->size);+ printf(" blhdr size: %d\n", jnl->jhdr->blhdr_size);+ printf(" jhdr size: %d\n", jnl->jhdr->jhdr_size);+ printf(" chksum: 0x%.8x\n", jnl->jhdr->checksum);++ printf(" completed transactions:\n");+ for (ctr = jnl->completed_trs; ctr; ctr = ctr->next) {+ printf(" 0x%.8llx - 0x%.8llx\n", ctr->journal_start, ctr->journal_end);+ }+}++++static off_t+free_space(journal *jnl)+{+ off_t free_space_offset;++ if (jnl->jhdr->start < jnl->jhdr->end) {+ free_space_offset = jnl->jhdr->size - (jnl->jhdr->end - jnl->jhdr->start) - jnl->jhdr->jhdr_size;+ } else if (jnl->jhdr->start > jnl->jhdr->end) {+ free_space_offset = jnl->jhdr->start - jnl->jhdr->end;+ } else {+ // journal is completely empty+ free_space_offset = jnl->jhdr->size - jnl->jhdr->jhdr_size;+ }++ return free_space_offset;+}+++//+// The journal must be locked on entry to this function.+// The "desired_size" is in bytes.+//+static int+check_free_space(journal *jnl, int desired_size, boolean_t *delayed_header_write, uint32_t sequence_num)+{+ size_t i;+ int counter=0;++ //printf("jnl: check free space (desired 0x%x, avail 0x%Lx)\n",+ // desired_size, free_space(jnl));++ if (delayed_header_write)+ *delayed_header_write = FALSE;++ while (1) {+ int old_start_empty;++ // make sure there's space in the journal to hold this transaction+ if (free_space(jnl) > desired_size && jnl->old_start[0] == 0) {+ break;+ }+ if (counter++ == 5000) {+ dump_journal(jnl);+ panic("jnl: check_free_space: buffer flushing isn't working "+ "(jnl @ %p s %lld e %lld f %lld [active start %lld]).\n", jnl,+ jnl->jhdr->start, jnl->jhdr->end, free_space(jnl), jnl->active_start);+ }+ if (counter > 7500) {+ printf("jnl: %s: check_free_space: giving up waiting for free space.\n", jnl->jdev_name);+ return ENOSPC;+ }++ //+ // here's where we lazily bump up jnl->jhdr->start. we'll consume+ // entries until there is enough space for the next transaction.+ //+ old_start_empty = 1;+ lock_oldstart(jnl);++ for (i = 0; i < sizeof(jnl->old_start)/sizeof(jnl->old_start[0]); i++) {+ int lcl_counter;++ lcl_counter = 0;+ while (jnl->old_start[i] & 0x8000000000000000LL) {+ if (lcl_counter++ > 10000) {+ panic("jnl: check_free_space: tr starting @ 0x%llx not flushing (jnl %p).\n",+ jnl->old_start[i], jnl);+ }++ unlock_oldstart(jnl);+ if (jnl->flush) {+ jnl->flush(jnl->flush_arg);+ }+ tsleep((caddr_t)jnl, PRIBIO, "check_free_space1", 1);+ lock_oldstart(jnl);+ }++ if (jnl->old_start[i] == 0) {+ continue;+ }++ old_start_empty = 0;+ jnl->jhdr->start = jnl->old_start[i];+ jnl->old_start[i] = 0;++ if (free_space(jnl) > desired_size) {++ if (delayed_header_write)+ *delayed_header_write = TRUE;+ else {+ unlock_oldstart(jnl);+ write_journal_header(jnl, 1, sequence_num);+ lock_oldstart(jnl);+ }+ break;+ }+ }+ unlock_oldstart(jnl);++ // if we bumped the start, loop and try again+ if (i < sizeof(jnl->old_start)/sizeof(jnl->old_start[0])) {+ continue;+ } else if (old_start_empty) {+ //+ // if there is nothing in old_start anymore then we can+ // bump the jhdr->start to be the same as active_start+ // since it is possible there was only one very large+ // transaction in the old_start array. if we didn't do+ // this then jhdr->start would never get updated and we+ // would wind up looping until we hit the panic at the+ // start of the loop.+ //+ jnl->jhdr->start = jnl->active_start;++ if (delayed_header_write)+ *delayed_header_write = TRUE;+ else+ write_journal_header(jnl, 1, sequence_num);+ continue;+ }+++ // if the file system gave us a flush function, call it to so that+ // it can flush some blocks which hopefully will cause some transactions+ // to complete and thus free up space in the journal.+ if (jnl->flush) {+ jnl->flush(jnl->flush_arg);+ }++ // wait for a while to avoid being cpu-bound (this will+ // put us to sleep for 10 milliseconds)+ tsleep((caddr_t)jnl, PRIBIO, "check_free_space2", 1);+ }++ return 0;+}++/*+ * Allocate a new active transaction.+ */+static errno_t+journal_allocate_transaction(journal *jnl)+{+ transaction *tr;+ boolean_t was_vm_privileged = FALSE;++ if (vfs_isswapmount(jnl->fsmount)) {+ /*+ * the disk driver can allocate memory on this path...+ * if we block waiting for memory, and there is enough pressure to+ * cause us to try and create a new swap file, we may end up deadlocking+ * due to waiting for the journal on the swap file creation path...+ * by making ourselves vm_privileged, we give ourselves the best chance+ * of not blocking+ */+ was_vm_privileged = set_vm_privilege(TRUE);+ }+ tr = hfs_malloc_type(transaction);++ tr->tbuffer_size = jnl->tbuffer_size;++ block_list_header_in_memory* blhdrim = hfs_new_with_hdr(block_list_header_in_memory, block_info, journal_max_blocks(jnl));+ blhdrim->buffers = hfs_malloc_data(tr->tbuffer_size - jnl->jhdr->blhdr_size);+ tr->tbuffer = (char*)&blhdrim->blhdr;++ if (vfs_isswapmount(jnl->fsmount) && (was_vm_privileged == FALSE))+ set_vm_privilege(FALSE);++ // journal replay code checksum check depends on this.+ memset(tr->tbuffer, 0, BLHDR_CHECKSUM_SIZE);+ // Fill up the rest of the block with unimportant bytes (0x5a 'Z' chosen for visibility)+ memset(tr->tbuffer + BLHDR_CHECKSUM_SIZE, 0x5a, jnl->jhdr->blhdr_size - BLHDR_CHECKSUM_SIZE);+ tr->blhdr = (block_list_header *)tr->tbuffer;+ tr->blhdr->max_blocks = journal_max_blocks(jnl);+ tr->blhdr->num_blocks = 1; // accounts for this header block+ tr->blhdr->bytes_used = jnl->jhdr->blhdr_size;+ tr->blhdr->flags = BLHDR_CHECK_CHECKSUMS | BLHDR_FIRST_HEADER;++ tr->sequence_num = ++jnl->sequence_num;+ tr->num_blhdrs = 1;+ tr->total_bytes = jnl->jhdr->blhdr_size;+ tr->jnl = jnl;++ jnl->active_tr = tr;++ return 0;+}++int+journal_start_transaction(journal *jnl)+{+ int ret;++ CHECK_JOURNAL(jnl);++ free_old_stuff(jnl);++ if (jnl->flags & JOURNAL_INVALID) {+ return EINVAL;+ }+ if (jnl->owner == current_thread()) {+ if (jnl->active_tr == NULL) {+ panic("jnl: start_tr: active_tr is NULL (jnl @ %p, owner %p, current_thread %p\n",+ jnl, jnl->owner, current_thread());+ }+ jnl->nested_count++;+ return 0;+ }++ journal_lock(jnl);++ if (jnl->nested_count != 0 || jnl->active_tr != NULL) {+ panic("jnl: start_tr: owner %p, nested count %d, active_tr %p jnl @ %p\n",+ jnl->owner, jnl->nested_count, jnl->active_tr, jnl);+ }++ jnl->nested_count = 1;++#if JOE+ // make sure there's room in the journal+ if (free_space(jnl) < jnl->tbuffer_size) {++ KERNEL_DEBUG(0xbbbbc030 | DBG_FUNC_START, jnl, 0, 0, 0, 0);++ // this is the call that really waits for space to free up+ // as well as updating jnl->jhdr->start+ if (check_free_space(jnl, jnl->tbuffer_size, NULL, jnl->sequence_num) != 0) {+ printf("jnl: %s: start transaction failed: no space\n", jnl->jdev_name);+ ret = ENOSPC;+ goto bad_start;+ }+ KERNEL_DEBUG(0xbbbbc030 | DBG_FUNC_END, jnl, 0, 0, 0, 0);+ }+#endif++ // if there's a buffered transaction, use it.+ if (jnl->cur_tr) {+ jnl->active_tr = jnl->cur_tr;+ jnl->cur_tr = NULL;++ return 0;+ }++ ret = journal_allocate_transaction(jnl);+ if (ret) {+ goto bad_start;+ }++ // printf("jnl: start_tr: owner 0x%x new tr @ 0x%x\n", jnl->owner, jnl->active_tr);++ return 0;++bad_start:+ jnl->nested_count = 0;+ journal_unlock(jnl);++ return ret;+}+++int+journal_modify_block_start(journal *jnl, struct buf *bp)+{+ transaction *tr;+ boolean_t was_vm_privileged = FALSE;++ CHECK_JOURNAL(jnl);+++ free_old_stuff(jnl);++ if (jnl->flags & JOURNAL_INVALID) {+ return EINVAL;+ }++ if (vfs_isswapmount(jnl->fsmount)) {+ /*+ * if we block waiting for memory, and there is enough pressure to+ * cause us to try and create a new swap file, we may end up deadlocking+ * due to waiting for the journal on the swap file creation path...+ * by making ourselves vm_privileged, we give ourselves the best chance+ * of not blocking+ */+ was_vm_privileged = set_vm_privilege(TRUE);+ }++ // XXXdbg - for debugging I want this to be true. later it may+ // not be necessary.+ if ((buf_flags(bp) & B_META) == 0) {+ panic("jnl: modify_block_start: bp @ %p is not a meta-data block! (jnl %p)\n", bp, jnl);+ }++ tr = jnl->active_tr;+ CHECK_TRANSACTION(tr);++ if (jnl->owner != current_thread()) {+ panic("jnl: modify_block_start: called w/out a transaction! jnl %p, owner %p, curact %p\n",+ jnl, jnl->owner, current_thread());+ }++ //printf("jnl: mod block start (bp 0x%x vp 0x%x l/blkno %qd/%qd bsz %d; total bytes %d)\n",+ // bp, buf_vnode(bp), buf_lblkno(bp), buf_blkno(bp), buf_size(bp), tr->total_bytes);++ // can't allow blocks that aren't an even multiple of the+ // underlying block size.+ if ((buf_size(bp) % jnl->jhdr->jhdr_size) != 0) {+ uint32_t phys_blksz, bad=0;++ if (VNOP_IOCTL(jnl->jdev, DKIOCGETBLOCKSIZE, (caddr_t)&phys_blksz, 0, vfs_context_kernel())) {+ bad = 1;+ } else if (phys_blksz != (uint32_t)jnl->jhdr->jhdr_size) {+ if (phys_blksz < 512) {+ panic("jnl: mod block start: phys blksz %d is too small (%d, %d)\n",+ phys_blksz, buf_size(bp), jnl->jhdr->jhdr_size);+ }++ if ((buf_size(bp) % phys_blksz) != 0) {+ bad = 1;+ } else if (phys_blksz < (uint32_t)jnl->jhdr->jhdr_size) {+ jnl->jhdr->jhdr_size = phys_blksz;+ } else {+ // the phys_blksz is now larger... need to realloc the jhdr+ char *new_header_buf;++ printf("jnl: %s: phys blksz got bigger (was: %d/%d now %d)\n",+ jnl->jdev_name, jnl->header_buf_size, jnl->jhdr->jhdr_size, phys_blksz);+ new_header_buf = hfs_malloc_data(phys_blksz);+ memcpy(new_header_buf, jnl->header_buf, jnl->header_buf_size);+ memset(&new_header_buf[jnl->header_buf_size], 0x18, (phys_blksz - jnl->header_buf_size));+ hfs_free_data(jnl->header_buf, jnl->header_buf_size);+ jnl->header_buf = new_header_buf;+ jnl->header_buf_size = phys_blksz;++ jnl->jhdr = (journal_header *)jnl->header_buf;+ jnl->jhdr->jhdr_size = phys_blksz;+ }+ } else {+ bad = 1;+ }++ if (bad) {+ panic("jnl: mod block start: bufsize %d not a multiple of block size %d\n",+ buf_size(bp), jnl->jhdr->jhdr_size);++ if (vfs_isswapmount(jnl->fsmount) && (was_vm_privileged == FALSE))+ set_vm_privilege(FALSE);+ return -1;+ }+ }++ // make sure that this transaction isn't bigger than the whole journal+ if (tr->total_bytes+buf_size(bp) >= (jnl->jhdr->size - jnl->jhdr->jhdr_size)) {+ panic("jnl: transaction too big (%d >= %lld bytes, bufsize %d, tr %p bp %p)\n",+ tr->total_bytes, (tr->jnl->jhdr->size - jnl->jhdr->jhdr_size), buf_size(bp), tr, bp);++ if (vfs_isswapmount(jnl->fsmount) && (was_vm_privileged == FALSE))+ set_vm_privilege(FALSE);+ return -1;+ }++#if DEBUG+ const int f = buf_flags(bp);+ hfs_assert(!ISSET(f, B_DELWRI) || ISSET(f, B_LOCKED));+#endif++ buf_setflags(bp, B_LOCKED);++ if (vfs_isswapmount(jnl->fsmount) && (was_vm_privileged == FALSE))+ set_vm_privilege(FALSE);++ return 0;+}++int+journal_modify_block_abort(journal *jnl, struct buf *bp)+{+ transaction *tr;+ block_list_header *blhdr;+ int i;++ CHECK_JOURNAL(jnl);++ free_old_stuff(jnl);++ tr = jnl->active_tr;++ //+ // if there's no active transaction then we just want to+ // call buf_brelse() and return since this is just a block+ // that happened to be modified as part of another tr.+ //+ if (tr == NULL) {+ buf_brelse(bp);+ return 0;+ }++ if (jnl->flags & JOURNAL_INVALID) {+ /* Still need to buf_brelse(). Callers assume we consume the bp. */+ buf_brelse(bp);+ return EINVAL;+ }++ CHECK_TRANSACTION(tr);++ if (jnl->owner != current_thread()) {+ panic("jnl: modify_block_abort: called w/out a transaction! jnl %p, owner %p, curact %p\n",+ jnl, jnl->owner, current_thread());+ }++ // printf("jnl: modify_block_abort: tr 0x%x bp 0x%x\n", jnl->active_tr, bp);++ // first check if it's already part of this transaction+ for (blhdr = tr->blhdr; blhdr; blhdr = (block_list_header *)((long)blhdr->binfo[0].bnum)) {+ for (i = 1; i < blhdr->num_blocks; i++) {+ if (bp == blhdr->binfo[i].u.bp) {+ break;+ }+ }++ if (i < blhdr->num_blocks) {+ break;+ }+ }++ //+ // if blhdr is null, then this block has only had modify_block_start+ // called on it as part of the current transaction. that means that+ // it is ok to clear the LOCKED bit since it hasn't actually been+ // modified. if blhdr is non-null then modify_block_end was called+ // on it and so we need to keep it locked in memory.+ //+ if (blhdr == NULL) {+ buf_clearflags(bp, B_LOCKED);+ }++ buf_brelse(bp);+ return 0;+}+++int+journal_modify_block_end(journal *jnl, struct buf *bp, void (*func)(buf_t bp, void *arg), void *arg)+{+ int i = 1;+ int tbuffer_offset=0;+ block_list_header *blhdr, *prev=NULL;+ transaction *tr;++ CHECK_JOURNAL(jnl);++ free_old_stuff(jnl);++ if (jnl->flags & JOURNAL_INVALID) {+ /* Still need to buf_brelse(). Callers assume we consume the bp. */+ buf_brelse(bp);+ return EINVAL;+ }++ tr = jnl->active_tr;+ CHECK_TRANSACTION(tr);++ if (jnl->owner != current_thread()) {+ panic("jnl: modify_block_end: called w/out a transaction! jnl %p, owner %p, curact %p\n",+ jnl, jnl->owner, current_thread());+ }++ //printf("jnl: mod block end: (bp 0x%x vp 0x%x l/blkno %qd/%qd bsz %d, total bytes %d)\n",+ // bp, buf_vnode(bp), buf_lblkno(bp), buf_blkno(bp), buf_size(bp), tr->total_bytes);++ if ((buf_flags(bp) & B_LOCKED) == 0) {+ panic("jnl: modify_block_end: bp %p not locked! jnl @ %p\n", bp, jnl);+ }++ // first check if it's already part of this transaction+ for (blhdr = tr->blhdr; blhdr; prev = blhdr, blhdr = (block_list_header *)((long)blhdr->binfo[0].bnum)) {+ tbuffer_offset = jnl->jhdr->blhdr_size;++ for (i = 1; i < blhdr->num_blocks; i++) {+ if (bp == blhdr->binfo[i].u.bp) {+ break;+ }+ if (blhdr->binfo[i].bnum != (off_t)-1) {+ tbuffer_offset += buf_size(blhdr->binfo[i].u.bp);+ } else {+ tbuffer_offset += blhdr->binfo[i].u.bi.bsize;+ }+ }++ if (i < blhdr->num_blocks) {+ break;+ }+ }++ if (blhdr == NULL+ && prev+ && (prev->num_blocks+1) <= prev->max_blocks+ && (prev->bytes_used+buf_size(bp)) <= (uint32_t)tr->tbuffer_size) {+ blhdr = prev;++ } else if (blhdr == NULL) {+ block_list_header *nblhdr;+ if (prev == NULL) {+ panic("jnl: modify block end: no way man, prev == NULL?!?, jnl %p, bp %p\n", jnl, bp);+ }++ // we got to the end of the list, didn't find the block and there's+ // no room in the block_list_header pointed to by prev++ // we allocate another tbuffer and link it in at the end of the list+ // through prev->binfo[0].bnum. that's a skanky way to do things but+ // avoids having yet another linked list of small data structures to manage.++ block_list_header_in_memory* blhdrim = hfs_new_with_hdr(block_list_header_in_memory, block_info, journal_max_blocks(jnl));+ blhdrim->buffers = hfs_malloc_data(tr->tbuffer_size - jnl->jhdr->blhdr_size);+ nblhdr = &blhdrim->blhdr;+ // journal replay code checksum check depends on this.+ memset(nblhdr, 0, BLHDR_CHECKSUM_SIZE);+ // Fill up the rest of the block with unimportant bytes+ memset((char*)nblhdr + BLHDR_CHECKSUM_SIZE, 0x5a, jnl->jhdr->blhdr_size - BLHDR_CHECKSUM_SIZE);++ // initialize the new guy+ nblhdr->max_blocks = journal_max_blocks(jnl);+ nblhdr->num_blocks = 1; // accounts for this header block+ nblhdr->bytes_used = jnl->jhdr->blhdr_size;+ nblhdr->flags = BLHDR_CHECK_CHECKSUMS;++ tr->num_blhdrs++;+ tr->total_bytes += jnl->jhdr->blhdr_size;++ // then link him in at the end+ prev->binfo[0].bnum = (off_t)((long)nblhdr);++ // and finally switch to using the new guy+ blhdr = nblhdr;+ tbuffer_offset = jnl->jhdr->blhdr_size;+ i = 1;+ }+++ if ((i+1) > blhdr->max_blocks) {+ panic("jnl: modify_block_end: i = %d, max_blocks %d\n", i, blhdr->max_blocks);+ }++ // if this is true then this is a new block we haven't seen+ if (i >= blhdr->num_blocks) {+ int bsize;+ vnode_t vp;++ vp = buf_vnode(bp);+ if (vnode_ref(vp)) {+ // Nobody checks the return values, so...+ jnl->flags |= JOURNAL_INVALID;++ buf_brelse(bp);++ // We're probably here due to a force unmount, so EIO is appropriate+ return EIO;+ }++ bsize = buf_size(bp);++ blhdr->binfo[i].bnum = (off_t)(buf_blkno(bp));+ blhdr->binfo[i].u.bp = bp;++ KERNEL_DEBUG_CONSTANT(0x3018004, kdebug_vnode(vp), blhdr->binfo[i].bnum, bsize, 0, 0);+ /*+ * Update the per-task logical counter for metadata write.+ * We use (2 * bsize) to account for the write to the journal and the+ * corresponding write to the btree.+ */+ task_update_logical_writes(current_task(), (2 * bsize), TASK_WRITE_METADATA, vp);+ /*+ * Update the physical writes counter for metadata writes.+ * We use (2 * bsize) to account for the write to the on-disk journal+ * followed by write to actual location later.+ */+ task_update_physical_writes(current_task(), TASK_PHYSICAL_WRITE_METADATA,+ (2 * bsize),+ TASK_BALANCE_CREDIT);++ if (func) {+ void (*old_func)(buf_t, void *)=NULL, *old_arg=NULL;++ buf_setfilter(bp, func, arg, &old_func, &old_arg);+ if (old_func != NULL && old_func != func) {+ panic("jnl: modify_block_end: old func %p / arg %p (func %p)", old_func, old_arg, func);+ }+ }++ blhdr->bytes_used += bsize;+ tr->total_bytes += bsize;++ blhdr->num_blocks++;+ }+ buf_bdwrite(bp);++ return 0;+}++int+journal_kill_block(journal *jnl, struct buf *bp)+{+ int i;+ int bflags;+ block_list_header *blhdr;+ transaction *tr;++ CHECK_JOURNAL(jnl);++ free_old_stuff(jnl);++ if (jnl->flags & JOURNAL_INVALID) {+ buf_brelse(bp);+ return 0;+ }++ tr = jnl->active_tr;+ CHECK_TRANSACTION(tr);++ if (jnl->owner != current_thread()) {+ panic("jnl: modify_block_end: called w/out a transaction! jnl %p, owner %p, curact %p\n",+ jnl, jnl->owner, current_thread());+ }++ bflags = buf_flags(bp);++ if ( !(bflags & B_LOCKED))+ panic("jnl: modify_block_end: called with bp not B_LOCKED");++ /*+ * bp must be BL_BUSY and B_LOCKED+ * first check if it's already part of this transaction+ */+ for (blhdr = tr->blhdr; blhdr; blhdr = (block_list_header *)((long)blhdr->binfo[0].bnum)) {++ for (i = 1; i < blhdr->num_blocks; i++) {+ if (bp == blhdr->binfo[i].u.bp) {+ vnode_t vp;++ buf_clearflags(bp, B_LOCKED);++ // this undoes the vnode_ref() in journal_modify_block_end()+ vp = buf_vnode(bp);+ vnode_rele_ext(vp, 0, 1);++ // if the block has the DELWRI and FILTER bits sets, then+ // things are seriously weird. if it was part of another+ // transaction then journal_modify_block_start() should+ // have force it to be written.+ //+ //if ((bflags & B_DELWRI) && (bflags & B_FILTER)) {+ // panic("jnl: kill block: this defies all logic! bp 0x%x\n", bp);+ //} else {+ tr->num_killed += buf_size(bp);+ //}+ blhdr->binfo[i].bnum = (off_t)-1;+ blhdr->binfo[i].u.bp = NULL;+ blhdr->binfo[i].u.bi.bsize = buf_size(bp);++ buf_markinvalid(bp);+ buf_brelse(bp);++ return 0;+ }+ }+ }++ /*+ * We did not find the block in any transaction buffer but we still+ * need to release it or else it will be left locked forever.+ */+ buf_brelse(bp);++ return 0;+}++/*+;________________________________________________________________________________+;+; Routine: journal_trim_set_callback+;+; Function: Provide the journal with a routine to be called back when a+; TRIM has (or would have) been issued to the device. That+; is, the transaction has been flushed to the device, and the+; blocks freed by the transaction are now safe for reuse.+;+; CAUTION: If the journal becomes invalid (eg., due to an I/O+; error when trying to write to the journal), this callback+; will stop getting called, even if extents got freed before+; the journal became invalid!+;+; Input Arguments:+; jnl - The journal structure for the filesystem.+; callback - The function to call when the TRIM is complete.+; arg - An argument to be passed to callback.+;________________________________________________________________________________+*/+void+journal_trim_set_callback(journal *jnl, jnl_trim_callback_t callback, void *arg)+{+ jnl->trim_callback = callback;+ jnl->trim_callback_arg = arg;+}+++/*+;________________________________________________________________________________+;+; Routine: journal_trim_realloc+;+; Function: Increase the amount of memory allocated for the list of extents+; to be unmapped (trimmed). This routine will be called when+; adding an extent to the list, and the list already occupies+; all of the space allocated to it. This routine returns ENOMEM+; if unable to allocate more space, or 0 if the extent list was+; grown successfully.+;+; Input Arguments:+; trim - The trim list to be resized.+;+; Output:+; (result) - ENOMEM or 0.+;+; Side effects:+; The allocated_count and extents fields of tr->trim are updated+; if the function returned 0.+;________________________________________________________________________________+*/+static int+trim_realloc(journal *jnl, struct jnl_trim_list *trim)+{+ void *new_extents;+ uint32_t new_allocated_count;+ boolean_t was_vm_privileged = FALSE;++ if (jnl_kdebug)+ KERNEL_DEBUG_CONSTANT(DBG_JOURNAL_TRIM_REALLOC | DBG_FUNC_START, obfuscate_addr(trim), 0, trim->allocated_count, trim->extent_count, 0);++ new_allocated_count = trim->allocated_count + JOURNAL_DEFAULT_TRIM_EXTENTS;++ if (vfs_isswapmount(jnl->fsmount)) {+ /*+ * if we block waiting for memory, and there is enough pressure to+ * cause us to try and create a new swap file, we may end up deadlocking+ * due to waiting for the journal on the swap file creation path...+ * by making ourselves vm_privileged, we give ourselves the best chance+ * of not blocking+ */+ was_vm_privileged = set_vm_privilege(TRUE);+ }+ new_extents = hfs_new_data(dk_extent_t, new_allocated_count);+ if (vfs_isswapmount(jnl->fsmount) && (was_vm_privileged == FALSE))+ set_vm_privilege(FALSE);++ if (new_extents == NULL) {+ printf("jnl: trim_realloc: unable to grow extent list!\n");+ /*+ * Since we could be called when allocating space previously marked+ * to be trimmed, we need to empty out the list to be safe.+ */+ trim->extent_count = 0;+ if (jnl_kdebug)+ KERNEL_DEBUG_CONSTANT(DBG_JOURNAL_TRIM_REALLOC | DBG_FUNC_END, ENOMEM, 0, trim->allocated_count, 0, 0);+ return ENOMEM;+ }++ /* Copy the old extent list to the newly allocated list. */+ if (trim->extents != NULL) {+ memmove(new_extents,+ trim->extents,+ trim->allocated_count * sizeof(dk_extent_t));+ hfs_delete_data(trim->extents, dk_extent_t, trim->allocated_count);+ }++ trim->allocated_count = new_allocated_count;+ trim->extents = new_extents;++ if (jnl_kdebug)+ KERNEL_DEBUG_CONSTANT(DBG_JOURNAL_TRIM_REALLOC | DBG_FUNC_END, 0, 0, new_allocated_count, trim->extent_count, 0);++ return 0;+}++/*+ ;________________________________________________________________________________+ ;+ ; Routine: trim_search_extent+ ;+ ; Function: Search the given extent list to see if any of its extents+ ; overlap the given extent.+ ;+ ; Input Arguments:+ ; trim - The trim list to be searched.+ ; offset - The first byte of the range to be searched for.+ ; length - The number of bytes of the extent being searched for.+ ; overlap_start - start of the overlapping extent+ ; overlap_len - length of the overlapping extent+ ;+ ; Output:+ ; (result) - TRUE if one or more extents overlap, FALSE otherwise.+ ;________________________________________________________________________________+ */+static int+trim_search_extent(struct jnl_trim_list *trim, uint64_t offset,+ uint64_t length, uint64_t *overlap_start, uint64_t *overlap_len)+{+ uint64_t end = offset + length;+ uint32_t lower = 0; /* Lowest index to search */+ uint32_t upper = trim->extent_count; /* Highest index to search + 1 */+ uint32_t middle;++ /* A binary search over the extent list. */+ while (lower < upper) {+ middle = (lower + upper) / 2;++ if (trim->extents[middle].offset >= end)+ upper = middle;+ else if (trim->extents[middle].offset + trim->extents[middle].length <= offset)+ lower = middle + 1;+ else {+ if (overlap_start) {+ *overlap_start = trim->extents[middle].offset;+ }+ if (overlap_len) {+ *overlap_len = trim->extents[middle].length;+ }+ return TRUE;+ }+ }++ return FALSE;+}+++/*+;________________________________________________________________________________+;+; Routine: journal_trim_add_extent+;+; Function: Keep track of extents that have been freed as part of this+; transaction. If the underlying device supports TRIM (UNMAP),+; then those extents will be trimmed/unmapped once the+; transaction has been written to the journal. (For example,+; SSDs can support trim/unmap and avoid having to recopy those+; blocks when doing wear leveling, and may reuse the same+; phsyical blocks for different logical blocks.)+;+; HFS also uses this, in combination with journal_trim_set_callback,+; to add recently freed extents to its free extent cache, but+; only after the transaction that freed them is committed to+; disk. (This reduces the chance of overwriting live data in+; a way that causes data loss if a transaction never gets+; written to the journal.)+;+; Input Arguments:+; jnl - The journal for the volume containing the byte range.+; offset - The first byte of the range to be trimmed.+; length - The number of bytes of the extent being trimmed.+;________________________________________________________________________________+*/+int+journal_trim_add_extent(journal *jnl, uint64_t offset, uint64_t length)+{+ uint64_t end;+ transaction *tr;+ dk_extent_t *extent;+ uint32_t insert_index;+ uint32_t replace_count;++ CHECK_JOURNAL(jnl);++ /* TODO: Is it OK to manipulate the trim list even if JOURNAL_INVALID is set? I think so... */+ if (jnl->flags & JOURNAL_INVALID) {+ return EINVAL;+ }++ tr = jnl->active_tr;+ CHECK_TRANSACTION(tr);++ if (jnl_kdebug)+ KERNEL_DEBUG_CONSTANT(DBG_JOURNAL_TRIM_ADD | DBG_FUNC_START, obfuscate_addr(jnl), offset, length, tr->trim.extent_count, 0);++ if (jnl->owner != current_thread()) {+ panic("jnl: trim_add_extent: called w/out a transaction! jnl %p, owner %p, curact %p\n",+ jnl, jnl->owner, current_thread());+ }++ free_old_stuff(jnl);++ end = offset + length;++ /*+ * Find the range of existing extents that can be combined with the+ * input extent. We start by counting the number of extents that end+ * strictly before the input extent, then count the number of extents+ * that overlap or are contiguous with the input extent.+ */+ extent = tr->trim.extents;+ insert_index = 0;+ while (insert_index < tr->trim.extent_count && extent->offset + extent->length < offset) {+ ++insert_index;+ ++extent;+ }+ replace_count = 0;+ while (insert_index + replace_count < tr->trim.extent_count && extent->offset <= end) {+ ++replace_count;+ ++extent;+ }++ /*+ * If none of the existing extents can be combined with the input extent,+ * then just insert it in the list (before item number insert_index).+ */+ if (replace_count == 0) {+ /* If the list was already full, we need to grow it. */+ if (tr->trim.extent_count == tr->trim.allocated_count) {+ if (trim_realloc(jnl, &tr->trim) != 0) {+ printf("jnl: trim_add_extent: out of memory!");+ if (jnl_kdebug)+ KERNEL_DEBUG_CONSTANT(DBG_JOURNAL_TRIM_ADD | DBG_FUNC_END, ENOMEM, 0, 0, tr->trim.extent_count, 0);+ return ENOMEM;+ }+ }++ /* Shift any existing extents with larger offsets. */+ if (insert_index < tr->trim.extent_count) {+ memmove(&tr->trim.extents[insert_index+1],+ &tr->trim.extents[insert_index],+ (tr->trim.extent_count - insert_index) * sizeof(dk_extent_t));+ }+ tr->trim.extent_count++;++ /* Store the new extent in the list. */+ tr->trim.extents[insert_index].offset = offset;+ tr->trim.extents[insert_index].length = length;++ /* We're done. */+ if (jnl_kdebug)+ KERNEL_DEBUG_CONSTANT(DBG_JOURNAL_TRIM_ADD | DBG_FUNC_END, 0, 0, 0, tr->trim.extent_count, 0);+ return 0;+ }++ /*+ * Update extent number insert_index to be the union of the input extent+ * and all of the replaced extents.+ */+ if (tr->trim.extents[insert_index].offset < offset)+ offset = tr->trim.extents[insert_index].offset;+ extent = &tr->trim.extents[insert_index + replace_count - 1];+ if (extent->offset + extent->length > end)+ end = extent->offset + extent->length;+ tr->trim.extents[insert_index].offset = offset;+ tr->trim.extents[insert_index].length = end - offset;++ /*+ * If we were replacing more than one existing extent, then shift any+ * extents with larger offsets, and update the count of extents.+ *+ * We're going to leave extent #insert_index alone since it was just updated, above.+ * We need to move extents from index (insert_index + replace_count) through the end of+ * the list by (replace_count - 1) positions so that they overwrite extent #(insert_index + 1).+ */+ if (replace_count > 1 && (insert_index + replace_count) < tr->trim.extent_count) {+ memmove(&tr->trim.extents[insert_index + 1],+ &tr->trim.extents[insert_index + replace_count],+ (tr->trim.extent_count - insert_index - replace_count) * sizeof(dk_extent_t));+ }+ tr->trim.extent_count -= replace_count - 1;++ if (jnl_kdebug)+ KERNEL_DEBUG_CONSTANT(DBG_JOURNAL_TRIM_ADD | DBG_FUNC_END, 0, 0, 0, tr->trim.extent_count, 0);+ return 0;+}++/*+ * journal_trim_extent_overlap+ *+ * Return 1 if there are any pending TRIMs that overlap with the given offset and length+ * Return 0 otherwise.+ */++int journal_trim_extent_overlap (journal *jnl, uint64_t offset, uint64_t length, uint64_t *end) {+ transaction *tr = NULL;+ int overlap = 0;++ uint64_t overlap_start;+ uint64_t overlap_len;+ tr = jnl->active_tr;+ CHECK_TRANSACTION(tr);++ /*+ * There are two lists that need to be examined for potential overlaps:+ *+ * The first is the current transaction. Since this function requires that+ * a transaction be active when this is called, this is the "active_tr"+ * pointer in the journal struct. This has a trimlist pointer which needs+ * to be searched.+ */+ overlap = trim_search_extent (&tr->trim, offset, length, &overlap_start, &overlap_len);+ if (overlap == 0) {+ /*+ * The second is the async trim list, which is only done if the current+ * transaction group (active transaction) did not overlap with our target+ * extent. This async trim list is the set of all previously+ * committed transaction groups whose I/Os are now in-flight. We need to hold the+ * trim lock in order to search this list. If we grab the list before the+ * TRIM has completed, then we will compare it. If it is grabbed AFTER the+ * TRIM has completed, then the pointer will be zeroed out and we won't have+ * to check anything.+ */+ lck_rw_lock_shared (&jnl->trim_lock);+ if (jnl->async_trim != NULL) {+ overlap = trim_search_extent(jnl->async_trim, offset, length, &overlap_start, &overlap_len);+ }+ lck_rw_unlock_shared (&jnl->trim_lock);+ }++ if (overlap) {+ /* compute the end (min) of the overlapping range */+ if ( (overlap_start + overlap_len) < (offset + length)) {+ *end = (overlap_start + overlap_len);+ }+ else {+ *end = (offset + length);+ }+ }+++ return overlap;+}++/*+ * journal_request_immediate_flush+ *+ * FS requests that the journal flush immediately upon the+ * active transaction's completion.+ *+ * Returns 0 if operation succeeds+ * Returns EPERM if we failed to leave hint+ */+int+journal_request_immediate_flush (journal *jnl) {++ transaction *tr = NULL;+ /*+ * Is a transaction still in process? You must do+ * this while there are txns open+ */+ tr = jnl->active_tr;+ if (tr != NULL) {+ CHECK_TRANSACTION(tr);+ tr->flush_on_completion = TRUE;+ }+ else {+ return EPERM;+ }+ return 0;+}++++/*+;________________________________________________________________________________+;+; Routine: trim_remove_extent+;+; Function: Indicate that a range of bytes, some of which may have previously+; been passed to journal_trim_add_extent, is now allocated.+; Any overlapping ranges currently in the journal's trim list will+; be removed. If the underlying device supports TRIM (UNMAP), then+; these extents will not be trimmed/unmapped when the transaction+; is written to the journal.+;+; HFS also uses this to prevent newly allocated space from being+; added to its free extent cache (if some portion of the newly+; allocated space was recently freed).+;+; Input Arguments:+; trim - The trim list to update.+; offset - The first byte of the range to be trimmed.+; length - The number of bytes of the extent being trimmed.+;________________________________________________________________________________+*/+static int+trim_remove_extent(journal *jnl, struct jnl_trim_list *trim, uint64_t offset, uint64_t length)+{+ u_int64_t end;+ dk_extent_t *extent;+ u_int32_t keep_before;+ u_int32_t keep_after;++ end = offset + length;++ /*+ * Find any existing extents that start before or end after the input+ * extent. These extents will be modified if they overlap the input+ * extent. Other extents between them will be deleted.+ */+ extent = trim->extents;+ keep_before = 0;+ while (keep_before < trim->extent_count && extent->offset < offset) {+ ++keep_before;+ ++extent;+ }+ keep_after = keep_before;+ if (keep_after > 0) {+ /* See if previous extent extends beyond both ends of input extent. */+ --keep_after;+ --extent;+ }+ while (keep_after < trim->extent_count && (extent->offset + extent->length) <= end) {+ ++keep_after;+ ++extent;+ }++ /*+ * When we get here, the first keep_before extents (0 .. keep_before-1)+ * start before the input extent, and extents (keep_after .. extent_count-1)+ * end after the input extent. We'll need to keep, all of those extents,+ * but possibly modify #(keep_before-1) and #keep_after to remove the portion+ * that overlaps with the input extent.+ */++ /*+ * Does the input extent start after and end before the same existing+ * extent? If so, we have to "punch a hole" in that extent and convert+ * it to two separate extents.+ */+ if (keep_before > keep_after) {+ /* If the list was already full, we need to grow it. */+ if (trim->extent_count == trim->allocated_count) {+ if (trim_realloc(jnl, trim) != 0) {+ printf("jnl: trim_remove_extent: out of memory!");+ return ENOMEM;+ }+ }++ /*+ * Make room for a new extent by shifting extents #keep_after and later+ * down by one extent. When we're done, extents #keep_before and+ * #keep_after will be identical, and we can fall through to removing+ * the portion that overlaps the input extent.+ */+ memmove(&trim->extents[keep_before],+ &trim->extents[keep_after],+ (trim->extent_count - keep_after) * sizeof(dk_extent_t));+ ++trim->extent_count;+ ++keep_after;++ /*+ * Fall through. We now have the case where the length of extent+ * #(keep_before - 1) needs to be updated, and the start of extent+ * #(keep_after) needs to be updated.+ */+ }++ /*+ * May need to truncate the end of extent #(keep_before - 1) if it overlaps+ * the input extent.+ */+ if (keep_before > 0) {+ extent = &trim->extents[keep_before - 1];+ if (extent->offset + extent->length > offset) {+ extent->length = offset - extent->offset;+ }+ }++ /*+ * May need to update the start of extent #(keep_after) if it overlaps the+ * input extent.+ */+ if (keep_after < trim->extent_count) {+ extent = &trim->extents[keep_after];+ if (extent->offset < end) {+ extent->length = extent->offset + extent->length - end;+ extent->offset = end;+ }+ }++ /*+ * If there were whole extents that overlapped the input extent, get rid+ * of them by shifting any following extents, and updating the count.+ */+ if (keep_after > keep_before && keep_after < trim->extent_count) {+ memmove(&trim->extents[keep_before],+ &trim->extents[keep_after],+ (trim->extent_count - keep_after) * sizeof(dk_extent_t));+ }+ trim->extent_count -= keep_after - keep_before;++ return 0;+}++/*+ ;________________________________________________________________________________+ ;+ ; Routine: journal_trim_remove_extent+ ;+ ; Function: Make note of a range of bytes, some of which may have previously+ ; been passed to journal_trim_add_extent, is now in use on the+ ; volume. The given bytes will be not be trimmed as part of+ ; this transaction, or a pending trim of a transaction being+ ; asynchronously flushed.+ ;+ ; Input Arguments:+ ; jnl - The journal for the volume containing the byte range.+ ; offset - The first byte of the range to be trimmed.+ ; length - The number of bytes of the extent being trimmed.+ ;________________________________________________________________________________+ */+int+journal_trim_remove_extent(journal *jnl, uint64_t offset, uint64_t length)+{+ int error = 0;+ transaction *tr;++ CHECK_JOURNAL(jnl);++ /* TODO: Is it OK to manipulate the trim list even if JOURNAL_INVALID is set? I think so... */+ if (jnl->flags & JOURNAL_INVALID) {+ return EINVAL;+ }++ tr = jnl->active_tr;+ CHECK_TRANSACTION(tr);++ if (jnl_kdebug)+ KERNEL_DEBUG_CONSTANT(DBG_JOURNAL_TRIM_REMOVE | DBG_FUNC_START, obfuscate_addr(jnl), offset, length, tr->trim.extent_count, 0);++ if (jnl->owner != current_thread()) {+ panic("jnl: trim_remove_extent: called w/out a transaction! jnl %p, owner %p, curact %p\n",+ jnl, jnl->owner, current_thread());+ }++ free_old_stuff(jnl);++ error = trim_remove_extent(jnl, &tr->trim, offset, length);+ if (error == 0) {+ int found = FALSE;++ /*+ * See if a pending trim has any extents that overlap with the+ * one we were given.+ */+ lck_rw_lock_shared(&jnl->trim_lock);+ if (jnl->async_trim != NULL)+ found = trim_search_extent(jnl->async_trim, offset, length, NULL, NULL);+ lck_rw_unlock_shared(&jnl->trim_lock);++ if (found) {+ /*+ * There was an overlap, so avoid trimming the extent we+ * just allocated. (Otherwise, it might get trimmed after+ * we've written to it, which will cause that data to be+ * corrupted.)+ */+ uint32_t async_extent_count = 0;++ if (jnl_kdebug)+ KERNEL_DEBUG_CONSTANT(DBG_JOURNAL_TRIM_REMOVE_PENDING | DBG_FUNC_START, obfuscate_addr(jnl), offset, length, 0, 0);+ lck_rw_lock_exclusive(&jnl->trim_lock);+ if (jnl->async_trim != NULL) {+ error = trim_remove_extent(jnl, jnl->async_trim, offset, length);+ async_extent_count = jnl->async_trim->extent_count;+ }+ lck_rw_unlock_exclusive(&jnl->trim_lock);+ if (jnl_kdebug)+ KERNEL_DEBUG_CONSTANT(DBG_JOURNAL_TRIM_REMOVE_PENDING | DBG_FUNC_END, error, 0, 0, async_extent_count, 0);+ }+ }++ if (jnl_kdebug)+ KERNEL_DEBUG_CONSTANT(DBG_JOURNAL_TRIM_REMOVE | DBG_FUNC_END, error, 0, 0, tr->trim.extent_count, 0);+ return error;+}+++static int+journal_trim_flush(journal *jnl, transaction *tr)+{+ int err = 0;+ boolean_t was_vm_privileged = FALSE;++ if (jnl_kdebug)+ KERNEL_DEBUG_CONSTANT(DBG_JOURNAL_TRIM_FLUSH | DBG_FUNC_START, obfuscate_addr(jnl), tr, 0, tr->trim.extent_count, 0);++ if (vfs_isswapmount(jnl->fsmount)) {+ /*+ * the disk driver can allocate memory on this path...+ * if we block waiting for memory, and there is enough pressure to+ * cause us to try and create a new swap file, we may end up deadlocking+ * due to waiting for the journal on the swap file creation path...+ * by making ourselves vm_privileged, we give ourselves the best chance+ * of not blocking+ */+ was_vm_privileged = set_vm_privilege(TRUE);+ }+ lck_rw_lock_shared(&jnl->trim_lock);+ if (tr->trim.extent_count > 0) {+ dk_unmap_t unmap;++ bzero(&unmap, sizeof(unmap));+ if (jnl->flags & JOURNAL_USE_UNMAP) {+ unmap.extents = tr->trim.extents;+ unmap.extentsCount = tr->trim.extent_count;+ if (jnl_kdebug)+ KERNEL_DEBUG_CONSTANT(DBG_JOURNAL_TRIM_UNMAP | DBG_FUNC_START, obfuscate_addr(jnl), tr, 0, tr->trim.extent_count, 0);+ err = VNOP_IOCTL(jnl->fsdev, DKIOCUNMAP, (caddr_t)&unmap, FWRITE, vfs_context_kernel());+ if (jnl_kdebug)+ KERNEL_DEBUG_CONSTANT(DBG_JOURNAL_TRIM_UNMAP | DBG_FUNC_END, err, 0, 0, 0, 0);+ }++ /*+ * Call back into the file system to tell them that we have+ * trimmed some extents and that they can now be reused.+ *+ * CAUTION: If the journal becomes invalid (eg., due to an I/O+ * error when trying to write to the journal), this callback+ * will stop getting called, even if extents got freed before+ * the journal became invalid!+ */+ if (jnl->trim_callback)+ jnl->trim_callback(jnl->trim_callback_arg, tr->trim.extent_count, tr->trim.extents);+ }+ lck_rw_unlock_shared(&jnl->trim_lock);++ if (vfs_isswapmount(jnl->fsmount) && (was_vm_privileged == FALSE))+ set_vm_privilege(FALSE);+ /*+ * If the transaction we're flushing was the async transaction, then+ * tell the current transaction that there is no pending trim+ * any more.+ *+ * NOTE: Since we released the lock, another thread could have+ * removed one or more extents from our list. That's not a+ * problem since any writes to the re-allocated blocks+ * would get sent to the device after the DKIOCUNMAP.+ */+ lck_rw_lock_exclusive(&jnl->trim_lock);+ if (jnl->async_trim == &tr->trim)+ jnl->async_trim = NULL;+ lck_rw_unlock_exclusive(&jnl->trim_lock);++ /*+ * By the time we get here, no other thread can discover the address+ * of "tr", so it is safe for us to manipulate tr->trim without+ * holding any locks.+ */+ if (tr->trim.extents) {+ hfs_delete_data(tr->trim.extents, dk_extent_t, tr->trim.allocated_count);+ tr->trim.allocated_count = 0;+ tr->trim.extent_count = 0;+ tr->trim.extents = NULL;+ }++ if (jnl_kdebug)+ KERNEL_DEBUG_CONSTANT(DBG_JOURNAL_TRIM_FLUSH | DBG_FUNC_END, err, 0, 0, 0, 0);++ return err;+}++static int+journal_binfo_cmp(const void *a, const void *b)+{+ const block_info *bi_a = (const struct block_info *)a;+ const block_info *bi_b = (const struct block_info *)b;+ daddr64_t res;++ if (bi_a->bnum == (off_t)-1) {+ return 1;+ }+ if (bi_b->bnum == (off_t)-1) {+ return -1;+ }++ // don't have to worry about negative block+ // numbers so this is ok to do.+ //+ res = (buf_blkno(bi_a->u.bp) - buf_blkno(bi_b->u.bp));++ return (int)res;+}+++/*+ * End a transaction. If the transaction is small enough, and we're not forcing+ * a write to disk, the "active" transaction becomes the "current" transaction,+ * and will be reused for the next transaction that is started (group commit).+ *+ * If the transaction gets written to disk (because force_it is true, or no+ * group commit, or the transaction is sufficiently full), the blocks get+ * written into the journal first, then the are written asynchronously. When+ * those async writes complete, the transaction can be freed and removed from+ * the journal.+ *+ * An optional callback can be supplied. If given, it is called after the+ * the blocks have been written to the journal, but before the async writes+ * of those blocks to their normal on-disk locations. This is used by+ * journal_relocate so that the location of the journal can be changed and+ * flushed to disk before the blocks get written to their normal locations.+ * Note that the callback is only called if the transaction gets written to+ * the journal during this end_transaction call; you probably want to set the+ * force_it flag.+ *+ * Inputs:+ * tr Transaction to add to the journal+ * force_it If true, force this transaction to the on-disk journal immediately.+ * callback See description above. Pass NULL for no callback.+ * callback_arg Argument passed to callback routine.+ *+ * Result+ * 0 No errors+ * -1 An error occurred. The journal is marked invalid.+ */+static int+end_transaction(transaction *tr, int force_it, errno_t (*callback)(void*), void *callback_arg, boolean_t drop_lock, boolean_t must_wait)+{+ block_list_header *blhdr=NULL, *next=NULL;+ int i, ret_val = 0;+ errno_t err;+ journal *jnl = tr->jnl;+ struct buf *bp;+ size_t tbuffer_offset;+ boolean_t drop_lock_early;++ if (jnl->cur_tr) {+ panic("jnl: jnl @ %p already has cur_tr %p, new tr: %p\n",+ jnl, jnl->cur_tr, tr);+ }++ // if there weren't any modified blocks in the transaction+ // just save off the transaction pointer and return.+ if (tr->total_bytes == jnl->jhdr->blhdr_size) {+ jnl->cur_tr = tr;+ goto done;+ }++ // if our transaction buffer isn't very full, just hang+ // on to it and don't actually flush anything. this is+ // what is known as "group commit". we will flush the+ // transaction buffer if it's full or if we have more than+ // one of them so we don't start hogging too much memory.+ //+ // We also check the device supports UNMAP/TRIM, and if so,+ // the number of extents waiting to be trimmed. If it is+ // small enough, then keep accumulating more (so we can+ // reduce the overhead of trimming). If there was a prior+ // trim error, then we stop issuing trims for this+ // volume, so we can also coalesce transactions.+ //+ if ( force_it == 0+ && (jnl->flags & JOURNAL_NO_GROUP_COMMIT) == 0+ && tr->num_blhdrs < 3+ && (tr->total_bytes <= ((tr->tbuffer_size*tr->num_blhdrs) - tr->tbuffer_size/8))+ && (!(jnl->flags & JOURNAL_USE_UNMAP) || (tr->trim.extent_count < jnl_trim_flush_limit))) {++ jnl->cur_tr = tr;+ goto done;+ }++ KERNEL_DEBUG(0xbbbbc018|DBG_FUNC_START, jnl, tr, drop_lock, must_wait, 0);++ lock_condition(jnl, &jnl->flushing, "end_transaction");++ /*+ * if the previous 'finish_end_transaction' was being run+ * asynchronously, it could have encountered a condition+ * that caused it to mark the journal invalid... if that+ * occurred while we were waiting for it to finish, we+ * need to notice and abort the current transaction+ */+ bool is_revoked = (vnode_isrecycled(jnl->jdev) || ((jnl->fsdev != jnl->jdev) && vnode_isrecycled(jnl->fsdev)));+ if ((jnl->flags & JOURNAL_INVALID) || jnl->flush_aborted == TRUE || is_revoked) {+ unlock_condition(jnl, &jnl->flushing);++ if (is_revoked) {+ jnl->flags |= JOURNAL_DEV_REVOKED;+ }+ abort_transaction(jnl, tr);+ ret_val = -1;+ KERNEL_DEBUG(0xbbbbc018|DBG_FUNC_END, jnl, tr, ret_val, 0, 0);+ goto done;+ }++ /*+ * Store a pointer to this transaction's trim list so that+ * future transactions can find it.+ *+ * Note: if there are no extents in the trim list, then don't+ * bother saving the pointer since nothing can add new extents+ * to the list (and other threads/transactions only care if+ * there is a trim pending).+ */+ lck_rw_lock_exclusive(&jnl->trim_lock);+ if (jnl->async_trim != NULL)+ panic("jnl: end_transaction: async_trim already non-NULL!");+ if (tr->trim.extent_count > 0)+ jnl->async_trim = &tr->trim;+ lck_rw_unlock_exclusive(&jnl->trim_lock);++ /*+ * snapshot the transaction sequence number while we are still behind+ * the journal lock since it will be bumped upon the start of the+ * next transaction group which may overlap the current journal flush...+ * we pass the snapshot into write_journal_header during the journal+ * flush so that it can write the correct version in the header...+ * because we hold the 'flushing' condition variable for the duration+ * of the journal flush, 'saved_sequence_num' remains stable+ */+ jnl->saved_sequence_num = jnl->sequence_num;++ /*+ * if we're here we're going to flush the transaction buffer to disk.+ * 'check_free_space' will not return untl there is enough free+ * space for this transaction in the journal and jnl->old_start[0]+ * is avaiable for use+ */+ KERNEL_DEBUG(0xbbbbc030 | DBG_FUNC_START, jnl, 0, 0, 0, 0);++ check_free_space(jnl, tr->total_bytes, &tr->delayed_header_write, jnl->saved_sequence_num);++ KERNEL_DEBUG(0xbbbbc030 | DBG_FUNC_END, jnl, tr->delayed_header_write, 0, 0, 0);++ // range check the end index+ if (jnl->jhdr->end <= 0 || jnl->jhdr->end > jnl->jhdr->size) {+ panic("jnl: end_transaction: end is bogus 0x%llx (sz 0x%llx)\n",+ jnl->jhdr->end, jnl->jhdr->size);+ }+ if (tr->delayed_header_write == TRUE) {+ thread_t thread = THREAD_NULL;++ lock_condition(jnl, &jnl->writing_header, "end_transaction");+ /*+ * fire up a thread to write the journal header+ * asynchronously... when it finishes, it will call+ * unlock_condition... we can overlap the preparation of+ * the log and buffers during this time+ */+ kernel_thread_start((thread_continue_t)write_header_thread, jnl, &thread);+ } else+ jnl->write_header_failed = FALSE;+++ // this transaction starts where the current journal ends+ tr->journal_start = jnl->jhdr->end;++ lock_oldstart(jnl);+ /*+ * Because old_start is locked above, we can cast away the volatile qualifier before passing it to memmove.+ * slide everyone else down and put our latest guy in the last+ * entry in the old_start array+ */+ memmove(__CAST_AWAY_QUALIFIER(&jnl->old_start[0], volatile, void *), __CAST_AWAY_QUALIFIER(&jnl->old_start[1], volatile, void *), sizeof(jnl->old_start)-sizeof(jnl->old_start[0]));+ jnl->old_start[sizeof(jnl->old_start)/sizeof(jnl->old_start[0]) - 1] = tr->journal_start | 0x8000000000000000LL;++ unlock_oldstart(jnl);+++ for (blhdr = tr->blhdr; blhdr; blhdr = next) {+ char *blkptr;+ buf_t sbp;+ int32_t bsize;++ // get block_list_header_in_memory pointer, since this is what we really allocated in memory and where the pointer+ // to the buffers buffer is+ block_list_header_in_memory *blhdrim = BLHDR_TO_BLHDRIM(blhdr);++ tbuffer_offset = 0;++ for (i = 1; i < blhdr->num_blocks; i++) {++ if (blhdr->binfo[i].bnum != (off_t)-1) {+ void (*func)(buf_t, void *);+ void *arg;++ bp = blhdr->binfo[i].u.bp;++ if (bp == NULL) {+ panic("jnl: inconsistent binfo (NULL bp w/bnum %lld; jnl @ %p, tr %p)\n",+ blhdr->binfo[i].bnum, jnl, tr);+ }+ /*+ * acquire the bp here so that we can safely+ * mess around with its data. buf_acquire()+ * will return EAGAIN if the buffer was busy,+ * so loop trying again.+ */+ do {+ err = buf_acquire(bp, BAC_REMOVE, 0, 0);+ } while (err == EAGAIN);++ if (err)+ panic("could not acquire bp %p (err %d)\n", bp, err);++ if ((buf_flags(bp) & (B_LOCKED|B_DELWRI)) != (B_LOCKED|B_DELWRI)) {+ if (jnl->flags & JOURNAL_CLOSE_PENDING) {+ buf_clearflags(bp, B_LOCKED);+ buf_brelse(bp);++ /*+ * this is an odd case that appears to happen occasionally+ * make sure we mark this block as no longer valid+ * so that we don't process it in "finish_end_transaction" since+ * the bp that is recorded in our array no longer belongs+ * to us (normally we substitute a shadow bp to be processed+ * issuing a 'buf_bawrite' on a stale buf_t pointer leads+ * to all kinds of problems.+ */+ blhdr->binfo[i].bnum = (off_t)-1;+ continue;+ } else {+ panic("jnl: end_tr: !!!DANGER!!! bp %p flags (0x%x) not LOCKED & DELWRI\n", bp, buf_flags(bp));+ }+ }+ bsize = buf_size(bp);++ buf_setfilter(bp, NULL, NULL, &func, &arg);++ blkptr = (char*)&blhdrim->buffers[tbuffer_offset];++ sbp = buf_create_shadow_priv(bp, FALSE, (uintptr_t)blkptr, 0, 0);++ if (sbp == NULL)+ panic("jnl: buf_create_shadow returned NULL");++ /*+ * copy the data into the transaction buffer...+ */+ memcpy(blkptr, (char *)buf_dataptr(bp), bsize);++ buf_clearflags(bp, B_LOCKED);+ buf_markclean(bp);+ buf_drop(bp);++ /*+ * adopt the shadow buffer for this block+ */+ if (func) {+ /*+ * transfer FS hook function to the+ * shadow buffer... it will get called+ * in finish_end_transaction+ */+ buf_setfilter(sbp, func, arg, NULL, NULL);+ }+ blhdr->binfo[i].u.bp = sbp;++ } else {+ // bnum == -1, only true if a block was "killed"+ bsize = blhdr->binfo[i].u.bi.bsize;+ }+ tbuffer_offset += bsize;+ }+ next = (block_list_header *)((long)blhdr->binfo[0].bnum);+ }+ /*+ * if callback != NULL, we don't want to drop the journal+ * lock, or complete end_transaction asynchronously, since+ * the caller is expecting the callback to run in the calling+ * context+ *+ * if drop_lock == FALSE, we can't complete end_transaction+ * asynchronously+ */+ if (callback)+ drop_lock_early = FALSE;+ else+ drop_lock_early = drop_lock;++ if (drop_lock_early == FALSE)+ must_wait = TRUE;++ if (drop_lock_early == TRUE) {+ journal_unlock(jnl);+ drop_lock = FALSE;+ }+ if (must_wait == TRUE)+ ret_val = finish_end_transaction(tr, callback, callback_arg);+ else {+ thread_t thread = THREAD_NULL;++ /*+ * fire up a thread to complete processing this transaction+ * asynchronously... when it finishes, it will call+ * unlock_condition+ */+ kernel_thread_start((thread_continue_t)finish_end_thread, tr, &thread);+ }+ KERNEL_DEBUG(0xbbbbc018|DBG_FUNC_END, jnl, tr, ret_val, 0, 0);+done:+ if (drop_lock == TRUE) {+ journal_unlock(jnl);+ }+ return (ret_val);+}+++static void+finish_end_thread(transaction *tr)+{+ throttle_set_thread_io_policy(IOPOL_PASSIVE);++ finish_end_transaction(tr, NULL, NULL);++ thread_deallocate(current_thread());+ thread_terminate(current_thread());+}++static void+write_header_thread(journal *jnl)+{+ throttle_set_thread_io_policy(IOPOL_PASSIVE);++ if (write_journal_header(jnl, 1, jnl->saved_sequence_num))+ jnl->write_header_failed = TRUE;+ else+ jnl->write_header_failed = FALSE;+ unlock_condition(jnl, &jnl->writing_header);++ thread_deallocate(current_thread());+ thread_terminate(current_thread());+}++static int+finish_end_transaction(transaction *tr, errno_t (*callback)(void*), void *callback_arg)+{+ int i, amt;+ int ret = 0;+ off_t end;+ journal *jnl = tr->jnl;+ buf_t bp, *bparray;+ vnode_t vp;+ block_list_header *blhdr=NULL, *next=NULL;+ size_t tbuffer_offset;+ int bufs_written = 0;+ int ret_val = 0;+ boolean_t was_vm_privileged = FALSE;++ KERNEL_DEBUG(0xbbbbc028|DBG_FUNC_START, jnl, tr, 0, 0, 0);++ if (vfs_isswapmount(jnl->fsmount)) {+ /*+ * if we block waiting for memory, and there is enough pressure to+ * cause us to try and create a new swap file, we may end up deadlocking+ * due to waiting for the journal on the swap file creation path...+ * by making ourselves vm_privileged, we give ourselves the best chance+ * of not blocking+ */+ was_vm_privileged = set_vm_privilege(TRUE);+ }+ end = jnl->jhdr->end;++ for (blhdr = tr->blhdr; blhdr; blhdr = (block_list_header *)((long)blhdr->binfo[0].bnum)) {+ // get block_list_header_in_memory pointer, since this is what we really allocated in memory and where the pointer+ // to the buffers buffer is+ block_list_header_in_memory *blhdrim = BLHDR_TO_BLHDRIM(blhdr);+ amt = blhdr->bytes_used;++ blhdr->binfo[0].u.bi.b.sequence_num = tr->sequence_num;++ blhdr->checksum = 0;+ blhdr->checksum = calc_checksum((char *)blhdr, BLHDR_CHECKSUM_SIZE);++ bparray = hfs_new(buf_t, blhdr->num_blocks);+ tbuffer_offset = 0;++ for (i = 1; i < blhdr->num_blocks; i++) {+ void (*func)(buf_t, void *);+ void *arg;+ int32_t bsize;++ /*+ * finish preparing the shadow buf_t before+ * calculating the individual block checksums+ */+ if (blhdr->binfo[i].bnum != (off_t)-1) {+ daddr64_t blkno;+ daddr64_t lblkno;++ bp = blhdr->binfo[i].u.bp;++ vp = buf_vnode(bp);+ blkno = buf_blkno(bp);+ lblkno = buf_lblkno(bp);++ if (vp == NULL && lblkno == blkno) {+ printf("jnl: %s: end_tr: bad news! buffer w/null vp and l/blkno = %qd/%qd. aborting the transaction.\n",+ jnl->jdev_name, lblkno, blkno);+ ret_val = -1;+ goto bad_journal;+ }++ // if the lblkno is the same as blkno and this bp isn't+ // associated with the underlying file system device then+ // we need to call bmap() to get the actual physical block.+ //+ if ((lblkno == blkno) && (vp != jnl->fsdev)) {+ off_t f_offset;+ size_t contig_bytes;++ if (hfs_vnop_blktooff(&(struct vnop_blktooff_args){+ .a_vp = vp,+ .a_lblkno = lblkno,+ .a_offset = &f_offset+ })) {+ printf("jnl: %s: end_tr: vnop_blktooff failed\n", jnl->jdev_name);+ ret_val = -1;+ goto bad_journal;+ }++ if (hfs_vnop_blockmap(&(struct vnop_blockmap_args) {+ .a_vp = vp,+ .a_foffset = f_offset,+ .a_size = buf_count(bp),+ .a_bpn = &blkno,+ .a_run = &contig_bytes+ })) {+ printf("jnl: %s: end_tr: can't blockmap the buffer\n", jnl->jdev_name);+ ret_val = -1;+ goto bad_journal;+ }++ if ((uint32_t)contig_bytes < buf_count(bp)) {+ printf("jnl: %s: end_tr: blk not physically contiguous on disk\n", jnl->jdev_name);+ ret_val = -1;+ goto bad_journal;+ }+ buf_setblkno(bp, blkno);+ }+ // update this so we write out the correct physical block number!+ blhdr->binfo[i].bnum = (off_t)(blkno);++ /*+ * pick up the FS hook function (if any) and prepare+ * to fire this buffer off in the next pass+ */+ buf_setfilter(bp, buffer_flushed_callback, tr, &func, &arg);++ if (func) {+ /*+ * call the hook function supplied by the filesystem...+ * this needs to happen BEFORE cacl_checksum in case+ * the FS morphs the data in the buffer+ */+ func(bp, arg);+ }+ bparray[i] = bp;+ bsize = buf_size(bp);+ blhdr->binfo[i].u.bi.bsize = bsize;+ blhdr->binfo[i].u.bi.b.cksum = calc_checksum(&blhdrim->buffers[tbuffer_offset], bsize);+ } else {+ bparray[i] = NULL;+ bsize = blhdr->binfo[i].u.bi.bsize;+ blhdr->binfo[i].u.bi.b.cksum = 0;+ }+ tbuffer_offset += bsize;+ }+ /*+ * if we fired off the journal_write_header asynchronously in+ * 'end_transaction', we need to wait for its completion+ * before writing the actual journal data+ */+ wait_condition(jnl, &jnl->writing_header, "finish_end_transaction");++ if (jnl->write_header_failed == FALSE) {+ int header_amt = amt;+ int buffers_amt = 0;+ if (amt > jnl->jhdr->blhdr_size) {+ header_amt = jnl->jhdr->blhdr_size;+ buffers_amt = amt - header_amt;+ }+ ret = write_journal_data(jnl, &end, blhdr, header_amt);+ if (buffers_amt) {+ ret += write_journal_data(jnl, &end, blhdrim->buffers, buffers_amt);+ }+ }+ else+ ret_val = -1;+ /*+ * put the bp pointers back so that we can+ * make the final pass on them+ */+ for (i = 1; i < blhdr->num_blocks; i++)+ blhdr->binfo[i].u.bp = bparray[i];++ hfs_delete(bparray, buf_t, blhdr->num_blocks);+ if (ret_val == -1)+ goto bad_journal;++ if (ret != amt) {+ printf("jnl: %s: end_transaction: only wrote %d of %d bytes to the journal!\n",+ jnl->jdev_name, ret, amt);++ ret_val = -1;+ goto bad_journal;+ }+ }+ jnl->jhdr->end = end; // update where the journal now ends+ tr->journal_end = end; // the transaction ends here too++ if (tr->journal_start == 0 || tr->journal_end == 0) {+ panic("jnl: end_transaction: bad tr journal start/end: 0x%llx 0x%llx\n",+ tr->journal_start, tr->journal_end);+ }++ if (write_journal_header(jnl, 0, jnl->saved_sequence_num) != 0) {+ ret_val = -1;+ goto bad_journal;+ }+ /*+ * If the caller supplied a callback, call it now that the blocks have been+ * written to the journal. This is used by journal_relocate so, for example,+ * the file system can change its pointer to the new journal.+ */+ if (callback != NULL && callback(callback_arg) != 0) {+ ret_val = -1;+ goto bad_journal;+ }++ //+ // Send a DKIOCUNMAP for the extents trimmed by this transaction, and+ // free up the extent list.+ //+ journal_trim_flush(jnl, tr);++ // the buffer_flushed_callback will only be called for the+ // real blocks that get flushed so we have to account for+ // the block_list_headers here.+ //+ tr->num_flushed = tr->num_blhdrs * jnl->jhdr->blhdr_size;++ lock_condition(jnl, &jnl->asyncIO, "finish_end_transaction");++ //+ // setup for looping through all the blhdr's.+ //+ for (blhdr = tr->blhdr; blhdr; blhdr = next) {+ uint16_t num_blocks;++ /*+ * grab this info ahead of issuing the buf_bawrites...+ * once the last one goes out, its possible for blhdr+ * to be freed (especially if we get preempted) before+ * we do the last check of num_blocks or+ * grab the next blhdr pointer...+ */+ next = (block_list_header *)((long)blhdr->binfo[0].bnum);+ num_blocks = blhdr->num_blocks;++ /*+ * we can re-order the buf ptrs because everything is written out already+ */+ kx_qsort(&blhdr->binfo[1], num_blocks-1, sizeof(block_info), journal_binfo_cmp);++ /*+ * need to make sure that the loop issuing the buf_bawrite's+ * does not touch blhdr once the last buf_bawrite has been+ * issued... at that point, we no longer have a legitmate+ * reference on the associated storage since it will be+ * released upon the completion of that last buf_bawrite+ */+ for (i = num_blocks-1; i >= 1; i--) {+ if (blhdr->binfo[i].bnum != (off_t)-1)+ break;+ num_blocks--;+ }+ for (i = 1; i < num_blocks; i++) {++ if ((bp = blhdr->binfo[i].u.bp)) {+ vp = buf_vnode(bp);++ buf_bawrite(bp);++ // this undoes the vnode_ref() in journal_modify_block_end()+ vnode_rele_ext(vp, 0, 1);++ bufs_written++;+ }+ }+ }+ if (bufs_written == 0) {+ /*+ * since we didn't issue any buf_bawrite's, there is no+ * async trigger to cause the memory associated with this+ * transaction to be freed... so, move it to the garbage+ * list now+ */+ lock_oldstart(jnl);++ tr->next = jnl->tr_freeme;+ jnl->tr_freeme = tr;++ unlock_oldstart(jnl);++ unlock_condition(jnl, &jnl->asyncIO);+ }++ //printf("jnl: end_tr: tr @ 0x%x, jnl-blocks: 0x%llx - 0x%llx. exit!\n",+ // tr, tr->journal_start, tr->journal_end);++bad_journal:+ if (ret_val == -1) {+ abort_transaction(jnl, tr); // cleans up list of extents to be trimmed++ /*+ * 'flush_aborted' is protected by the flushing condition... we need to+ * set it before dropping the condition so that it will be+ * noticed in 'end_transaction'... we add this additional+ * aborted condition so that we can drop the 'flushing' condition+ * before grabbing the journal lock... this avoids a deadlock+ * in 'end_transaction' which is holding the journal lock while+ * waiting for the 'flushing' condition to clear...+ * everyone else will notice the JOURNAL_INVALID flag+ */+ jnl->flush_aborted = TRUE;++ unlock_condition(jnl, &jnl->flushing);+ journal_lock(jnl);++ jnl->flags |= JOURNAL_INVALID;+ jnl->old_start[sizeof(jnl->old_start)/sizeof(jnl->old_start[0]) - 1] &= ~0x8000000000000000LL;++ journal_unlock(jnl);+ } else+ unlock_condition(jnl, &jnl->flushing);++ if (vfs_isswapmount(jnl->fsmount) && (was_vm_privileged == FALSE))+ set_vm_privilege(FALSE);++ KERNEL_DEBUG(0xbbbbc028|DBG_FUNC_END, jnl, tr, bufs_written, ret_val, 0);++ return (ret_val);+}+++static void+lock_condition(journal *jnl, boolean_t *condition, const char *condition_name)+{++ KERNEL_DEBUG(0xbbbbc020|DBG_FUNC_START, jnl, condition, 0, 0, 0);++ lock_flush(jnl);++ while (*condition == TRUE)+ msleep(condition, &jnl->flock, PRIBIO, condition_name, NULL);++ *condition = TRUE;+ unlock_flush(jnl);++ KERNEL_DEBUG(0xbbbbc020|DBG_FUNC_END, jnl, condition, 0, 0, 0);+}++static void+wait_condition(journal *jnl, boolean_t *condition, const char *condition_name)+{++ if (*condition == FALSE)+ return;++ KERNEL_DEBUG(0xbbbbc02c|DBG_FUNC_START, jnl, condition, 0, 0, 0);++ lock_flush(jnl);++ while (*condition == TRUE)+ msleep(condition, &jnl->flock, PRIBIO, condition_name, NULL);++ unlock_flush(jnl);++ KERNEL_DEBUG(0xbbbbc02c|DBG_FUNC_END, jnl, condition, 0, 0, 0);+}++static void+unlock_condition(journal *jnl, boolean_t *condition)+{+ lock_flush(jnl);++ *condition = FALSE;+ wakeup(condition);++ unlock_flush(jnl);+}++static void+abort_transaction(journal *jnl, transaction *tr)+{+ block_list_header *blhdr, *next;++ // for each block list header, iterate over the blocks then+ // free up the memory associated with the block list.+ //+ // find each of the primary blocks (i.e. the list could+ // contain a mix of shadowed and real buf_t's depending+ // on when the abort condition was detected) and mark them+ // clean and locked in the cache... this at least allows+ // the FS a consistent view between it's incore data structures+ // and the meta-data held in the cache+ //+ KERNEL_DEBUG(0xbbbbc034|DBG_FUNC_START, jnl, tr, 0, 0, 0);++ for (blhdr = tr->blhdr; blhdr; blhdr = next) {+ int i;++ for (i = 1; i < blhdr->num_blocks; i++) {+ buf_t bp, tbp, sbp;+ vnode_t bp_vp;+ errno_t err;++ if (blhdr->binfo[i].bnum == (off_t)-1)+ continue;++ tbp = blhdr->binfo[i].u.bp;++ bp_vp = buf_vnode(tbp);++ if (buf_shadow(tbp)) {+ sbp = tbp;+ buf_setfilter(tbp, NULL, NULL, NULL, NULL);+ } else {+ if (!(jnl->flags & JOURNAL_DEV_REVOKED)) {+ hfs_assert(ISSET(buf_flags(tbp), B_LOCKED));+ }++ sbp = NULL;++ do {+ err = buf_acquire(tbp, BAC_REMOVE, 0, 0);+ } while (err == EAGAIN);++ if (!err) {+ buf_setfilter(tbp, NULL, NULL, NULL, NULL);+ buf_brelse(tbp);+ }+ }++ if (bp_vp) {+ err = buf_meta_bread(bp_vp,+ buf_lblkno(tbp),+ buf_size(tbp),+ NOCRED,+ &bp);+ if (err == 0) {+ if (sbp == NULL && bp != tbp && (buf_flags(tbp) & B_LOCKED)) {+ panic("jnl: abort_tr: got back a different bp! (bp %p should be %p, jnl %p\n",+ bp, tbp, jnl);+ }+ /*+ * once the journal has been marked INVALID and aborted,+ * NO meta data can be written back to the disk, so+ * mark the buf_t clean and make sure it's locked in the cache+ * note: if we found a shadow, the real buf_t needs to be relocked+ */+ buf_setflags(bp, B_LOCKED);+ buf_markclean(bp);+ buf_brelse(bp);++ KERNEL_DEBUG(0xbbbbc034|DBG_FUNC_NONE, jnl, tr, bp, 0, 0);++ /*+ * this undoes the vnode_ref() in journal_modify_block_end()+ */+ vnode_rele_ext(bp_vp, 0, 1);+ } else {+ printf("jnl: %s: abort_tr: could not find block %lld for vnode!\n",+ jnl->jdev_name, blhdr->binfo[i].bnum);+ if (bp) {+ buf_brelse(bp);+ }+ }+ }+ if (sbp)+ buf_brelse(sbp);+ }+ next = (block_list_header *)((long)blhdr->binfo[0].bnum);++ // we can free blhdr here since we won't need it any more+ blhdr->binfo[0].bnum = 0xdeadc0de;+ // get block_list_header_in_memory pointer, since this is what we really allocated in memory+ block_list_header_in_memory *blhdrim = BLHDR_TO_BLHDRIM(blhdr);+ hfs_free_data(blhdrim->buffers, tr->tbuffer_size - jnl->jhdr->blhdr_size);+ hfs_delete_with_hdr(blhdrim, block_list_header_in_memory, block_info, journal_max_blocks(jnl));+ }++ /*+ * If the transaction we're aborting was the async transaction, then+ * tell the current transaction that there is no pending trim+ * any more.+ */+ lck_rw_lock_exclusive(&jnl->trim_lock);+ if (jnl->async_trim == &tr->trim)+ jnl->async_trim = NULL;+ lck_rw_unlock_exclusive(&jnl->trim_lock);+++ if (tr->trim.extents) {+ hfs_delete_data(tr->trim.extents, dk_extent_t, tr->trim.allocated_count);+ }+ tr->trim.allocated_count = 0;+ tr->trim.extent_count = 0;+ tr->trim.extents = NULL;+ tr->tbuffer = NULL;+ tr->blhdr = NULL;+ tr->total_bytes = 0xdbadc0de;+ hfs_free_type(tr, transaction);++ KERNEL_DEBUG(0xbbbbc034|DBG_FUNC_END, jnl, tr, 0, 0, 0);+}+++int+journal_end_transaction(journal *jnl)+{+ int ret;+ transaction *tr;++ CHECK_JOURNAL(jnl);++ free_old_stuff(jnl);++ if ((jnl->flags & JOURNAL_INVALID) && jnl->owner == NULL) {+ return 0;+ }++ if (jnl->owner != current_thread()) {+ panic("jnl: end_tr: I'm not the owner! jnl %p, owner %p, curact %p\n",+ jnl, jnl->owner, current_thread());+ }+ jnl->nested_count--;++ if (jnl->nested_count > 0) {+ return 0;+ } else if (jnl->nested_count < 0) {+ panic("jnl: jnl @ %p has negative nested count (%d). bad boy.\n", jnl, jnl->nested_count);+ }++ if (jnl->flags & JOURNAL_INVALID) {+ if (jnl->active_tr) {+ if (jnl->cur_tr != NULL) {+ panic("jnl: journal @ %p has active tr (%p) and cur tr (%p)\n",+ jnl, jnl->active_tr, jnl->cur_tr);+ }+ tr = jnl->active_tr;+ jnl->active_tr = NULL;++ abort_transaction(jnl, tr);+ }+ journal_unlock(jnl);++ return EINVAL;+ }++ tr = jnl->active_tr;+ CHECK_TRANSACTION(tr);++ // clear this out here so that when check_free_space() calls+ // the FS flush function, we don't panic in journal_flush()+ // if the FS were to call that. note: check_free_space() is+ // called from end_transaction().+ //+ jnl->active_tr = NULL;++ /* Examine the force-journal-flush state in the active txn */+ if (tr->flush_on_completion == TRUE) {+ /*+ * If the FS requested it, disallow group commit and force the+ * transaction out to disk immediately.+ */+ ret = end_transaction(tr, 1, NULL, NULL, TRUE, TRUE);+ }+ else {+ /* in the common path we can simply use the double-buffered journal */+ ret = end_transaction(tr, 0, NULL, NULL, TRUE, FALSE);+ }++ return ret;+}+++/*+ * Flush the contents of the journal to the disk.+ *+ * Input:+ * wait_for_IO -+ * If TRUE, wait to write in-memory journal to the disk+ * consistently, and also wait to write all asynchronous+ * metadata blocks to its corresponding locations+ * consistently on the disk. This means that the journal+ * is empty at this point and does not contain any+ * transactions. This is overkill in normal scenarios+ * but is useful whenever the metadata blocks are required+ * to be consistent on-disk instead of just the journal+ * being consistent; like before live verification+ * and live volume resizing.+ *+ * If FALSE, only wait to write in-memory journal to the+ * disk consistently. This means that the journal still+ * contains uncommitted transactions and the file system+ * metadata blocks in the journal transactions might be+ * written asynchronously to the disk. But there is no+ * guarantee that they are written to the disk before+ * returning to the caller. Note that this option is+ * sufficient for file system data integrity as it+ * guarantees consistent journal content on the disk.+ */+int+journal_flush(journal *jnl, journal_flush_options_t options)+{+ boolean_t drop_lock = FALSE;+ errno_t error = 0;+ uint32_t flush_count = 0;++ CHECK_JOURNAL(jnl);++ free_old_stuff(jnl);++ if (jnl->flags & JOURNAL_INVALID) {+ return -1;+ }++ KDBG(DBG_JOURNAL_FLUSH | DBG_FUNC_START, jnl);++ if (jnl->owner != current_thread()) {+ journal_lock(jnl);+ drop_lock = TRUE;+ }++ if (ISSET(options, JOURNAL_FLUSH_FULL))+ flush_count = jnl->flush_counter;++ // if we're not active, flush any buffered transactions+ if (jnl->active_tr == NULL && jnl->cur_tr) {+ transaction *tr = jnl->cur_tr;++ jnl->cur_tr = NULL;++ if (ISSET(options, JOURNAL_WAIT_FOR_IO)) {+ wait_condition(jnl, &jnl->flushing, "journal_flush");+ wait_condition(jnl, &jnl->asyncIO, "journal_flush");+ }+ /*+ * "end_transction" will wait for any current async flush+ * to complete, before flushing "cur_tr"... because we've+ * specified the 'must_wait' arg as TRUE, it will then+ * synchronously flush the "cur_tr"+ */+ end_transaction(tr, 1, NULL, NULL, drop_lock, TRUE); // force it to get flushed++ } else {+ if (drop_lock == TRUE) {+ journal_unlock(jnl);+ }++ /* Because of pipelined journal, the journal transactions+ * might be in process of being flushed on another thread.+ * If there is nothing to flush currently, we should+ * synchronize ourselves with the pipelined journal thread+ * to ensure that all inflight transactions, if any, are+ * flushed before we return success to caller.+ */+ wait_condition(jnl, &jnl->flushing, "journal_flush");+ }+ if (ISSET(options, JOURNAL_WAIT_FOR_IO)) {+ wait_condition(jnl, &jnl->asyncIO, "journal_flush");+ }++ if (ISSET(options, JOURNAL_FLUSH_FULL)) {++ dk_synchronize_t sync_request = {+ .options = 0,+ };++ // We need a full cache flush. If it has not been done, do it here.+ if (flush_count == jnl->flush_counter)+ error = VNOP_IOCTL(jnl->jdev, DKIOCSYNCHRONIZE, (caddr_t)&sync_request, FWRITE, vfs_context_kernel());++ // If external journal partition is enabled, flush filesystem data partition.+ if (jnl->jdev != jnl->fsdev)+ error = VNOP_IOCTL(jnl->fsdev, DKIOCSYNCHRONIZE, (caddr_t)&sync_request, FWRITE, vfs_context_kernel());++ }++ KDBG(DBG_JOURNAL_FLUSH | DBG_FUNC_END, jnl);++ return 0;+}++int+journal_active(journal *jnl)+{+ if (jnl->flags & JOURNAL_INVALID) {+ return -1;+ }++ return (jnl->active_tr == NULL) ? 0 : 1;+}++void *+journal_owner(journal *jnl)+{+ return jnl->owner;+}++int journal_uses_fua(journal *jnl)+{+ if (jnl->flags & JOURNAL_DO_FUA_WRITES)+ return 1;+ return 0;+}++/*+ * Relocate the journal.+ *+ * You provide the new starting offset and size for the journal. You may+ * optionally provide a new tbuffer_size; passing zero defaults to not+ * changing the tbuffer size except as needed to fit within the new journal+ * size.+ *+ * You must have already started a transaction. The transaction may contain+ * modified blocks (such as those needed to deallocate the old journal,+ * allocate the new journal, and update the location and size of the journal+ * in filesystem-private structures). Any transactions prior to the active+ * transaction will be flushed to the old journal. The new journal will be+ * initialized, and the blocks from the active transaction will be written to+ * the new journal.+ *+ * The caller will need to update the structures that identify the location+ * and size of the journal. These updates should be made in the supplied+ * callback routine. These updates must NOT go into a transaction. You should+ * force these updates to the media before returning from the callback. In the+ * even of a crash, either the old journal will be found, with an empty journal,+ * or the new journal will be found with the contents of the active transaction.+ *+ * Upon return from the callback, the blocks from the active transaction are+ * written to their normal locations on disk.+ *+ * (Remember that we have to ensure that blocks get committed to the journal+ * before being committed to their normal locations. But the blocks don't count+ * as committed until the new journal is pointed at.)+ *+ * Upon return, there is still an active transaction: newly allocated, and+ * with no modified blocks. Call journal_end_transaction as normal. You may+ * modifiy additional blocks before calling journal_end_transaction, and those+ * blocks will (eventually) go to the relocated journal.+ *+ * Inputs:+ * jnl The (opened) journal to relocate.+ * offset The new journal byte offset (from start of the journal device).+ * journal_size The size, in bytes, of the new journal.+ * tbuffer_size The new desired transaction buffer size. Pass zero to keep+ * the same size as the current journal. The size will be+ * modified as needed to fit the new journal.+ * callback Routine called after the new journal has been initialized,+ * and the active transaction written to the new journal, but+ * before the blocks are written to their normal locations.+ * Pass NULL for no callback.+ * callback_arg An argument passed to the callback routine.+ *+ * Result:+ * 0 No errors+ * EINVAL The offset is not block aligned+ * EINVAL The journal_size is not a multiple of the block size+ * EINVAL The journal is invalid+ * (any) An error returned by journal_flush.+ *+ */+int journal_relocate(journal *jnl, off_t offset, off_t journal_size, int32_t tbuffer_size,+ errno_t (*callback)(void *), void *callback_arg)+{+ int ret;+ transaction *tr;+ size_t i = 0;++ /*+ * Sanity check inputs, and adjust the size of the transaction buffer.+ */+ if (jnl->jhdr->jhdr_size == 0) {+ printf("jnl: %s: relocate: bad jhdr size (%d)\n", jnl->jdev_name, jnl->jhdr->jhdr_size);+ return EINVAL;+ }++ if ((offset % jnl->jhdr->jhdr_size) != 0) {+ printf("jnl: %s: relocate: offset 0x%llx is not an even multiple of block size 0x%x\n",+ jnl->jdev_name, offset, jnl->jhdr->jhdr_size);+ return EINVAL;+ }+ if ((journal_size % jnl->jhdr->jhdr_size) != 0) {+ printf("jnl: %s: relocate: journal size 0x%llx is not an even multiple of block size 0x%x\n",+ jnl->jdev_name, journal_size, jnl->jhdr->jhdr_size);+ return EINVAL;+ }++ CHECK_JOURNAL(jnl);++ /* Guarantee we own the active transaction. */+ if (jnl->flags & JOURNAL_INVALID) {+ return EINVAL;+ }+ if (jnl->owner != current_thread()) {+ panic("jnl: relocate: Not the owner! jnl %p, owner %p, curact %p\n",+ jnl, jnl->owner, current_thread());+ }++ if (tbuffer_size == 0)+ tbuffer_size = jnl->tbuffer_size;+ size_up_tbuffer(jnl, tbuffer_size, jnl->jhdr->jhdr_size);++ /*+ * Flush any non-active transactions. We have to temporarily hide the+ * active transaction to make journal_flush flush out non-active but+ * current (unwritten) transactions.+ */+ tr = jnl->active_tr;+ CHECK_TRANSACTION(tr);+ jnl->active_tr = NULL;+ ret = journal_flush(jnl, JOURNAL_WAIT_FOR_IO);+ jnl->active_tr = tr;++ if (ret) {+ return ret;+ }+ wait_condition(jnl, &jnl->flushing, "end_transaction");++ /*+ * At this point, we have completely flushed the contents of the current+ * journal to disk (and have asynchronously written all of the txns to+ * their actual desired locations). As a result, we can (and must) clear+ * out the old_start array. If we do not, then if the last written transaction+ * started at the beginning of the journal (starting 1 block into the+ * journal file) it could confuse the buffer_flushed callback. This is+ * because we're about to reset the start/end pointers of the journal header+ * below.+ */+ lock_oldstart(jnl);+ for (i = 0; i < sizeof (jnl->old_start) / sizeof(jnl->old_start[0]); i++) {+ jnl->old_start[i] = 0;+ }+ unlock_oldstart(jnl);++ /* Update the journal's offset and size in memory. */+ jnl->jdev_offset = offset;+ jnl->jhdr->start = jnl->jhdr->end = jnl->jhdr->jhdr_size;+ jnl->jhdr->size = journal_size;+ jnl->active_start = jnl->jhdr->start;++ /*+ * Force the active transaction to be written to the new journal. Call the+ * supplied callback after the blocks have been written to the journal, but+ * before they get written to their normal on-disk locations.+ */+ jnl->active_tr = NULL;+ ret = end_transaction(tr, 1, callback, callback_arg, FALSE, TRUE);+ if (ret) {+ printf("jnl: %s: relocate: end_transaction failed (%d)\n", jnl->jdev_name, ret);+ goto bad_journal;+ }++ /*+ * Create a new, empty transaction to be the active transaction. This way+ * our caller can use journal_end_transaction as usual.+ */+ ret = journal_allocate_transaction(jnl);+ if (ret) {+ printf("jnl: %s: relocate: could not allocate new transaction (%d)\n", jnl->jdev_name, ret);+ goto bad_journal;+ }++ return 0;++bad_journal:+ jnl->flags |= JOURNAL_INVALID;+ abort_transaction(jnl, tr);+ return ret;+}++uint32_t journal_current_txn(journal *jnl)+{+ return jnl->sequence_num + (jnl->active_tr || jnl->cur_tr ? 0 : 1);+}diff --git a/xnu/files/bsd/hfs/hfs_journal.h b/xnu/files/bsd/hfs/hfs_journal.hnew file mode 100644index 0000000..594f574--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_journal.h@@ -0,0 +1,384 @@+/*+ * Copyright (c) 2000-2015 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@+ */+/*+ * This header contains the structures and function prototypes+ * for the vfs journaling code. The data types are not meant+ * to be modified by user code. Just use the functions and do+ * not mess around with the structs.+ */+#ifndef HFS_JOURNAL_H_+#define HFS_JOURNAL_H_++#include <sys/appleapiopts.h>+#include <sys/cdefs.h>++#ifdef __APPLE_API_UNSTABLE++#include <sys/types.h>+#include <kern/locks.h>+#include <sys/disk.h>+++typedef struct _blk_info {+ int32_t bsize;+ union {+ int32_t cksum;+ uint32_t sequence_num;+ } b;+} _blk_info;++typedef struct block_info {+ off_t bnum; // block # on the file system device+ union {+ _blk_info bi;+ struct buf *bp;+ } u;+} __attribute__((__packed__)) block_info;++typedef struct block_list_header {+ u_int16_t max_blocks; // max number of blocks in this chunk+ u_int16_t num_blocks; // number of valid block numbers in block_nums+ int32_t bytes_used; // how many bytes of this tbuffer are used+ uint32_t checksum; // on-disk: checksum of this header and binfo[0]+ int32_t flags; // check-checksums, initial blhdr, etc+ block_info binfo[]; // so we can reference them by name+} block_list_header;++typedef struct block_list_header_in_memory {+ char* buffers; // pointer to the actual buffers+ block_list_header blhdr;+} block_list_header_in_memory;++#define BLHDR_CHECK_CHECKSUMS 0x0001+#define BLHDR_FIRST_HEADER 0x0002+++struct journal;++struct jnl_trim_list {+ uint32_t allocated_count;+ uint32_t extent_count;+ dk_extent_t *extents;+};++typedef void (*jnl_trim_callback_t)(void *arg, uint32_t extent_count, const dk_extent_t *extents);++typedef struct transaction {+ int tbuffer_size; // in bytes+ char *tbuffer; // memory copy of the transaction+ block_list_header *blhdr; // points to the first byte of tbuffer+ int num_blhdrs; // how many buffers we've allocated+ int total_bytes; // total # of bytes in transaction+ int num_flushed; // how many bytes have been flushed+ int num_killed; // how many bytes were "killed"+ off_t journal_start; // where in the journal this transaction starts+ off_t journal_end; // where in the journal this transaction ends+ struct journal *jnl; // ptr back to the journal structure+ struct transaction *next; // list of tr's (either completed or to be free'd)+ uint32_t sequence_num;+ struct jnl_trim_list trim;+ boolean_t delayed_header_write;+ boolean_t flush_on_completion; //flush transaction immediately upon txn end.+} transaction;+++/*+ * This is written to block zero of the journal and it+ * maintains overall state about the journal.+ */+typedef struct journal_header {+ int32_t magic;+ int32_t endian;+ volatile off_t start; // zero-based byte offset of the start of the first transaction+ volatile off_t end; // zero-based byte offset of where free space begins+ off_t size; // size in bytes of the entire journal+ int32_t blhdr_size; // size in bytes of each block_list_header in the journal+ uint32_t checksum;+ int32_t jhdr_size; // block size (in bytes) of the journal header+ uint32_t sequence_num; // NEW FIELD: a monotonically increasing value assigned to all txn's+} journal_header;++#define JOURNAL_HEADER_MAGIC 0x4a4e4c78 // 'JNLx'+#define ENDIAN_MAGIC 0x12345678++//+// we only checksum the original size of the journal_header to remain+// backwards compatible. the size of the original journal_heade is+// everything up to the the sequence_num field, hence we use the+// offsetof macro to calculate the size.+//+#define JOURNAL_HEADER_CKSUM_SIZE (offsetof(struct journal_header, sequence_num))++#define OLD_JOURNAL_HEADER_MAGIC 0x4a484452 // 'JHDR'+++/*+ * In memory structure about the journal.+ */+typedef struct journal {+ lck_mtx_t jlock; // protects the struct journal data+ lck_mtx_t flock; // serializes flushing of journal+ lck_rw_t trim_lock; // protects the async_trim field, below+++ struct vnode *jdev; // vnode of the device where the journal lives+ off_t jdev_offset; // byte offset to the start of the journal+ const char *jdev_name;++ struct vnode *fsdev; // vnode of the file system device+ struct mount *fsmount; // mount of the file system++ void (*flush)(void *arg); // fs callback to flush meta data blocks+ void *flush_arg; // arg that's passed to flush()++ int32_t flags;+ int32_t tbuffer_size; // default transaction buffer size+ boolean_t flush_aborted;+ boolean_t flushing;+ boolean_t asyncIO;+ boolean_t writing_header;+ boolean_t write_header_failed;++ struct jnl_trim_list *async_trim; // extents to be trimmed by transaction being asynchronously flushed+ jnl_trim_callback_t trim_callback;+ void *trim_callback_arg;++ char *header_buf; // in-memory copy of the journal header+ int32_t header_buf_size;+ journal_header *jhdr; // points to the first byte of header_buf++ uint32_t saved_sequence_num;+ uint32_t sequence_num;++ off_t max_read_size;+ off_t max_write_size;++ transaction *cur_tr; // for group-commit+ transaction *completed_trs; // out-of-order transactions that completed+ transaction *active_tr; // for nested transactions+ int32_t nested_count; // for nested transactions+ void *owner; // a ptr that's unique to the calling process++ transaction *tr_freeme; // transaction structs that need to be free'd++ volatile off_t active_start; // the active start that we only keep in memory+ lck_mtx_t old_start_lock; // protects the old_start+ volatile off_t old_start[16]; // this is how we do lazy start update++ int last_flush_err; // last error from flushing the cache+ uint32_t flush_counter; // a monotonically increasing value assigned on track cache flush+} journal;++/* internal-only journal flags (top 16 bits) */+#define JOURNAL_CLOSE_PENDING 0x00010000+#define JOURNAL_INVALID 0x00020000+#define JOURNAL_FLUSHCACHE_ERR 0x00040000 // means we already printed this err+#define JOURNAL_NEED_SWAP 0x00080000 // swap any data read from disk+#define JOURNAL_DO_FUA_WRITES 0x00100000 // do force-unit-access writes+#define JOURNAL_USE_UNMAP 0x00200000 // device supports UNMAP (TRIM)+#define JOURNAL_FEATURE_BARRIER 0x00400000 // device supports barrier-only flush+#define JOURNAL_DEV_REVOKED 0x00800000 // journal device vnode has been revoked+++/* journal_open/create options are always in the low-16 bits */+#define JOURNAL_OPTION_FLAGS_MASK 0x0000ffff++__BEGIN_DECLS+/*+ * Prototypes.+ */++/*+ * Call journal_init() to initialize the journaling code (sets up lock attributes)+ */+void journal_init(void);++/*+ * Call journal_create() to create a new journal. You only+ * call this once, typically at file system creation time.+ *+ * The "jvp" argument is the vnode where the journal is written.+ * The journal starts at "offset" and is "journal_size" bytes long.+ *+ * The "fsvp" argument is the vnode of your file system. It may be+ * the same as "jvp".+ *+ * The "min_fs_block_size" argument is the minimum block size+ * (in bytes) that the file system will ever write. Typically+ * this is the block size of the file system (1k, 4k, etc) but+ * on HFS+ it is the minimum block size of the underlying device.+ *+ * The flags argument lets you disable group commit if you+ * want tighter guarantees on transactions (in exchange for+ * lower performance).+ *+ * The tbuffer_size is the size of the transaction buffer+ * used by the journal. If you specify zero, the journal code+ * will use a reasonable defaults. The tbuffer_size should+ * be an integer multiple of the min_fs_block_size.+ *+ * Returns a valid journal pointer or NULL if one could not+ * be created.+ */+journal *journal_create(struct vnode *jvp,+ off_t offset,+ off_t journal_size,+ struct vnode *fsvp,+ size_t min_fs_block_size,+ int32_t flags,+ int32_t tbuffer_size,+ void (*flush)(void *arg),+ void *arg,+ struct mount *fsmount);++/*+ * Call journal_open() when mounting an existing file system+ * that has a previously created journal. It will take care+ * of validating the journal and replaying it if necessary.+ *+ * See journal_create() for a description of the arguments.+ *+ * Returns a valid journal pointer of NULL if it runs into+ * trouble reading/playing back the journal.+ */+journal *journal_open(struct vnode *jvp,+ off_t offset,+ off_t journal_size,+ struct vnode *fsvp,+ size_t min_fs_block_size,+ int32_t flags,+ int32_t tbuffer_size,+ void (*flush)(void *arg),+ void *arg,+ struct mount *fsmount);++/*+ * Test whether the journal is clean or not. This is intended+ * to be used when you're mounting read-only. If the journal+ * is not clean for some reason then you should not mount the+ * volume as your data structures may be in an unknown state.+ */+int journal_is_clean(struct vnode *jvp,+ off_t offset,+ off_t journal_size,+ struct vnode *fsvp,+ size_t min_fs_block_size);+++/*+ * Call journal_close() just before your file system is unmounted.+ * It flushes any outstanding transactions and makes sure the+ * journal is in a consistent state.+ */+void journal_close(journal *journalp);++/*+ * flags for journal_create/open. only can use+ * the low 16 bits for flags because internal+ * bits go in the high 16.+ */+#define JOURNAL_NO_GROUP_COMMIT 0x00000001+#define JOURNAL_RESET 0x00000002++/*+ * Transaction related functions.+ *+ * Before you start modifying file system meta data, you+ * should call journal_start_transaction(). Then before+ * you modify each block, call journal_modify_block_start()+ * and when you're done, journal_modify_block_end(). When+ * you've modified the last block as part of a transaction,+ * call journal_end_transaction() to commit the changes.+ *+ * If you decide to abort the modifications to a block you+ * should call journal_modify_block_abort().+ *+ * If as part of a transaction you need want to throw out+ * any previous copies of a block (because it got deleted)+ * then call journal_kill_block(). This will mark it so+ * that the journal does not play it back (effectively+ * dropping it).+ *+ * journal_trim_add_extent() marks a range of bytes on the device which should+ * be trimmed (invalidated, unmapped). journal_trim_remove_extent() marks a+ * range of bytes which should no longer be trimmed. Accumulated extents+ * will be trimmed when the transaction is flushed to the on-disk journal.+ */+int journal_start_transaction(journal *jnl);+int journal_modify_block_start(journal *jnl, struct buf *bp);+int journal_modify_block_abort(journal *jnl, struct buf *bp);+int journal_modify_block_end(journal *jnl, struct buf *bp, void (*func)(struct buf *bp, void *arg), void *arg);+int journal_kill_block(journal *jnl, struct buf *bp);+int journal_trim_add_extent(journal *jnl, uint64_t offset, uint64_t length);+int journal_trim_remove_extent(journal *jnl, uint64_t offset, uint64_t length);+void journal_trim_set_callback(journal *jnl, jnl_trim_callback_t callback, void *arg);+int journal_trim_extent_overlap (journal *jnl, uint64_t offset, uint64_t length, uint64_t *end);+/* Mark state in the journal that requests an immediate journal flush upon txn completion */+int journal_request_immediate_flush (journal *jnl);+int journal_end_transaction(journal *jnl);++int journal_active(journal *jnl);++typedef enum journal_flush_options {+ JOURNAL_WAIT_FOR_IO = 0x01, // Flush journal and metadata blocks, wait for async IO to complete.+ JOURNAL_FLUSH_FULL = 0x02, // Flush track cache to media+} journal_flush_options_t;++int journal_flush(journal *jnl, journal_flush_options_t options);+void *journal_owner(journal *jnl); // compare against current_thread()+int journal_uses_fua(journal *jnl);+void journal_lock(journal *jnl);+void journal_unlock(journal *jnl);+++/*+ * Relocate the journal.+ *+ * You provide the new starting offset and size for the journal. You may+ * optionally provide a new tbuffer_size; passing zero defaults to not+ * changing the tbuffer size except as needed to fit within the new journal+ * size.+ *+ * You must have already started a transaction. The transaction may contain+ * modified blocks (such as those needed to deallocate the old journal,+ * allocate the new journal, and update the location and size of the journal+ * in filesystem-private structures). Any transactions prior to the active+ * transaction will be flushed to the old journal. The new journal will be+ * initialized, and the blocks from the active transaction will be written to+ * the new journal. The caller will need to update the structures that+ * identify the location and size of the journal from the callback routine.+ */+int journal_relocate(journal *jnl, off_t offset, off_t journal_size, int32_t tbuffer_size,+ errno_t (*callback)(void *), void *callback_arg);++uint32_t journal_current_txn(journal *jnl);++__END_DECLS++#endif /* __APPLE_API_UNSTABLE */+#endif /* !HFS_JOURNAL_H_ */diff --git a/xnu/files/bsd/hfs/hfs_kdebug.h b/xnu/files/bsd/hfs/hfs_kdebug.hnew file mode 100644index 0000000..827fc4f--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_kdebug.h@@ -0,0 +1,114 @@+/*+ * Copyright (c) 2014 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@+ */+#ifndef HFS_KDEBUG_H_+#define HFS_KDEBUG_H_++#include <sys/kdebug.h>++/*+ * KERNEL_DEBUG related definitions for HFS.+ *+ * NOTE: The Class DBG_FSYSTEM = 3, and Subclass DBG_HFS = 8, so these+ * debug codes are of the form 0x0308nnnn.+ */+#define HFSDBG_CODE(code) FSDBG_CODE(DBG_HFS, code)++enum {+ HFSDBG_WRITE = FSDBG_CODE(DBG_FSRW, 0), /* 0x3010000 */+ HFSDBG_TRUNCATE = FSDBG_CODE(DBG_FSRW, 7), /* 0x301001C */+ HFSDBG_READ = FSDBG_CODE(DBG_FSRW, 12), /* 0x3010030 */+ HFSDBG_GETNEWVNODE = FSDBG_CODE(DBG_FSRW, 37), /* 0x3010094 */+ HFSDBG_UPDATE = FSDBG_CODE(DBG_FSRW, 8192), /* 0x3018000 */+ HFSDBG_UNMAP_FREE = HFSDBG_CODE(0), /* 0x03080000 */+ HFSDBG_UNMAP_ALLOC = HFSDBG_CODE(1), /* 0x03080004 */+ HFSDBG_UNMAP_CALLBACK = HFSDBG_CODE(2), /* 0x03080008 */+ /* 0x0308000C is unused */+ HFSDBG_BLOCK_ALLOCATE = HFSDBG_CODE(4), /* 0x03080010 */+ HFSDBG_BLOCK_DEALLOCATE = HFSDBG_CODE(5), /* 0x03080014 */+ HFSDBG_READ_BITMAP_BLOCK = HFSDBG_CODE(6), /* 0x03080018 */+ HFSDBG_RELEASE_BITMAP_BLOCK = HFSDBG_CODE(7), /* 0x0308001C */+ HFSDBG_FIND_CONTIG_BITMAP = HFSDBG_CODE(8), /* 0x03080020 */+ HFSDBG_ALLOC_ANY_BITMAP = HFSDBG_CODE(9), /* 0x03080024 */+ HFSDBG_ALLOC_FIND_KNOWN = HFSDBG_CODE(10), /* 0x03080028 */+ HFSDBG_MARK_ALLOC_BITMAP = HFSDBG_CODE(11), /* 0x0308002C */+ HFSDBG_MARK_FREE_BITMAP = HFSDBG_CODE(12), /* 0x03080030 */+ HFSDBG_BLOCK_FIND_CONTIG = HFSDBG_CODE(13), /* 0x03080034 */+ HFSDBG_IS_ALLOCATED = HFSDBG_CODE(14), /* 0x03080038 */+ /* 0x0308003C is unused */+ HFSDBG_RESET_EXTENT_CACHE = HFSDBG_CODE(16), /* 0x03080040 */+ HFSDBG_REMOVE_EXTENT_CACHE = HFSDBG_CODE(17), /* 0x03080044 */+ HFSDBG_ADD_EXTENT_CACHE = HFSDBG_CODE(18), /* 0x03080048 */+ HFSDBG_READ_BITMAP_RANGE = HFSDBG_CODE(19), /* 0x0308004C */+ HFSDBG_RELEASE_SCAN_BITMAP = HFSDBG_CODE(20), /* 0x03080050 */+ HFSDBG_SYNCER = HFSDBG_CODE(21), /* 0x03080054 */+ HFSDBG_SYNCER_TIMED = HFSDBG_CODE(22), /* 0x03080058 */+ HFSDBG_UNMAP_SCAN = HFSDBG_CODE(23), /* 0x0308005C */+ HFSDBG_UNMAP_SCAN_TRIM = HFSDBG_CODE(24), /* 0x03080060 */+};++/*+ Parameters logged by the above tracepoints:+---------------------------------------------------------------------------------------------------------------------------------+ CODE EVENT NAME DBG_FUNC_START arg1, arg2, arg3, arg4, arg5 ... DBG_FUNC_END arg1, arg2, arg3, arg4, arg5+ DBG_FUNC_NONE arg1, arg2, arg3, arg4, arg5+---------------------------------------------------------------------------------------------------------------------------------+0x3010000 HFSDBG_WRITE offset, uio_resid, ff_size, filebytes, 0 ... uio_offset, uio_resid, ff_size, filebytes, 0+ offset, uio_resid, ff_size, filebytes, 0+0x301001C HFSDBG_TRUNCATE length, ff_size, filebytes, 0, 0 ... length, ff_size, filebytes, retval, 0+ length, ff_size, filebytes, 0, 0+0x3010030 HFSDBG_READ uio_offset, uio_resid, filesize, filebytes, 0 ... uio_offset, uio_resid, filesize, filebytes, 0+0x3010094 HFSDBG_GETNEWVNODE c_vp, c_rsrc_vp, 0, 0, 0+0x3018000 HFSDBG_UPDATE vp, tstate, 0, 0, 0 ... vp, tstate, error, 0/-1, 0+ 0 HFSDBG_UNMAP_FREE startBlock, blockCount, 0, 0, 0 ... err, 0, 0, 0, 0+ 1 HFSDBG_UNMAP_ALLOC startBlock, blockCount, 0, 0, 0 ... err, 0, 0, 0, 0+ 2 HFSDBG_UNMAP_CALLBACK 0, extentCount, 0, 0, 0 ... 0, 0, 0, 0, 0+ 3 unused+ 4 HFSDBG_BLOCK_ALLOCATE startBlock, minBlocks, maxBlocks, flags, 0 ... err, actualStartBlock, actualBlockCount, 0, 0+ 5 HFSDBG_BLOCK_DEALLOCATE startBlock, blockCount, flags, 0, 0 ... err, 0, 0, 0, 0+ 6 HFSDBG_READ_BITMAP_BLOCK startBlock, 0, 0, 0, 0 ... err, 0, 0, 0, 0+ 7 HFSDBG_RELEASE_BITMAP_BLOCK dirty, 0, 0, 0, 0 ... 0, 0, 0, 0, 0+ 8 HFSDBG_FIND_CONTIG_BITMAP startBlock, minBlocks, maxBlocks, useMeta, 0 ... err, actualStartBlock, actualBlockCount, 0, 0+ 9 HFSDBG_ALLOC_ANY_BITMAP startBlock, endBlock, maxBlocks, useMeta, 0 ... err, actualStartBlock, actualBlockCount, 0, 0+ 10 HFSDBG_ALLOC_FIND_KNOWN 0, 0, maxBlocks, 0, 0 ... err, actualStartBlock, actualBlockCount, 0, 0+ 11 HFSDBG_MARK_ALLOC_BITMAP startBlock, blockCount, flags, 0, 0 ... err, 0, 0, 0, 0+ 12 HFSDBG_MARK_FREE_BITMAP startBlock, blockCount, valid, 0, 0 ... err, 0, 0, 0, 0+ 13 HFSDBG_BLOCK_FIND_CONTIG startBlock, endBlock, minBlocks, maxBlocks, 0 ... err, actualStartBlock, actualBlockCount, 0, 0+ 14 HFSDBG_IS_ALLOCATED startBlock, blockCount, stop, 0, 0 ... err, 0, actualBlockCount, 0, 0+ 15 unused+ 16 HFSDBG_RESET_EXTENT_CACHE 0, 0, 0, 0, 0 ... 0, 0, 0, 0, 0+ 17 HFSDBG_REMOVE_EXTENT_CACHE startBlock, blockCount, vcbFreeExtCnt, 0, 0 ... 0, 0, vcbFreeExtCnt, extentsRemoved, 0+ 18 HFSDBG_ADD_EXTENT_CACHE startBlock, blockCount, vcbFreeExtCnt, 0, 0 ... 0, 0, vcbFreeExtCnt, retval, 0+ 19 HFSDBG_READ_BITMAP_RANGE startBlock, iosize, 0, 0, 0 ... err, 0, 0, 0, 0+ 20 HFSDBG_RELEASE_SCAN_BITMAP 0, 0, 0, 0, 0 ... 0, 0, 0, 0, 0+ 21 HFSDBG_SYNCER hfsmp, now, mnt_last_write_completed_timestamp, mnt_pending_write_size, 0 ... err, deadline, 0, 0, 0+ 22 HFSDBG_SYNCER_TIMED now, last_write_completed, hfs_mp->mnt_last_write_issued_timestamp, mnt_pending_write_size, 0 ... now, mnt_last_write_completed_timestamp, mnt_last_write_issued_timestamp, hfs_mp->mnt_pending_write_size, 0+ 23 HFSDBG_UNMAP_SCAN hfs_raw_dev, 0, 0, 0, 0 ... hfs_raw_dev, error, 0, 0, 0+ 24 HFSDBG_UNMAP_TRIM hfs_raw_dev, 0, 0, 0, 0 ... hfs_raw_dev, error, 0, 0, 0+*/++#endif // HFS_KDEBUG_H_diff --git a/xnu/files/bsd/hfs/hfs_link.c b/xnu/files/bsd/hfs/hfs_link.cnew file mode 100644index 0000000..880fdb0--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_link.c@@ -0,0 +1,1419 @@+/*+ * Copyright (c) 1999-2015 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@+ */+++#include <sys/systm.h>+#include <sys/kernel.h>+#include <sys/malloc.h>+#include <sys/mount.h>+#include <sys/stat.h>+#include <sys/vnode.h>+#include <vfs/vfs_support.h>+#include <libkern/libkern.h>+#include <sys/fsctl.h>++#include "hfs.h"+#include "hfs_catalog.h"+#include "hfs_format.h"+#include "hfs_endian.h"+++static int cur_link_id = 0;++/*+ * Private directories where hardlink inodes reside.+ */+const char *hfs_private_names[] = {+ HFSPLUSMETADATAFOLDER, /* FILE HARDLINKS */+ HFSPLUS_DIR_METADATA_FOLDER /* DIRECTORY HARDLINKS */+};+++/*+ * Hardlink inodes save the head of their link chain in a+ * private extended attribute. The following calls are+ * used to access this attribute.+ */+static int setfirstlink(struct hfsmount * hfsmp, cnid_t fileid, cnid_t firstlink);+static int getfirstlink(struct hfsmount * hfsmp, cnid_t fileid, cnid_t *firstlink);++/*+ * Create a new catalog link record+ *+ * An indirect link is a reference to an inode (the real+ * file or directory record).+ *+ * All the indirect links for a given inode are chained+ * together in a doubly linked list.+ *+ * Pre-Leopard file hard links do not have kHFSHasLinkChainBit+ * set and do not have first/prev/next link IDs i.e. the values+ * are zero. If a new link is being added to an existing+ * pre-Leopard file hard link chain, do not set kHFSHasLinkChainBit.+ */+static int+createindirectlink(struct hfsmount *hfsmp, u_int32_t linknum, struct cat_desc *descp,+ cnid_t nextcnid, cnid_t *linkcnid, int is_inode_linkchain_set)+{+ struct FndrFileInfo *fip;+ struct cat_attr attr;++ if (linknum == 0) {+ printf("hfs: createindirectlink: linknum is zero!\n");+ return (EINVAL);+ }++ /* Setup the default attributes */+ bzero(&attr, sizeof(attr));++ /* Links are matched to inodes by link ID and to volumes by create date */+ attr.ca_linkref = linknum;+ attr.ca_itime = hfsmp->hfs_metadata_createdate;+ attr.ca_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH;+ attr.ca_recflags = kHFSHasLinkChainMask | kHFSThreadExistsMask;+ attr.ca_flags = UF_IMMUTABLE;+ fip = (struct FndrFileInfo *)&attr.ca_finderinfo;++ if (descp->cd_flags & CD_ISDIR) {+ fip->fdType = SWAP_BE32 (kHFSAliasType);+ fip->fdCreator = SWAP_BE32 (kHFSAliasCreator);+ fip->fdFlags = SWAP_BE16 (kIsAlias);+ } else /* file */ {+ fip->fdType = SWAP_BE32 (kHardLinkFileType);+ fip->fdCreator = SWAP_BE32 (kHFSPlusCreator);+ fip->fdFlags = SWAP_BE16 (kHasBeenInited);+ /* If the file inode does not have kHFSHasLinkChainBit set+ * and the next link chain ID is zero, assume that this+ * is pre-Leopard file inode. Therefore clear the bit.+ */+ if ((is_inode_linkchain_set == 0) && (nextcnid == 0)) {+ attr.ca_recflags &= ~kHFSHasLinkChainMask;+ }+ }+ /* Create the indirect link directly in the catalog */+ return cat_createlink(hfsmp, descp, &attr, nextcnid, linkcnid);+}+++/*+ * Make a link to the cnode cp in the directory dp+ * using the name in cnp. src_vp is the vnode that+ * corresponds to 'cp' which was part of the arguments to+ * hfs_vnop_link.+ *+ * The cnodes cp and dcp must be locked.+ */+static int+hfs_makelink(struct hfsmount *hfsmp, struct vnode *src_vp, struct cnode *cp,+ struct cnode *dcp, struct componentname *cnp, vfs_context_t ctx)+{+ struct proc *p = vfs_context_proc(ctx);+ u_int32_t indnodeno = 0;+ char inodename[32];+ struct cat_desc to_desc;+ struct cat_desc link_desc;+ int newlink = 0;+ int lockflags;+ int retval = 0;+ cat_cookie_t cookie;+ cnid_t orig_cnid;+ cnid_t linkcnid = 0;+ cnid_t orig_firstlink;+ enum privdirtype type;++ type = S_ISDIR(cp->c_mode) ? DIR_HARDLINKS : FILE_HARDLINKS;++ if (cur_link_id == 0) {+ cur_link_id = ((random() & 0x3fffffff) + 100);+ }++ /* We don't allow link nodes in our private system directories. */+ if (dcp->c_fileid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid ||+ dcp->c_fileid == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {+ return (EPERM);+ }++ bzero(&cookie, sizeof(cat_cookie_t));+ /* Reserve some space in the Catalog file. */+ if ((retval = cat_preflight(hfsmp, (2 * CAT_CREATE)+ CAT_RENAME, &cookie, p))) {+ return (retval);+ }++ lockflags = SFL_CATALOG | SFL_ATTRIBUTE;+ /* Directory hard links allocate space for a symlink. */+ if (type == DIR_HARDLINKS) {+ lockflags |= SFL_BITMAP;+ }+ lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);++ /* Save the current cnid value so we restore it if an error occurs. */+ orig_cnid = cp->c_desc.cd_cnid;++ /*+ * If this is a new hardlink then we need to create the inode+ * and replace the original file/dir object with a link node.+ */+ if ((cp->c_linkcount == 2) && !(cp->c_flag & C_HARDLINK)) {+ newlink = 1;+ bzero(&to_desc, sizeof(to_desc));+ to_desc.cd_parentcnid = hfsmp->hfs_private_desc[type].cd_cnid;+ to_desc.cd_cnid = cp->c_fileid;+ to_desc.cd_flags = (type == DIR_HARDLINKS) ? CD_ISDIR : 0;++ do {+ if (type == DIR_HARDLINKS) {+ /* Directory hardlinks always use the cnid. */+ indnodeno = cp->c_fileid;+ MAKE_DIRINODE_NAME(inodename, sizeof(inodename),+ indnodeno);+ } else {+ /* Get a unique indirect node number */+ if (retval == 0) {+ indnodeno = cp->c_fileid;+ } else {+ indnodeno = cur_link_id++;+ }+ MAKE_INODE_NAME(inodename, sizeof(inodename),+ indnodeno);+ }+ /* Move original file/dir to data node directory */+ to_desc.cd_nameptr = (const u_int8_t *)inodename;+ to_desc.cd_namelen = strlen(inodename);++ retval = cat_rename(hfsmp, &cp->c_desc, &hfsmp->hfs_private_desc[type],+ &to_desc, NULL);++ if (retval != 0 && retval != EEXIST) {+ printf("hfs_makelink: cat_rename to %s failed (%d) fileid=%d, vol=%s\n",+ inodename, retval, cp->c_fileid, hfsmp->vcbVN);+ }+ } while ((retval == EEXIST) && (type == FILE_HARDLINKS));+ if (retval)+ goto out;++ /*+ * Replace original file/dir with a link record.+ */++ bzero(&link_desc, sizeof(link_desc));+ link_desc.cd_nameptr = cp->c_desc.cd_nameptr;+ link_desc.cd_namelen = cp->c_desc.cd_namelen;+ link_desc.cd_parentcnid = cp->c_parentcnid;+ link_desc.cd_flags = S_ISDIR(cp->c_mode) ? CD_ISDIR : 0;++ retval = createindirectlink(hfsmp, indnodeno, &link_desc, 0, &linkcnid, true);+ if (retval) {+ int err;++ /* Restore the cnode's cnid. */+ cp->c_desc.cd_cnid = orig_cnid;++ /* Put the original file back. */+ err = cat_rename(hfsmp, &to_desc, &dcp->c_desc, &cp->c_desc, NULL);+ if (err) {+ if (err != EIO && err != ENXIO)+ printf("hfs_makelink: error %d from cat_rename backout 1", err);+ hfs_mark_inconsistent(hfsmp, HFS_ROLLBACK_FAILED);+ }+ if (retval != EIO && retval != ENXIO) {+ printf("hfs_makelink: createindirectlink (1) failed: %d\n", retval);+ retval = EIO;+ }+ goto out;+ }+ cp->c_attr.ca_linkref = indnodeno;+ cp->c_desc.cd_cnid = linkcnid;+ /* Directory hard links store the first link in an attribute. */+ if (type == DIR_HARDLINKS) {+ if (setfirstlink(hfsmp, cp->c_fileid, linkcnid) == 0)+ cp->c_attr.ca_recflags |= kHFSHasAttributesMask;+ } else /* FILE_HARDLINKS */ {+ cp->c_attr.ca_firstlink = linkcnid;+ }+ cp->c_attr.ca_recflags |= kHFSHasLinkChainMask;+ } else {+ indnodeno = cp->c_attr.ca_linkref;+ }++ /*+ * Create a catalog entry for the new link (parentID + name).+ */++ bzero(&link_desc, sizeof(link_desc));+ link_desc.cd_nameptr = (const u_int8_t *)cnp->cn_nameptr;+ link_desc.cd_namelen = strlen(cnp->cn_nameptr);+ link_desc.cd_parentcnid = dcp->c_fileid;+ link_desc.cd_flags = S_ISDIR(cp->c_mode) ? CD_ISDIR : 0;++ /* Directory hard links store the first link in an attribute. */+ if (type == DIR_HARDLINKS) {+ retval = getfirstlink(hfsmp, cp->c_fileid, &orig_firstlink);+ } else /* FILE_HARDLINKS */ {+ orig_firstlink = cp->c_attr.ca_firstlink;+ }+ if (retval == 0)+ retval = createindirectlink(hfsmp, indnodeno, &link_desc,+ orig_firstlink, &linkcnid,+ (cp->c_attr.ca_recflags & kHFSHasLinkChainMask));+ if (retval && newlink) {+ int err;++ /* Get rid of new link */+ (void) cat_delete(hfsmp, &cp->c_desc, &cp->c_attr);++ /* Restore the cnode's cnid. */+ cp->c_desc.cd_cnid = orig_cnid;++ /* Put the original file back. */+ err = cat_rename(hfsmp, &to_desc, &dcp->c_desc, &cp->c_desc, NULL);+ if (err) {+ if (err != EIO && err != ENXIO)+ printf("hfs_makelink: error %d from cat_rename backout 2", err);+ hfs_mark_inconsistent(hfsmp, HFS_ROLLBACK_FAILED);+ }++ cp->c_attr.ca_linkref = 0;++ if (retval != EIO && retval != ENXIO) {+ printf("hfs_makelink: createindirectlink (2) failed: %d\n", retval);+ retval = EIO;+ }+ goto out;+ } else if (retval == 0) {++ /* Update the original first link to point back to the new first link. */+ if (cp->c_attr.ca_recflags & kHFSHasLinkChainMask) {+ (void) cat_update_siblinglinks(hfsmp, orig_firstlink, linkcnid, HFS_IGNORABLE_LINK);++ /* Update the inode's first link value. */+ if (type == DIR_HARDLINKS) {+ if (setfirstlink(hfsmp, cp->c_fileid, linkcnid) == 0)+ cp->c_attr.ca_recflags |= kHFSHasAttributesMask;+ } else {+ cp->c_attr.ca_firstlink = linkcnid;+ }+ }+ /*+ * Finally, if this is a new hardlink then:+ * - update the private system directory+ * - mark the cnode as a hard link+ */+ if (newlink) {+ vnode_t vp;++ hfsmp->hfs_private_attr[type].ca_entries++;+ /* From application perspective, directory hard link is a+ * normal directory. Therefore count the new directory+ * hard link for folder count calculation.+ */+ if (type == DIR_HARDLINKS) {+ INC_FOLDERCOUNT(hfsmp, hfsmp->hfs_private_attr[type]);+ }+ retval = cat_update(hfsmp, &hfsmp->hfs_private_desc[type],+ &hfsmp->hfs_private_attr[type], NULL, NULL);+ if (retval) {+ if (retval != EIO && retval != ENXIO) {+ printf("hfs_makelink: cat_update of privdir failed! (%d)\n", retval);+ retval = EIO;+ }+ hfs_mark_inconsistent(hfsmp, HFS_OP_INCOMPLETE);+ }+ cp->c_flag |= C_HARDLINK;++ /*+ * Now we need to mark the vnodes as being hardlinks via the vnode_setmultipath call.+ * Note that we're calling vnode_get here, which should simply add an iocount if possible, without+ * doing much checking. It's safe to call this because we are protected by the cnode lock, which+ * ensures that anyone trying to reclaim it will block until we release it. vnode_get will usually+ * give us an extra iocount, unless the vnode is about to be reclaimed (and has no iocounts).+ * In that case, we'd error out, but we'd also not care if we added the VISHARDLINK bit to the vnode.+ *+ * As for the iocount we're about to add, we can't necessarily always call vnode_put here.+ * If the one we add is the only iocount on the vnode, and there was+ * sufficient vnode pressure, it could go through VNOP_INACTIVE immediately, which would+ * require the cnode lock and cause us to double-lock panic. We can only call vnode_put if we know+ * that the vnode we're operating on is the one with which we came into hfs_vnop_link, because+ * that means VFS took an iocount on it for us. If it's *not* the one that we came into the call+ * with, then mark it as NEED_VNODE_PUT to have hfs_unlock drop it for us. hfs_vnop_link will+ * unlock the cnode when it is finished.+ */+ if ((vp = cp->c_vp) != NULLVP) {+ if (vnode_get(vp) == 0) {+ vnode_setmultipath(vp);+ if (vp == src_vp) {+ /* we have an iocount on data fork vnode already. */+ vnode_put(vp);+ }+ else {+ cp->c_flag |= C_NEED_DVNODE_PUT;+ }+ }+ }+ if ((vp = cp->c_rsrc_vp) != NULLVP) {+ if (vnode_get(vp) == 0) {+ vnode_setmultipath(vp);+ if (vp == src_vp) {+ vnode_put(vp);+ }+ else {+ cp->c_flag |= C_NEED_RVNODE_PUT;+ }+ }+ }+ cp->c_flag |= C_MODIFIED;+ cp->c_touch_chgtime = TRUE;+ }+ }+out:+ hfs_systemfile_unlock(hfsmp, lockflags);++ cat_postflight(hfsmp, &cookie, p);++ if (retval == 0 && newlink) {+ hfs_volupdate(hfsmp, VOL_MKFILE, 0);+ }+ return (retval);+}+++/*+ * link vnode operation+ *+ * IN vnode_t a_vp;+ * IN vnode_t a_tdvp;+ * IN struct componentname *a_cnp;+ * IN vfs_context_t a_context;+ */+int+hfs_vnop_link(struct vnop_link_args *ap)+{+ struct hfsmount *hfsmp;+ struct vnode *vp = ap->a_vp;+ struct vnode *tdvp = ap->a_tdvp;+ struct vnode *fdvp = NULLVP;+ struct componentname *cnp = ap->a_cnp;+ struct cnode *cp;+ struct cnode *tdcp;+ struct cnode *fdcp = NULL;+ struct cat_desc todesc;+ cnid_t parentcnid;+ int lockflags = 0;+ int intrans = 0;+ enum vtype v_type;+ int error, ret;++ hfsmp = VTOHFS(vp);+ v_type = vnode_vtype(vp);++ /* No hard links in HFS standard file systems. */+ if (hfsmp->hfs_flags & HFS_STANDARD) {+ return (ENOTSUP);+ }+ /* Linking to a special file is not permitted. */+ if (v_type == VBLK || v_type == VCHR) {+ return (EPERM);+ }++ /*+ * For now, return ENOTSUP for a symlink target. This can happen+ * for linkat(2) when called without AT_SYMLINK_FOLLOW.+ */+ if (v_type == VLNK)+ return (ENOTSUP);++ cp = VTOC(vp);++ if (v_type == VDIR) {+#if CONFIG_HFS_DIRLINK+ /* Make sure our private directory exists. */+ if (hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid == 0) {+ return (EPERM);+ }+ /*+ * Directory hardlinks (ADLs) have only been qualified on+ * journaled HFS+. If/when they are tested on non-journaled+ * file systems then this test can be removed.+ */+ if (hfsmp->jnl == NULL) {+ return (EPERM);+ }++ /* Directory hardlinks also need the parent of the original directory. */+ if ((error = hfs_vget(hfsmp, hfs_currentparent(cp, /* have_lock: */ false),+ &fdvp, 1, 0))) {+ return (error);+ }+#else+ /* some platforms don't support directory hardlinks. */+ return EPERM;+#endif+ } else {+ /* Make sure our private directory exists. */+ if (hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid == 0) {+ return (ENOTSUP);+ }+ }+ if (hfs_freeblks(hfsmp, 0) == 0) {+ if (fdvp) {+ vnode_put(fdvp);+ }+ return (ENOSPC);+ }++ nspace_snapshot_event(vp, VTOC(vp)->c_ctime, NAMESPACE_HANDLER_LINK_CREATE, NULL);++ /* Lock the cnodes. */+ if (fdvp) {+ if ((error = hfs_lockfour(VTOC(tdvp), VTOC(vp), VTOC(fdvp), NULL, HFS_EXCLUSIVE_LOCK, NULL))) {+ if (fdvp) {+ vnode_put(fdvp);+ }+ return (error);+ }+ fdcp = VTOC(fdvp);+ } else {+ if ((error = hfs_lockpair(VTOC(tdvp), VTOC(vp), HFS_EXCLUSIVE_LOCK))) {+ return (error);+ }+ }+ tdcp = VTOC(tdvp);+ /* grab the parent CNID from originlist after grabbing cnode locks */+ parentcnid = hfs_currentparent(cp, /* have_lock: */ true);++ /*+ * Make sure we didn't race the src or dst parent directories with rmdir.+ * Note that we should only have a src parent directory cnode lock+ * if we're dealing with a directory hardlink here.+ */+ if (fdcp) {+ if (fdcp->c_flag & (C_NOEXISTS | C_DELETED)) {+ error = ENOENT;+ goto out;+ }+ }++ if (tdcp->c_flag & (C_NOEXISTS | C_DELETED)) {+ error = ENOENT;+ goto out;+ }++ /* Check the source for errors:+ * too many links, immutable, race with unlink+ */+ if (cp->c_linkcount >= HFS_LINK_MAX) {+ error = EMLINK;+ goto out;+ }+ if (cp->c_bsdflags & (IMMUTABLE | APPEND)) {+ error = EPERM;+ goto out;+ }+ if (cp->c_flag & (C_NOEXISTS | C_DELETED)) {+ error = ENOENT;+ goto out;+ }++ tdcp->c_flag |= C_DIR_MODIFICATION;++ if (hfs_start_transaction(hfsmp) != 0) {+ error = EINVAL;+ goto out;+ }+ intrans = 1;++ todesc.cd_flags = (v_type == VDIR) ? CD_ISDIR : 0;+ todesc.cd_encoding = 0;+ todesc.cd_nameptr = (const u_int8_t *)cnp->cn_nameptr;+ todesc.cd_namelen = cnp->cn_namelen;+ todesc.cd_parentcnid = tdcp->c_fileid;+ todesc.cd_hint = 0;+ todesc.cd_cnid = 0;++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);++ /* If destination exists then we lost a race with create. */+ if (cat_lookup(hfsmp, &todesc, 0, 0, NULL, NULL, NULL, NULL) == 0) {+ error = EEXIST;+ goto out;+ }+ if (cp->c_flag & C_HARDLINK) {+ struct cat_attr cattr;++ /* If inode is missing then we lost a race with unlink. */+ if ((cat_idlookup(hfsmp, cp->c_fileid, 0, 0, NULL, &cattr, NULL) != 0) ||+ (cattr.ca_fileid != cp->c_fileid)) {+ error = ENOENT;+ goto out;+ }+ } else {+ cnid_t fileid;++ /* If source is missing then we lost a race with unlink. */+ if ((cat_lookup(hfsmp, &cp->c_desc, 0, 0, NULL, NULL, NULL, &fileid) != 0) ||+ (fileid != cp->c_fileid)) {+ error = ENOENT;+ goto out;+ }+ }+ /*+ * All directory links must reside in an non-ARCHIVED hierarchy.+ */+ if (v_type == VDIR) {+ /*+ * - Source parent and destination parent cannot match+ * - A link is not permitted in the root directory+ * - Parent of 'pointed at' directory is not the root directory+ * - The 'pointed at' directory (source) is not an ancestor+ * of the new directory hard link (destination).+ * - No ancestor of the new directory hard link (destination)+ * is a directory hard link.+ */+ if ((parentcnid == tdcp->c_fileid) ||+ (tdcp->c_fileid == kHFSRootFolderID) ||+ (parentcnid == kHFSRootFolderID) ||+ cat_check_link_ancestry(hfsmp, tdcp->c_fileid, cp->c_fileid)) {+ error = EPERM; /* abide by the rules, you did not */+ goto out;+ }+ }+ hfs_systemfile_unlock(hfsmp, lockflags);+ lockflags = 0;++ cp->c_linkcount++;+ cp->c_flag |= C_MODIFIED;+ cp->c_touch_chgtime = TRUE;+ error = hfs_makelink(hfsmp, vp, cp, tdcp, cnp, ap->a_context);+ if (error) {+ cp->c_linkcount--;+ hfs_volupdate(hfsmp, VOL_UPDATE, 0);+ } else {+ /* Invalidate negative cache entries in the destination directory */+ if (tdcp->c_flag & C_NEG_ENTRIES) {+ cache_purge_negatives(tdvp);+ tdcp->c_flag &= ~C_NEG_ENTRIES;+ }++ /* Update the target directory and volume stats */+ tdcp->c_entries++;+ if (v_type == VDIR) {+ INC_FOLDERCOUNT(hfsmp, tdcp->c_attr);+ tdcp->c_attr.ca_recflags |= kHFSHasChildLinkMask;++ /* Set kHFSHasChildLinkBit in the destination hierarchy */+ error = cat_set_childlinkbit(hfsmp, tdcp->c_parentcnid);+ if (error) {+ printf ("hfs_vnop_link: error updating destination parent chain for id=%u, vol=%s\n", tdcp->c_cnid, hfsmp->vcbVN);+ error = 0;+ }+ }+ tdcp->c_dirchangecnt++;+ tdcp->c_flag |= C_MODIFIED;+ hfs_incr_gencount(tdcp);+ tdcp->c_touch_chgtime = TRUE;+ tdcp->c_touch_modtime = TRUE;++ error = hfs_update(tdvp, 0);+ if (error) {+ if (error != EIO && error != ENXIO) {+ printf("hfs_vnop_link: error %d updating tdvp %p\n", error, tdvp);+ error = EIO;+ }+ hfs_mark_inconsistent(hfsmp, HFS_OP_INCOMPLETE);+ }++ if ((v_type == VDIR) &&+ (fdcp != NULL) &&+ ((fdcp->c_attr.ca_recflags & kHFSHasChildLinkMask) == 0)) {++ fdcp->c_attr.ca_recflags |= kHFSHasChildLinkMask;+ fdcp->c_flag |= C_MODIFIED;+ fdcp->c_touch_chgtime = TRUE;+ error = hfs_update(fdvp, 0);+ if (error) {+ if (error != EIO && error != ENXIO) {+ printf("hfs_vnop_link: error %d updating fdvp %p\n", error, fdvp);+ // No point changing error as it's set immediate below+ }+ hfs_mark_inconsistent(hfsmp, HFS_OP_INCOMPLETE);+ }++ /* Set kHFSHasChildLinkBit in the source hierarchy */+ error = cat_set_childlinkbit(hfsmp, fdcp->c_parentcnid);+ if (error) {+ printf ("hfs_vnop_link: error updating source parent chain for id=%u, vol=%s\n", fdcp->c_cnid, hfsmp->vcbVN);+ error = 0;+ }+ }+ hfs_volupdate(hfsmp, VOL_MKFILE,+ (tdcp->c_cnid == kHFSRootFolderID));+ }++ if (error == 0 && (ret = hfs_update(vp, 0)) != 0) {+ if (ret != EIO && ret != ENXIO)+ printf("hfs_vnop_link: error %d updating vp @ %p\n", ret, vp);+ hfs_mark_inconsistent(hfsmp, HFS_OP_INCOMPLETE);+ }++out:+ if (lockflags) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ }+ if (intrans) {+ hfs_end_transaction(hfsmp);+ }++ tdcp->c_flag &= ~C_DIR_MODIFICATION;+ wakeup((caddr_t)&tdcp->c_flag);++ if (fdcp) {+ hfs_unlockfour(tdcp, cp, fdcp, NULL);+ } else {+ hfs_unlockpair(tdcp, cp);+ }+ if (fdvp) {+ vnode_put(fdvp);+ }+ return (error);+}+++/*+ * Remove a link to a hardlink file/dir.+ *+ * Note: dvp and vp cnodes are already locked.+ */+int+hfs_unlink(struct hfsmount *hfsmp, struct vnode *dvp, struct vnode *vp, struct componentname *cnp, int skip_reserve)+{+ struct cnode *cp;+ struct cnode *dcp;+ struct cat_desc cndesc;+ struct timeval tv;+ char inodename[32];+ cnid_t prevlinkid;+ cnid_t nextlinkid;+ int lockflags = 0;+ int started_tr;+ int error;++ if (hfsmp->hfs_flags & HFS_STANDARD) {+ return (EPERM);+ }+ cp = VTOC(vp);+ dcp = VTOC(dvp);++ dcp->c_flag |= C_DIR_MODIFICATION;++ /* Remove the entry from the namei cache: */+ cache_purge(vp);++ if ((error = hfs_start_transaction(hfsmp)) != 0) {+ started_tr = 0;+ goto out;+ }+ started_tr = 1;++ /*+ * Protect against a race with rename by using the component+ * name passed in and parent id from dvp (instead of using+ * the cp->c_desc which may have changed).+ *+ * Re-lookup the component name so we get the correct cnid+ * for the name (as opposed to the c_cnid in the cnode which+ * could have changed before the cnode was locked).+ */+ cndesc.cd_flags = vnode_isdir(vp) ? CD_ISDIR : 0;+ cndesc.cd_encoding = cp->c_desc.cd_encoding;+ cndesc.cd_nameptr = (const u_int8_t *)cnp->cn_nameptr;+ cndesc.cd_namelen = cnp->cn_namelen;+ cndesc.cd_parentcnid = dcp->c_fileid;+ cndesc.cd_hint = dcp->c_childhint;++ lockflags = SFL_CATALOG | SFL_ATTRIBUTE;+ if (cndesc.cd_flags & CD_ISDIR) {+ /* We'll be removing the alias resource allocation blocks. */+ lockflags |= SFL_BITMAP;+ }+ lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);++ if ((error = cat_lookuplink(hfsmp, &cndesc, &cndesc.cd_cnid, &prevlinkid, &nextlinkid))) {+ goto out;+ }++ /* Reserve some space in the catalog file. */+ if (!skip_reserve && (error = cat_preflight(hfsmp, 2 * CAT_DELETE, NULL, 0))) {+ goto out;+ }++ /* Purge any cached origin entries for a directory or file hard link. */+ hfs_relorigin(cp, dcp->c_fileid);+ if (dcp->c_fileid != dcp->c_cnid) {+ hfs_relorigin(cp, dcp->c_cnid);+ }++ /* Delete the link record. */+ if ((error = cat_deletelink(hfsmp, &cndesc))) {+ goto out;+ }++ /* Update the parent directory. */+ if (dcp->c_entries > 0) {+ dcp->c_entries--;+ }+ if (cndesc.cd_flags & CD_ISDIR) {+ DEC_FOLDERCOUNT(hfsmp, dcp->c_attr);+ }+ dcp->c_dirchangecnt++;+ hfs_incr_gencount(dcp);+ microtime(&tv);+ dcp->c_touch_chgtime = dcp->c_touch_modtime = true;+ dcp->c_flag |= C_MODIFIED;+ hfs_update(dcp->c_vp, 0);++ /*+ * If this is the last link then we need to process the inode.+ * Otherwise we need to fix up the link chain.+ */+ --cp->c_linkcount;+ if (cp->c_linkcount < 1) {+ char delname[32];+ struct cat_desc to_desc;+ struct cat_desc from_desc;++ /*+ * If a file inode or directory inode is being deleted, rename+ * it to an open deleted file. This ensures that deletion+ * of inode and its corresponding extended attributes does+ * not overflow the journal. This inode will be deleted+ * either in hfs_vnop_inactive() or in hfs_remove_orphans().+ * Note: a rename failure here is not fatal.+ */+ bzero(&from_desc, sizeof(from_desc));+ bzero(&to_desc, sizeof(to_desc));+ if (vnode_isdir(vp)) {+ if (cp->c_entries != 0) {+ panic("hfs_unlink: dir not empty (id %d, %d entries)", cp->c_fileid, cp->c_entries);+ }+ MAKE_DIRINODE_NAME(inodename, sizeof(inodename),+ cp->c_attr.ca_linkref);+ from_desc.cd_parentcnid = hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid;+ from_desc.cd_flags = CD_ISDIR;+ to_desc.cd_flags = CD_ISDIR;+ } else {+ MAKE_INODE_NAME(inodename, sizeof(inodename),+ cp->c_attr.ca_linkref);+ from_desc.cd_parentcnid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid;+ from_desc.cd_flags = 0;+ to_desc.cd_flags = 0;+ }+ from_desc.cd_nameptr = (const u_int8_t *)inodename;+ from_desc.cd_namelen = strlen(inodename);+ from_desc.cd_cnid = cp->c_fileid;++ MAKE_DELETED_NAME(delname, sizeof(delname), cp->c_fileid);+ to_desc.cd_nameptr = (const u_int8_t *)delname;+ to_desc.cd_namelen = strlen(delname);+ to_desc.cd_parentcnid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid;+ to_desc.cd_cnid = cp->c_fileid;++ error = cat_rename(hfsmp, &from_desc, &hfsmp->hfs_private_desc[FILE_HARDLINKS],+ &to_desc, (struct cat_desc *)NULL);+ if (error == 0) {+ cp->c_flag |= C_DELETED;+ cp->c_attr.ca_recflags &= ~kHFSHasLinkChainMask;+ cp->c_attr.ca_firstlink = 0;+ if (vnode_isdir(vp)) {+ hfsmp->hfs_private_attr[DIR_HARDLINKS].ca_entries--;+ DEC_FOLDERCOUNT(hfsmp, hfsmp->hfs_private_attr[DIR_HARDLINKS]);++ hfsmp->hfs_private_attr[FILE_HARDLINKS].ca_entries++;+ INC_FOLDERCOUNT(hfsmp, hfsmp->hfs_private_attr[FILE_HARDLINKS]);++ (void)cat_update(hfsmp, &hfsmp->hfs_private_desc[DIR_HARDLINKS],+ &hfsmp->hfs_private_attr[DIR_HARDLINKS], NULL, NULL);+ (void)cat_update(hfsmp, &hfsmp->hfs_private_desc[FILE_HARDLINKS],+ &hfsmp->hfs_private_attr[FILE_HARDLINKS], NULL, NULL);+ }+ } else {+ error = 0; /* rename failure here is not fatal */+ }+ } else /* Still some links left */ {+ cnid_t firstlink;++ /*+ * Update the start of the link chain.+ * Note: Directory hard links store the first link in an attribute.+ */+ if (vnode_isdir(vp) &&+ getfirstlink(hfsmp, cp->c_fileid, &firstlink) == 0 &&+ firstlink == cndesc.cd_cnid) {+ if (setfirstlink(hfsmp, cp->c_fileid, nextlinkid) == 0)+ cp->c_attr.ca_recflags |= kHFSHasAttributesMask;+ } else if (cp->c_attr.ca_firstlink == cndesc.cd_cnid) {+ cp->c_attr.ca_firstlink = nextlinkid;+ }+ /* Update previous link. */+ if (prevlinkid) {+ (void) cat_update_siblinglinks(hfsmp, prevlinkid, HFS_IGNORABLE_LINK, nextlinkid);+ }+ /* Update next link. */+ if (nextlinkid) {+ (void) cat_update_siblinglinks(hfsmp, nextlinkid, prevlinkid, HFS_IGNORABLE_LINK);+ }+ }++ /*+ * The call to cat_releasedesc below will only release the name+ * buffer; it does not zero out the rest of the fields in the+ * 'cat_desc' data structure.+ *+ * As a result, since there are still other links at this point,+ * we need to make the current cnode descriptor point to the raw+ * inode. If a path-based system call comes along first, it will+ * replace the descriptor with a valid link ID. If a userland+ * process already has a file descriptor open, then they will+ * bypass that lookup, though. Replacing the descriptor CNID with+ * the raw inode will force it to generate a new full path.+ */+ cp->c_cnid = cp->c_fileid;++ /* Push new link count to disk. */+ cp->c_ctime = tv.tv_sec;+ (void) cat_update(hfsmp, &cp->c_desc, &cp->c_attr, NULL, NULL);++ /* All done with the system files. */+ hfs_systemfile_unlock(hfsmp, lockflags);+ lockflags = 0;++ /* Update file system stats. */+ hfs_volupdate(hfsmp, VOL_RMFILE, (dcp->c_cnid == kHFSRootFolderID));++ /*+ * All done with this cnode's descriptor...+ *+ * Note: all future catalog calls for this cnode may be+ * by fileid only. This is OK for HFS (which doesn't have+ * file thread records) since HFS doesn't support hard links.+ */+ cat_releasedesc(&cp->c_desc);++out:+ if (lockflags) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ }+ if (started_tr) {+ hfs_end_transaction(hfsmp);+ }++ dcp->c_flag &= ~C_DIR_MODIFICATION;+ wakeup((caddr_t)&dcp->c_flag);++ return (error);+}+++/*+ * Initialize the HFS+ private system directories.+ *+ * These directories are used to hold the inodes+ * for file and directory hardlinks as well as+ * open-unlinked files.+ *+ * If they don't yet exist they will get created.+ *+ * This call is assumed to be made during mount.+ */+void+hfs_privatedir_init(struct hfsmount * hfsmp, enum privdirtype type)+{+ struct vnode * dvp = NULLVP;+ struct cnode * dcp = NULL;+ struct cat_desc *priv_descp;+ struct cat_attr *priv_attrp;+ struct FndrDirInfo * fndrinfo;+ struct timeval tv;+ int lockflags;+ int trans = 0;+ int error;++ if (hfsmp->hfs_flags & HFS_STANDARD) {+ return;+ }++ priv_descp = &hfsmp->hfs_private_desc[type];+ priv_attrp = &hfsmp->hfs_private_attr[type];++ /* Check if directory already exists. */+ if (priv_descp->cd_cnid != 0) {+ return;+ }++ priv_descp->cd_parentcnid = kRootDirID;+ priv_descp->cd_nameptr = (const u_int8_t *)hfs_private_names[type];+ priv_descp->cd_namelen = strlen((const char *)priv_descp->cd_nameptr);+ priv_descp->cd_flags = CD_ISDIR | CD_DECOMPOSED;++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);+ error = cat_lookup(hfsmp, priv_descp, 0, 0, NULL, priv_attrp, NULL, NULL);+ hfs_systemfile_unlock(hfsmp, lockflags);++ if (error == 0) {+ if (type == FILE_HARDLINKS) {+ hfsmp->hfs_metadata_createdate = priv_attrp->ca_itime;+ }+ priv_descp->cd_cnid = priv_attrp->ca_fileid;+ goto exit;+ }++ /* Directory is missing, if this is read-only then we're done. */+ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ goto exit;+ }++ /* Grab the root directory so we can update it later. */+ if (hfs_vget(hfsmp, kRootDirID, &dvp, 0, 0) != 0) {+ goto exit;+ }+ dcp = VTOC(dvp);++ /* Setup the default attributes */+ bzero(priv_attrp, sizeof(struct cat_attr));+ priv_attrp->ca_flags = UF_IMMUTABLE | UF_HIDDEN;+ priv_attrp->ca_mode = S_IFDIR;+ if (type == DIR_HARDLINKS) {+ priv_attrp->ca_mode |= S_ISVTX | S_IRUSR | S_IXUSR | S_IRGRP |+ S_IXGRP | S_IROTH | S_IXOTH;+ }+ priv_attrp->ca_linkcount = 1;+ priv_attrp->ca_itime = hfsmp->hfs_itime;+ priv_attrp->ca_recflags = kHFSHasFolderCountMask;++ fndrinfo = (struct FndrDirInfo *)&priv_attrp->ca_finderinfo;+ fndrinfo->frLocation.v = SWAP_BE16(16384);+ fndrinfo->frLocation.h = SWAP_BE16(16384);+ fndrinfo->frFlags = SWAP_BE16(kIsInvisible + kNameLocked);++ if (hfs_start_transaction(hfsmp) != 0) {+ goto exit;+ }+ trans = 1;++ /* Need the catalog and EA b-trees for CNID acquisition */+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE, HFS_EXCLUSIVE_LOCK);++ /* Make sure there's space in the Catalog file. */+ if (cat_preflight(hfsmp, CAT_CREATE, NULL, 0) != 0) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ goto exit;+ }++ /* Get the CNID for use */+ cnid_t new_id;+ if ((error = cat_acquire_cnid(hfsmp, &new_id))) {+ hfs_systemfile_unlock (hfsmp, lockflags);+ goto exit;+ }++ /* Create the private directory on disk. */+ error = cat_create(hfsmp, new_id, priv_descp, priv_attrp, NULL);+ if (error == 0) {+ priv_descp->cd_cnid = priv_attrp->ca_fileid;++ /* Update the parent directory */+ dcp->c_entries++;+ INC_FOLDERCOUNT(hfsmp, dcp->c_attr);+ dcp->c_dirchangecnt++;+ hfs_incr_gencount(dcp);+ microtime(&tv);+ dcp->c_ctime = tv.tv_sec;+ dcp->c_mtime = tv.tv_sec;+ (void) cat_update(hfsmp, &dcp->c_desc, &dcp->c_attr, NULL, NULL);+ }++ hfs_systemfile_unlock(hfsmp, lockflags);++ if (error) {+ goto exit;+ }+ if (type == FILE_HARDLINKS) {+ hfsmp->hfs_metadata_createdate = priv_attrp->ca_itime;+ }+ hfs_volupdate(hfsmp, VOL_MKDIR, 1);+exit:+ if (trans) {+ hfs_end_transaction(hfsmp);+ }+ if (dvp) {+ hfs_unlock(dcp);+ vnode_put(dvp);+ }+ if ((error == 0) && (type == DIR_HARDLINKS)) {+ hfs_xattr_init(hfsmp);+ }+}+++/*+ * Lookup a hardlink link (from chain)+ */+int+hfs_lookup_siblinglinks(struct hfsmount *hfsmp, cnid_t linkfileid, cnid_t *prevlinkid, cnid_t *nextlinkid)+{+ int lockflags;+ int error;++ *prevlinkid = 0;+ *nextlinkid = 0;++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);++ error = cat_lookup_siblinglinks(hfsmp, linkfileid, prevlinkid, nextlinkid);+ if (error == ENOLINK) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE, HFS_SHARED_LOCK);++ error = getfirstlink(hfsmp, linkfileid, nextlinkid);+ }+ hfs_systemfile_unlock(hfsmp, lockflags);++ return (error);+}+++/* Find the oldest / last hardlink in the link chain */+int+hfs_lookup_lastlink (struct hfsmount *hfsmp, cnid_t linkfileid,+ cnid_t *lastid, struct cat_desc *cdesc) {+ int lockflags;+ int error;++ *lastid = 0;++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);++ error = cat_lookup_lastlink(hfsmp, linkfileid, lastid, cdesc);++ hfs_systemfile_unlock(hfsmp, lockflags);++ /*+ * cat_lookup_lastlink will zero out the lastid/cdesc arguments as needed+ * upon error cases.+ */+ return error;+}+++/*+ * Cache the origin of a directory or file hard link+ *+ * cnode must be lock on entry+ */+void+hfs_savelinkorigin(cnode_t *cp, cnid_t parentcnid)+{+ linkorigin_t *origin = NULL;+ thread_t thread = current_thread();+ int count = 0;+ int maxorigins = (S_ISDIR(cp->c_mode)) ? MAX_CACHED_ORIGINS : MAX_CACHED_FILE_ORIGINS;+ /*+ * Look for an existing origin first. If not found, create/steal one.+ */+ TAILQ_FOREACH(origin, &cp->c_originlist, lo_link) {+ ++count;+ if (origin->lo_thread == thread) {+ TAILQ_REMOVE(&cp->c_originlist, origin, lo_link);+ break;+ }+ }+ if (origin == NULL) {+ /* Recycle the last (i.e., the oldest) if we have too many. */+ if (count > maxorigins) {+ origin = TAILQ_LAST(&cp->c_originlist, hfs_originhead);+ TAILQ_REMOVE(&cp->c_originlist, origin, lo_link);+ } else {+ origin = hfs_malloc_type(linkorigin_t);+ }+ origin->lo_thread = thread;+ }+ origin->lo_cnid = cp->c_cnid;+ origin->lo_parentcnid = parentcnid;+ TAILQ_INSERT_HEAD(&cp->c_originlist, origin, lo_link);+}++/*+ * Release any cached origins for a directory or file hard link+ *+ * cnode must be lock on entry+ */+void+hfs_relorigins(struct cnode *cp)+{+ linkorigin_t *origin, *prev;++ TAILQ_FOREACH_SAFE(origin, &cp->c_originlist, lo_link, prev) {+ hfs_free_type(origin, linkorigin_t);+ }+ TAILQ_INIT(&cp->c_originlist);+}++/*+ * Release a specific origin for a directory or file hard link+ *+ * cnode must be lock on entry+ */+void+hfs_relorigin(struct cnode *cp, cnid_t parentcnid)+{+ linkorigin_t *origin, *prev;+ thread_t thread = current_thread();++ TAILQ_FOREACH_SAFE(origin, &cp->c_originlist, lo_link, prev) {+ if (origin->lo_thread == thread) {+ TAILQ_REMOVE(&cp->c_originlist, origin, lo_link);+ hfs_free_type(origin, linkorigin_t);+ break;+ } else if (origin->lo_parentcnid == parentcnid) {+ /*+ * If the threads don't match, then we don't want to+ * delete the entry because that might cause other threads+ * to fall back and use whatever happens to be in+ * c_parentcnid or the wrong link ID. By setting the+ * values to zero here, it should serve as an indication+ * that the path is no longer valid and that's better than+ * using a random parent ID or link ID.+ */+ origin->lo_parentcnid = 0;+ origin->lo_cnid = 0;+ }+ }+}++/*+ * Test if a directory or file hard link has a cached origin+ *+ * cnode must be lock on entry+ */+int+hfs_haslinkorigin(cnode_t *cp)+{+ if (cp->c_flag & C_HARDLINK) {+ linkorigin_t *origin;+ thread_t thread = current_thread();++ TAILQ_FOREACH(origin, &cp->c_originlist, lo_link) {+ if (origin->lo_thread == thread) {+ return origin->lo_cnid != 0;+ }+ }+ }+ return (0);+}++/*+ * Obtain the current parent cnid of a directory or file hard link+ *+ * cnode must be lock on entry+ */+cnid_t+hfs_currentparent(cnode_t *cp, bool have_lock)+{+ if (cp->c_flag & C_HARDLINK) {+ if (!have_lock)+ hfs_lock_always(cp, HFS_SHARED_LOCK);++ linkorigin_t *origin;+ thread_t thread = current_thread();++ TAILQ_FOREACH(origin, &cp->c_originlist, lo_link) {+ if (origin->lo_thread == thread) {+ if (!have_lock)+ hfs_unlock(cp);+ return (origin->lo_parentcnid);+ }+ }++ if (!have_lock)+ hfs_unlock(cp);+ }+ return (cp->c_parentcnid);+}++/*+ * Obtain the current cnid of a directory or file hard link+ *+ * cnode must be lock on entry+ */+cnid_t+hfs_currentcnid(cnode_t *cp)+{+ if (cp->c_flag & C_HARDLINK) {+ linkorigin_t *origin;+ thread_t thread = current_thread();++ TAILQ_FOREACH(origin, &cp->c_originlist, lo_link) {+ if (origin->lo_thread == thread) {+ return (origin->lo_cnid);+ }+ }+ }+ return (cp->c_cnid);+}+++/*+ * Set the first link attribute for a given file id.+ *+ * The attributes b-tree must already be locked.+ * If journaling is enabled, a transaction must already be started.+ */+static int+setfirstlink(struct hfsmount * hfsmp, cnid_t fileid, cnid_t firstlink)+{+ FCB * btfile;+ BTreeIterator * iterator;+ FSBufferDescriptor btdata;+ u_int8_t attrdata[FIRST_LINK_XATTR_REC_SIZE];+ HFSPlusAttrData *dataptr;+ int result;+ u_int16_t datasize;++ if (hfsmp->hfs_attribute_cp == NULL) {+ return (EPERM);+ }+ iterator = hfs_malloc_type(BTreeIterator);++ result = hfs_buildattrkey(fileid, FIRST_LINK_XATTR_NAME, (HFSPlusAttrKey *)&iterator->key);+ if (result) {+ goto out;+ }+ dataptr = (HFSPlusAttrData *)&attrdata[0];+ dataptr->recordType = kHFSPlusAttrInlineData;+ dataptr->reserved[0] = 0;+ dataptr->reserved[1] = 0;++ /*+ * Since attrData is variable length, we calculate the size of+ * attrData by subtracting the size of all other members of+ * structure HFSPlusAttData from the size of attrdata.+ */+ (void)snprintf((char *)&dataptr->attrData[0],+ sizeof(dataptr) - (4 * sizeof(uint32_t)),+ "%lu", (unsigned long)firstlink);+ dataptr->attrSize = 1 + strlen((char *)&dataptr->attrData[0]);++ /* Calculate size of record rounded up to multiple of 2 bytes. */+ datasize = sizeof(HFSPlusAttrData) - 2 + dataptr->attrSize + ((dataptr->attrSize & 1) ? 1 : 0);++ btdata.bufferAddress = dataptr;+ btdata.itemSize = datasize;+ btdata.itemCount = 1;++ btfile = hfsmp->hfs_attribute_cp->c_datafork;++ /* Insert the attribute. */+ result = BTInsertRecord(btfile, iterator, &btdata, datasize);+ if (result == btExists) {+ result = BTReplaceRecord(btfile, iterator, &btdata, datasize);+ }+ (void) BTFlushPath(btfile);+out:+ hfs_free_type(iterator, BTreeIterator);++ return MacToVFSError(result);+}++/*+ * Get the first link attribute for a given file id.+ *+ * The attributes b-tree must already be locked.+ */+static int+getfirstlink(struct hfsmount * hfsmp, cnid_t fileid, cnid_t *firstlink)+{+ FCB * btfile;+ BTreeIterator * iterator;+ FSBufferDescriptor btdata;+ u_int8_t attrdata[FIRST_LINK_XATTR_REC_SIZE];+ HFSPlusAttrData *dataptr;+ int result;+ u_int16_t datasize;++ if (hfsmp->hfs_attribute_cp == NULL) {+ return (EPERM);+ }+ iterator = hfs_malloc_type(BTreeIterator);++ result = hfs_buildattrkey(fileid, FIRST_LINK_XATTR_NAME, (HFSPlusAttrKey *)&iterator->key);+ if (result)+ goto out;++ dataptr = (HFSPlusAttrData *)&attrdata[0];+ datasize = sizeof(attrdata);++ btdata.bufferAddress = dataptr;+ btdata.itemSize = sizeof(attrdata);+ btdata.itemCount = 1;++ btfile = hfsmp->hfs_attribute_cp->c_datafork;++ result = BTSearchRecord(btfile, iterator, &btdata, NULL, NULL);+ if (result)+ goto out;++ if (dataptr->attrSize < 3) {+ result = ENOENT;+ goto out;+ }+ *firstlink = strtoul((char*)&dataptr->attrData[0], NULL, 10);+out:+ hfs_free_type(iterator, BTreeIterator);++ return MacToVFSError(result);+}++errno_t hfs_first_link(hfsmount_t *hfsmp, cnode_t *cp, cnid_t *link_id)+{+ errno_t error = 0;++ if (S_ISDIR(cp->c_mode)) {+ int lockf = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE, HFS_SHARED_LOCK);++ error = getfirstlink(hfsmp, cp->c_fileid, link_id);++ hfs_systemfile_unlock(hfsmp, lockf);+ } else {+ if (cp->c_attr.ca_firstlink)+ *link_id = cp->c_attr.ca_firstlink;+ else {+ // This can happen if the cnode has been deleted+ error = ENOENT;+ }+ }++ return error;+}diff --git a/xnu/files/bsd/hfs/hfs_lookup.c b/xnu/files/bsd/hfs/hfs_lookup.cnew file mode 100644index 0000000..80763ac--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_lookup.c@@ -0,0 +1,675 @@+/*+ * Copyright (c) 1999-2015 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@+ */+/*+ * Copyright (c) 1989, 1993+ * The Regents of the University of California. All rights reserved.+ * (c) UNIX System Laboratories, Inc.+ * All or some portions of this file are derived from material licensed+ * to the University of California by American Telephone and Telegraph+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with+ * the permission of UNIX System Laboratories, Inc.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. Redistributions in binary form must reproduce the above copyright+ * notice, this list of conditions and the following disclaimer in the+ * documentation and/or other materials provided with the distribution.+ * 3. All advertising materials mentioning features or use of this software+ * must display the following acknowledgement:+ * This product includes software developed by the University of+ * California, Berkeley and its contributors.+ * 4. Neither the name of the University nor the names of its contributors+ * may be used to endorse or promote products derived from this software+ * without specific prior written permission.+ *+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+ * SUCH DAMAGE.+ *+ * @(#)hfs_lookup.c 1.0+ * derived from @(#)ufs_lookup.c 8.15 (Berkeley) 6/16/95+ *+ * (c) 1998-1999 Apple Inc. All Rights Reserved+ * (c) 1990, 1992 NeXT Computer, Inc. All Rights Reserved+ *+ *+ * hfs_lookup.c -- code to handle directory traversal on HFS/HFS+ volume+ */++#include <sys/param.h>+#include <sys/file.h>+#include <sys/mount.h>+#include <sys/vnode.h>+#include <sys/malloc.h>+#include <sys/kdebug.h>+#include <sys/kauth.h>+#include <sys/namei.h>+#include <sys/user.h>++#include "hfs.h"+#include "hfs_catalog.h"+#include "hfs_cnode.h"+++/*+ * FROM FREEBSD 3.1+ * Convert a component of a pathname into a pointer to a locked cnode.+ * This is a very central and rather complicated routine.+ * If the file system is not maintained in a strict tree hierarchy,+ * this can result in a deadlock situation (see comments in code below).+ *+ * The cnp->cn_nameiop argument is LOOKUP, CREATE, RENAME, or DELETE depending+ * on whether the name is to be looked up, created, renamed, or deleted.+ * When CREATE, RENAME, or DELETE is specified, information usable in+ * creating, renaming, or deleting a directory entry may be calculated.+ * Notice that these are the only operations that can affect the directory of the target.+ *+ * LOCKPARENT and WANTPARENT actually refer to the parent of the last item,+ * so if ISLASTCN is not set, they should be ignored. Also they are mutually exclusive, or+ * WANTPARENT really implies DONTLOCKPARENT. Either of them set means that the calling+ * routine wants to access the parent of the target, locked or unlocked.+ *+ * Keeping the parent locked as long as possible protects from other processes+ * looking up the same item, so it has to be locked until the cnode is totally finished+ *+ * hfs_cache_lookup() performs the following for us:+ * check that it is a directory+ * check accessibility of directory+ * check for modification attempts on read-only mounts+ * if name found in cache+ * if at end of path and deleting or creating+ * drop it+ * else+ * return name.+ * return hfs_lookup()+ *+ * Overall outline of hfs_lookup:+ *+ * handle simple cases of . and ..+ * search for name in directory, to found or notfound+ * notfound:+ * if creating, return locked directory, leaving info on available slots+ * else return error+ * found:+ * if at end of path and deleting, return information to allow delete+ * if at end of path and rewriting (RENAME and LOCKPARENT), lock target+ * cnode and return info to allow rewrite+ * if not at end, add name to cache; if at end and neither creating+ * nor deleting, add name to cache+ */+++/*+ * Lookup *cnp in directory *dvp, return it in *vpp.+ * **vpp is held on exit.+ * We create a cnode for the file, but we do NOT open the file here.++#% lookup dvp L ? ?+#% lookup vpp - L -++ IN struct vnode *dvp - Parent node of file;+ INOUT struct vnode **vpp - node of target file, its a new node if+ the target vnode did not exist;+ IN struct componentname *cnp - Name of file;++ * When should we lock parent_hp in here ??+ */+static int+hfs_lookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, int *cnode_locked, int force_casesensitive_lookup)+{+ struct cnode *dcp; /* cnode for directory being searched */+ struct vnode *tvp; /* target vnode */+ struct hfsmount *hfsmp;+ int flags;+ int nameiop;+ int retval = 0;+ int isDot;+ struct cat_desc desc;+ struct cat_desc cndesc;+ struct cat_attr attr;+ struct cat_fork fork;+ int lockflags;+ int newvnode_flags;++ retry:+ newvnode_flags = 0;+ dcp = NULL;+ hfsmp = VTOHFS(dvp);+ *vpp = NULL;+ *cnode_locked = 0;+ isDot = FALSE;+ tvp = NULL;+ nameiop = cnp->cn_nameiop;+ flags = cnp->cn_flags;+ bzero(&desc, sizeof(desc));++ /*+ * First check to see if it is a . or .., else look it up.+ */+ if (flags & ISDOTDOT) { /* Wanting the parent */+ cnp->cn_flags &= ~MAKEENTRY;+ goto found; /* .. is always defined */+ } else if ((cnp->cn_nameptr[0] == '.') && (cnp->cn_namelen == 1)) {+ isDot = TRUE;+ cnp->cn_flags &= ~MAKEENTRY;+ goto found; /* We always know who we are */+ } else {+ if (hfs_lock(VTOC(dvp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0) {+ retval = ENOENT; /* The parent no longer exists ? */+ goto exit;+ }+ dcp = VTOC(dvp);++ if (dcp->c_flag & C_DIR_MODIFICATION) {+ // This needs to be changed to sleep on c_flag using assert_wait.+ // msleep((caddr_t)&dcp->c_flag, &dcp->c_rwlock, PINOD, "hfs_vnop_lookup", 0);+ hfs_unlock(dcp);+ tsleep((caddr_t)dvp, PRIBIO, "hfs_lookup", 1);++ goto retry;+ }+++ /*+ * We shouldn't need to go to the catalog if there are no children.+ * However, in the face of a minor disk corruption where the valence of+ * the directory is off, we could infinite loop here if we return ENOENT+ * even though there are actually items in the directory. (create will+ * see the ENOENT, try to create something, which will return with+ * EEXIST over and over again). As a result, always check the catalog.+ */++ bzero(&cndesc, sizeof(cndesc));+ cndesc.cd_nameptr = (const u_int8_t *)cnp->cn_nameptr;+ cndesc.cd_namelen = cnp->cn_namelen;+ cndesc.cd_parentcnid = dcp->c_fileid;+ cndesc.cd_hint = dcp->c_childhint;++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);++ retval = cat_lookup(hfsmp, &cndesc, 0, force_casesensitive_lookup, &desc, &attr, &fork, NULL);++ hfs_systemfile_unlock(hfsmp, lockflags);++ if (retval == 0) {+ dcp->c_childhint = desc.cd_hint;+ /*+ * Note: We must drop the parent lock here before calling+ * hfs_getnewvnode (which takes the child lock).+ */+ hfs_unlock(dcp);+ dcp = NULL;++ /* Verify that the item just looked up isn't one of the hidden directories. */+ if (desc.cd_cnid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid ||+ desc.cd_cnid == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {+ retval = ENOENT;+ goto exit;+ }++ goto found;+ }++ if (retval == HFS_ERESERVEDNAME) {+ /*+ * We found the name in the catalog, but it is unavailable+ * to us. The exact error to return to our caller depends+ * on the operation, and whether we've already reached the+ * last path component. In all cases, avoid a negative+ * cache entry, since someone else may be able to access+ * the name if their lookup is configured differently.+ */++ cnp->cn_flags &= ~MAKEENTRY;++ if (((flags & ISLASTCN) == 0) || ((nameiop == LOOKUP) || (nameiop == DELETE))) {+ /* A reserved name for a pure lookup is the same as the path not being present */+ retval = ENOENT;+ } else {+ /* A reserved name with intent to create must be rejected as impossible */+ retval = EEXIST;+ }+ }+ if (retval != ENOENT)+ goto exit;+ /*+ * This is a non-existing entry+ *+ * If creating, and at end of pathname and current+ * directory has not been removed, then can consider+ * allowing file to be created.+ */+ if ((nameiop == CREATE || nameiop == RENAME) &&+ (flags & ISLASTCN) &&+ !(ISSET(dcp->c_flag, C_DELETED | C_NOEXISTS))) {+ retval = EJUSTRETURN;+ goto exit;+ }+ /*+ * Insert name into the name cache (as non-existent).+ */+ if ((cnp->cn_flags & MAKEENTRY) &&+ (nameiop != CREATE)) {+ cache_enter(dvp, NULL, cnp);+ dcp->c_flag |= C_NEG_ENTRIES;+ }+ goto exit;+ }++found:+ if (flags & ISLASTCN) {+ switch(nameiop) {+ case DELETE:+ cnp->cn_flags &= ~MAKEENTRY;+ break;++ case RENAME:+ cnp->cn_flags &= ~MAKEENTRY;+ if (isDot) {+ retval = EISDIR;+ goto exit;+ }+ break;+ }+ }++ if (isDot) {+ if ((retval = vnode_get(dvp)))+ goto exit;+ *vpp = dvp;+ } else if (flags & ISDOTDOT) {+ /*+ * Directory hard links can have multiple parents so+ * find the appropriate parent for the current thread.+ */+ if ((retval = hfs_vget(hfsmp, hfs_currentparent(VTOC(dvp),+ /* have_lock: */ false), &tvp, 0, 0))) {+ goto exit;+ }+ *cnode_locked = 1;+ *vpp = tvp;+ } else {+ int type = (attr.ca_mode & S_IFMT);++ if (!(flags & ISLASTCN) && (type != S_IFDIR) && (type != S_IFLNK)) {+ retval = ENOTDIR;+ goto exit;+ }+ /* Don't cache directory hardlink names. */+ if (attr.ca_recflags & kHFSHasLinkChainMask) {+ cnp->cn_flags &= ~MAKEENTRY;+ }+ /* Names with composed chars are not cached. */+ if (cnp->cn_namelen != desc.cd_namelen)+ cnp->cn_flags &= ~MAKEENTRY;++ retval = hfs_getnewvnode(hfsmp, dvp, cnp, &desc, 0, &attr, &fork, &tvp, &newvnode_flags);++ if (retval) {+ /*+ * If this was a create/rename operation lookup, then by this point+ * we expected to see the item returned from hfs_getnewvnode above.+ * In the create case, it would probably eventually bubble out an EEXIST+ * because the item existed when we were trying to create it. In the+ * rename case, it would let us know that we need to go ahead and+ * delete it as part of the rename. However, if we hit the condition below+ * then it means that we found the element during cat_lookup above, but+ * it is now no longer there. We simply behave as though we never found+ * the element at all and return EJUSTRETURN.+ */+ if ((retval == ENOENT) &&+ ((cnp->cn_nameiop == CREATE) || (cnp->cn_nameiop == RENAME)) &&+ (flags & ISLASTCN)) {+ retval = EJUSTRETURN;+ }++ /*+ * If this was a straight lookup operation, we may need to redrive the entire+ * lookup starting from cat_lookup if the element was deleted as the result of+ * a rename operation. Since rename is supposed to guarantee atomicity, then+ * lookups cannot fail because the underlying element is deleted as a result of+ * the rename call -- either they returned the looked up element prior to rename+ * or return the newer element. If we are in this region, then all we can do is add+ * workarounds to guarantee the latter case. The element has already been deleted, so+ * we just re-try the lookup to ensure the caller gets the most recent element.+ */+ if ((retval == ENOENT) && (cnp->cn_nameiop == LOOKUP) &&+ (newvnode_flags & (GNV_CHASH_RENAMED | GNV_CAT_DELETED))) {+ if (dcp) {+ hfs_unlock (dcp);+ }+ /* get rid of any name buffers that may have lingered from the cat_lookup call */+ cat_releasedesc (&desc);+ goto retry;+ }++ /* Also, re-drive the lookup if the item we looked up was a hardlink, and the number+ * or name of hardlinks has changed in the interim between the cat_lookup above, and+ * our call to hfs_getnewvnode. hfs_getnewvnode will validate the cattr we passed it+ * against what is actually in the catalog after the cnode is created. If there were+ * any issues, it will bubble out ERECYCLE, which we need to swallow and use as the+ * key to redrive as well. We need to special case this below because in this case,+ * it needs to occur regardless of the type of lookup we're doing here.+ */+ if ((retval == ERECYCLE) && (newvnode_flags & GNV_CAT_ATTRCHANGED)) {+ if (dcp) {+ hfs_unlock (dcp);+ }+ /* get rid of any name buffers that may have lingered from the cat_lookup call */+ cat_releasedesc (&desc);+ retval = 0;+ goto retry;+ }++ /* skip to the error-handling code if we can't retry */+ goto exit;+ }++ /*+ * Save the origin info for file and directory hardlinks. Directory hardlinks+ * need the origin for '..' lookups, and file hardlinks need it to ensure that+ * competing lookups do not cause us to vend different hardlinks than the ones requested.+ */+ if (ISSET(VTOC(tvp)->c_flag, C_HARDLINK))+ hfs_savelinkorigin(VTOC(tvp), VTOC(dvp)->c_fileid);+ *cnode_locked = 1;+ *vpp = tvp;+ }+exit:+ if (dcp) {+ hfs_unlock(dcp);+ }+ cat_releasedesc(&desc);+ return (retval);+}++++/*+ * Name caching works as follows:+ *+ * Names found by directory scans are retained in a cache+ * for future reference. It is managed LRU, so frequently+ * used names will hang around. Cache is indexed by hash value+ * obtained from (vp, name) where vp refers to the directory+ * containing name.+ *+ * If it is a "negative" entry, (i.e. for a name that is known NOT to+ * exist) the vnode pointer will be NULL.+ *+ * Upon reaching the last segment of a path, if the reference+ * is for DELETE, or NOCACHE is set (rewrite), and the+ * name is located in the cache, it will be dropped.+ *+ */++int+hfs_vnop_lookup(struct vnop_lookup_args *ap)+{+ struct vnode *dvp = ap->a_dvp;+ struct vnode *vp;+ struct cnode *cp;+ struct cnode *dcp;+ struct hfsmount *hfsmp;+ int error;+ struct vnode **vpp = ap->a_vpp;+ struct componentname *cnp = ap->a_cnp;+ int flags = cnp->cn_flags;+ struct proc *p = vfs_context_proc(ap->a_context);+ int force_casesensitive_lookup = proc_is_forcing_hfs_case_sensitivity(p);+ int cnode_locked;+ int fastdev_candidate = 0;+ int auto_candidate = 0;++ *vpp = NULL;+ dcp = VTOC(dvp);+ hfsmp = VTOHFS(dvp);++ if ((hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) && (vnode_isfastdevicecandidate(dvp) || (dcp->c_attr.ca_recflags & kHFSFastDevCandidateMask)) ){+ fastdev_candidate = 1;+ auto_candidate = (vnode_isautocandidate(dvp) || (dcp->c_attr.ca_recflags & kHFSAutoCandidateMask));+ }+++ /*+ * Lookup an entry in the cache+ *+ * If the lookup succeeds, the vnode is returned in *vpp,+ * and a status of -1 is returned.+ *+ * If the lookup determines that the name does not exist+ * (negative cacheing), a status of ENOENT is returned.+ *+ * If the lookup fails, a status of zero is returned.+ */+ error = cache_lookup(dvp, vpp, cnp);+ if (error != -1) {+ if ((error == ENOENT) && (cnp->cn_nameiop != CREATE))+ goto exit; /* found a negative cache entry */+ goto lookup; /* did not find it in the cache */+ }+ /*+ * We have a name that matched+ * cache_lookup returns the vp with an iocount reference already taken+ */+ error = 0;+ vp = *vpp;+ cp = VTOC(vp);++ /* We aren't allowed to vend out vp's via lookup to the hidden directory */+ if (cp->c_cnid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid ||+ cp->c_cnid == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {+ /* Drop the iocount from cache_lookup */+ vnode_put (vp);+ error = ENOENT;+ goto exit;+ }++ if (cp->c_attr.ca_recflags & kHFSDoNotFastDevPinMask) {+ fastdev_candidate = 0;+ }++ /*+ * If this is a hard-link vnode then we need to update+ * the name (of the link), the parent ID, the cnid, the+ * text encoding and the catalog hint. This enables+ * getattrlist calls to return the correct link info.+ */++ /*+ * Alternatively, if we are forcing a case-sensitive lookup+ * on a case-insensitive volume, the namecache entry+ * may have been for an incorrect case. Since we cannot+ * determine case vs. normalization, redrive the catalog+ * lookup based on any byte mismatch.+ */+ if (((flags & ISLASTCN) && (cp->c_flag & C_HARDLINK))+ || (force_casesensitive_lookup && !(hfsmp->hfs_flags & HFS_CASE_SENSITIVE))) {+ int stale_link = 0;++ hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ if ((cp->c_parentcnid != dcp->c_cnid) ||+ (cnp->cn_namelen != cp->c_desc.cd_namelen) ||+ (bcmp(cnp->cn_nameptr, cp->c_desc.cd_nameptr, cp->c_desc.cd_namelen) != 0)) {+ struct cat_desc desc;+ struct cat_attr lookup_attr;+ int lockflags;++ if (force_casesensitive_lookup && !(hfsmp->hfs_flags & HFS_CASE_SENSITIVE)) {+ /*+ * Since the name in the cnode doesn't match our lookup+ * string exactly, do a full lookup.+ */+ hfs_unlock (cp);++ vnode_put(vp);+ goto lookup;+ }++ /*+ * Get an updated descriptor+ */+ desc.cd_nameptr = (const u_int8_t *)cnp->cn_nameptr;+ desc.cd_namelen = cnp->cn_namelen;+ desc.cd_parentcnid = dcp->c_fileid;+ desc.cd_hint = dcp->c_childhint;+ desc.cd_encoding = 0;+ desc.cd_cnid = 0;+ desc.cd_flags = S_ISDIR(cp->c_mode) ? CD_ISDIR : 0;++ /*+ * Because lookups call replace_desc to put a new descriptor in+ * the cnode we are modifying it is possible that this cnode's+ * descriptor is out of date for the parent ID / name that+ * we are trying to look up. (It may point to a different hardlink).+ *+ * We need to be cautious that when re-supplying the+ * descriptor below that the results of the catalog lookup+ * still point to the same raw inode for the hardlink. This would+ * not be the case if we found something in the cache above but+ * the vnode it returned no longer has a valid hardlink for the+ * parent ID/filename combo we are requesting. (This is because+ * hfs_unlink does not directly trigger namecache removal).+ *+ * As a result, before vending out the vnode (and replacing+ * its descriptor) verify that the fileID is the same by comparing+ * the in-cnode attributes vs. the one returned from the lookup call+ * below. If they do not match, treat this lookup as if we never hit+ * in the cache at all.+ */++ lockflags = hfs_systemfile_lock(VTOHFS(dvp), SFL_CATALOG, HFS_SHARED_LOCK);++ error = cat_lookup(VTOHFS(vp), &desc, 0, 0, &desc, &lookup_attr, NULL, NULL);++ hfs_systemfile_unlock(VTOHFS(dvp), lockflags);++ /*+ * Note that cat_lookup may fail to find something with the name provided in the+ * stack-based descriptor above. In that case, an ENOENT is a legitimate errno+ * to be placed in error, which will get returned in the fastpath below.+ */+ if (error == 0) {+ if (lookup_attr.ca_fileid == cp->c_attr.ca_fileid) {+ /* It still points to the right raw inode. Replacing the descriptor is fine */+ replace_desc (cp, &desc);++ /*+ * Save the origin info for file and directory hardlinks. Directory hardlinks+ * need the origin for '..' lookups, and file hardlinks need it to ensure that+ * competing lookups do not cause us to vend different hardlinks than the ones requested.+ */+ hfs_savelinkorigin(cp, dcp->c_fileid);+ }+ else {+ /* If the fileID does not match then do NOT replace the descriptor! */+ stale_link = 1;+ }+ }+ }+ hfs_unlock (cp);++ if (stale_link) {+ /*+ * If we had a stale_link, then we need to pretend as though+ * we never found this vnode and force a lookup through the+ * traditional path. Drop the iocount acquired through+ * cache_lookup above and force a cat lookup / getnewvnode+ */+ vnode_put(vp);+ goto lookup;+ }++ if (error) {+ /*+ * If the cat_lookup failed then the caller will not expect+ * a vnode with an iocount on it.+ */+ vnode_put(vp);+ }++ }+ goto exit;++lookup:+ /*+ * The vnode was not in the name cache or it was stale.+ *+ * So we need to do a real lookup.+ */+ cnode_locked = 0;++ error = hfs_lookup(dvp, vpp, cnp, &cnode_locked, force_casesensitive_lookup);++ if (*vpp && (VTOC(*vpp)->c_attr.ca_recflags & kHFSDoNotFastDevPinMask)) {+ fastdev_candidate = 0;+ }++ if (*vpp && (VTOC(*vpp)->c_attr.ca_recflags & kHFSAutoCandidateMask)) {+ //printf("vp %s / %d is an auto-candidate\n", (*vpp)->v_name ? (*vpp)->v_name : "no-name", VTOC(*vpp)->c_fileid);+ auto_candidate = 1;+ }++ if (cnode_locked)+ hfs_unlock(VTOC(*vpp));+exit:+ if (*vpp && fastdev_candidate && !vnode_isfastdevicecandidate(*vpp)) {+ vnode_setfastdevicecandidate(*vpp);+ if (auto_candidate) {+ vnode_setautocandidate(*vpp);+ }+ }++ /*+ * check to see if we issued any I/O while completing this lookup and+ * this thread/task is throttleable... if so, throttle now+ *+ * this allows us to throttle in between multiple meta data reads that+ * might result due to looking up a long pathname (since we'll have to+ * re-enter hfs_vnop_lookup for each component of the pathnam not in+ * the VFS cache), instead of waiting until the entire path lookup has+ * completed and throttling at the systemcall return+ */+ if (__builtin_expect(throttle_lowpri_window(), 0))+ throttle_lowpri_io(1);++ return (error);+}++diff --git a/xnu/files/bsd/hfs/hfs_macos_defs.h b/xnu/files/bsd/hfs/hfs_macos_defs.hnew file mode 100644index 0000000..029262d--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_macos_defs.h@@ -0,0 +1,299 @@+/*+ * Copyright (c) 2000-2015 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@+ */++#ifndef __HFS_MACOS_TYPES__+#define __HFS_MACOS_TYPES__++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE++#include <sys/param.h>++#include <libkern/OSTypes.h>+#include <libkern/libkern.h>+#include <sys/systm.h>+#include <sys/types.h>+#include <sys/time.h>+#include <sys/proc.h>+++#define TARGET_OS_WIN32 0+#define TARGET_OS_UNIX 0++#define PRAGMA_IMPORT 0+#define PRAGMA_STRUCT_ALIGN 1+#define PRAGMA_ONCE 0+#define PRAGMA_STRUCT_PACK 0+#define PRAGMA_STRUCT_PACKPUSH 0++#if __GNUC__ >= 2+ #define TYPE_LONGLONG 1+#else+ #define TYPE_LONGLONG 0+#endif+#ifdef __cplusplus+ #define TYPE_BOOL 1+#else+ #define TYPE_BOOL 0+#endif++#define EXTERN_API(_type) extern _type+#define EXTERN_API_C(_type) extern _type++#define CALLBACK_API_C(_type, _name) _type ( * _name)++#define TARGET_API_MACOS_X 1+#define TARGET_API_MAC_OS8 0+#define TARGET_API_MAC_CARBON 0++++/****** START OF MACOSTYPES *********/+++/*+ 4.4BSD's sys/types.h defines size_t without defining __size_t__:+ Things are a lot clearer from here on if we define __size_t__ now.+ */+#define __size_t__++/********************************************************************************++ Special values in C++ NULL The C standard for an impossible pointer value+ nil A carry over from pascal, NULL is prefered for C++*********************************************************************************/+#ifndef NULL+ #define NULL 0+#endif++#ifndef nil+ #define nil NULL+#endif++typedef char * Ptr;+typedef long Size;++typedef int16_t OSErr;+typedef u_int32_t ItemCount;+typedef u_int32_t ByteCount;+typedef u_int8_t * BytePtr;+typedef u_int32_t ByteOffset;++typedef u_int16_t UniChar;+typedef unsigned char Str255[256];+typedef unsigned char Str31[32];+typedef unsigned char * StringPtr;+typedef const unsigned char * ConstStr255Param;+typedef const unsigned char * ConstStr31Param;+typedef const unsigned char * ConstUTF8Param;++typedef u_int8_t Byte;++typedef u_int32_t TextEncoding;+typedef UniChar * UniCharArrayPtr;+typedef const UniChar * ConstUniCharArrayPtr;+++/********************************************************************************++ Boolean types and values++ Boolean A one byte value, holds "false" (0) or "true" (1)+ false The Boolean value of zero (0)+ true The Boolean value of one (1)++*********************************************************************************/+/*+ The identifiers "true" and "false" are becoming keywords in C+++ and work with the new built-in type "bool"+ "Boolean" will remain an unsigned char for compatibility with source+ code written before "bool" existed.+*/+#if !TYPE_BOOL && !__bool_true_false_are_defined++enum {+ false = 0,+ true = 1+};++#endif /* !TYPE_BOOL */+++EXTERN_API( void ) DebugStr(const char * debuggerMsg);++/*********************************************************************************++ Added types for HFSPlus MacOS X functionality. Needs to be incorporated to+ other places++*********************************************************************************/++typedef struct vnode* FileReference;+++/***** START OF MACOSSTUBS ********/+++/*+ SizeTDef.h -- Common definitions++ size_t - this type is defined by several ANSI headers.+*/+#if ! defined (__size_t__)+ #define __size_t__+ #if defined (__xlc) || defined (__xlC) || defined (__xlC__) || defined (__MWERKS__)+ typedef unsigned long size_t;+ #else /* __xlC */+ typedef unsigned int size_t;+ #endif /* __xlC */+#endif /* __size_t__ */+++/*+ File: Errors.h++*/+enum {+ noErr = 0,+ dskFulErr = -34, /*disk full*/+ bdNamErr = -37, /*there may be no bad names in the final system!*/+ paramErr = -50, /*error in user parameter list*/+ memFullErr = -108, /*Not enough room in heap zone*/+ fileBoundsErr = -1309, /*file's EOF, offset, mark or size is too big*/+ kTECUsedFallbacksStatus = -8783,++};+++enum {+ /* Finder Flags */+ kHasBeenInited = 0x0100,+ kHasCustomIcon = 0x0400,+ kIsStationery = 0x0800,+ kNameLocked = 0x1000,+ kHasBundle = 0x2000,+ kIsInvisible = 0x4000,+ kIsAlias = 0x8000+};++enum {+ fsRtParID = 1,+ fsRtDirID = 2+};+++enum {+ /* Mac OS encodings*/+ kTextEncodingMacRoman = 0L,+ kTextEncodingMacJapanese = 1,+ kTextEncodingMacChineseTrad = 2,+ kTextEncodingMacKorean = 3,+ kTextEncodingMacArabic = 4,+ kTextEncodingMacHebrew = 5,+ kTextEncodingMacGreek = 6,+ kTextEncodingMacCyrillic = 7,+ kTextEncodingMacDevanagari = 9,+ kTextEncodingMacGurmukhi = 10,+ kTextEncodingMacGujarati = 11,+ kTextEncodingMacOriya = 12,+ kTextEncodingMacBengali = 13,+ kTextEncodingMacTamil = 14,+ kTextEncodingMacTelugu = 15,+ kTextEncodingMacKannada = 16,+ kTextEncodingMacMalayalam = 17,+ kTextEncodingMacSinhalese = 18,+ kTextEncodingMacBurmese = 19,+ kTextEncodingMacKhmer = 20,+ kTextEncodingMacThai = 21,+ kTextEncodingMacLaotian = 22,+ kTextEncodingMacGeorgian = 23,+ kTextEncodingMacArmenian = 24,+ kTextEncodingMacChineseSimp = 25,+ kTextEncodingMacTibetan = 26,+ kTextEncodingMacMongolian = 27,+ kTextEncodingMacEthiopic = 28,+ kTextEncodingMacCentralEurRoman = 29,+ kTextEncodingMacVietnamese = 30,+ kTextEncodingMacExtArabic = 31, /* The following use script code 0, smRoman*/+ kTextEncodingMacSymbol = 33,+ kTextEncodingMacDingbats = 34,+ kTextEncodingMacTurkish = 35,+ kTextEncodingMacCroatian = 36,+ kTextEncodingMacIcelandic = 37,+ kTextEncodingMacRomanian = 38,+ kTextEncodingMacUnicode = 0x7E,++ kTextEncodingMacFarsi = 0x8C, /* Like MacArabic but uses Farsi digits */ /* The following use script code 7, smCyrillic */+ kTextEncodingMacUkrainian = 0x98, /* The following use script code 32, smUnimplemented */+};+++/* PROTOTYPES */++#if DEBUG+ extern void RequireFileLock(FileReference vp, int shareable);+ #define REQUIRE_FILE_LOCK(vp,s) RequireFileLock((vp),(s))+#else+ #define REQUIRE_FILE_LOCK(vp,s)+#endif+++EXTERN_API( void )+BlockMoveData(const void * srcPtr, void * destPtr, Size byteCount);++#define BlockMoveData(src, dest, len) bcopy((src), (dest), (len))++EXTERN_API_C( void )+ClearMemory(void * start, u_int32_t length);++#define ClearMemory(start, length) bzero((start), (size_t)(length));++/*+ * The maximum number UTF-16 code units required to represent a HFS+ * standard file name. The derivation for this number is not+ * documented; it has been this value for some time. Mark, our+ * resident Unicode expert, says "I'm not entirely certain, but I+ * think it is the worst case for Korean Hangul conjoining jamos. The+ * '15' is because a Str31 can contain at most 15 two-byte characters+ * (in MacKorean encoding). Worst case, each one of those characters+ * gets normalized to up to 5 UTF-16 code points. Each character is+ * composed of up to three jamos; up to two of those jamos might not+ * be in Unicode plane 0, which means they can take two UTF-16 code+ * points (each) to represent. So your '5' is '2 + 2 + 1'." Sounds+ * plausible! Safe to ship it, I say!+ */+#define MAX_HFS_UNICODE_CHARS (15*5)++#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */+#endif /* __HFS_MACOS_TYPES__ */diff --git a/xnu/files/bsd/hfs/hfs_mount.h b/xnu/files/bsd/hfs/hfs_mount.hnew file mode 100644index 0000000..abbe61a--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_mount.h@@ -0,0 +1,83 @@+/*+ * Copyright (c) 2000-2015 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@+ */+/*+ * Copyright (c) 1997-2002 Apple Inc. All Rights Reserved+ *+ */++#ifndef _HFS_MOUNT_H_+#define _HFS_MOUNT_H_++#include <sys/appleapiopts.h>++#include <sys/mount.h>+#include <sys/time.h>++/*+ * Arguments to mount HFS-based filesystems+ */++#define OVERRIDE_UNKNOWN_PERMISSIONS 0++#define UNKNOWNUID ((uid_t)99)+#define UNKNOWNGID ((gid_t)99)+#define UNKNOWNPERMISSIONS (S_IRWXU | S_IROTH | S_IXOTH) /* 705 */++#ifdef __APPLE_API_UNSTABLE+struct hfs_mount_args {+#ifndef KERNEL+ char *fspec; /* block special device to mount */+#endif+ uid_t hfs_uid; /* uid that owns hfs files (standard HFS only) */+ gid_t hfs_gid; /* gid that owns hfs files (standard HFS only) */+ mode_t hfs_mask; /* mask to be applied for hfs perms (standard HFS only) */+ u_int32_t hfs_encoding; /* encoding for this volume (standard HFS only) */+ struct timezone hfs_timezone; /* user time zone info (standard HFS only) */+ int flags; /* mounting flags, see below */+ int journal_tbuffer_size; /* size in bytes of the journal transaction buffer */+ int journal_flags; /* flags to pass to journal_open/create */+ int journal_disable; /* don't use journaling (potentially dangerous) */+};++#define HFSFSMNT_NOXONFILES 0x1 /* disable execute permissions for files */+#define HFSFSMNT_WRAPPER 0x2 /* mount HFS wrapper (if it exists) */+#define HFSFSMNT_EXTENDED_ARGS 0x4 /* indicates new fields after "flags" are valid */++/*+ * Sysctl values for HFS+ */+#define HFS_ENCODINGBIAS 1 /* encoding matching CJK bias */+#define HFS_EXTEND_FS 2+#define HFS_ENABLE_JOURNALING 0x082969+#define HFS_DISABLE_JOURNALING 0x031272+#define HFS_REPLAY_JOURNAL 0x6a6e6c72+#define HFS_ENABLE_RESIZE_DEBUG 4 /* enable debug code for volume resizing */++#endif /* __APPLE_API_UNSTABLE */++#endif /* ! _HFS_MOUNT_H_ */diff --git a/xnu/files/bsd/hfs/hfs_notification.c b/xnu/files/bsd/hfs/hfs_notification.cnew file mode 100644index 0000000..614c32d--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_notification.c@@ -0,0 +1,198 @@+/*+ * Copyright (C) 2003-2015 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@+ */++#include <sys/systm.h>+#include <sys/kernel.h>+#include <sys/file.h>+#include <sys/dirent.h>+#include <sys/stat.h>+#include <sys/mount.h>+#include <sys/vnode.h>+#include <sys/malloc.h>+#include <sys/ubc.h>+#include <sys/quota.h>++#include <sys/kdebug.h>++#include "hfs.h"+#include "hfs_catalog.h"+#include "hfs_cnode.h"+#include "hfs_dbg.h"+#include "hfs_mount.h"+#include "hfs_quota.h"+#include "hfs_endian.h"++#include "BTreesInternal.h"+#include "FileMgrInternal.h"++++void hfs_generate_volume_notifications(struct hfsmount *hfsmp)+{+ fsid_t fsid;+ u_int32_t freeblks, state=999;++ /* Do not generate low disk notifications for read-only volumes */+ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return;+ }++ fsid.val[0] = hfsmp->hfs_raw_dev;+ fsid.val[1] = vfs_typenum(HFSTOVFS(hfsmp));++ freeblks = hfs_freeblks(hfsmp, 1);++ /*+ * Find the theshold the number of free blocks fits into.+ * We fire upon reaching a level below desired only once,+ * except for when we reach the low disk or near low disk levels+ * from below, in which case we do not fire unless we have also+ * reached the desired disk level (hysteresis).+ * This is illustrated in the following diagram:+ *+ * fire ^+ * --------- desired level+ * |+ *+ *+ * |+ * --------- near low disk level+ * fire v+ *+ *+ * |+ * --------- low disk level+ * fire v+ *+ *+ * | ^ fire+ * --------- very low disk level+ * fire v |+ *+ */+ if (freeblks < hfsmp->hfs_freespace_notify_dangerlimit) {+ state = 4;+ } else if (freeblks < hfsmp->hfs_freespace_notify_warninglimit) {+ state = 3;+ } else if (freeblks < hfsmp->hfs_freespace_notify_nearwarninglimit) {+ state = 2;+ } else if (freeblks < hfsmp->hfs_freespace_notify_desiredlevel) {+ /* We are between the near low disk and desired levels */+ state = 1;+ } else if (freeblks >= hfsmp->hfs_freespace_notify_desiredlevel) {+ state = 0;+ }++ /* Free blocks are less than dangerlimit for the first time */+ if (state == 4 && !(hfsmp->hfs_notification_conditions & VQ_VERYLOWDISK)) {+ /* Dump some logging to track down intermittent issues */+ printf("hfs: set VeryLowDisk: vol:%s, freeblks:%d, dangerlimit:%d\n", hfsmp->vcbVN, freeblks, hfsmp->hfs_freespace_notify_dangerlimit);++#if HFS_SPARSE_DEV+ // If we're a sparse device, dump some info about the backing store..+ hfs_lock_mount(hfsmp);+ vnode_t backing_vp = hfsmp->hfs_backingvp;+ if (backing_vp && vnode_get(backing_vp) != 0)+ backing_vp = NULL;+ hfs_unlock_mount(hfsmp);++ if (backing_vp) {+ struct vfsstatfs *sfs = vfs_statfs(vnode_mount(backing_vp));+ printf("hfs: set VeryLowDisk: vol:%s, backingstore b_avail:%lld, tag:%d\n",+ hfsmp->vcbVN, sfs->f_bavail, vnode_tag(backing_vp));+ vnode_put(backing_vp);+ }+#endif++ hfsmp->hfs_notification_conditions |= (VQ_VERYLOWDISK|VQ_LOWDISK|VQ_NEARLOWDISK);+ vfs_event_signal(&fsid, hfsmp->hfs_notification_conditions, (intptr_t)NULL);+ } else if (state == 3) {+ /* Free blocks are less than warning limit for the first time */+ if (!(hfsmp->hfs_notification_conditions & VQ_LOWDISK)) {+ printf("hfs: set LowDisk: vol:%s, freeblks:%d, warninglimit:%d\n", hfsmp->vcbVN, freeblks, hfsmp->hfs_freespace_notify_warninglimit);+ hfsmp->hfs_notification_conditions |= (VQ_LOWDISK|VQ_NEARLOWDISK);+ vfs_event_signal(&fsid, hfsmp->hfs_notification_conditions, (intptr_t)NULL);+ } else if (hfsmp->hfs_notification_conditions & VQ_VERYLOWDISK) {+ /* Free blocks count has increased from danger limit to warning limit, so just clear VERYLOWDISK warning */+ printf("hfs: clear VeryLowDisk: vol:%s, freeblks:%d, dangerlimit:%d\n", hfsmp->vcbVN, freeblks, hfsmp->hfs_freespace_notify_dangerlimit);+ hfsmp->hfs_notification_conditions &= ~VQ_VERYLOWDISK;+ vfs_event_signal(&fsid, hfsmp->hfs_notification_conditions, (intptr_t)NULL);+ }+ } else if (state == 2) {+ /* Free blocks are less than the near warning limit for the first time */+ if (!(hfsmp->hfs_notification_conditions & VQ_NEARLOWDISK)) {+ printf("hfs: set NearLowDisk: vol:%s, freeblks:%d, nearwarninglimit:%d\n", hfsmp->vcbVN, freeblks,+ hfsmp->hfs_freespace_notify_nearwarninglimit);++ hfsmp->hfs_notification_conditions |= VQ_NEARLOWDISK;+ vfs_event_signal(&fsid, hfsmp->hfs_notification_conditions, (intptr_t)NULL);+ } else {+ /* Free blocks count has increased from warning/danger limit to near warning limit,+ * so clear VERYLOWDISK / LOWDISK warnings, and signal if we clear VERYLOWDISK */+ hfsmp->hfs_notification_conditions &= ~VQ_LOWDISK;+ if (hfsmp->hfs_notification_conditions & VQ_VERYLOWDISK) {+ printf("hfs: clear VeryLowDisk: vol:%s, freeblks:%d, dangerlimit:%d\n", hfsmp->vcbVN, freeblks,+ hfsmp->hfs_freespace_notify_dangerlimit);++ hfsmp->hfs_notification_conditions &= ~VQ_VERYLOWDISK;+ vfs_event_signal(&fsid, hfsmp->hfs_notification_conditions, (intptr_t)NULL);+ }+ }+ } else if (state == 1) {+ /* Free blocks are less than the desireable level, but more than the near warning level+ * In this case, we may have to notify if we were previously underneath the danger limit */+ if (hfsmp->hfs_notification_conditions & VQ_VERYLOWDISK) {+ printf("hfs: clear VeryLowDisk: vol:%s, freeblks:%d, dangerlimit:%d\n", hfsmp->vcbVN, freeblks,+ hfsmp->hfs_freespace_notify_dangerlimit);++ hfsmp->hfs_notification_conditions &= ~VQ_VERYLOWDISK;+ vfs_event_signal(&fsid, hfsmp->hfs_notification_conditions, (intptr_t)NULL);+ }+ } else if (state == 0) {+ /* Free blocks count has increased to desirable level, so clear all conditions */+ if (hfsmp->hfs_notification_conditions & (VQ_NEARLOWDISK|VQ_LOWDISK|VQ_VERYLOWDISK)) {+ if (hfsmp->hfs_notification_conditions & VQ_NEARLOWDISK) {+ printf("hfs: clear NearLowDisk: vol:%s, freeblks:%d, nearwarninglimit:%d, desiredlevel:%d\n", hfsmp->vcbVN,+ freeblks, hfsmp->hfs_freespace_notify_nearwarninglimit, hfsmp->hfs_freespace_notify_desiredlevel);+ }+ if (hfsmp->hfs_notification_conditions & VQ_LOWDISK) {+ printf("hfs: clear LowDisk: vol:%s, freeblks:%d, warninglimit:%d, desiredlevel:%d\n", hfsmp->vcbVN, freeblks,+ hfsmp->hfs_freespace_notify_warninglimit, hfsmp->hfs_freespace_notify_desiredlevel);+ }+ if (hfsmp->hfs_notification_conditions & VQ_VERYLOWDISK) {+ printf("hfs: clear VeryLowDisk: vol:%s, freeblks:%d, dangerlimit:%d\n", hfsmp->vcbVN, freeblks, hfsmp->hfs_freespace_notify_warninglimit);+ }+ hfsmp->hfs_notification_conditions &= ~(VQ_VERYLOWDISK|VQ_LOWDISK|VQ_NEARLOWDISK);+ if (hfsmp->hfs_notification_conditions == 0) {+ vfs_event_signal(&fsid, VQ_UPDATE|VQ_DESIRED_DISK, (intptr_t)NULL);+ } else {+ vfs_event_signal(&fsid, hfsmp->hfs_notification_conditions, (intptr_t)NULL);+ }+ }+ }+}diff --git a/xnu/files/bsd/hfs/hfs_quota.c b/xnu/files/bsd/hfs/hfs_quota.cnew file mode 100644index 0000000..da47b9c--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_quota.c@@ -0,0 +1,1014 @@+/*+ * Copyright (c) 2002-2015 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@+ */+/*+ * Copyright (c) 1982, 1986, 1990, 1993, 1995+ * The Regents of the University of California. All rights reserved.+ *+ * This code is derived from software contributed to Berkeley by+ * Robert Elz at The University of Melbourne.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. Redistributions in binary form must reproduce the above copyright+ * notice, this list of conditions and the following disclaimer in the+ * documentation and/or other materials provided with the distribution.+ * 3. All advertising materials mentioning features or use of this software+ * must display the following acknowledgement:+ * This product includes software developed by the University of+ * California, Berkeley and its contributors.+ * 4. Neither the name of the University nor the names of its contributors+ * may be used to endorse or promote products derived from this software+ * without specific prior written permission.+ *+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+ * SUCH DAMAGE.+ *+ * @(#)hfs_quota.c+ * derived from @(#)ufs_quota.c 8.5 (Berkeley) 5/20/95+ */++#if QUOTA++#include <sys/param.h>+#include <sys/kernel.h>+#include <sys/systm.h>+#include <sys/mount.h>+#include <sys/malloc.h>+#include <sys/file.h>+#include <sys/proc.h>+#include <sys/kauth.h>+#include <sys/vnode.h>+#include <sys/quota.h>+#include <sys/vm.h>++#include "hfs.h"+#include "hfs_cnode.h"+#include "hfs_quota.h"+#include "hfs_mount.h"+++/*+ * Quota name to error message mapping.+ */+#if 0+static char *quotatypes[] = INITQFNAMES;+#endif++/*+ * Set up the quotas for a cnode.+ *+ * This routine completely defines the semantics of quotas.+ * If other criterion want to be used to establish quotas, the+ * MAXQUOTAS value in quotas.h should be increased, and the+ * additional dquots set up here.+ */+int+hfs_getinoquota(cp)+ register struct cnode *cp;+{+ struct hfsmount *hfsmp;+ struct vnode *vp;+ int error;+ int drop_usrquota = false;++ vp = cp->c_vp ? cp->c_vp : cp->c_rsrc_vp;+ hfsmp = VTOHFS(vp);+ /*+ * Set up the user quota based on file uid.+ * EINVAL means that quotas are not enabled.+ */+ if (cp->c_dquot[USRQUOTA] == NODQUOT) {+ error = dqget(cp->c_uid, &hfsmp->hfs_qfiles[USRQUOTA], USRQUOTA, &cp->c_dquot[USRQUOTA]);+ if ((error != 0) && (error != EINVAL)) {+ return error;+ } else if (error == 0) {+ drop_usrquota = true;+ }+ }++ /*+ * Set up the group quota based on file gid.+ * EINVAL means that quotas are not enabled.+ */+ if (cp->c_dquot[GRPQUOTA] == NODQUOT) {+ error = dqget(cp->c_gid, &hfsmp->hfs_qfiles[GRPQUOTA], GRPQUOTA, &cp->c_dquot[GRPQUOTA]);+ if ((error != 0) && (error != EINVAL)) {+ if (drop_usrquota == true) {+ dqrele(cp->c_dquot[USRQUOTA]);+ cp->c_dquot[USRQUOTA] = NODQUOT;+ }+ return error;+ }+ }++ return (0);+}++/*+ * Update disk usage, and take corrective action.+ */+int+hfs_chkdq(cp, change, cred, flags)+ register struct cnode *cp;+ int64_t change;+ kauth_cred_t cred;+ int flags;+{+ register struct dquot *dq;+ register int i;+ int64_t ncurbytes;+ int error=0;+ struct proc *p;++#if DIAGNOSTIC+ if ((flags & CHOWN) == 0)+ hfs_chkdquot(cp);+#endif+ if (change == 0)+ return (0);+ if (change < 0) {+ for (i = 0; i < MAXQUOTAS; i++) {+ if ((dq = cp->c_dquot[i]) == NODQUOT)+ continue;+ dqlock(dq);++ ncurbytes = dq->dq_curbytes + change;+ if (ncurbytes >= 0)+ dq->dq_curbytes = ncurbytes;+ else+ dq->dq_curbytes = 0;+ dq->dq_flags &= ~DQ_BLKS;+ dq->dq_flags |= DQ_MOD;++ dqunlock(dq);+ }+ return (0);+ }+ p = current_proc();+ /*+ * This use of proc_ucred() is safe because kernproc credential never+ * changes.+ */+ if (!IS_VALID_CRED(cred))+ cred = proc_ucred(kernproc);+ if (suser(cred, NULL) || proc_forcequota(p)) {+ for (i = 0; i < MAXQUOTAS; i++) {+ if ((dq = cp->c_dquot[i]) == NODQUOT)+ continue;+ error = hfs_chkdqchg(cp, change, cred, i);+ if (error) {+ break;+ }+ }+ }+ if ((flags & FORCE) || error == 0) {+ for (i = 0; i < MAXQUOTAS; i++) {+ if ((dq = cp->c_dquot[i]) == NODQUOT)+ continue;+ dqlock(dq);++ dq->dq_curbytes += change;+ dq->dq_flags |= DQ_MOD;++ dqunlock(dq);+ }+ }+ return (error);+}++/*+ * Check for a valid change to a users allocation.+ * Issue an error message and vfs event if appropriate.+ */+int+hfs_chkdqchg(cp, change, cred, type)+ struct cnode *cp;+ int64_t change;+ kauth_cred_t cred;+ int type;+{+ register struct dquot *dq = cp->c_dquot[type];+ u_int64_t ncurbytes;+ struct vnode *vp = cp->c_vp ? cp->c_vp : cp->c_rsrc_vp;++ fsid_t fsid;+ fsid.val[0] = VTOHFS(vp)->hfs_raw_dev;+ fsid.val[1] = vfs_typenum(VTOVFS(vp));++ dqlock(dq);++ ncurbytes = dq->dq_curbytes + change;+ /*+ * If user would exceed their hard limit, disallow space allocation.+ */+ if (ncurbytes >= dq->dq_bhardlimit && dq->dq_bhardlimit) {+ if ((dq->dq_flags & DQ_BLKS) == 0 &&+ cp->c_uid == kauth_cred_getuid(cred)) {+#if 0+ printf("\nhfs: write failed, %s disk limit reached\n",+ quotatypes[type]);+#endif+ dq->dq_flags |= DQ_BLKS;+ vfs_event_signal(&fsid, VQ_QUOTA, (intptr_t)NULL);+ }+ dqunlock(dq);++ return (EDQUOT);+ }+ /*+ * If user is over their soft limit for too long, disallow space+ * allocation. Reset time limit as they cross their soft limit.+ */+ if (ncurbytes >= dq->dq_bsoftlimit && dq->dq_bsoftlimit) {+ struct timeval tv;++ microuptime(&tv);+ if (dq->dq_curbytes < dq->dq_bsoftlimit) {+ dq->dq_btime = tv.tv_sec ++ VTOHFS(vp)->hfs_qfiles[type].qf_btime;+#if 0+ if (cp->c_uid == kauth_cred_getuid(cred))+ printf("\nhfs: warning, %s %s\n",+ quotatypes[type], "disk quota exceeded");+#endif+ vfs_event_signal(&fsid, VQ_QUOTA, (intptr_t)NULL);+ dqunlock(dq);++ return (0);+ }+ if (tv.tv_sec > (time_t)dq->dq_btime) {+ if ((dq->dq_flags & DQ_BLKS) == 0 &&+ cp->c_uid == kauth_cred_getuid(cred)) {+#if 0+ printf("\nhfs: write failed, %s %s\n",+ quotatypes[type],+ "disk quota exceeded for too long");+#endif+ dq->dq_flags |= DQ_BLKS;+ vfs_event_signal(&fsid, VQ_QUOTA, (intptr_t)NULL);+ }+ dqunlock(dq);++ return (EDQUOT);+ }+ }+ dqunlock(dq);++ return (0);+}++/*+ * Check the inode limit, applying corrective action.+ */+int+hfs_chkiq(cp, change, cred, flags)+ register struct cnode *cp;+ int32_t change;+ kauth_cred_t cred;+ int flags;+{+ register struct dquot *dq;+ register int i;+ int ncurinodes, error=0;+ struct proc *p;++#if DIAGNOSTIC+ if ((flags & CHOWN) == 0)+ hfs_chkdquot(cp);+#endif+ if (change == 0)+ return (0);+ if (change < 0) {+ for (i = 0; i < MAXQUOTAS; i++) {+ if ((dq = cp->c_dquot[i]) == NODQUOT)+ continue;+ dqlock(dq);++ ncurinodes = dq->dq_curinodes + change;+ if (ncurinodes >= 0)+ dq->dq_curinodes = ncurinodes;+ else+ dq->dq_curinodes = 0;+ dq->dq_flags &= ~DQ_INODS;+ dq->dq_flags |= DQ_MOD;++ dqunlock(dq);+ }+ return (0);+ }+ p = current_proc();+ /*+ * This use of proc_ucred() is safe because kernproc credential never+ * changes.+ */+ if (!IS_VALID_CRED(cred))+ cred = proc_ucred(kernproc);+ if (suser(cred, NULL) || proc_forcequota(p)) {+ for (i = 0; i < MAXQUOTAS; i++) {+ if ((dq = cp->c_dquot[i]) == NODQUOT)+ continue;+ error = hfs_chkiqchg(cp, change, cred, i);+ if (error) {+ break;+ }+ }+ }+ if ((flags & FORCE) || error == 0) {+ for (i = 0; i < MAXQUOTAS; i++) {+ if ((dq = cp->c_dquot[i]) == NODQUOT)+ continue;+ dqlock(dq);++ dq->dq_curinodes += change;+ dq->dq_flags |= DQ_MOD;++ dqunlock(dq);+ }+ }+ return (error);+}+++/*+ * Check to see if a change to a user's allocation should be permitted or not.+ * Issue an error message if it should not be permitted. Return 0 if+ * it should be allowed.+ */+int hfs_isiqchg_allowed(dq, hfsmp, change, cred, type, uid)+ struct dquot* dq;+ struct hfsmount* hfsmp;+ int32_t change;+ kauth_cred_t cred;+ int type;+ uid_t uid;+{+ u_int32_t ncurinodes;++ fsid_t fsid;+ fsid.val[0] = hfsmp->hfs_raw_dev;+ fsid.val[1] = vfs_typenum(HFSTOVFS(hfsmp));++ dqlock(dq);++ ncurinodes = dq->dq_curinodes + change;+ /*+ * If user would exceed their hard limit, disallow cnode allocation.+ */+ if (ncurinodes >= dq->dq_ihardlimit && dq->dq_ihardlimit) {+ if ((dq->dq_flags & DQ_INODS) == 0 &&+ uid == kauth_cred_getuid(cred)) {+ dq->dq_flags |= DQ_INODS;+ vfs_event_signal(&fsid, VQ_QUOTA, (intptr_t)NULL);+ }+ dqunlock(dq);++ return (EDQUOT);+ }+ /*+ * If user is over their soft limit for too long, disallow cnode+ * allocation. Reset time limit as they cross their soft limit.+ */+ if (ncurinodes >= dq->dq_isoftlimit && dq->dq_isoftlimit) {+ struct timeval tv;++ microuptime(&tv);+ if (dq->dq_curinodes < dq->dq_isoftlimit) {+ dq->dq_itime = tv.tv_sec + hfsmp->hfs_qfiles[type].qf_itime;+ vfs_event_signal(&fsid, VQ_QUOTA, (intptr_t)NULL);+ dqunlock(dq);+ return (0);+ }+ if (tv.tv_sec > (time_t)dq->dq_itime) {+ if (((dq->dq_flags & DQ_INODS) == 0) &&+ (uid == kauth_cred_getuid(cred))) {+ dq->dq_flags |= DQ_INODS;+ vfs_event_signal(&fsid, VQ_QUOTA, (intptr_t)NULL);+ }+ dqunlock(dq);++ return (EDQUOT);+ }+ }+ dqunlock(dq);++ return (0);+}+++/*+ * Check for a valid change to a users allocation.+ * Issue an error message if appropriate.+ */+int+hfs_chkiqchg(cp, change, cred, type)+ struct cnode *cp;+ int32_t change;+ kauth_cred_t cred;+ int type;+{+ register struct dquot *dq = cp->c_dquot[type];+ u_int32_t ncurinodes;+ struct vnode *vp = cp->c_vp ? cp->c_vp : cp->c_rsrc_vp;++ dqlock(dq);++ ncurinodes = dq->dq_curinodes + change;+ /*+ * If user would exceed their hard limit, disallow cnode allocation.+ */+ if (ncurinodes >= dq->dq_ihardlimit && dq->dq_ihardlimit) {+ if ((dq->dq_flags & DQ_INODS) == 0 &&+ cp->c_uid == kauth_cred_getuid(cred)) {+#if 0+ printf("\nhfs: write failed, %s cnode limit reached\n",+ quotatypes[type]);+#endif+ dq->dq_flags |= DQ_INODS;+ }+ dqunlock(dq);++ return (EDQUOT);+ }+ /*+ * If user is over their soft limit for too long, disallow cnode+ * allocation. Reset time limit as they cross their soft limit.+ */+ if (ncurinodes >= dq->dq_isoftlimit && dq->dq_isoftlimit) {+ struct timeval tv;++ microuptime(&tv);+ if (dq->dq_curinodes < dq->dq_isoftlimit) {+ dq->dq_itime = tv.tv_sec ++ VTOHFS(vp)->hfs_qfiles[type].qf_itime;+#if 0+ if (cp->c_uid == kauth_cred_getuid(cred))+ printf("\nhfs: warning, %s %s\n",+ quotatypes[type], "cnode quota exceeded");+#endif+ dqunlock(dq);++ return (0);+ }+ if (tv.tv_sec > (time_t)dq->dq_itime) {+ if ((dq->dq_flags & DQ_INODS) == 0 &&+ cp->c_uid == kauth_cred_getuid(cred)) {+#if 0+ printf("\nhfs: write failed, %s %s\n",+ quotatypes[type],+ "cnode quota exceeded for too long");+#endif+ dq->dq_flags |= DQ_INODS;+ }+ dqunlock(dq);++ return (EDQUOT);+ }+ }+ dqunlock(dq);++ return (0);+}++#if DIAGNOSTIC+/*+ * On filesystems with quotas enabled, it is an error for a file to change+ * size and not to have a dquot structure associated with it.+ */+void+hfs_chkdquot(cp)+ register struct cnode *cp;+{+ struct vnode *vp = cp->c_vp ? cp->c_vp : cp->c_rsrc_vp;+ struct hfsmount *hfsmp = VTOHFS(vp);+ register int i;++ for (i = 0; i < MAXQUOTAS; i++) {+ if (hfsmp->hfs_qfiles[i].qf_vp == NULLVP)+ continue;+ if (cp->c_dquot[i] == NODQUOT) {+ vprint("chkdquot: missing dquot", vp);+ panic("missing dquot");+ }+ }+}+#endif++/*+ * Code to process quotactl commands.+ */++/*+ * Q_QUOTAON - set up a quota file for a particular file system.+ */+struct hfs_quotaon_cargs {+ int error;+};++static int+hfs_quotaon_callback(struct vnode *vp, void *cargs)+{+ struct hfs_quotaon_cargs *args;++ args = (struct hfs_quotaon_cargs *)cargs;++ args->error = hfs_getinoquota(VTOC(vp));+ if (args->error)+ return (VNODE_RETURNED_DONE);++ return (VNODE_RETURNED);+}++int+hfs_quotaon(p, mp, type, fnamep)+ struct proc *p;+ struct mount *mp;+ register int type;+ caddr_t fnamep;+{+ struct hfsmount *hfsmp = VFSTOHFS(mp);+ struct quotafile *qfp;+ struct vnode *vp;+ int error = 0;+ struct hfs_quotaon_cargs args;++ /* Finish setting up quota structures. */+ dqhashinit();++ qfp = &hfsmp->hfs_qfiles[type];++ if ( (qf_get(qfp, QTF_OPENING)) )+ return (0);++ error = vnode_open(fnamep, FREAD|FWRITE, 0, 0, &vp, NULL);+ if (error) {+ goto out;+ }+ if (!vnode_isreg(vp)) {+ (void) vnode_close(vp, FREAD|FWRITE, NULL);+ error = EACCES;+ goto out;+ }+ vfs_setflags(mp, (u_int64_t)((unsigned int)MNT_QUOTA));+ hfs_lock_mount (hfsmp);+ hfsmp->hfs_flags |= HFS_QUOTAS;+ hfs_unlock_mount (hfsmp);+ vnode_setnoflush(vp);+ /*+ * Save the credential of the process that turned on quotas.+ */+ qfp->qf_cred = kauth_cred_proc_ref(p);+ qfp->qf_vp = vp;+ /*+ * Finish initializing the quota file+ */+ error = dqfileopen(qfp, type);+ if (error) {+ (void) vnode_close(vp, FREAD|FWRITE, NULL);++ if (IS_VALID_CRED(qfp->qf_cred))+ kauth_cred_unref(&qfp->qf_cred);+ qfp->qf_vp = NULLVP;+ goto out;+ }+ qf_put(qfp, QTF_OPENING);++ /*+ * Search vnodes associated with this mount point,+ * adding references to quota file being opened.+ * NB: only need to add dquot's for cnodes being modified.+ *+ * hfs_quota_callback will be called for each vnode open for+ * 'write' (VNODE_WRITEABLE) hung off of this mount point+ * the vnode will be in an 'unbusy' state (VNODE_WAIT) and+ * properly referenced and unreferenced around the callback+ */+ args.error = 0;++ vnode_iterate(mp, VNODE_WRITEABLE | VNODE_WAIT, hfs_quotaon_callback, (void *)&args);++ error = args.error;++ if (error) {+ hfs_quotaoff(p, mp, type);+ }+ return (error);++out:+ qf_put(qfp, QTF_OPENING);++ return (error);+}+++/*+ * Q_QUOTAOFF - turn off disk quotas for a filesystem.+ */+struct hfs_quotaoff_cargs {+ int type;+};++static int+hfs_quotaoff_callback(struct vnode *vp, void *cargs)+{+ struct hfs_quotaoff_cargs *args;+ struct cnode *cp;+ struct dquot *dq;++ args = (struct hfs_quotaoff_cargs *)cargs;++ cp = VTOC(vp);++ dq = cp->c_dquot[args->type];+ cp->c_dquot[args->type] = NODQUOT;++ dqrele(dq);++ return (VNODE_RETURNED);+}++int+hfs_quotaoff(__unused struct proc *p, struct mount *mp, register int type)+{+ struct vnode *qvp;+ struct hfsmount *hfsmp = VFSTOHFS(mp);+ struct quotafile *qfp;+ int error;+ struct hfs_quotaoff_cargs args;++ /*+ * If quotas haven't been initialized, there's no work to be done.+ */+ if (!dqisinitialized())+ return (0);++ qfp = &hfsmp->hfs_qfiles[type];++ if ( (qf_get(qfp, QTF_CLOSING)) )+ return (0);+ qvp = qfp->qf_vp;++ /*+ * Sync out any orpaned dirty dquot entries.+ */+ dqsync_orphans(qfp);++ /*+ * Search vnodes associated with this mount point,+ * deleting any references to quota file being closed.+ *+ * hfs_quotaoff_callback will be called for each vnode+ * hung off of this mount point+ * the vnode will be in an 'unbusy' state (VNODE_WAIT) and+ * properly referenced and unreferenced around the callback+ */+ args.type = type;++ vnode_iterate(mp, VNODE_WAIT, hfs_quotaoff_callback, (void *)&args);++ dqflush(qvp);+ /* Finish tearing down the quota file */+ dqfileclose(qfp, type);++ vnode_clearnoflush(qvp);+ error = vnode_close(qvp, FREAD|FWRITE, NULL);++ qfp->qf_vp = NULLVP;++ if (IS_VALID_CRED(qfp->qf_cred))+ kauth_cred_unref(&qfp->qf_cred);+ for (type = 0; type < MAXQUOTAS; type++)+ if (hfsmp->hfs_qfiles[type].qf_vp != NULLVP)+ break;+ if (type == MAXQUOTAS) {+ vfs_clearflags(mp, (u_int64_t)((unsigned int)MNT_QUOTA));+ hfs_lock_mount (hfsmp);+ hfsmp->hfs_flags &= ~HFS_QUOTAS;+ hfs_unlock_mount (hfsmp);+ }++ qf_put(qfp, QTF_CLOSING);++ return (error);+}++/*+ * hfs_quotacheck - checks quotas mountwide for a hypothetical situation. It probes+ * the quota data structures to see if adding an inode would be allowed or not. If it+ * will be allowed, the change is made. Otherwise, it reports an error back out so the+ * caller will know not to proceed with inode allocation in the HFS Catalog.+ *+ * Note that this function ONLY tests for addition of inodes, not subtraction.+ */+int hfs_quotacheck(hfsmp, change, uid, gid, cred)+ struct hfsmount *hfsmp;+ int change;+ uid_t uid;+ gid_t gid;+ kauth_cred_t cred;+{+ struct dquot *dq = NULL;+ struct proc *p;+ int error = 0;+ int i;+ id_t id = uid;++ p = current_proc();+ if (!IS_VALID_CRED(cred)) {+ /* This use of proc_ucred() is safe because kernproc credential never changes */+ cred = proc_ucred(kernproc);+ }++ if (suser(cred, NULL) || proc_forcequota(p)) {+ for (i = 0; i < MAXQUOTAS; i++) {+ /* Select if user or group id should be used */+ if (i == USRQUOTA)+ id = uid;+ else if (i == GRPQUOTA)+ id = gid;++ error = dqget(id, &hfsmp->hfs_qfiles[i], i, &dq);+ if (error && (error != EINVAL))+ break;++ error = 0;+ if (dq == NODQUOT)+ continue;++ /* Check quota information */+ error = hfs_isiqchg_allowed(dq, hfsmp, change, cred, i, id);+ if (error) {+ dqrele(dq);+ break;+ }++ dqlock(dq);+ /* Update quota information */+ dq->dq_curinodes += change;+ dqunlock(dq);+ dqrele(dq);+ }+ }++ return error;+}+++/*+ * Q_GETQUOTA - return current values in a dqblk structure.+ */+int+hfs_getquota(mp, id, type, datap)+ struct mount *mp;+ u_int32_t id;+ int type;+ caddr_t datap;+{+ struct dquot *dq;+ int error;++ error = dqget(id, &VFSTOHFS(mp)->hfs_qfiles[type], type, &dq);+ if (error)+ return (error);+ dqlock(dq);++ bcopy(&dq->dq_dqb, datap, sizeof(dq->dq_dqb));++ dqunlock(dq);+ dqrele(dq);++ return (error);+}++/*+ * Q_SETQUOTA - assign an entire dqblk structure.+ */+int+hfs_setquota(mp, id, type, datap)+ struct mount *mp;+ u_int32_t id;+ int type;+ caddr_t datap;+{+ struct dquot *dq;+ struct hfsmount *hfsmp = VFSTOHFS(mp);+ struct dqblk * newlimp = (struct dqblk *) datap;+ struct timeval tv;+ int error;++ error = dqget(id, &hfsmp->hfs_qfiles[type], type, &dq);+ if (error)+ return (error);+ dqlock(dq);++ /*+ * Copy all but the current values.+ * Reset time limit if previously had no soft limit or were+ * under it, but now have a soft limit and are over it.+ */+ newlimp->dqb_curbytes = dq->dq_curbytes;+ newlimp->dqb_curinodes = dq->dq_curinodes;+ if (dq->dq_id != 0) {+ newlimp->dqb_btime = dq->dq_btime;+ newlimp->dqb_itime = dq->dq_itime;+ }+ if (newlimp->dqb_bsoftlimit &&+ dq->dq_curbytes >= newlimp->dqb_bsoftlimit &&+ (dq->dq_bsoftlimit == 0 || dq->dq_curbytes < dq->dq_bsoftlimit)) {+ microuptime(&tv);+ newlimp->dqb_btime = tv.tv_sec + hfsmp->hfs_qfiles[type].qf_btime;+ }+ if (newlimp->dqb_isoftlimit &&+ dq->dq_curinodes >= newlimp->dqb_isoftlimit &&+ (dq->dq_isoftlimit == 0 || dq->dq_curinodes < dq->dq_isoftlimit)) {+ microuptime(&tv);+ newlimp->dqb_itime = tv.tv_sec + hfsmp->hfs_qfiles[type].qf_itime;+ }+ bcopy(newlimp, &dq->dq_dqb, sizeof(dq->dq_dqb));+ if (dq->dq_curbytes < dq->dq_bsoftlimit)+ dq->dq_flags &= ~DQ_BLKS;+ if (dq->dq_curinodes < dq->dq_isoftlimit)+ dq->dq_flags &= ~DQ_INODS;+ if (dq->dq_isoftlimit == 0 && dq->dq_bsoftlimit == 0 &&+ dq->dq_ihardlimit == 0 && dq->dq_bhardlimit == 0)+ dq->dq_flags |= DQ_FAKE;+ else+ dq->dq_flags &= ~DQ_FAKE;+ dq->dq_flags |= DQ_MOD;++ dqunlock(dq);+ dqrele(dq);++ return (0);+}++/*+ * Q_SETUSE - set current cnode and byte usage.+ */+int+hfs_setuse(mp, id, type, datap)+ struct mount *mp;+ u_int32_t id;+ int type;+ caddr_t datap;+{+ struct hfsmount *hfsmp = VFSTOHFS(mp);+ struct dquot *dq;+ struct timeval tv;+ int error;+ struct dqblk *quotablkp = (struct dqblk *) datap;++ error = dqget(id, &hfsmp->hfs_qfiles[type], type, &dq);+ if (error)+ return (error);+ dqlock(dq);++ /*+ * Reset time limit if have a soft limit and were+ * previously under it, but are now over it.+ */+ if (dq->dq_bsoftlimit && dq->dq_curbytes < dq->dq_bsoftlimit &&+ quotablkp->dqb_curbytes >= dq->dq_bsoftlimit) {+ microuptime(&tv);+ dq->dq_btime = tv.tv_sec + hfsmp->hfs_qfiles[type].qf_btime;+ }+ if (dq->dq_isoftlimit && dq->dq_curinodes < dq->dq_isoftlimit &&+ quotablkp->dqb_curinodes >= dq->dq_isoftlimit) {+ microuptime(&tv);+ dq->dq_itime = tv.tv_sec + hfsmp->hfs_qfiles[type].qf_itime;+ }+ dq->dq_curbytes = quotablkp->dqb_curbytes;+ dq->dq_curinodes = quotablkp->dqb_curinodes;+ if (dq->dq_curbytes < dq->dq_bsoftlimit)+ dq->dq_flags &= ~DQ_BLKS;+ if (dq->dq_curinodes < dq->dq_isoftlimit)+ dq->dq_flags &= ~DQ_INODS;+ dq->dq_flags |= DQ_MOD;++ dqunlock(dq);+ dqrele(dq);++ return (0);+}+++/*+ * Q_SYNC - sync quota files to disk.+ */+static int+hfs_qsync_callback(struct vnode *vp, __unused void *cargs)+{+ struct cnode *cp;+ struct dquot *dq;+ int i;++ cp = VTOC(vp);++ for (i = 0; i < MAXQUOTAS; i++) {+ dq = cp->c_dquot[i];+ if (dq != NODQUOT && (dq->dq_flags & DQ_MOD))+ dqsync(dq);+ }+ return (VNODE_RETURNED);+}++int+hfs_qsync(mp)+ struct mount *mp;+{+ struct hfsmount *hfsmp = VFSTOHFS(mp);+ int i;++ if (!dqisinitialized())+ return (0);++ /*+ * Check if the mount point has any quotas.+ * If not, simply return.+ */+ for (i = 0; i < MAXQUOTAS; i++)+ if (hfsmp->hfs_qfiles[i].qf_vp != NULLVP)+ break;+ if (i == MAXQUOTAS)+ return (0);++ /*+ * Sync out any orpaned dirty dquot entries.+ */+ for (i = 0; i < MAXQUOTAS; i++)+ if (hfsmp->hfs_qfiles[i].qf_vp != NULLVP)+ dqsync_orphans(&hfsmp->hfs_qfiles[i]);++ /*+ * Search vnodes associated with this mount point,+ * synchronizing any modified dquot structures.+ *+ * hfs_qsync_callback will be called for each vnode+ * hung off of this mount point+ * the vnode will be+ * properly referenced and unreferenced around the callback+ */+ vnode_iterate(mp, 0, hfs_qsync_callback, (void *)NULL);++ return (0);+}++/*+ * Q_QUOTASTAT - get quota on/off status+ */+int+hfs_quotastat(mp, type, datap)+ struct mount *mp;+ register int type;+ caddr_t datap;+{+ struct hfsmount *hfsmp = VFSTOHFS(mp);+ int error = 0;+ int qstat;++ if ((((unsigned int)vfs_flags(mp)) & MNT_QUOTA) && (hfsmp->hfs_qfiles[type].qf_vp != NULLVP))+ qstat = 1; /* quotas are on for this type */+ else+ qstat = 0; /* quotas are off for this type */++ *((int *)datap) = qstat;+ return (error);+}++#endif // QUOTAdiff --git a/xnu/files/bsd/hfs/hfs_quota.h b/xnu/files/bsd/hfs/hfs_quota.hnew file mode 100644index 0000000..27ee6a5--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_quota.h@@ -0,0 +1,111 @@+/*+ * Copyright (c) 2002 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@+ */+/*+ * Copyright (c) 1982, 1986, 1993+ * The Regents of the University of California. All rights reserved.+ *+ * This code is derived from software contributed to Berkeley by+ * Robert Elz at The University of Melbourne.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. Redistributions in binary form must reproduce the above copyright+ * notice, this list of conditions and the following disclaimer in the+ * documentation and/or other materials provided with the distribution.+ * 3. All advertising materials mentioning features or use of this software+ * must display the following acknowledgement:+ * This product includes software developed by the University of+ * California, Berkeley and its contributors.+ * 4. Neither the name of the University nor the names of its contributors+ * may be used to endorse or promote products derived from this software+ * without specific prior written permission.+ *+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+ * SUCH DAMAGE.+ *+ * @(#)hfs_quota.h+ * derived from @(#)quota.h 8.3 (Berkeley) 8/19/94+ */++#ifndef _HFS_QUOTA_H_+#define _HFS_QUOTA_H_++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE+#include <sys/queue.h>++#include <sys/cdefs.h>++struct cnode;+struct mount;+struct proc;+#ifndef _KAUTH_CRED_T+#define _KAUTH_CRED_T+struct ucred;+typedef struct ucred *kauth_cred_t;+#endif /* !_KAUTH_CRED_T */+__BEGIN_DECLS+int hfs_chkdq(struct cnode *, int64_t, kauth_cred_t, int);+int hfs_chkdqchg(struct cnode *, int64_t, kauth_cred_t, int);+int hfs_chkiq(struct cnode *, int32_t, kauth_cred_t, int);+int hfs_chkiqchg(struct cnode *, int32_t, kauth_cred_t, int);+int hfs_getinoquota(struct cnode *);+int hfs_getquota(struct mount *, u_int32_t, int, caddr_t);+int hfs_qsync(struct mount *mp);+int hfs_quotaoff(struct proc *, struct mount *, int);+int hfs_quotaon(struct proc *, struct mount *, int, caddr_t);+int hfs_quotastat(struct mount *, int, caddr_t);+int hfs_setquota(struct mount *, u_int32_t, int, caddr_t);+int hfs_setuse(struct mount *, u_int32_t, int, caddr_t);+int hfs_isiqchg_allowed(struct dquot *, struct hfsmount *, int32_t, kauth_cred_t, int, uid_t);+int hfs_quotacheck (struct hfsmount *, int , uid_t, gid_t, kauth_cred_t);+__END_DECLS++#if DIAGNOSTIC+__BEGIN_DECLS+void hfs_chkdquot(struct cnode *);+__END_DECLS+#endif+#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */++#endif /* ! _HFS_QUOTA_H_ */diff --git a/xnu/files/bsd/hfs/hfs_readwrite.c b/xnu/files/bsd/hfs/hfs_readwrite.cnew file mode 100644index 0000000..6a182c4--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_readwrite.c@@ -0,0 +1,5959 @@+/*+ * Copyright (c) 2000-2020 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@+ */+/* @(#)hfs_readwrite.c 1.0+ *+ * (c) 1998-2001 Apple Inc. All Rights Reserved+ *+ * hfs_readwrite.c -- vnode operations to deal with reading and writing files.+ *+ */++#include <sys/param.h>+#include <sys/systm.h>+#include <sys/kernel.h>+#include <sys/fcntl.h>+#include <sys/stat.h>+#include <sys/buf.h>+#include <sys/proc.h>+#include <sys/kauth.h>+#include <sys/vnode.h>+#include <sys/uio.h>+#include <sys/vfs_context.h>+#include <sys/disk.h>+#include <sys/sysctl.h>+#include <sys/fsctl.h>+#include <sys/ubc.h>+#include <sys/fsevents.h>+#include <uuid/uuid.h>++#include <libkern/OSDebug.h>++#include <miscfs/specfs/specdev.h>++#include <sys/ubc.h>++#include <vm/vm_pageout.h>+#include <vm/vm_kern.h>++#include <IOKit/IOBSD.h>++#include <sys/kdebug.h>++#include "hfs.h"+#include "hfs_attrlist.h"+#include "hfs_endian.h"+#include "hfs_fsctl.h"+#include "hfs_quota.h"+#include "FileMgrInternal.h"+#include "BTreesInternal.h"+#include "hfs_cnode.h"+#include "hfs_dbg.h"++#if HFS_CONFIG_KEY_ROLL+#include "hfs_key_roll.h"+#endif++#define can_cluster(size) ((((size & (4096-1))) == 0) && (size <= (MAXPHYSIO/2)))++enum {+ MAXHFSFILESIZE = 0x7FFFFFFF /* this needs to go in the mount structure */+};++/* from bsd/hfs/hfs_vfsops.c */+extern int hfs_vfs_vget (struct mount *mp, ino64_t ino, struct vnode **vpp, vfs_context_t context);++/* from hfs_hotfiles.c */+extern int hfs_pin_overflow_extents (struct hfsmount *hfsmp, uint32_t fileid,+ uint8_t forktype, uint32_t *pinned);++static int hfs_clonefile(struct vnode *, int, int, int);+static int hfs_clonesysfile(struct vnode *, int, int, int, kauth_cred_t, struct proc *);+static int do_hfs_truncate(struct vnode *vp, off_t length, int flags, int skip, vfs_context_t context);+++/*+ * Read data from a file.+ */+int+hfs_vnop_read(struct vnop_read_args *ap)+{+ /*+ struct vnop_read_args {+ struct vnodeop_desc *a_desc;+ vnode_t a_vp;+ struct uio *a_uio;+ int a_ioflag;+ vfs_context_t a_context;+ };+ */++ uio_t uio = ap->a_uio;+ struct vnode *vp = ap->a_vp;+ struct cnode *cp;+ struct filefork *fp;+ struct hfsmount *hfsmp;+ off_t filesize;+ off_t filebytes;+ off_t start_resid = uio_resid(uio);+ off_t offset = uio_offset(uio);+ int retval = 0;+ int took_truncate_lock = 0;+ int io_throttle = 0;+ int throttled_count = 0;++ /* Preflight checks */+ if (!vnode_isreg(vp)) {+ /* can only read regular files */+ if (vnode_isdir(vp))+ return (EISDIR);+ else+ return (EPERM);+ }+ if (start_resid == 0)+ return (0); /* Nothing left to do */+ if (offset < 0)+ return (EINVAL); /* cant read from a negative offset */++#if SECURE_KERNEL+ if ((ap->a_ioflag & (IO_SKIP_ENCRYPTION|IO_SYSCALL_DISPATCH)) ==+ (IO_SKIP_ENCRYPTION|IO_SYSCALL_DISPATCH)) {+ /* Don't allow unencrypted io request from user space */+ return EPERM;+ }+#endif++#if HFS_COMPRESSION+ if (VNODE_IS_RSRC(vp)) {+ if (hfs_hides_rsrc(ap->a_context, VTOC(vp), 1)) { /* 1 == don't take the cnode lock */+ return 0;+ }+ /* otherwise read the resource fork normally */+ } else {+ int compressed = hfs_file_is_compressed(VTOC(vp), 1); /* 1 == don't take the cnode lock */+ if (compressed) {+ retval = decmpfs_read_compressed(ap, &compressed, VTOCMP(vp));+ if (retval == 0 && !(ap->a_ioflag & IO_EVTONLY) && vnode_isfastdevicecandidate(vp)) {+ (void) hfs_addhotfile(vp);+ }+ if (compressed) {+ if (retval == 0) {+ /* successful read, update the access time */+ VTOC(vp)->c_touch_acctime = TRUE;++ //+ // compressed files are not traditional hot file candidates+ // but they may be for CF (which ignores the ff_bytesread+ // field)+ //+ if (VTOHFS(vp)->hfc_stage == HFC_RECORDING) {+ VTOF(vp)->ff_bytesread = 0;+ }+ }+ return retval;+ }+ /* otherwise the file was converted back to a regular file while we were reading it */+ retval = 0;+ } else if ((VTOC(vp)->c_bsdflags & UF_COMPRESSED)) {+ int error;++ error = check_for_dataless_file(vp, NAMESPACE_HANDLER_READ_OP);+ if (error) {+ return error;+ }++ }+ }+#endif /* HFS_COMPRESSION */++ cp = VTOC(vp);+ fp = VTOF(vp);+ hfsmp = VTOHFS(vp);++#if CONFIG_PROTECT+ if ((retval = cp_handle_vnop (vp, CP_READ_ACCESS, ap->a_ioflag)) != 0) {+ goto exit;+ }++#if HFS_CONFIG_KEY_ROLL+ if (ISSET(ap->a_ioflag, IO_ENCRYPTED)) {+ off_rsrc_t off_rsrc = off_rsrc_make(offset + start_resid,+ VNODE_IS_RSRC(vp));++ retval = hfs_key_roll_up_to(ap->a_context, vp, off_rsrc);+ if (retval)+ goto exit;+ }+#endif // HFS_CONFIG_KEY_ROLL+#endif // CONFIG_PROTECT++ /*+ * If this read request originated from a syscall (as opposed to+ * an in-kernel page fault or something), then set it up for+ * throttle checks+ */+ if (ap->a_ioflag & IO_SYSCALL_DISPATCH) {+ io_throttle = IO_RETURN_ON_THROTTLE;+ }++read_again:++ /* Protect against a size change. */+ hfs_lock_truncate(cp, HFS_SHARED_LOCK, HFS_LOCK_DEFAULT);+ took_truncate_lock = 1;++ filesize = fp->ff_size;+ filebytes = (off_t)fp->ff_blocks * (off_t)hfsmp->blockSize;++ /*+ * Check the file size. Note that per POSIX spec, we return 0 at+ * file EOF, so attempting a read at an offset that is too big+ * should just return 0 on HFS+. Since the return value was initialized+ * to 0 above, we just jump to exit. HFS Standard has its own behavior.+ */+ if (offset > filesize) {+ goto exit;+ }++ KERNEL_DEBUG(HFSDBG_READ | DBG_FUNC_START,+ (int)uio_offset(uio), uio_resid(uio), (int)filesize, (int)filebytes, 0);++ retval = cluster_read(vp, uio, filesize, ap->a_ioflag |io_throttle);++ cp->c_touch_acctime = TRUE;++ KERNEL_DEBUG(HFSDBG_READ | DBG_FUNC_END,+ (int)uio_offset(uio), uio_resid(uio), (int)filesize, (int)filebytes, 0);++ /*+ * Keep track blocks read+ */+ if (hfsmp->hfc_stage == HFC_RECORDING && retval == 0) {+ int took_cnode_lock = 0;+ off_t bytesread;++ bytesread = start_resid - uio_resid(uio);++ /* When ff_bytesread exceeds 32-bits, update it behind the cnode lock. */+ if ((fp->ff_bytesread + bytesread) > 0x00000000ffffffff) {+ hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ took_cnode_lock = 1;+ }+ /*+ * If this file hasn't been seen since the start of+ * the current sampling period then start over.+ */+ if (cp->c_atime < hfsmp->hfc_timebase) {+ struct timeval tv;++ fp->ff_bytesread = bytesread;+ microtime(&tv);+ cp->c_atime = tv.tv_sec;+ } else {+ fp->ff_bytesread += bytesread;+ }++ if (!(ap->a_ioflag & IO_EVTONLY) && vnode_isfastdevicecandidate(vp)) {+ //+ // We don't add hotfiles for processes doing IO_EVTONLY I/O+ // on the assumption that they're system processes such as+ // mdworker which scan everything in the system (and thus+ // do not represent user-initiated access to files)+ //+ (void) hfs_addhotfile(vp);+ }+ if (took_cnode_lock)+ hfs_unlock(cp);+ }+exit:+ if (took_truncate_lock) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ }+ if (retval == EAGAIN) {+ throttle_lowpri_io(1);+ throttled_count++;++ retval = 0;+ goto read_again;+ }+ if (throttled_count)+ throttle_info_reset_window(NULL);+ return (retval);+}++/*+ * Ideally, this wouldn't be necessary; the cluster code should be+ * able to handle this on the read-side. See <rdar://20420068>.+ */+static errno_t hfs_zero_eof_page(vnode_t vp, off_t zero_up_to)+{+ hfs_assert(VTOC(vp)->c_lockowner != current_thread());+ hfs_assert(VTOC(vp)->c_truncatelockowner == current_thread());++ struct filefork *fp = VTOF(vp);++ if (!(fp->ff_size & PAGE_MASK_64) || zero_up_to <= fp->ff_size) {+ // Nothing to do+ return 0;+ }++ zero_up_to = MIN(zero_up_to, (off_t)round_page_64(fp->ff_size));++ /* N.B. At present, @zero_up_to is not important because the cluster+ code will always zero up to the end of the page anyway. */+ return cluster_write(vp, NULL, fp->ff_size, zero_up_to,+ fp->ff_size, 0, IO_HEADZEROFILL);+}++/*+ * Write data to a file.+ */+int+hfs_vnop_write(struct vnop_write_args *ap)+{+ uio_t uio = ap->a_uio;+ struct vnode *vp = ap->a_vp;+ struct cnode *cp;+ struct filefork *fp;+ struct hfsmount *hfsmp;+ kauth_cred_t cred = NULL;+ off_t origFileSize;+ off_t writelimit;+ off_t bytesToAdd = 0;+ off_t actualBytesAdded;+ off_t filebytes;+ off_t offset;+ ssize_t resid;+ int eflags = 0;+ int ioflag = ap->a_ioflag;+ int retval = 0;+ int lockflags;+ int cnode_locked = 0;+ int partialwrite = 0;+ int do_snapshot = 1;+ time_t orig_ctime=VTOC(vp)->c_ctime;+ int took_truncate_lock = 0;+ int io_return_on_throttle = 0;+ int throttled_count = 0;++#if HFS_COMPRESSION+ if ( hfs_file_is_compressed(VTOC(vp), 1) ) { /* 1 == don't take the cnode lock */+ int state = decmpfs_cnode_get_vnode_state(VTOCMP(vp));+ switch(state) {+ case FILE_IS_COMPRESSED:+ return EACCES;+ case FILE_IS_CONVERTING:+ /* if FILE_IS_CONVERTING, we allow writes but do not+ bother with snapshots or else we will deadlock.+ */+ do_snapshot = 0;+ break;+ default:+ printf("invalid state %d for compressed file\n", state);+ /* fall through */+ }+ } else if ((VTOC(vp)->c_bsdflags & UF_COMPRESSED)) {+ int error;++ error = check_for_dataless_file(vp, NAMESPACE_HANDLER_WRITE_OP);+ if (error != 0) {+ return error;+ }+ }++ if (do_snapshot) {+ nspace_snapshot_event(vp, orig_ctime, NAMESPACE_HANDLER_WRITE_OP, uio);+ }++#endif++#if SECURE_KERNEL+ if ((ioflag & (IO_SKIP_ENCRYPTION|IO_SYSCALL_DISPATCH)) ==+ (IO_SKIP_ENCRYPTION|IO_SYSCALL_DISPATCH)) {+ /* Don't allow unencrypted io request from user space */+ return EPERM;+ }+#endif++ resid = uio_resid(uio);+ offset = uio_offset(uio);++ if (offset < 0)+ return (EINVAL);+ if (resid == 0)+ return (E_NONE);+ if (!vnode_isreg(vp))+ return (EPERM); /* Can only write regular files */++ cp = VTOC(vp);+ fp = VTOF(vp);+ hfsmp = VTOHFS(vp);++#if CONFIG_PROTECT+ if ((retval = cp_handle_vnop (vp, CP_WRITE_ACCESS, 0)) != 0) {+ goto exit;+ }+#endif++ eflags = kEFDeferMask; /* defer file block allocations */+#if HFS_SPARSE_DEV+ /*+ * When the underlying device is sparse and space+ * is low (< 8MB), stop doing delayed allocations+ * and begin doing synchronous I/O.+ */+ if ((hfsmp->hfs_flags & HFS_HAS_SPARSE_DEVICE) &&+ (hfs_freeblks(hfsmp, 0) < 2048)) {+ eflags &= ~kEFDeferMask;+ ioflag |= IO_SYNC;+ }+#endif /* HFS_SPARSE_DEV */++ if ((ioflag & (IO_SINGLE_WRITER | IO_SYSCALL_DISPATCH)) ==+ (IO_SINGLE_WRITER | IO_SYSCALL_DISPATCH)) {+ io_return_on_throttle = IO_RETURN_ON_THROTTLE;+ }++again:+ /*+ * Protect against a size change.+ *+ * Note: If took_truncate_lock is true, then we previously got the lock shared+ * but needed to upgrade to exclusive. So try getting it exclusive from the+ * start.+ */+ if (ioflag & IO_APPEND || took_truncate_lock) {+ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ }+ else {+ hfs_lock_truncate(cp, HFS_SHARED_LOCK, HFS_LOCK_DEFAULT);+ }+ took_truncate_lock = 1;++ /* Update UIO */+ if (ioflag & IO_APPEND) {+ uio_setoffset(uio, fp->ff_size);+ offset = fp->ff_size;+ }+ if ((cp->c_bsdflags & APPEND) && offset != fp->ff_size) {+ retval = EPERM;+ goto exit;+ }++ cred = vfs_context_ucred(ap->a_context);+ if (cred && suser(cred, NULL) != 0)+ eflags |= kEFReserveMask;++ origFileSize = fp->ff_size;+ writelimit = offset + resid;++ /*+ * We may need an exclusive truncate lock for several reasons, all+ * of which are because we may be writing to a (portion of a) block+ * for the first time, and we need to make sure no readers see the+ * prior, uninitialized contents of the block. The cases are:+ *+ * 1. We have unallocated (delayed allocation) blocks. We may be+ * allocating new blocks to the file and writing to them.+ * (A more precise check would be whether the range we're writing+ * to contains delayed allocation blocks.)+ * 2. We need to extend the file. The bytes between the old EOF+ * and the new EOF are not yet initialized. This is important+ * even if we're not allocating new blocks to the file. If the+ * old EOF and new EOF are in the same block, we still need to+ * protect that range of bytes until they are written for the+ * first time.+ *+ * If we had a shared lock with the above cases, we need to try to upgrade+ * to an exclusive lock. If the upgrade fails, we will lose the shared+ * lock, and will need to take the truncate lock again; the took_truncate_lock+ * flag will still be set, causing us to try for an exclusive lock next time.+ */+ if ((cp->c_truncatelockowner == HFS_SHARED_OWNER) &&+ ((fp->ff_unallocblocks != 0) ||+ (writelimit > origFileSize))) {+ if (lck_rw_lock_shared_to_exclusive(&cp->c_truncatelock) == FALSE) {+ /*+ * Lock upgrade failed and we lost our shared lock, try again.+ * Note: we do not set took_truncate_lock=0 here. Leaving it+ * set to 1 will cause us to try to get the lock exclusive.+ */+ goto again;+ }+ else {+ /* Store the owner in the c_truncatelockowner field if we successfully upgrade */+ cp->c_truncatelockowner = current_thread();+ }+ }++ if ( (retval = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ goto exit;+ }+ cnode_locked = 1;++ filebytes = hfs_blk_to_bytes(fp->ff_blocks, hfsmp->blockSize);++ if (offset > filebytes+ && (hfs_blk_to_bytes(hfs_freeblks(hfsmp, ISSET(eflags, kEFReserveMask)),+ hfsmp->blockSize) < offset - filebytes)) {+ retval = ENOSPC;+ goto exit;+ }++ KERNEL_DEBUG(HFSDBG_WRITE | DBG_FUNC_START,+ (int)offset, uio_resid(uio), (int)fp->ff_size,+ (int)filebytes, 0);++ /* Check if we do not need to extend the file */+ if (writelimit <= filebytes) {+ goto sizeok;+ }++ bytesToAdd = writelimit - filebytes;++#if QUOTA+ retval = hfs_chkdq(cp, (int64_t)(roundup(bytesToAdd, hfsmp->blockSize)),+ cred, 0);+ if (retval)+ goto exit;+#endif /* QUOTA */++ if (hfs_start_transaction(hfsmp) != 0) {+ retval = EINVAL;+ goto exit;+ }++ while (writelimit > filebytes) {+ bytesToAdd = writelimit - filebytes;++ /* Protect extents b-tree and allocation bitmap */+ lockflags = SFL_BITMAP;+ if (overflow_extents(fp))+ lockflags |= SFL_EXTENTS;+ lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);++ /* Files that are changing size are not hot file candidates. */+ if (hfsmp->hfc_stage == HFC_RECORDING) {+ fp->ff_bytesread = 0;+ }+ retval = MacToVFSError(ExtendFileC (hfsmp, (FCB*)fp, bytesToAdd,+ 0, eflags, &actualBytesAdded));++ hfs_systemfile_unlock(hfsmp, lockflags);++ if ((actualBytesAdded == 0) && (retval == E_NONE))+ retval = ENOSPC;+ if (retval != E_NONE)+ break;+ filebytes = (off_t)fp->ff_blocks * (off_t)hfsmp->blockSize;+ KERNEL_DEBUG(HFSDBG_WRITE | DBG_FUNC_NONE,+ (int)offset, uio_resid(uio), (int)fp->ff_size, (int)filebytes, 0);+ }+ (void) hfs_update(vp, 0);+ (void) hfs_volupdate(hfsmp, VOL_UPDATE, 0);+ (void) hfs_end_transaction(hfsmp);++ /*+ * If we didn't grow the file enough try a partial write.+ * POSIX expects this behavior.+ */+ if ((retval == ENOSPC) && (filebytes > offset)) {+ retval = 0;+ partialwrite = 1;+ uio_setresid(uio, (uio_resid(uio) - bytesToAdd));+ resid -= bytesToAdd;+ writelimit = filebytes;+ }+sizeok:+ if (retval == E_NONE) {+ off_t filesize;+ off_t head_off;+ int lflag;++ if (writelimit > fp->ff_size) {+ filesize = writelimit;+ struct timeval tv;+ rl_add(fp->ff_size, writelimit - 1 , &fp->ff_invalidranges);+ microuptime(&tv);+ cp->c_zftimeout = tv.tv_sec + ZFTIMELIMIT;+ } else+ filesize = fp->ff_size;++ lflag = ioflag & ~(IO_TAILZEROFILL | IO_HEADZEROFILL | IO_NOZEROVALID | IO_NOZERODIRTY);++ /*+ * We no longer use IO_HEADZEROFILL or IO_TAILZEROFILL (except+ * for one case below). For the regions that lie before the+ * beginning and after the end of this write that are in the+ * same page, we let the cluster code handle zeroing that out+ * if necessary. If those areas are not cached, the cluster+ * code will try and read those areas in, and in the case+ * where those regions have never been written to,+ * hfs_vnop_blockmap will consult the invalid ranges and then+ * indicate that. The cluster code will zero out those areas.+ */++ head_off = trunc_page_64(offset);++ if (head_off < offset && head_off >= fp->ff_size) {+ /*+ * The first page is beyond current EOF, so as an+ * optimisation, we can pass IO_HEADZEROFILL.+ */+ lflag |= IO_HEADZEROFILL;+ }++ hfs_unlock(cp);+ cnode_locked = 0;++ /*+ * We need to tell UBC the fork's new size BEFORE calling+ * cluster_write, in case any of the new pages need to be+ * paged out before cluster_write completes (which does happen+ * in embedded systems due to extreme memory pressure).+ * Similarly, we need to tell hfs_vnop_pageout what the new EOF+ * will be, so that it can pass that on to cluster_pageout, and+ * allow those pageouts.+ *+ * We don't update ff_size yet since we don't want pageins to+ * be able to see uninitialized data between the old and new+ * EOF, until cluster_write has completed and initialized that+ * part of the file.+ *+ * The vnode pager relies on the file size last given to UBC via+ * ubc_setsize. hfs_vnop_pageout relies on fp->ff_new_size or+ * ff_size (whichever is larger). NOTE: ff_new_size is always+ * zero, unless we are extending the file via write.+ */+ if (filesize > fp->ff_size) {+ retval = hfs_zero_eof_page(vp, offset);+ if (retval)+ goto exit;+ fp->ff_new_size = filesize;+ ubc_setsize(vp, filesize);+ }+ retval = cluster_write(vp, uio, fp->ff_size, filesize, head_off,+ 0, lflag | IO_NOZERODIRTY | io_return_on_throttle);+ if (retval) {+ fp->ff_new_size = 0; /* no longer extending; use ff_size */++ if (retval == EAGAIN) {+ /*+ * EAGAIN indicates that we still have I/O to do, but+ * that we now need to be throttled+ */+ if (resid != uio_resid(uio)) {+ /*+ * did manage to do some I/O before returning EAGAIN+ */+ resid = uio_resid(uio);+ offset = uio_offset(uio);++ cp->c_touch_chgtime = TRUE;+ cp->c_touch_modtime = TRUE;+ hfs_incr_gencount(cp);+ }+ if (filesize > fp->ff_size) {+ /*+ * we called ubc_setsize before the call to+ * cluster_write... since we only partially+ * completed the I/O, we need to+ * re-adjust our idea of the filesize based+ * on our interim EOF+ */+ ubc_setsize(vp, offset);++ fp->ff_size = offset;+ }+ goto exit;+ }+ if (filesize > origFileSize) {+ ubc_setsize(vp, origFileSize);+ }+ goto ioerr_exit;+ }++ if (filesize > origFileSize) {+ fp->ff_size = filesize;++ /* Files that are changing size are not hot file candidates. */+ if (hfsmp->hfc_stage == HFC_RECORDING) {+ fp->ff_bytesread = 0;+ }+ }+ fp->ff_new_size = 0; /* ff_size now has the correct size */+ }+ if (partialwrite) {+ uio_setresid(uio, (uio_resid(uio) + bytesToAdd));+ resid += bytesToAdd;+ }++ if (vnode_should_flush_after_write(vp, ioflag))+ hfs_flush(hfsmp, HFS_FLUSH_CACHE);++ioerr_exit:+ if (!cnode_locked) {+ hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ cnode_locked = 1;+ }++ if (resid > uio_resid(uio)) {+ cp->c_touch_chgtime = TRUE;+ cp->c_touch_modtime = TRUE;+ hfs_incr_gencount(cp);++ /*+ * If we successfully wrote any data, and we are not the superuser+ * we clear the setuid and setgid bits as a precaution against+ * tampering.+ */+ if (cp->c_mode & (S_ISUID | S_ISGID)) {+ cred = vfs_context_ucred(ap->a_context);+ if (cred && suser(cred, NULL)) {+ cp->c_mode &= ~(S_ISUID | S_ISGID);+ }+ }+ }+ if (retval) {+ if (ioflag & IO_UNIT) {+ (void)hfs_truncate(vp, origFileSize, ioflag & IO_SYNC,+ 0, ap->a_context);+ uio_setoffset(uio, (uio_offset(uio) - (resid - uio_resid(uio))));+ uio_setresid(uio, resid);+ filebytes = (off_t)fp->ff_blocks * (off_t)hfsmp->blockSize;+ }+ } else if ((ioflag & IO_SYNC) && (resid > uio_resid(uio)))+ retval = hfs_update(vp, 0);++ /* Updating vcbWrCnt doesn't need to be atomic. */+ hfsmp->vcbWrCnt++;++ KERNEL_DEBUG(HFSDBG_WRITE | DBG_FUNC_END,+ (int)uio_offset(uio), uio_resid(uio), (int)fp->ff_size, (int)filebytes, 0);+exit:+ if (retval && took_truncate_lock+ && cp->c_truncatelockowner == current_thread()) {+ fp->ff_new_size = 0;+ rl_remove(fp->ff_size, RL_INFINITY, &fp->ff_invalidranges);+ }++ if (cnode_locked)+ hfs_unlock(cp);++ if (took_truncate_lock) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ }+ if (retval == EAGAIN) {+ throttle_lowpri_io(1);+ throttled_count++;++ retval = 0;+ goto again;+ }+ if (throttled_count)+ throttle_info_reset_window(NULL);+ return (retval);+}++/* support for the "bulk-access" fcntl */++#define CACHE_LEVELS 16+#define NUM_CACHE_ENTRIES (64*16)+#define PARENT_IDS_FLAG 0x100++struct access_cache {+ int numcached;+ int cachehits; /* these two for statistics gathering */+ int lookups;+ unsigned int *acache;+ unsigned char *haveaccess;+};++struct access_t {+ uid_t uid; /* IN: effective user id */+ short flags; /* IN: access requested (i.e. R_OK) */+ short num_groups; /* IN: number of groups user belongs to */+ int num_files; /* IN: number of files to process */+ int *file_ids; /* IN: array of file ids */+ gid_t *groups; /* IN: array of groups */+ short *access; /* OUT: access info for each file (0 for 'has access') */+} __attribute__((unavailable)); // this structure is for reference purposes only++struct user32_access_t {+ uid_t uid; /* IN: effective user id */+ short flags; /* IN: access requested (i.e. R_OK) */+ short num_groups; /* IN: number of groups user belongs to */+ int num_files; /* IN: number of files to process */+ user32_addr_t file_ids; /* IN: array of file ids */+ user32_addr_t groups; /* IN: array of groups */+ user32_addr_t access; /* OUT: access info for each file (0 for 'has access') */+};++struct user64_access_t {+ uid_t uid; /* IN: effective user id */+ short flags; /* IN: access requested (i.e. R_OK) */+ short num_groups; /* IN: number of groups user belongs to */+ int num_files; /* IN: number of files to process */+ user64_addr_t file_ids; /* IN: array of file ids */+ user64_addr_t groups; /* IN: array of groups */+ user64_addr_t access; /* OUT: access info for each file (0 for 'has access') */+};+++// these are the "extended" versions of the above structures+// note that it is crucial that they be different sized than+// the regular version+struct ext_access_t {+ uint32_t flags; /* IN: access requested (i.e. R_OK) */+ uint32_t num_files; /* IN: number of files to process */+ uint32_t map_size; /* IN: size of the bit map */+ uint32_t *file_ids; /* IN: Array of file ids */+ char *bitmap; /* OUT: hash-bitmap of interesting directory ids */+ short *access; /* OUT: access info for each file (0 for 'has access') */+ uint32_t num_parents; /* future use */+ cnid_t *parents; /* future use */+} __attribute__((unavailable)); // this structure is for reference purposes only++struct user32_ext_access_t {+ uint32_t flags; /* IN: access requested (i.e. R_OK) */+ uint32_t num_files; /* IN: number of files to process */+ uint32_t map_size; /* IN: size of the bit map */+ user32_addr_t file_ids; /* IN: Array of file ids */+ user32_addr_t bitmap; /* OUT: hash-bitmap of interesting directory ids */+ user32_addr_t access; /* OUT: access info for each file (0 for 'has access') */+ uint32_t num_parents; /* future use */+ user32_addr_t parents; /* future use */+};++struct user64_ext_access_t {+ uint32_t flags; /* IN: access requested (i.e. R_OK) */+ uint32_t num_files; /* IN: number of files to process */+ uint32_t map_size; /* IN: size of the bit map */+ user64_addr_t file_ids; /* IN: array of file ids */+ user64_addr_t bitmap; /* IN: array of groups */+ user64_addr_t access; /* OUT: access info for each file (0 for 'has access') */+ uint32_t num_parents;/* future use */+ user64_addr_t parents;/* future use */+};+++/*+ * Perform a binary search for the given parent_id. Return value is+ * the index if there is a match. If no_match_indexp is non-NULL it+ * will be assigned with the index to insert the item (even if it was+ * not found).+ */+static int cache_binSearch(cnid_t *array, unsigned int hi, cnid_t parent_id, int *no_match_indexp)+{+ int index=-1;+ unsigned int lo=0;++ do {+ unsigned int mid = ((hi - lo)/2) + lo;+ unsigned int this_id = array[mid];++ if (parent_id == this_id) {+ hi = mid;+ break;+ }++ if (parent_id < this_id) {+ hi = mid;+ continue;+ }++ if (parent_id > this_id) {+ lo = mid + 1;+ continue;+ }+ } while(lo < hi);++ /* check if lo and hi converged on the match */+ if (parent_id == array[hi]) {+ index = hi;+ }++ if (no_match_indexp) {+ *no_match_indexp = hi;+ }++ return index;+}+++static int+lookup_bucket(struct access_cache *cache, int *indexp, cnid_t parent_id)+{+ unsigned int hi;+ int matches = 0;+ int index, no_match_index;++ if (cache->numcached == 0) {+ *indexp = 0;+ return 0; // table is empty, so insert at index=0 and report no match+ }++ if (cache->numcached > NUM_CACHE_ENTRIES) {+ cache->numcached = NUM_CACHE_ENTRIES;+ }++ hi = cache->numcached - 1;++ index = cache_binSearch(cache->acache, hi, parent_id, &no_match_index);++ /* if no existing entry found, find index for new one */+ if (index == -1) {+ index = no_match_index;+ matches = 0;+ } else {+ matches = 1;+ }++ *indexp = index;+ return matches;+}++/*+ * Add a node to the access_cache at the given index (or do a lookup first+ * to find the index if -1 is passed in). We currently do a replace rather+ * than an insert if the cache is full.+ */+static void+add_node(struct access_cache *cache, int index, cnid_t nodeID, int access)+{+ int lookup_index = -1;++ /* need to do a lookup first if -1 passed for index */+ if (index == -1) {+ if (lookup_bucket(cache, &lookup_index, nodeID)) {+ if (cache->haveaccess[lookup_index] != access && cache->haveaccess[lookup_index] == ESRCH) {+ // only update an entry if the previous access was ESRCH (i.e. a scope checking error)+ cache->haveaccess[lookup_index] = access;+ }++ /* mission accomplished */+ return;+ } else {+ index = lookup_index;+ }++ }++ /* if the cache is full, do a replace rather than an insert */+ if (cache->numcached >= NUM_CACHE_ENTRIES) {+ cache->numcached = NUM_CACHE_ENTRIES-1;++ if (index > cache->numcached) {+ index = cache->numcached;+ }+ }++ if (index < cache->numcached && index < NUM_CACHE_ENTRIES && nodeID > cache->acache[index]) {+ index++;+ }++ if (index >= 0 && index < cache->numcached) {+ /* only do bcopy if we're inserting */+ bcopy( cache->acache+index, cache->acache+(index+1), (cache->numcached - index)*sizeof(int) );+ bcopy( cache->haveaccess+index, cache->haveaccess+(index+1), (cache->numcached - index)*sizeof(unsigned char) );+ }++ cache->acache[index] = nodeID;+ cache->haveaccess[index] = access;+ cache->numcached++;+}+++struct cinfo {+ uid_t uid;+ gid_t gid;+ mode_t mode;+ cnid_t parentcnid;+ u_int16_t recflags;+};++static int+snoop_callback(const cnode_t *cp, void *arg)+{+ struct cinfo *cip = arg;++ cip->uid = cp->c_uid;+ cip->gid = cp->c_gid;+ cip->mode = cp->c_mode;+ cip->parentcnid = cp->c_parentcnid;+ cip->recflags = cp->c_attr.ca_recflags;++ return (0);+}++/*+ * Lookup the cnid's attr info (uid, gid, and mode) as well as its parent id. If the item+ * isn't incore, then go to the catalog.+ */+static int+do_attr_lookup(struct hfsmount *hfsmp, struct access_cache *cache, cnid_t cnid,+ struct cnode *skip_cp, CatalogKey *keyp, struct cat_attr *cnattrp)+{+ int error = 0;++ /* if this id matches the one the fsctl was called with, skip the lookup */+ if (cnid == skip_cp->c_cnid) {+ cnattrp->ca_uid = skip_cp->c_uid;+ cnattrp->ca_gid = skip_cp->c_gid;+ cnattrp->ca_mode = skip_cp->c_mode;+ cnattrp->ca_recflags = skip_cp->c_attr.ca_recflags;+ keyp->hfsPlus.parentID = skip_cp->c_parentcnid;+ } else {+ struct cinfo c_info;++ /* otherwise, check the cnode hash incase the file/dir is incore */+ error = hfs_chash_snoop(hfsmp, cnid, 0, snoop_callback, &c_info);++ if (error == EACCES) {+ // File is deleted+ return ENOENT;+ } else if (!error) {+ cnattrp->ca_uid = c_info.uid;+ cnattrp->ca_gid = c_info.gid;+ cnattrp->ca_mode = c_info.mode;+ cnattrp->ca_recflags = c_info.recflags;+ keyp->hfsPlus.parentID = c_info.parentcnid;+ } else {+ int lockflags;++ if (throttle_io_will_be_throttled(-1, HFSTOVFS(hfsmp)))+ throttle_lowpri_io(1);++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);++ /* lookup this cnid in the catalog */+ error = cat_getkeyplusattr(hfsmp, cnid, keyp, cnattrp);++ hfs_systemfile_unlock(hfsmp, lockflags);++ cache->lookups++;+ }+ }++ return (error);+}+++/*+ * Compute whether we have access to the given directory (nodeID) and all its parents. Cache+ * up to CACHE_LEVELS as we progress towards the root.+ */+static int+do_access_check(struct hfsmount *hfsmp, int *err, struct access_cache *cache, HFSCatalogNodeID nodeID,+ struct cnode *skip_cp, struct proc *theProcPtr, kauth_cred_t myp_ucred,+ struct vfs_context *my_context,+ char *bitmap,+ uint32_t map_size,+ cnid_t* parents,+ uint32_t num_parents)+{+ int myErr = 0;+ int myResult;+ HFSCatalogNodeID thisNodeID;+ unsigned int myPerms;+ struct cat_attr cnattr;+ int cache_index = -1, scope_index = -1, scope_idx_start = -1;+ CatalogKey catkey;++ int i = 0, ids_to_cache = 0;+ int parent_ids[CACHE_LEVELS];++ thisNodeID = nodeID;+ while (thisNodeID >= kRootDirID) {+ myResult = 0; /* default to "no access" */++ /* check the cache before resorting to hitting the catalog */++ /* ASSUMPTION: access info of cached entries is "final"... i.e. no need+ * to look any further after hitting cached dir */++ if (lookup_bucket(cache, &cache_index, thisNodeID)) {+ cache->cachehits++;+ myErr = cache->haveaccess[cache_index];+ if (scope_index != -1) {+ if (myErr == ESRCH) {+ myErr = 0;+ }+ } else {+ scope_index = 0; // so we'll just use the cache result+ scope_idx_start = ids_to_cache;+ }+ myResult = (myErr == 0) ? 1 : 0;+ goto ExitThisRoutine;+ }+++ if (parents) {+ int tmp;+ tmp = cache_binSearch(parents, num_parents-1, thisNodeID, NULL);+ if (scope_index == -1)+ scope_index = tmp;+ if (tmp != -1 && scope_idx_start == -1 && ids_to_cache < CACHE_LEVELS) {+ scope_idx_start = ids_to_cache;+ }+ }++ /* remember which parents we want to cache */+ if (ids_to_cache < CACHE_LEVELS) {+ parent_ids[ids_to_cache] = thisNodeID;+ ids_to_cache++;+ }+ // Inefficient (using modulo) and we might want to use a hash function, not rely on the node id to be "nice"...+ if (bitmap && map_size) {+ bitmap[(thisNodeID/8)%(map_size)]|=(1<<(thisNodeID&7));+ }+++ /* do the lookup (checks the cnode hash, then the catalog) */+ myErr = do_attr_lookup(hfsmp, cache, thisNodeID, skip_cp, &catkey, &cnattr);+ if (myErr) {+ goto ExitThisRoutine; /* no access */+ }++ /* Root always gets access. */+ if (suser(myp_ucred, NULL) == 0) {+ thisNodeID = catkey.hfsPlus.parentID;+ myResult = 1;+ continue;+ }++ // if the thing has acl's, do the full permission check+ if ((cnattr.ca_recflags & kHFSHasSecurityMask) != 0) {+ struct vnode *vp;++ /* get the vnode for this cnid */+ myErr = hfs_vget(hfsmp, thisNodeID, &vp, 0, 0);+ if ( myErr ) {+ myResult = 0;+ goto ExitThisRoutine;+ }++ thisNodeID = VTOC(vp)->c_parentcnid;++ hfs_unlock(VTOC(vp));++ if (vnode_vtype(vp) == VDIR) {+ myErr = vnode_authorize(vp, NULL, (KAUTH_VNODE_SEARCH | KAUTH_VNODE_LIST_DIRECTORY), my_context);+ } else {+ myErr = vnode_authorize(vp, NULL, KAUTH_VNODE_READ_DATA, my_context);+ }++ vnode_put(vp);+ if (myErr) {+ myResult = 0;+ goto ExitThisRoutine;+ }+ } else {+ unsigned int flags;+ int mode = cnattr.ca_mode & S_IFMT;+ myPerms = DerivePermissionSummary(cnattr.ca_uid, cnattr.ca_gid, cnattr.ca_mode, hfsmp->hfs_mp,myp_ucred, theProcPtr);++ if (mode == S_IFDIR) {+ flags = R_OK | X_OK;+ } else {+ flags = R_OK;+ }+ if ( (myPerms & flags) != flags) {+ myResult = 0;+ myErr = EACCES;+ goto ExitThisRoutine; /* no access */+ }++ /* up the hierarchy we go */+ thisNodeID = catkey.hfsPlus.parentID;+ }+ }++ /* if here, we have access to this node */+ myResult = 1;++ ExitThisRoutine:+ if (parents && myErr == 0 && scope_index == -1) {+ myErr = ESRCH;+ }++ if (myErr) {+ myResult = 0;+ }+ *err = myErr;++ /* cache the parent directory(ies) */+ for (i = 0; i < ids_to_cache; i++) {+ if (myErr == 0 && parents && (scope_idx_start == -1 || i > scope_idx_start)) {+ add_node(cache, -1, parent_ids[i], ESRCH);+ } else {+ add_node(cache, -1, parent_ids[i], myErr);+ }+ }++ return (myResult);+}++static int+do_bulk_access_check(struct hfsmount *hfsmp, struct vnode *vp,+ struct vnop_ioctl_args *ap, int arg_size, vfs_context_t context)+{+ boolean_t is64bit;++ /*+ * NOTE: on entry, the vnode has an io_ref. In case this vnode+ * happens to be in our list of file_ids, we'll note it+ * avoid calling hfs_chashget_nowait() on that id as that+ * will cause a "locking against myself" panic.+ */+ Boolean check_leaf = true;++ struct user64_ext_access_t *user_access_structp;+ struct user64_ext_access_t tmp_user_access;+ struct access_cache cache;++ int error = 0, prev_parent_check_ok=1;+ unsigned int i;++ short flags;+ unsigned int num_files = 0;+ int map_size = 0;+ int num_parents = 0;+ int *file_ids=NULL;+ short *access=NULL;+ char *bitmap=NULL;+ cnid_t *parents=NULL;+ int leaf_index;++ cnid_t cnid;+ cnid_t prevParent_cnid = 0;+ unsigned int myPerms;+ short myaccess = 0;+ struct cat_attr cnattr;+ CatalogKey catkey;+ struct cnode *skip_cp = VTOC(vp);+ kauth_cred_t cred = vfs_context_ucred(context);+ proc_t p = vfs_context_proc(context);++ is64bit = proc_is64bit(p);++ /* initialize the local cache and buffers */+ cache.numcached = 0;+ cache.cachehits = 0;+ cache.lookups = 0;+ cache.acache = NULL;+ cache.haveaccess = NULL;++ /* struct copyin done during dispatch... need to copy file_id array separately */+ if (ap->a_data == NULL) {+ error = EINVAL;+ goto err_exit_bulk_access;+ }++ if (is64bit) {+ if (arg_size != sizeof(struct user64_ext_access_t)) {+ error = EINVAL;+ goto err_exit_bulk_access;+ }++ user_access_structp = (struct user64_ext_access_t *)ap->a_data;++ } else if (arg_size == sizeof(struct user32_access_t)) {+ struct user32_access_t *accessp = (struct user32_access_t *)ap->a_data;++ // convert an old style bulk-access struct to the new style+ tmp_user_access.flags = accessp->flags;+ tmp_user_access.num_files = accessp->num_files;+ tmp_user_access.map_size = 0;+ tmp_user_access.file_ids = CAST_USER_ADDR_T(accessp->file_ids);+ tmp_user_access.bitmap = USER_ADDR_NULL;+ tmp_user_access.access = CAST_USER_ADDR_T(accessp->access);+ tmp_user_access.num_parents = 0;+ user_access_structp = &tmp_user_access;++ } else if (arg_size == sizeof(struct user32_ext_access_t)) {+ struct user32_ext_access_t *accessp = (struct user32_ext_access_t *)ap->a_data;++ // up-cast from a 32-bit version of the struct+ tmp_user_access.flags = accessp->flags;+ tmp_user_access.num_files = accessp->num_files;+ tmp_user_access.map_size = accessp->map_size;+ tmp_user_access.num_parents = accessp->num_parents;++ tmp_user_access.file_ids = CAST_USER_ADDR_T(accessp->file_ids);+ tmp_user_access.bitmap = CAST_USER_ADDR_T(accessp->bitmap);+ tmp_user_access.access = CAST_USER_ADDR_T(accessp->access);+ tmp_user_access.parents = CAST_USER_ADDR_T(accessp->parents);++ user_access_structp = &tmp_user_access;+ } else {+ error = EINVAL;+ goto err_exit_bulk_access;+ }++ map_size = user_access_structp->map_size;++ num_files = user_access_structp->num_files;++ num_parents= user_access_structp->num_parents;++ if (num_files < 1) {+ goto err_exit_bulk_access;+ }+ if (num_files > 1024) {+ error = EINVAL;+ goto err_exit_bulk_access;+ }++ if (num_parents > 1024) {+ error = EINVAL;+ goto err_exit_bulk_access;+ }++ file_ids = hfs_new_data(int, num_files);+ access = hfs_new_data(short, num_files);+ if (map_size) {+ bitmap = hfs_new_zero_data(char, map_size);+ }++ if (num_parents) {+ parents = hfs_new_data(cnid_t, num_parents);+ }++ cache.acache = hfs_new_data(unsigned int, NUM_CACHE_ENTRIES);+ cache.haveaccess = hfs_new_data(unsigned char, NUM_CACHE_ENTRIES);++ if ((error = copyin(user_access_structp->file_ids, (caddr_t)file_ids,+ num_files * sizeof(int)))) {+ goto err_exit_bulk_access;+ }++ if (num_parents) {+ if ((error = copyin(user_access_structp->parents, (caddr_t)parents,+ num_parents * sizeof(cnid_t)))) {+ goto err_exit_bulk_access;+ }+ }++ flags = user_access_structp->flags;+ if ((flags & (F_OK | R_OK | W_OK | X_OK)) == 0) {+ flags = R_OK;+ }++ /* check if we've been passed leaf node ids or parent ids */+ if (flags & PARENT_IDS_FLAG) {+ check_leaf = false;+ }++ /* Check access to each file_id passed in */+ for (i = 0; i < num_files; i++) {+ leaf_index=-1;+ cnid = (cnid_t) file_ids[i];++ /* root always has access */+ if ((!parents) && (!suser(cred, NULL))) {+ access[i] = 0;+ continue;+ }++ if (check_leaf) {+ /* do the lookup (checks the cnode hash, then the catalog) */+ error = do_attr_lookup(hfsmp, &cache, cnid, skip_cp, &catkey, &cnattr);+ if (error) {+ access[i] = (short) error;+ continue;+ }++ if (parents) {+ // Check if the leaf matches one of the parent scopes+ leaf_index = cache_binSearch(parents, num_parents-1, cnid, NULL);+ if (leaf_index >= 0 && parents[leaf_index] == cnid)+ prev_parent_check_ok = 0;+ else if (leaf_index >= 0)+ prev_parent_check_ok = 1;+ }++ // if the thing has acl's, do the full permission check+ if ((cnattr.ca_recflags & kHFSHasSecurityMask) != 0) {+ struct vnode *cvp;+ int myErr = 0;+ /* get the vnode for this cnid */+ myErr = hfs_vget(hfsmp, cnid, &cvp, 0, 0);+ if ( myErr ) {+ access[i] = myErr;+ continue;+ }++ hfs_unlock(VTOC(cvp));++ if (vnode_vtype(cvp) == VDIR) {+ myErr = vnode_authorize(cvp, NULL, (KAUTH_VNODE_SEARCH | KAUTH_VNODE_LIST_DIRECTORY), context);+ } else {+ myErr = vnode_authorize(cvp, NULL, KAUTH_VNODE_READ_DATA, context);+ }++ vnode_put(cvp);+ if (myErr) {+ access[i] = myErr;+ continue;+ }+ } else {+ /* before calling CheckAccess(), check the target file for read access */+ myPerms = DerivePermissionSummary(cnattr.ca_uid, cnattr.ca_gid,+ cnattr.ca_mode, hfsmp->hfs_mp, cred, p);++ /* fail fast if no access */+ if ((myPerms & flags) == 0) {+ access[i] = EACCES;+ continue;+ }+ }+ } else {+ /* we were passed an array of parent ids */+ catkey.hfsPlus.parentID = cnid;+ }++ /* if the last guy had the same parent and had access, we're done */+ if (i > 0 && catkey.hfsPlus.parentID == prevParent_cnid && access[i-1] == 0 && prev_parent_check_ok) {+ cache.cachehits++;+ access[i] = 0;+ continue;+ }++ myaccess = do_access_check(hfsmp, &error, &cache, catkey.hfsPlus.parentID,+ skip_cp, p, cred, context,bitmap, map_size, parents, num_parents);++ if (myaccess || (error == ESRCH && leaf_index != -1)) {+ access[i] = 0; // have access.. no errors to report+ } else {+ access[i] = (error != 0 ? (short) error : EACCES);+ }++ prevParent_cnid = catkey.hfsPlus.parentID;+ }++ /* copyout the access array */+ if ((error = copyout((caddr_t)access, user_access_structp->access,+ num_files * sizeof (short)))) {+ goto err_exit_bulk_access;+ }+ if (map_size && bitmap) {+ if ((error = copyout((caddr_t)bitmap, user_access_structp->bitmap,+ map_size * sizeof (char)))) {+ goto err_exit_bulk_access;+ }+ }+++ err_exit_bulk_access:++ hfs_delete_data(file_ids, int, num_files);+ hfs_delete_data(parents, cnid_t, num_parents);+ hfs_delete_data(bitmap, char, map_size);+ hfs_delete_data(access, short, num_files);+ hfs_delete_data(cache.acache, unsigned int, NUM_CACHE_ENTRIES);+ hfs_delete_data(cache.haveaccess, unsigned char, NUM_CACHE_ENTRIES);++ return (error);+}+++/* end "bulk-access" support */+++static int+hfs_cas_bsdflags(struct hfsmount *hfsmp, struct vnode *vp,+ struct vnop_ioctl_args *ap)+{+ struct fsioc_cas_bsdflags *cas = (void *)ap->a_data;+ struct cnode *cp = VTOC(vp);+ u_int32_t document_id = 0;+ bool unlock_truncate = false, unlock_cp = false;+ int decmpfs_reset_state = 0;+ int error;++ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return (EROFS);+ }++ /* Don't allow modification of the journal. */+ if (hfs_is_journal_file(hfsmp, cp)) {+ return (EPERM);+ }++ //+ // Since we will perform operations that are difficult or wasteful+ // to unwind, perform an up-front check of the flags.+ //+ if ((error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ return (error);+ }++ // Make sure that flags are as expected.+ cas->actual_flags = cp->c_bsdflags;+ hfs_unlock(cp);++ if (cas->actual_flags != cas->expected_flags) {+ return (0);+ }++ //+ // Check if we'll need a new document id.+ //+ if ((cas->new_flags & UF_TRACKED) && !(cp->c_bsdflags & UF_TRACKED)) {+ // Following hfs_vnop_getattr(), we can obtain this safely+ // without holding any cnode lock.+ document_id = hfs_get_document_id(cp);++ //+ // If the document_id is not set, get a new one. It will be set+ // on the file down below once we hold the cnode lock.+ //+ if (document_id == 0) {+ if (hfs_generate_document_id(hfsmp, &document_id) != 0) {+ document_id = 0;+ }+ }+ }++ //+ // Check if we need to set UF_COMPRESSED.+ // If so, ask decmpfs if we're allowed to (and if so, if we need to truncate+ // the data fork to 0 - taking the lock here).+ //+ if (!(cas->expected_flags & UF_COMPRESSED) && (cas->new_flags & UF_COMPRESSED)) {+ struct vnode_attr vap;+ VATTR_INIT(&vap);+ VATTR_SET(&vap, va_flags, cas->new_flags);++ error = decmpfs_update_attributes(vp, &vap);+ if (error) {+ return (error);+ }++ //+ // Similar to hfs_vnop_setattr(), we call decmpfs_update_attributes()+ // as it is the ultimate arbiter of whether or not UF_COMPRESSED can be set.+ // (If the decmpfs xattr is not present or invalid, for example,+ // UF_COMPRESSED should *not* be set.)+ // It will also tell us if we need to truncate the data fork to 0.+ //+ if (!(vap.va_flags & UF_COMPRESSED)) {+ // The request to update UF_COMPRESSED is denied.+ // (Note that decmpfs_update_attributes() won't touch va_active+ // in this case.) Error out.+ return (EPERM);+ }++ if (VATTR_IS_ACTIVE(&vap, va_data_size) && (vap.va_data_size == 0)+ && (VTOF(vp)->ff_size)) {+ // We must also truncate this file's data fork to 0.+ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ unlock_truncate = true;+ }+ }+ // From this point on, locks must be dropped before returning.++ if ((error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ goto out_unlock;+ }+ unlock_cp = true;++ // Make sure that flags are as expected.+ cas->actual_flags = cp->c_bsdflags;+ if (cas->actual_flags != cas->expected_flags) {+ goto out_unlock;+ }++ // Attempt to truncate our data fork to 0 length if necessary,+ // and drop the truncate lock.+ if (unlock_truncate) {+ error = hfs_truncate(vp, 0, IO_NDELAY, 0, ap->a_context);+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ unlock_truncate = false; // so we don't unlock it below++ if (error) {+ goto out_unlock;+ }+ }++ // Set the BSD flags (setting decmpfs_reset_state upon success).+ error = hfs_set_bsd_flags(hfsmp, cp, cas->new_flags,+ document_id, ap->a_context,+ &decmpfs_reset_state);+ if (error) {+ goto out_unlock;+ }++ error = hfs_update(vp, 0);++out_unlock:+ if (unlock_truncate) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ }++ if (unlock_cp) {+ hfs_unlock(cp);+ }++ if (error) {+ return (error);+ }++#if HFS_COMPRESSION+ if (decmpfs_reset_state) {+ /*+ * we've changed the UF_COMPRESSED flag, so reset the decmpfs state for this cnode+ * but don't do it while holding the hfs cnode lock+ */+ decmpfs_cnode *dp = VTOCMP(vp);+ if (!dp) {+ /*+ * call hfs_lazy_init_decmpfs_cnode() to make sure that the decmpfs_cnode+ * is filled in; we need a decmpfs_cnode to prevent decmpfs state changes+ * on this file if it's locked+ */+ dp = hfs_lazy_init_decmpfs_cnode(VTOC(vp));+ if (!dp) {+ /* failed to allocate a decmpfs_cnode */+ return ENOMEM; /* what should this be? */+ }+ }+ decmpfs_cnode_set_vnode_state(dp, FILE_TYPE_UNKNOWN, 0);+ }+#endif++ return 0;+}++/*+ * Control filesystem operating characteristics.+ */+int+hfs_vnop_ioctl( struct vnop_ioctl_args /* {+ vnode_t a_vp;+ long a_command;+ caddr_t a_data;+ int a_fflag;+ vfs_context_t a_context;+ } */ *ap)+{+ struct vnode * vp = ap->a_vp;+ struct hfsmount *hfsmp = VTOHFS(vp);+ vfs_context_t context = ap->a_context;+ kauth_cred_t cred = vfs_context_ucred(context);+ proc_t p = vfs_context_proc(context);+ struct vfsstatfs *vfsp;+ boolean_t is64bit;+ off_t jnl_start, jnl_size;+ struct hfs_journal_info *jip;+#if HFS_COMPRESSION+ int compressed = 0;+ off_t uncompressed_size = -1;+ int decmpfs_error = 0;++ if (ap->a_command == F_RDADVISE) {+ /* we need to inspect the decmpfs state of the file as early as possible */+ compressed = hfs_file_is_compressed(VTOC(vp), 0);+ if (compressed) {+ if (VNODE_IS_RSRC(vp)) {+ /* if this is the resource fork, treat it as if it were empty */+ uncompressed_size = 0;+ } else {+ decmpfs_error = hfs_uncompressed_size_of_compressed_file(NULL, vp, 0, &uncompressed_size, 0);+ if (decmpfs_error != 0) {+ /* failed to get the uncompressed size, we'll check for this later */+ uncompressed_size = -1;+ }+ }+ }+ }+#endif /* HFS_COMPRESSION */++ is64bit = proc_is64bit(p);++#if CONFIG_PROTECT+#if HFS_CONFIG_KEY_ROLL+ // The HFSIOC_KEY_ROLL fsctl does its own access checks+ if (ap->a_command != HFSIOC_KEY_ROLL)+#endif+ {+ int error = 0;+ if ((error = cp_handle_vnop(vp, CP_WRITE_ACCESS, 0)) != 0) {+ return error;+ }+ }+#endif /* CONFIG_PROTECT */++ switch (ap->a_command) {++ case HFSIOC_GETPATH:+ {+ struct vnode *file_vp;+ cnid_t cnid;+ int error;+ int flags = 0;+ char *bufptr;+#ifdef VN_GETPATH_NEW+ size_t outlen;+#else // VN_GETPATH_NEW+ int outlen;+#endif // VN_GETPATH_NEW++ /* Caller must be owner of file system. */+ vfsp = vfs_statfs(HFSTOVFS(hfsmp));+ if (suser(cred, NULL) &&+ kauth_cred_getuid(cred) != vfsp->f_owner) {+ return (EACCES);+ }+ /* Target vnode must be file system's root. */+ if (!vnode_isvroot(vp)) {+ return (EINVAL);+ }+ bufptr = (char *)ap->a_data;+ cnid = strtoul(bufptr, NULL, 10);+ if (ap->a_fflag & HFS_GETPATH_VOLUME_RELATIVE) {+ flags |= BUILDPATH_VOLUME_RELATIVE;+ }++ /* We need to call hfs_vfs_vget to leverage the code that will+ * fix the origin list for us if needed, as opposed to calling+ * hfs_vget, since we will need the parent for vn_getpath_ext call.+ */++ if ((error = hfs_vfs_vget(HFSTOVFS(hfsmp), cnid, &file_vp, context))) {+ return (error);+ }++ outlen = sizeof(pathname_t);+ error = vn_getpath_ext(file_vp, NULLVP, bufptr, &outlen, flags);+ vnode_put(file_vp);++ return (error);+ }++ case HFSIOC_SET_MAX_DEFRAG_SIZE:+ {+ int error = 0; /* Assume success */+ u_int32_t maxsize = 0;++ if (vnode_vfsisrdonly(vp)) {+ return (EROFS);+ }+ vfsp = vfs_statfs(HFSTOVFS(hfsmp));+ if (!kauth_cred_issuser(cred)) {+ return (EACCES); /* must be root */+ }++ maxsize = *(u_int32_t *)ap->a_data;++ hfs_lock_mount(hfsmp);+ if (maxsize > HFS_MAX_DEFRAG_SIZE) {+ error = EINVAL;+ }+ else {+ hfsmp->hfs_defrag_max = maxsize;+ }+ hfs_unlock_mount(hfsmp);++ return (error);+ }++ case HFSIOC_FORCE_ENABLE_DEFRAG:+ {+ int error = 0; /* Assume success */+ u_int32_t do_enable = 0;++ if (vnode_vfsisrdonly(vp)) {+ return (EROFS);+ }+ vfsp = vfs_statfs(HFSTOVFS(hfsmp));+ if (!kauth_cred_issuser(cred)) {+ return (EACCES); /* must be root */+ }++ do_enable = *(u_int32_t *)ap->a_data;++ hfs_lock_mount(hfsmp);+ if (do_enable != 0) {+ hfsmp->hfs_defrag_nowait = 1;+ }+ else {+ error = EINVAL;+ }++ hfs_unlock_mount(hfsmp);++ return (error);+ }+++ case HFSIOC_TRANSFER_DOCUMENT_ID:+ {+ struct cnode *cp = NULL;+ int error;+ u_int32_t to_fd = *(u_int32_t *)ap->a_data;+ struct fileproc *to_fp;+ struct vnode *to_vp;+ struct cnode *to_cp;++ cp = VTOC(vp);++ if ((error = fp_getfvp(p, to_fd, &to_fp, &to_vp)) != 0) {+ //printf("could not get the vnode for fd %d (err %d)\n", to_fd, error);+ return error;+ }+ if ( (error = vnode_getwithref(to_vp)) ) {+ file_drop(to_fd);+ return error;+ }++ if (VTOHFS(to_vp) != hfsmp) {+ error = EXDEV;+ goto transfer_cleanup;+ }++ int need_unlock = 1;+ to_cp = VTOC(to_vp);+ error = hfs_lockpair(cp, to_cp, HFS_EXCLUSIVE_LOCK);+ if (error != 0) {+ //printf("could not lock the pair of cnodes (error %d)\n", error);+ goto transfer_cleanup;+ }++ if (!(cp->c_bsdflags & UF_TRACKED)) {+ error = EINVAL;+ } else if (to_cp->c_bsdflags & UF_TRACKED) {+ //+ // if the destination is already tracked, return an error+ // as otherwise it's a silent deletion of the target's+ // document-id+ //+ error = EEXIST;+ } else if (S_ISDIR(cp->c_attr.ca_mode) || S_ISREG(cp->c_attr.ca_mode) || S_ISLNK(cp->c_attr.ca_mode)) {+ //+ // we can use the FndrExtendedFileInfo because the doc-id is the first+ // thing in both it and the ExtendedDirInfo struct which is fixed in+ // format and can not change layout+ //+ struct FndrExtendedFileInfo *f_extinfo = (struct FndrExtendedFileInfo *)((u_int8_t*)cp->c_finderinfo + 16);+ struct FndrExtendedFileInfo *to_extinfo = (struct FndrExtendedFileInfo *)((u_int8_t*)to_cp->c_finderinfo + 16);++ if (f_extinfo->document_id == 0) {+ uint32_t new_id;++ hfs_unlockpair(cp, to_cp); // have to unlock to be able to get a new-id++ if ((error = hfs_generate_document_id(hfsmp, &new_id)) == 0) {+ //+ // re-lock the pair now that we have the document-id+ //+ hfs_lockpair(cp, to_cp, HFS_EXCLUSIVE_LOCK);+ f_extinfo->document_id = new_id;+ } else {+ goto transfer_cleanup;+ }+ }++ to_extinfo->document_id = f_extinfo->document_id;+ f_extinfo->document_id = 0;+ //printf("TRANSFERRING: doc-id %d from ino %d to ino %d\n", to_extinfo->document_id, cp->c_fileid, to_cp->c_fileid);++ // make sure the destination is also UF_TRACKED+ to_cp->c_bsdflags |= UF_TRACKED;+ cp->c_bsdflags &= ~UF_TRACKED;++ // mark the cnodes dirty+ cp->c_flag |= C_MODIFIED;+ to_cp->c_flag |= C_MODIFIED;++ int lockflags;+ if ((error = hfs_start_transaction(hfsmp)) == 0) {++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);++ (void) cat_update(hfsmp, &cp->c_desc, &cp->c_attr, NULL, NULL);+ (void) cat_update(hfsmp, &to_cp->c_desc, &to_cp->c_attr, NULL, NULL);++ hfs_systemfile_unlock (hfsmp, lockflags);+ (void) hfs_end_transaction(hfsmp);+ }++ add_fsevent(FSE_DOCID_CHANGED, context,+ FSE_ARG_DEV, hfsmp->hfs_raw_dev,+ FSE_ARG_INO, (ino64_t)cp->c_fileid, // src inode #+ FSE_ARG_INO, (ino64_t)to_cp->c_fileid, // dst inode #+ FSE_ARG_INT32, to_extinfo->document_id,+ FSE_ARG_DONE);++ hfs_unlockpair(cp, to_cp); // unlock this so we can send the fsevents+ need_unlock = 0;++ if (need_fsevent(FSE_STAT_CHANGED, vp)) {+ add_fsevent(FSE_STAT_CHANGED, context, FSE_ARG_VNODE, vp, FSE_ARG_DONE);+ }+ if (need_fsevent(FSE_STAT_CHANGED, to_vp)) {+ add_fsevent(FSE_STAT_CHANGED, context, FSE_ARG_VNODE, to_vp, FSE_ARG_DONE);+ }+ }++ if (need_unlock) {+ hfs_unlockpair(cp, to_cp);+ }++ transfer_cleanup:+ vnode_put(to_vp);+ file_drop(to_fd);++ return error;+ }++++ case HFSIOC_PREV_LINK:+ case HFSIOC_NEXT_LINK:+ {+ cnid_t linkfileid;+ cnid_t nextlinkid;+ cnid_t prevlinkid;+ int error;++ /* Caller must be owner of file system. */+ vfsp = vfs_statfs(HFSTOVFS(hfsmp));+ if (suser(cred, NULL) &&+ kauth_cred_getuid(cred) != vfsp->f_owner) {+ return (EACCES);+ }+ /* Target vnode must be file system's root. */+ if (!vnode_isvroot(vp)) {+ return (EINVAL);+ }+ linkfileid = *(cnid_t *)ap->a_data;+ if (linkfileid < kHFSFirstUserCatalogNodeID) {+ return (EINVAL);+ }+ if ((error = hfs_lookup_siblinglinks(hfsmp, linkfileid, &prevlinkid, &nextlinkid))) {+ return (error);+ }+ if (ap->a_command == HFSIOC_NEXT_LINK) {+ *(cnid_t *)ap->a_data = nextlinkid;+ } else {+ *(cnid_t *)ap->a_data = prevlinkid;+ }+ return (0);+ }++ case HFSIOC_RESIZE_PROGRESS: {++ vfsp = vfs_statfs(HFSTOVFS(hfsmp));+ if (suser(cred, NULL) &&+ kauth_cred_getuid(cred) != vfsp->f_owner) {+ return (EACCES); /* must be owner of file system */+ }+ if (!vnode_isvroot(vp)) {+ return (EINVAL);+ }+ /* file system must not be mounted read-only */+ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return (EROFS);+ }++ return hfs_resize_progress(hfsmp, (u_int32_t *)ap->a_data);+ }++ case HFSIOC_RESIZE_VOLUME: {+ u_int64_t newsize;+ u_int64_t cursize;+ int ret;++ vfsp = vfs_statfs(HFSTOVFS(hfsmp));+ if (suser(cred, NULL) &&+ kauth_cred_getuid(cred) != vfsp->f_owner) {+ return (EACCES); /* must be owner of file system */+ }+ if (!vnode_isvroot(vp)) {+ return (EINVAL);+ }++ /* filesystem must not be mounted read only */+ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return (EROFS);+ }+ newsize = *(u_int64_t *)ap->a_data;+ cursize = (u_int64_t)hfsmp->totalBlocks * (u_int64_t)hfsmp->blockSize;++ if (newsize == cursize) {+ return (0);+ }+ IOBSDMountChange(hfsmp->hfs_mp, kIOMountChangeWillResize);+ if (newsize > cursize) {+ ret = hfs_extendfs(hfsmp, *(u_int64_t *)ap->a_data, context);+ } else {+ ret = hfs_truncatefs(hfsmp, *(u_int64_t *)ap->a_data, context);+ }+ IOBSDMountChange(hfsmp->hfs_mp, kIOMountChangeDidResize);+ return (ret);+ }+ case HFSIOC_CHANGE_NEXT_ALLOCATION: {+ int error = 0; /* Assume success */+ u_int32_t location;++ if (vnode_vfsisrdonly(vp)) {+ return (EROFS);+ }+ vfsp = vfs_statfs(HFSTOVFS(hfsmp));+ if (suser(cred, NULL) &&+ kauth_cred_getuid(cred) != vfsp->f_owner) {+ return (EACCES); /* must be owner of file system */+ }+ if (!vnode_isvroot(vp)) {+ return (EINVAL);+ }+ hfs_lock_mount(hfsmp);+ location = *(u_int32_t *)ap->a_data;+ if ((location >= hfsmp->allocLimit) &&+ (location != HFS_NO_UPDATE_NEXT_ALLOCATION)) {+ error = EINVAL;+ goto fail_change_next_allocation;+ }+ /* Return previous value. */+ *(u_int32_t *)ap->a_data = hfsmp->nextAllocation;+ if (location == HFS_NO_UPDATE_NEXT_ALLOCATION) {+ /* On magic value for location, set nextAllocation to next block+ * after metadata zone and set flag in mount structure to indicate+ * that nextAllocation should not be updated again.+ */+ if (hfsmp->hfs_metazone_end != 0) {+ HFS_UPDATE_NEXT_ALLOCATION(hfsmp, hfsmp->hfs_metazone_end + 1);+ }+ hfsmp->hfs_flags |= HFS_SKIP_UPDATE_NEXT_ALLOCATION;+ } else {+ hfsmp->hfs_flags &= ~HFS_SKIP_UPDATE_NEXT_ALLOCATION;+ HFS_UPDATE_NEXT_ALLOCATION(hfsmp, location);+ }+ MarkVCBDirty(hfsmp);+fail_change_next_allocation:+ hfs_unlock_mount(hfsmp);+ return (error);+ }++#if HFS_SPARSE_DEV+ case HFSIOC_SETBACKINGSTOREINFO: {+ struct vnode * di_vp;+ struct hfs_backingstoreinfo *bsdata;+ int error = 0;++ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return (EROFS);+ }+ if (hfsmp->hfs_flags & HFS_HAS_SPARSE_DEVICE) {+ return (EALREADY);+ }+ vfsp = vfs_statfs(HFSTOVFS(hfsmp));+ if (suser(cred, NULL) &&+ kauth_cred_getuid(cred) != vfsp->f_owner) {+ return (EACCES); /* must be owner of file system */+ }+ bsdata = (struct hfs_backingstoreinfo *)ap->a_data;+ if (bsdata == NULL) {+ return (EINVAL);+ }+ if ((error = file_vnode(bsdata->backingfd, &di_vp))) {+ return (error);+ }+ if ((error = vnode_getwithref(di_vp))) {+ file_drop(bsdata->backingfd);+ return(error);+ }++ if (vnode_mount(vp) == vnode_mount(di_vp)) {+ (void)vnode_put(di_vp);+ file_drop(bsdata->backingfd);+ return (EINVAL);+ }++ // Dropped in unmount+ error = vnode_ref(di_vp);+ if (error) {+ (void)vnode_put(di_vp);+ file_drop(bsdata->backingfd);+ return (error);+ }++ hfs_lock_mount(hfsmp);+ hfsmp->hfs_backingvp = di_vp;+ hfsmp->hfs_flags |= HFS_HAS_SPARSE_DEVICE;+ hfsmp->hfs_sparsebandblks = bsdata->bandsize / hfsmp->blockSize * 4;+ hfs_unlock_mount(hfsmp);++ /* We check the MNTK_VIRTUALDEV bit instead of marking the dependent process */++ /*+ * If the sparse image is on a sparse image file (as opposed to a sparse+ * bundle), then we may need to limit the free space to the maximum size+ * of a file on that volume. So we query (using pathconf), and if we get+ * a meaningful result, we cache the number of blocks for later use in+ * hfs_freeblks().+ */+ hfsmp->hfs_backingfs_maxblocks = 0;+ if (vnode_vtype(di_vp) == VREG) {+ int terr;+ int hostbits;+ terr = vn_pathconf(di_vp, _PC_FILESIZEBITS, &hostbits, context);+ if (terr == 0 && hostbits != 0 && hostbits < 64) {+ u_int64_t hostfilesizemax = ((u_int64_t)1) << hostbits;++ hfsmp->hfs_backingfs_maxblocks = hostfilesizemax / hfsmp->blockSize;+ }+ }++ /* The free extent cache is managed differently for sparse devices.+ * There is a window between which the volume is mounted and the+ * device is marked as sparse, so the free extent cache for this+ * volume is currently initialized as normal volume (sorted by block+ * count). Reset the cache so that it will be rebuilt again+ * for sparse device (sorted by start block).+ */+ ResetVCBFreeExtCache(hfsmp);++ (void)vnode_put(di_vp);+ file_drop(bsdata->backingfd);+ return (0);+ }++ case HFSIOC_CLRBACKINGSTOREINFO: {+ struct vnode * tmpvp;++ vfsp = vfs_statfs(HFSTOVFS(hfsmp));+ if (suser(cred, NULL) &&+ kauth_cred_getuid(cred) != vfsp->f_owner) {+ return (EACCES); /* must be owner of file system */+ }+ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return (EROFS);+ }++ if ((hfsmp->hfs_flags & HFS_HAS_SPARSE_DEVICE) &&+ hfsmp->hfs_backingvp) {++ hfs_lock_mount(hfsmp);+ hfsmp->hfs_flags &= ~HFS_HAS_SPARSE_DEVICE;+ tmpvp = hfsmp->hfs_backingvp;+ hfsmp->hfs_backingvp = NULLVP;+ hfsmp->hfs_sparsebandblks = 0;+ hfs_unlock_mount(hfsmp);++ vnode_rele(tmpvp);+ }+ return (0);+ }+#endif /* HFS_SPARSE_DEV */++ /* Change the next CNID stored in the VH */+ case HFSIOC_CHANGE_NEXTCNID: {+ int error = 0; /* Assume success */+ u_int32_t fileid;+ int wraparound = 0;+ int lockflags = 0;++ if (vnode_vfsisrdonly(vp)) {+ return (EROFS);+ }+ vfsp = vfs_statfs(HFSTOVFS(hfsmp));+ if (suser(cred, NULL) &&+ kauth_cred_getuid(cred) != vfsp->f_owner) {+ return (EACCES); /* must be owner of file system */+ }++ fileid = *(u_int32_t *)ap->a_data;++ /* Must have catalog lock excl. to advance the CNID pointer */+ lockflags = hfs_systemfile_lock (hfsmp, SFL_CATALOG , HFS_EXCLUSIVE_LOCK);++ hfs_lock_mount(hfsmp);++ /* If it is less than the current next CNID, force the wraparound bit to be set */+ if (fileid < hfsmp->vcbNxtCNID) {+ wraparound=1;+ }++ /* Return previous value. */+ *(u_int32_t *)ap->a_data = hfsmp->vcbNxtCNID;++ hfsmp->vcbNxtCNID = fileid;++ if (wraparound) {+ hfsmp->vcbAtrb |= kHFSCatalogNodeIDsReusedMask;+ }++ MarkVCBDirty(hfsmp);+ hfs_unlock_mount(hfsmp);+ hfs_systemfile_unlock (hfsmp, lockflags);++ return (error);+ }++ case F_FREEZE_FS: {+ struct mount *mp;++ mp = vnode_mount(vp);+ hfsmp = VFSTOHFS(mp);++ if (!(hfsmp->jnl))+ return (ENOTSUP);++ vfsp = vfs_statfs(mp);++ if (kauth_cred_getuid(cred) != vfsp->f_owner &&+ !kauth_cred_issuser(cred))+ return (EACCES);++ return hfs_freeze(hfsmp);+ }++ case F_THAW_FS: {+ vfsp = vfs_statfs(vnode_mount(vp));+ if (kauth_cred_getuid(cred) != vfsp->f_owner &&+ !kauth_cred_issuser(cred))+ return (EACCES);++ return hfs_thaw(hfsmp, current_proc());+ }++ case HFSIOC_EXT_BULKACCESS32:+ case HFSIOC_EXT_BULKACCESS64: {+ int size;++ if (is64bit) {+ size = sizeof(struct user64_ext_access_t);+ } else {+ size = sizeof(struct user32_ext_access_t);+ }++ return do_bulk_access_check(hfsmp, vp, ap, size, context);+ }++ case HFSIOC_SET_XATTREXTENTS_STATE: {+ int state;++ if (ap->a_data == NULL) {+ return (EINVAL);+ }++ state = *(int *)ap->a_data;++ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return (EROFS);+ }++ /* Super-user can enable or disable extent-based extended+ * attribute support on a volume+ * Note: Starting Mac OS X 10.7, extent-based extended attributes+ * are enabled by default, so any change will be transient only+ * till the volume is remounted.+ */+ if (!kauth_cred_issuser(kauth_cred_get())) {+ return (EPERM);+ }+ if (state == 0 || state == 1)+ return hfs_set_volxattr(hfsmp, HFSIOC_SET_XATTREXTENTS_STATE, state);+ else+ return (EINVAL);+ }++ case F_SETSTATICCONTENT: {+ int error;+ int enable_static = 0;+ struct cnode *cp = NULL;+ /*+ * lock the cnode, decorate the cnode flag, and bail out.+ * VFS should have already authenticated the caller for us.+ */++ if (ap->a_data) {+ /*+ * Note that even though ap->a_data is of type caddr_t,+ * the fcntl layer at the syscall handler will pass in NULL+ * or 1 depending on what the argument supplied to the fcntl+ * was. So it is in fact correct to check the ap->a_data+ * argument for zero or non-zero value when deciding whether or not+ * to enable the static bit in the cnode.+ */+ enable_static = 1;+ }+ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return EROFS;+ }+ cp = VTOC(vp);++ error = hfs_lock (cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ if (error == 0) {+ if (enable_static) {+ cp->c_flag |= C_SSD_STATIC;+ }+ else {+ cp->c_flag &= ~C_SSD_STATIC;+ }+ hfs_unlock (cp);+ }+ return error;+ }++ case F_SET_GREEDY_MODE: {+ int error;+ int enable_greedy_mode = 0;+ struct cnode *cp = NULL;+ /*+ * lock the cnode, decorate the cnode flag, and bail out.+ * VFS should have already authenticated the caller for us.+ */++ if (ap->a_data) {+ /*+ * Note that even though ap->a_data is of type caddr_t,+ * the fcntl layer at the syscall handler will pass in NULL+ * or 1 depending on what the argument supplied to the fcntl+ * was. So it is in fact correct to check the ap->a_data+ * argument for zero or non-zero value when deciding whether or not+ * to enable the greedy mode bit in the cnode.+ */+ enable_greedy_mode = 1;+ }+ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return EROFS;+ }+ cp = VTOC(vp);++ error = hfs_lock (cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ if (error == 0) {+ if (enable_greedy_mode) {+ cp->c_flag |= C_SSD_GREEDY_MODE;+ }+ else {+ cp->c_flag &= ~C_SSD_GREEDY_MODE;+ }+ hfs_unlock (cp);+ }+ return error;+ }++ case F_SETIOTYPE: {+ int error;+ uint32_t iotypeflag = 0;++ struct cnode *cp = NULL;+ /*+ * lock the cnode, decorate the cnode flag, and bail out.+ * VFS should have already authenticated the caller for us.+ */++ if (ap->a_data == NULL) {+ return EINVAL;+ }++ /*+ * Note that even though ap->a_data is of type caddr_t, we+ * can only use 32 bits of flag values.+ */+ iotypeflag = (uint32_t) ap->a_data;+ switch (iotypeflag) {+ case F_IOTYPE_ISOCHRONOUS:+ break;+ default:+ return EINVAL;+ }+++ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return EROFS;+ }+ cp = VTOC(vp);++ error = hfs_lock (cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ if (error == 0) {+ switch (iotypeflag) {+ case F_IOTYPE_ISOCHRONOUS:+ cp->c_flag |= C_IO_ISOCHRONOUS;+ break;+ default:+ break;+ }+ hfs_unlock (cp);+ }+ return error;+ }++ case F_MAKECOMPRESSED: {+ int error = 0;+ uint32_t gen_counter;+ struct cnode *cp = NULL;+ int reset_decmp = 0;++ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return EROFS;+ }++ /*+ * acquire & lock the cnode.+ * VFS should have already authenticated the caller for us.+ */++ if (ap->a_data) {+ /*+ * Cast the pointer into a uint32_t so we can extract the+ * supplied generation counter.+ */+ gen_counter = *((uint32_t*)ap->a_data);+ }+ else {+ return EINVAL;+ }++#if HFS_COMPRESSION+ cp = VTOC(vp);+ /* Grab truncate lock first; we may truncate the file */+ hfs_lock_truncate (cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);++ error = hfs_lock (cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ if (error) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ return error;+ }++ /* Are there any other usecounts/FDs? */+ if (vnode_isinuse(vp, 1)) {+ hfs_unlock(cp);+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ return EBUSY;+ }++ /* now we have the cnode locked down; Validate arguments */+ if (cp->c_attr.ca_flags & (UF_IMMUTABLE | UF_COMPRESSED)) {+ /* EINVAL if you are trying to manipulate an IMMUTABLE file */+ hfs_unlock(cp);+ hfs_unlock_truncate (cp, HFS_LOCK_DEFAULT);+ return EINVAL;+ }++ if ((hfs_get_gencount (cp)) == gen_counter) {+ /*+ * OK, the gen_counter matched. Go for it:+ * Toggle state bits, truncate file, and suppress mtime update+ */+ reset_decmp = 1;+ cp->c_bsdflags |= UF_COMPRESSED;++ error = hfs_truncate(vp, 0, IO_NDELAY, HFS_TRUNCATE_SKIPTIMES,+ ap->a_context);+ }+ else {+ error = ESTALE;+ }++ /* Unlock cnode before executing decmpfs ; they may need to get an EA */+ hfs_unlock(cp);++ /*+ * Reset the decmp state while still holding the truncate lock. We need to+ * serialize here against a listxattr on this node which may occur at any+ * time.+ *+ * Even if '0/skiplock' is passed in 2nd argument to hfs_file_is_compressed,+ * that will still potentially require getting the com.apple.decmpfs EA. If the+ * EA is required, then we can't hold the cnode lock, because the getxattr call is+ * generic(through VFS), and can't pass along any info telling it that we're already+ * holding it (the lock). If we don't serialize, then we risk listxattr stopping+ * and trying to fill in the hfs_file_is_compressed info during the callback+ * operation, which will result in deadlock against the b-tree node.+ *+ * So, to serialize against listxattr (which will grab buf_t meta references on+ * the b-tree blocks), we hold the truncate lock as we're manipulating the+ * decmpfs payload.+ */+ if ((reset_decmp) && (error == 0)) {+ decmpfs_cnode *dp = VTOCMP (vp);+ if (dp != NULL) {+ decmpfs_cnode_set_vnode_state(dp, FILE_TYPE_UNKNOWN, 0);+ }++ /* Initialize the decmpfs node as needed */+ (void) hfs_file_is_compressed (cp, 0); /* ok to take lock */+ }++ hfs_unlock_truncate (cp, HFS_LOCK_DEFAULT);++#endif+ return error;+ }++ case F_SETBACKINGSTORE: {++ int error = 0;++ /*+ * See comment in F_SETSTATICCONTENT re: using+ * a null check for a_data+ */+ if (ap->a_data) {+ error = hfs_set_backingstore (vp, 1);+ }+ else {+ error = hfs_set_backingstore (vp, 0);+ }++ return error;+ }++ case F_GETPATH_MTMINFO: {+ int error = 0;++ int *data = (int*) ap->a_data;++ /* Ask if this is a backingstore vnode */+ error = hfs_is_backingstore (vp, data);++ return error;+ }++ case F_FULLFSYNC: {+ int error;++ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return (EROFS);+ }+ error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ if (error == 0) {+ error = hfs_fsync(vp, MNT_WAIT, HFS_FSYNC_FULL, p);+ hfs_unlock(VTOC(vp));+ }++ return error;+ }++ case F_BARRIERFSYNC: {+ int error;++ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return (EROFS);+ }+ error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ if (error == 0) {+ error = hfs_fsync(vp, MNT_WAIT, HFS_FSYNC_BARRIER, p);+ hfs_unlock(VTOC(vp));+ }++ return error;+ }++ case F_CHKCLEAN: {+ register struct cnode *cp;+ int error;++ if (!vnode_isreg(vp))+ return EINVAL;++ error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ if (error == 0) {+ cp = VTOC(vp);+ /*+ * used by regression test to determine if+ * all the dirty pages (via write) have been cleaned+ * after a call to 'fsysnc'.+ */+ error = is_file_clean(vp, VTOF(vp)->ff_size);+ hfs_unlock(cp);+ }+ return (error);+ }++ case F_RDADVISE: {+ register struct radvisory *ra;+ struct filefork *fp;+ int error;++ if (!vnode_isreg(vp))+ return EINVAL;++ ra = (struct radvisory *)(ap->a_data);+ fp = VTOF(vp);++ /* Protect against a size change. */+ hfs_lock_truncate(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);++#if HFS_COMPRESSION+ if (compressed) {+ if (uncompressed_size == -1) {+ /* fetching the uncompressed size failed above, so return the error */+ error = decmpfs_error;+ } else if (ra->ra_offset >= uncompressed_size) {+ error = EFBIG;+ } else {+ error = advisory_read(vp, uncompressed_size, ra->ra_offset, ra->ra_count);+ }+ } else+#endif /* HFS_COMPRESSION */+ if (ra->ra_offset >= fp->ff_size) {+ error = EFBIG;+ } else {+ error = advisory_read(vp, fp->ff_size, ra->ra_offset, ra->ra_count);+ }++ hfs_unlock_truncate(VTOC(vp), HFS_LOCK_DEFAULT);+ return (error);+ }++ case HFSIOC_GET_VOL_CREATE_TIME_32: {+ *(user32_time_t *)(ap->a_data) = (user32_time_t) (to_bsd_time(VTOVCB(vp)->localCreateDate));+ return 0;+ }++ case HFSIOC_GET_VOL_CREATE_TIME_64: {+ *(user64_time_t *)(ap->a_data) = (user64_time_t) (to_bsd_time(VTOVCB(vp)->localCreateDate));+ return 0;+ }++ case SPOTLIGHT_IOC_GET_MOUNT_TIME:+ *(uint32_t *)ap->a_data = hfsmp->hfs_mount_time;+ break;++ case SPOTLIGHT_IOC_GET_LAST_MTIME:+ *(uint32_t *)ap->a_data = hfsmp->hfs_last_mounted_mtime;+ break;++ case HFSIOC_GET_VERY_LOW_DISK:+ *(uint32_t*)ap->a_data = hfsmp->hfs_freespace_notify_dangerlimit;+ break;++ case HFSIOC_SET_VERY_LOW_DISK:+ if (*(uint32_t *)ap->a_data >= hfsmp->hfs_freespace_notify_warninglimit) {+ return EINVAL;+ }++ hfsmp->hfs_freespace_notify_dangerlimit = *(uint32_t *)ap->a_data;+ break;++ case HFSIOC_GET_LOW_DISK:+ *(uint32_t*)ap->a_data = hfsmp->hfs_freespace_notify_warninglimit;+ break;++ case HFSIOC_SET_LOW_DISK:+ if ( *(uint32_t *)ap->a_data >= hfsmp->hfs_freespace_notify_desiredlevel+ || *(uint32_t *)ap->a_data <= hfsmp->hfs_freespace_notify_dangerlimit) {++ return EINVAL;+ }++ hfsmp->hfs_freespace_notify_warninglimit = *(uint32_t *)ap->a_data;+ break;++ /* The following two fsctls were ported from apfs. */+ case APFSIOC_GET_NEAR_LOW_DISK:+ *(uint32_t*)ap->a_data = hfsmp->hfs_freespace_notify_nearwarninglimit;+ break;++ case APFSIOC_SET_NEAR_LOW_DISK:+ if ( *(uint32_t *)ap->a_data >= hfsmp->hfs_freespace_notify_desiredlevel+ || *(uint32_t *)ap->a_data <= hfsmp->hfs_freespace_notify_warninglimit) {+ return EINVAL;+ }++ hfsmp->hfs_freespace_notify_nearwarninglimit = *(uint32_t *)ap->a_data;+ break;++ case HFSIOC_GET_DESIRED_DISK:+ *(uint32_t*)ap->a_data = hfsmp->hfs_freespace_notify_desiredlevel;+ break;++ case HFSIOC_SET_DESIRED_DISK:+ if (*(uint32_t *)ap->a_data <= hfsmp->hfs_freespace_notify_warninglimit) {+ return EINVAL;+ }++ hfsmp->hfs_freespace_notify_desiredlevel = *(uint32_t *)ap->a_data;+ break;++ case HFSIOC_VOLUME_STATUS:+ *(uint32_t *)ap->a_data = hfsmp->hfs_notification_conditions;+ break;++ case HFS_SET_BOOT_INFO:+ if (!vnode_isvroot(vp))+ return(EINVAL);+ if (!kauth_cred_issuser(cred) && (kauth_cred_getuid(cred) != vfs_statfs(HFSTOVFS(hfsmp))->f_owner))+ return(EACCES); /* must be superuser or owner of filesystem */+ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return (EROFS);+ }+ hfs_lock_mount (hfsmp);+ bcopy(ap->a_data, &hfsmp->vcbFndrInfo, sizeof(hfsmp->vcbFndrInfo));+ /* Null out the cached UUID, to be safe */+ uuid_clear (hfsmp->hfs_full_uuid);+ hfs_unlock_mount (hfsmp);+ (void) hfs_flushvolumeheader(hfsmp, HFS_FVH_WAIT);+ break;++ case HFS_GET_BOOT_INFO:+ if (!vnode_isvroot(vp))+ return(EINVAL);+ hfs_lock_mount (hfsmp);+ bcopy(&hfsmp->vcbFndrInfo, ap->a_data, sizeof(hfsmp->vcbFndrInfo));+ hfs_unlock_mount(hfsmp);+ break;++ /* case HFS_MARK_BOOT_CORRUPT: _IO are the same */+ case HFSIOC_MARK_BOOT_CORRUPT:+ /* Mark the boot volume corrupt by setting+ * kHFSVolumeInconsistentBit in the volume header. This will+ * force fsck_hfs on next mount.+ */+ if (!kauth_cred_issuser(kauth_cred_get())) {+ return EACCES;+ }++ /* Allowed only on the root vnode of the boot volume */+ if (!(vfs_flags(HFSTOVFS(hfsmp)) & MNT_ROOTFS) ||+ !vnode_isvroot(vp)) {+ return EINVAL;+ }+ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return (EROFS);+ }+ printf ("hfs_vnop_ioctl: Marking the boot volume corrupt.\n");+ hfs_mark_inconsistent(hfsmp, HFS_FSCK_FORCED);+ break;++ case HFSIOC_GET_JOURNAL_INFO:+ jip = (struct hfs_journal_info*)ap->a_data;++ if (vp == NULLVP)+ return EINVAL;++ if (hfsmp->jnl == NULL) {+ jnl_start = 0;+ jnl_size = 0;+ } else {+ jnl_start = hfs_blk_to_bytes(hfsmp->jnl_start, hfsmp->blockSize) + hfsmp->hfsPlusIOPosOffset;+ jnl_size = hfsmp->jnl_size;+ }++ jip->jstart = jnl_start;+ jip->jsize = jnl_size;+ break;++ case HFSIOC_SET_ALWAYS_ZEROFILL: {+ struct cnode *cp = VTOC(vp);++ if (*(int *)ap->a_data) {+ cp->c_flag |= C_ALWAYS_ZEROFILL;+ } else {+ cp->c_flag &= ~C_ALWAYS_ZEROFILL;+ }+ break;+ }++ /* case HFS_DISABLE_METAZONE: _IO are the same */+ case HFSIOC_DISABLE_METAZONE: {+ /* Only root can disable metadata zone */+ if (!kauth_cred_issuser(kauth_cred_get())) {+ return EACCES;+ }+ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return (EROFS);+ }++ /* Disable metadata zone now */+ (void) hfs_metadatazone_init(hfsmp, true);+ printf ("hfs: Disabling metadata zone on %s\n", hfsmp->vcbVN);+ break;+ }+++ case HFSIOC_FSINFO_METADATA_BLOCKS: {+ int error;+ struct hfsinfo_metadata *hinfo;++ hinfo = (struct hfsinfo_metadata *)ap->a_data;++ /* Get information about number of metadata blocks */+ error = hfs_getinfo_metadata_blocks(hfsmp, hinfo);+ if (error) {+ return error;+ }++ break;+ }++ case HFSIOC_GET_FSINFO: {+ hfs_fsinfo *fsinfo = (hfs_fsinfo *)ap->a_data;++ /* Only root is allowed to get fsinfo */+ if (!kauth_cred_issuser(kauth_cred_get())) {+ return EACCES;+ }++ /*+ * Make sure that the caller's version number matches with+ * the kernel's version number. This will make sure that+ * if the structures being read/written into are changed+ * by the kernel, the caller will not read incorrect data.+ *+ * The first three fields --- request_type, version and+ * flags are same for all the hfs_fsinfo structures, so+ * we can access the version number by assuming any+ * structure for now.+ */+ if (fsinfo->header.version != HFS_FSINFO_VERSION) {+ return ENOTSUP;+ }++ /* Make sure that the current file system is not marked inconsistent */+ if (hfsmp->vcbAtrb & kHFSVolumeInconsistentMask) {+ return EIO;+ }++ return hfs_get_fsinfo(hfsmp, ap->a_data);+ }++ case HFSIOC_CS_FREESPACE_TRIM: {+ int error = 0;+ int lockflags = 0;++ /* Only root allowed */+ if (!kauth_cred_issuser(kauth_cred_get())) {+ return EACCES;+ }++ /*+ * This core functionality is similar to hfs_scan_blocks().+ * The main difference is that hfs_scan_blocks() is called+ * as part of mount where we are assured that the journal is+ * empty to start with. This fcntl() can be called on a+ * mounted volume, therefore it has to flush the content of+ * the journal as well as ensure the state of summary table.+ *+ * This fcntl scans over the entire allocation bitmap,+ * creates list of all the free blocks, and issues TRIM+ * down to the underlying device. This can take long time+ * as it can generate up to 512MB of read I/O.+ */++ if ((hfsmp->hfs_flags & HFS_SUMMARY_TABLE) == 0) {+ error = hfs_init_summary(hfsmp);+ if (error) {+ printf("hfs: fsctl() could not initialize summary table for %s\n", hfsmp->vcbVN);+ return error;+ }+ }++ /*+ * The journal maintains list of recently deallocated blocks to+ * issue DKIOCUNMAPs when the corresponding journal transaction is+ * flushed to the disk. To avoid any race conditions, we only+ * want one active trim list and only one thread issuing DKIOCUNMAPs.+ * Therefore we make sure that the journal trim list is sync'ed,+ * empty, and not modifiable for the duration of our scan.+ *+ * Take the journal lock before flushing the journal to the disk.+ * We will keep on holding the journal lock till we don't get the+ * bitmap lock to make sure that no new journal transactions can+ * start. This will make sure that the journal trim list is not+ * modified after the journal flush and before getting bitmap lock.+ * We can release the journal lock after we acquire the bitmap+ * lock as it will prevent any further block deallocations.+ */+ hfs_journal_lock(hfsmp);++ /* Flush the journal and wait for all I/Os to finish up */+ error = hfs_flush(hfsmp, HFS_FLUSH_JOURNAL_META);+ if (error) {+ hfs_journal_unlock(hfsmp);+ return error;+ }++ /* Take bitmap lock to ensure it is not being modified */+ lockflags = hfs_systemfile_lock(hfsmp, SFL_BITMAP, HFS_EXCLUSIVE_LOCK);++ /* Release the journal lock */+ hfs_journal_unlock(hfsmp);++ /*+ * ScanUnmapBlocks reads the bitmap in large block size+ * (up to 1MB) unlike the runtime which reads the bitmap+ * in the 4K block size. This can cause buf_t collisions+ * and potential data corruption. To avoid this, we+ * invalidate all the existing buffers associated with+ * the bitmap vnode before scanning it.+ *+ * Note: ScanUnmapBlock() cleans up all the buffers+ * after itself, so there won't be any large buffers left+ * for us to clean up after it returns.+ */+ error = buf_invalidateblks(hfsmp->hfs_allocation_vp, 0, 0, 0);+ if (error) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ return error;+ }++ /* Traverse bitmap and issue DKIOCUNMAPs */+ error = ScanUnmapBlocks(hfsmp);+ hfs_systemfile_unlock(hfsmp, lockflags);+ if (error) {+ return error;+ }++ break;+ }++ case HFSIOC_SET_HOTFILE_STATE: {+ int error;+ struct cnode *cp = VTOC(vp);+ uint32_t hf_state = *((uint32_t*)ap->a_data);+ uint32_t num_unpinned = 0;++ error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ if (error) {+ return error;+ }++ // printf("hfs: setting hotfile state %d on %s\n", hf_state, vp->v_name);+ if (hf_state == HFS_MARK_FASTDEVCANDIDATE) {+ vnode_setfastdevicecandidate(vp);++ cp->c_attr.ca_recflags |= kHFSFastDevCandidateMask;+ cp->c_attr.ca_recflags &= ~kHFSDoNotFastDevPinMask;+ cp->c_flag |= C_MODIFIED;+ } else if (hf_state == HFS_UNMARK_FASTDEVCANDIDATE || hf_state == HFS_NEVER_FASTDEVCANDIDATE) {+ vnode_clearfastdevicecandidate(vp);+ hfs_removehotfile(vp);++ if (cp->c_attr.ca_recflags & kHFSFastDevPinnedMask) {+ hfs_pin_vnode(hfsmp, vp, HFS_UNPIN_IT, &num_unpinned);+ }++ if (hf_state == HFS_NEVER_FASTDEVCANDIDATE) {+ cp->c_attr.ca_recflags |= kHFSDoNotFastDevPinMask;+ }+ cp->c_attr.ca_recflags &= ~(kHFSFastDevCandidateMask|kHFSFastDevPinnedMask);+ cp->c_flag |= C_MODIFIED;++ } else {+ error = EINVAL;+ }++ if (num_unpinned != 0) {+ lck_mtx_lock(&hfsmp->hfc_mutex);+ hfsmp->hfs_hotfile_freeblks += num_unpinned;+ lck_mtx_unlock(&hfsmp->hfc_mutex);+ }++ hfs_unlock(cp);+ return error;+ }++ case HFSIOC_REPIN_HOTFILE_STATE: {+ int error=0;+ uint32_t repin_what = *((uint32_t*)ap->a_data);++ /* Only root allowed */+ if (!kauth_cred_issuser(kauth_cred_get())) {+ return EACCES;+ }++ if (!(hfsmp->hfs_flags & (HFS_CS_METADATA_PIN | HFS_CS_HOTFILE_PIN))) {+ // this system is neither regular Fusion or Cooperative Fusion+ // so this fsctl makes no sense.+ return EINVAL;+ }++ //+ // After a converting a CoreStorage volume to be encrypted, the+ // extents could have moved around underneath us. This call+ // allows corestoraged to re-pin everything that should be+ // pinned (it would happen on the next reboot too but that could+ // be a long time away).+ //+ if ((repin_what & HFS_REPIN_METADATA) && (hfsmp->hfs_flags & HFS_CS_METADATA_PIN)) {+ hfs_pin_fs_metadata(hfsmp);+ }+ if ((repin_what & HFS_REPIN_USERDATA) && (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN)) {+ hfs_repin_hotfiles(hfsmp);+ }+ if ((repin_what & HFS_REPIN_USERDATA) && (hfsmp->hfs_flags & HFS_CS_SWAPFILE_PIN)) {+ //XXX Swapfiles (marked SWAP_PINNED) may have moved too.+ //XXX Do we care? They have a more transient/dynamic nature/lifetime.+ }++ return error;+ }++#if HFS_CONFIG_KEY_ROLL++ case HFSIOC_KEY_ROLL: {+ if (!kauth_cred_issuser(kauth_cred_get()))+ return EACCES;++ hfs_key_roll_args_t *args = (hfs_key_roll_args_t *)ap->a_data;++ return hfs_key_roll_op(ap->a_context, ap->a_vp, args);+ }++ case HFSIOC_GET_KEY_AUTO_ROLL: {+ if (!kauth_cred_issuser(kauth_cred_get()))+ return EACCES;++ hfs_key_auto_roll_args_t *args = (hfs_key_auto_roll_args_t *)ap->a_data;+ if (args->api_version != HFS_KEY_AUTO_ROLL_API_VERSION_1)+ return ENOTSUP;+ args->flags = (ISSET(hfsmp->cproot_flags, CP_ROOT_AUTO_ROLL_OLD_CLASS_GENERATION)+ ? HFS_KEY_AUTO_ROLL_OLD_CLASS_GENERATION : 0);+ args->min_key_os_version = hfsmp->hfs_auto_roll_min_key_os_version;+ args->max_key_os_version = hfsmp->hfs_auto_roll_max_key_os_version;+ break;+ }++ case HFSIOC_SET_KEY_AUTO_ROLL: {+ if (!kauth_cred_issuser(kauth_cred_get()))+ return EACCES;++ hfs_key_auto_roll_args_t *args = (hfs_key_auto_roll_args_t *)ap->a_data;+ if (args->api_version != HFS_KEY_AUTO_ROLL_API_VERSION_1)+ return ENOTSUP;+ return cp_set_auto_roll(hfsmp, args);+ }++#endif // HFS_CONFIG_KEY_ROLL++#if CONFIG_PROTECT+ case F_TRANSCODEKEY:+ /*+ * This API is only supported when called via kernel so+ * a_fflag must be set to 1 (it's not possible to get here+ * with it set to 1 via fsctl).+ */+ if (ap->a_fflag != 1)+ return ENOTTY;+ return cp_vnode_transcode(vp, (cp_key_t *)ap->a_data);++ case F_GETPROTECTIONLEVEL:+ return cp_get_root_major_vers (vp, (uint32_t *)ap->a_data);++ case F_GETDEFAULTPROTLEVEL:+ return cp_get_default_level(vp, (uint32_t *)ap->a_data);+#endif // CONFIG_PROTECT++ case FIOPINSWAP:+ return hfs_pin_vnode(hfsmp, vp, HFS_PIN_IT | HFS_DATALESS_PIN,+ NULL);++ case FSIOC_CAS_BSDFLAGS:+ return hfs_cas_bsdflags(hfsmp, vp, ap);++ default:+ return (ENOTTY);+ }++ return 0;+}++/*+ * select+ */+int+hfs_vnop_select(__unused struct vnop_select_args *ap)+/*+ struct vnop_select_args {+ vnode_t a_vp;+ int a_which;+ int a_fflags;+ void *a_wql;+ vfs_context_t a_context;+ };+*/+{+ /*+ * We should really check to see if I/O is possible.+ */+ return (1);+}++/*+ * Converts a logical block number to a physical block, and optionally returns+ * the amount of remaining blocks in a run. The logical block is based on hfsNode.logBlockSize.+ * The physical block number is based on the device block size, currently its 512.+ * The block run is returned in logical blocks, and is the REMAINING amount of blocks+ */+int+hfs_bmap(struct vnode *vp, daddr_t bn, struct vnode **vpp, daddr64_t *bnp, unsigned int *runp)+{+ struct filefork *fp = VTOF(vp);+ struct hfsmount *hfsmp = VTOHFS(vp);+ int retval = E_NONE;+ u_int32_t logBlockSize;+ size_t bytesContAvail = 0;+ off_t blockposition;+ int lockExtBtree;+ int lockflags = 0;++ /*+ * Check for underlying vnode requests and ensure that logical+ * to physical mapping is requested.+ */+ if (vpp != NULL)+ *vpp = hfsmp->hfs_devvp;+ if (bnp == NULL)+ return (0);++ logBlockSize = GetLogicalBlockSize(vp);+ blockposition = (off_t)bn * logBlockSize;++ lockExtBtree = overflow_extents(fp);++ if (lockExtBtree)+ lockflags = hfs_systemfile_lock(hfsmp, SFL_EXTENTS, HFS_EXCLUSIVE_LOCK);++ retval = MacToVFSError(+ MapFileBlockC (HFSTOVCB(hfsmp),+ (FCB*)fp,+ MAXPHYSIO,+ blockposition,+ bnp,+ &bytesContAvail));++ if (lockExtBtree)+ hfs_systemfile_unlock(hfsmp, lockflags);++ if (retval == E_NONE) {+ /* Figure out how many read ahead blocks there are */+ if (runp != NULL) {+ if (can_cluster(logBlockSize)) {+ /* Make sure this result never goes negative: */+ *runp = (bytesContAvail < logBlockSize) ? 0 : (bytesContAvail / logBlockSize) - 1;+ } else {+ *runp = 0;+ }+ }+ }+ return (retval);+}++/*+ * Convert logical block number to file offset.+ */+int+hfs_vnop_blktooff(struct vnop_blktooff_args *ap)+/*+ struct vnop_blktooff_args {+ vnode_t a_vp;+ daddr64_t a_lblkno;+ off_t *a_offset;+ };+*/+{+ if (ap->a_vp == NULL)+ return (EINVAL);+ *ap->a_offset = (off_t)ap->a_lblkno * (off_t)GetLogicalBlockSize(ap->a_vp);++ return(0);+}++/*+ * Convert file offset to logical block number.+ */+int+hfs_vnop_offtoblk(struct vnop_offtoblk_args *ap)+/*+ struct vnop_offtoblk_args {+ vnode_t a_vp;+ off_t a_offset;+ daddr64_t *a_lblkno;+ };+*/+{+ if (ap->a_vp == NULL)+ return (EINVAL);+ *ap->a_lblkno = (daddr64_t)(ap->a_offset / (off_t)GetLogicalBlockSize(ap->a_vp));++ return(0);+}++/*+ * Map file offset to physical block number.+ *+ * If this function is called for write operation, and if the file+ * had virtual blocks allocated (delayed allocation), real blocks+ * are allocated by calling ExtendFileC().+ *+ * If this function is called for read operation, and if the file+ * had virtual blocks allocated (delayed allocation), no change+ * to the size of file is done, and if required, rangelist is+ * searched for mapping.+ *+ * System file cnodes are expected to be locked (shared or exclusive).+ *+ * -- INVALID RANGES --+ *+ * Invalid ranges are used to keep track of where we have extended a+ * file, but have not yet written that data to disk. In the past we+ * would clear up the invalid ranges as we wrote to those areas, but+ * before data was actually flushed to disk. The problem with that+ * approach is that the data can be left in the cache and is therefore+ * still not valid on disk. So now we clear up the ranges here, when+ * the flags field has VNODE_WRITE set, indicating a write is about to+ * occur. This isn't ideal (ideally we want to clear them up when+ * know the data has been successfully written), but it's the best we+ * can do.+ *+ * For reads, we use the invalid ranges here in block map to indicate+ * to the caller that the data should be zeroed (a_bpn == -1). We+ * have to be careful about what ranges we return to the cluster code.+ * Currently the cluster code can only handle non-rounded values for+ * the EOF; it cannot handle funny sized ranges in the middle of the+ * file (the main problem is that it sends down odd sized I/Os to the+ * disk). Our code currently works because whilst the very first+ * offset and the last offset in the invalid ranges are not aligned,+ * gaps in the invalid ranges between the first and last, have to be+ * aligned (because we always write page sized blocks). For example,+ * consider this arrangement:+ *+ * +-------------+-----+-------+------++ * | |XXXXX| |XXXXXX|+ * +-------------+-----+-------+------++ * a b c d+ *+ * This shows two invalid ranges <a, b> and <c, d>. Whilst a and d+ * are not necessarily aligned, b and c *must* be.+ *+ * Zero-filling occurs in a number of ways:+ *+ * 1. When a read occurs and we return with a_bpn == -1.+ *+ * 2. When hfs_fsync or hfs_filedone calls hfs_flush_invalid_ranges+ * which will cause us to iterate over the ranges bringing in+ * pages that are not present in the cache and zeroing them. Any+ * pages that are already in the cache are left untouched. Note+ * that hfs_fsync does not always flush invalid ranges.+ *+ * 3. When we extend a file we zero out from the old EOF to the end+ * of the page. It would be nice if we didn't have to do this if+ * the page wasn't present (and could defer it), but because of+ * the problem described above, we have to.+ *+ * The invalid ranges are also used to restrict the size that we write+ * out on disk: see hfs_prepare_fork_for_update.+ *+ * Note that invalid ranges are ignored when neither the VNODE_READ or+ * the VNODE_WRITE flag is specified. This is useful for the+ * F_LOG2PHYS* fcntls which are not interested in invalid ranges: they+ * just want to know whether blocks are physically allocated or not.+ */+int+hfs_vnop_blockmap(struct vnop_blockmap_args *ap)+/*+ struct vnop_blockmap_args {+ vnode_t a_vp;+ off_t a_foffset;+ size_t a_size;+ daddr64_t *a_bpn;+ size_t *a_run;+ void *a_poff;+ int a_flags;+ vfs_context_t a_context;+ };+*/+{+ struct vnode *vp = ap->a_vp;+ struct cnode *cp;+ struct filefork *fp;+ struct hfsmount *hfsmp;+ size_t bytesContAvail = ap->a_size;+ int retval = E_NONE;+ int syslocks = 0;+ int lockflags = 0;+ struct rl_entry *invalid_range;+ enum rl_overlaptype overlaptype;+ int started_tr = 0;+ int tooklock = 0;++#if HFS_COMPRESSION+ if (VNODE_IS_RSRC(vp)) {+ /* allow blockmaps to the resource fork */+ } else {+ if ( hfs_file_is_compressed(VTOC(vp), 1) ) { /* 1 == don't take the cnode lock */+ int state = decmpfs_cnode_get_vnode_state(VTOCMP(vp));+ switch(state) {+ case FILE_IS_COMPRESSED:+ return ENOTSUP;+ case FILE_IS_CONVERTING:+ /* if FILE_IS_CONVERTING, we allow blockmap */+ break;+ default:+ printf("invalid state %d for compressed file\n", state);+ /* fall through */+ }+ }+ }+#endif /* HFS_COMPRESSION */++ /* Do not allow blockmap operation on a directory */+ if (vnode_isdir(vp)) {+ return (ENOTSUP);+ }++ /*+ * Check for underlying vnode requests and ensure that logical+ * to physical mapping is requested.+ */+ if (ap->a_bpn == NULL)+ return (0);++ hfsmp = VTOHFS(vp);+ cp = VTOC(vp);+ fp = VTOF(vp);++ if ( !vnode_issystem(vp) && !vnode_islnk(vp) && !vnode_isswap(vp)) {+ if (cp->c_lockowner != current_thread()) {+ hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ tooklock = 1;+ }++ // For reads, check the invalid ranges+ if (ISSET(ap->a_flags, VNODE_READ)) {+ if (ap->a_foffset >= fp->ff_size) {+ retval = ERANGE;+ goto exit;+ }++ overlaptype = rl_scan(&fp->ff_invalidranges, ap->a_foffset,+ ap->a_foffset + (off_t)bytesContAvail - 1,+ &invalid_range);+ switch(overlaptype) {+ case RL_MATCHINGOVERLAP:+ case RL_OVERLAPCONTAINSRANGE:+ case RL_OVERLAPSTARTSBEFORE:+ /* There's no valid block for this byte offset */+ *ap->a_bpn = (daddr64_t)-1;+ /* There's no point limiting the amount to be returned+ * if the invalid range that was hit extends all the way+ * to the EOF (i.e. there's no valid bytes between the+ * end of this range and the file's EOF):+ */+ if (((off_t)fp->ff_size > (invalid_range->rl_end + 1)) &&+ ((size_t)(invalid_range->rl_end + 1 - ap->a_foffset) < bytesContAvail)) {+ bytesContAvail = invalid_range->rl_end + 1 - ap->a_foffset;+ }++ retval = 0;+ goto exit;++ case RL_OVERLAPISCONTAINED:+ case RL_OVERLAPENDSAFTER:+ /* The range of interest hits an invalid block before the end: */+ if (invalid_range->rl_start == ap->a_foffset) {+ /* There's actually no valid information to be had starting here: */+ *ap->a_bpn = (daddr64_t)-1;+ if (((off_t)fp->ff_size > (invalid_range->rl_end + 1)) &&+ ((size_t)(invalid_range->rl_end + 1 - ap->a_foffset) < bytesContAvail)) {+ bytesContAvail = invalid_range->rl_end + 1 - ap->a_foffset;+ }++ retval = 0;+ goto exit;+ } else {+ /*+ * Sadly, the lower layers don't like us to+ * return unaligned ranges, so we skip over+ * any invalid ranges here that are less than+ * a page: zeroing of those bits is not our+ * responsibility (it's dealt with elsewhere).+ */+ do {+ off_t rounded_start = round_page_64(invalid_range->rl_start);+ if ((off_t)bytesContAvail < rounded_start - ap->a_foffset)+ break;+ if (rounded_start < invalid_range->rl_end + 1) {+ bytesContAvail = rounded_start - ap->a_foffset;+ break;+ }+ } while ((invalid_range = TAILQ_NEXT(invalid_range,+ rl_link)));+ }+ break;++ case RL_NOOVERLAP:+ break;+ } // switch+ }+ }++#if CONFIG_PROTECT+ if (cp->c_cpentry) {+ const int direction = (ISSET(ap->a_flags, VNODE_WRITE)+ ? VNODE_WRITE : VNODE_READ);++ cp_io_params_t io_params;+ cp_io_params(hfsmp, cp->c_cpentry,+ off_rsrc_make(ap->a_foffset, VNODE_IS_RSRC(vp)),+ direction, &io_params);++ if (io_params.max_len < (off_t)bytesContAvail)+ bytesContAvail = io_params.max_len;++ if (io_params.phys_offset != -1) {+ *ap->a_bpn = ((io_params.phys_offset + hfsmp->hfsPlusIOPosOffset)+ / hfsmp->hfs_logical_block_size);++ retval = 0;+ goto exit;+ }+ }+#endif++retry:++ /* Check virtual blocks only when performing write operation */+ if ((ap->a_flags & VNODE_WRITE) && (fp->ff_unallocblocks != 0)) {+ if (hfs_start_transaction(hfsmp) != 0) {+ retval = EINVAL;+ goto exit;+ } else {+ started_tr = 1;+ }+ syslocks = SFL_EXTENTS | SFL_BITMAP;++ } else if (overflow_extents(fp)) {+ syslocks = SFL_EXTENTS;+ }++ if (syslocks)+ lockflags = hfs_systemfile_lock(hfsmp, syslocks, HFS_EXCLUSIVE_LOCK);++ /*+ * Check for any delayed allocations.+ */+ if ((ap->a_flags & VNODE_WRITE) && (fp->ff_unallocblocks != 0)) {+ int64_t actbytes;+ u_int32_t loanedBlocks;++ //+ // Make sure we have a transaction. It's possible+ // that we came in and fp->ff_unallocblocks was zero+ // but during the time we blocked acquiring the extents+ // btree, ff_unallocblocks became non-zero and so we+ // will need to start a transaction.+ //+ if (started_tr == 0) {+ if (syslocks) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ syslocks = 0;+ }+ goto retry;+ }++ /*+ * Note: ExtendFileC will Release any blocks on loan and+ * aquire real blocks. So we ask to extend by zero bytes+ * since ExtendFileC will account for the virtual blocks.+ */++ loanedBlocks = fp->ff_unallocblocks;+ retval = ExtendFileC(hfsmp, (FCB*)fp, 0, 0,+ kEFAllMask | kEFNoClumpMask, &actbytes);++ if (retval) {+ fp->ff_unallocblocks = loanedBlocks;+ cp->c_blocks += loanedBlocks;+ fp->ff_blocks += loanedBlocks;++ hfs_lock_mount (hfsmp);+ hfsmp->loanedBlocks += loanedBlocks;+ hfs_unlock_mount (hfsmp);++ hfs_systemfile_unlock(hfsmp, lockflags);+ cp->c_flag |= C_MODIFIED;+ if (started_tr) {+ (void) hfs_update(vp, 0);+ (void) hfs_volupdate(hfsmp, VOL_UPDATE, 0);++ hfs_end_transaction(hfsmp);+ started_tr = 0;+ }+ goto exit;+ }+ }++#if NEW_XATTR+ // check for the alternate xattr vnode+ if (vp == hfsmp->hfs_attrdata_vp) {+ HFSPlusExtentDescriptor real_fext;+ size_t availableBytes;+ u_int32_t sectorsPerBlock; // Number of sectors per allocation block+ u_int32_t sectorSize;+ uint64_t f_offset;++ if (!hfs_xattr_fext_find(&hfsmp->hfs_xattr_io, hfsmp->blockSize,+ ap->a_foffset, &real_fext, &f_offset)) {+ panic("cannot find xattr fext for %llu", f_offset);+ }++ sectorSize = hfsmp->hfs_logical_block_size;+ // Compute the number of sectors in an allocation block+ sectorsPerBlock = hfsmp->blockSize / sectorSize;++ *ap->a_bpn = (f_offset / hfsmp->blockSize) * sectorsPerBlock;+ availableBytes = real_fext.blockCount * hfsmp->blockSize - (f_offset - (real_fext.startBlock * hfsmp->blockSize));+ if (availableBytes < bytesContAvail) {+ bytesContAvail = availableBytes;+ }++ goto got_fext;+ }+#endif++ retval = MapFileBlockC(hfsmp, (FCB *)fp, bytesContAvail, ap->a_foffset,+ ap->a_bpn, &bytesContAvail);++#if NEW_XATTR+got_fext:+#endif++ if (syslocks) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ syslocks = 0;+ }++ if (retval) {+ /* On write, always return error because virtual blocks, if any,+ * should have been allocated in ExtendFileC(). We do not+ * allocate virtual blocks on read, therefore return error+ * only if no virtual blocks are allocated. Otherwise we search+ * rangelist for zero-fills+ */+ if ((MacToVFSError(retval) != ERANGE) ||+ (ap->a_flags & VNODE_WRITE) ||+ ((ap->a_flags & VNODE_READ) && (fp->ff_unallocblocks == 0))) {+ goto exit;+ }++ /* Validate if the start offset is within logical file size */+ if (ap->a_foffset >= fp->ff_size) {+ goto exit;+ }++ /*+ * At this point, we have encountered a failure during+ * MapFileBlockC that resulted in ERANGE, and we are not+ * servicing a write, and there are borrowed blocks.+ *+ * However, the cluster layer will not call blockmap for+ * blocks that are borrowed and in-cache. We have to assume+ * that because we observed ERANGE being emitted from+ * MapFileBlockC, this extent range is not valid on-disk. So+ * we treat this as a mapping that needs to be zero-filled+ * prior to reading.+ */++ if (fp->ff_size - ap->a_foffset < (off_t)bytesContAvail)+ bytesContAvail = fp->ff_size - ap->a_foffset;++ *ap->a_bpn = (daddr64_t) -1;+ retval = 0;++ goto exit;+ }++exit:+ if (retval == 0) {+ if (ISSET(ap->a_flags, VNODE_WRITE)) {+ struct rl_entry *r = TAILQ_FIRST(&fp->ff_invalidranges);++ // See if we might be overlapping invalid ranges...+ if (r && (ap->a_foffset + (off_t)bytesContAvail) > r->rl_start) {+ /*+ * Mark the file as needing an update if we think the+ * on-disk EOF has changed.+ */+ if (ap->a_foffset <= r->rl_start)+ SET(cp->c_flag, C_MODIFIED);++ /*+ * This isn't the ideal place to put this. Ideally, we+ * should do something *after* we have successfully+ * written to the range, but that's difficult to do+ * because we cannot take locks in the callback. At+ * present, the cluster code will call us with VNODE_WRITE+ * set just before it's about to write the data so we know+ * that data is about to be written. If we get an I/O+ * error at this point then chances are the metadata+ * update to follow will also have an I/O error so the+ * risk here is small.+ */+ rl_remove(ap->a_foffset, ap->a_foffset + bytesContAvail - 1,+ &fp->ff_invalidranges);++ if (!TAILQ_FIRST(&fp->ff_invalidranges)) {+ cp->c_flag &= ~C_ZFWANTSYNC;+ cp->c_zftimeout = 0;+ }+ }+ }++ if (ap->a_run)+ *ap->a_run = bytesContAvail;++ if (ap->a_poff)+ *(int *)ap->a_poff = 0;+ }++ if (started_tr) {+ hfs_update(vp, TRUE);+ hfs_volupdate(hfsmp, VOL_UPDATE, 0);+ hfs_end_transaction(hfsmp);+ started_tr = 0;+ }++ if (tooklock)+ hfs_unlock(cp);++ return (MacToVFSError(retval));+}++/*+ * prepare and issue the I/O+ * buf_strategy knows how to deal+ * with requests that require+ * fragmented I/Os+ */+int+hfs_vnop_strategy(struct vnop_strategy_args *ap)+{+ buf_t bp = ap->a_bp;+ vnode_t vp = buf_vnode(bp);+ int error = 0;++ /* Mark buffer as containing static data if cnode flag set */+ if (VTOC(vp)->c_flag & C_SSD_STATIC) {+ buf_markstatic(bp);+ }++ /* Mark buffer as containing static data if cnode flag set */+ if (VTOC(vp)->c_flag & C_SSD_GREEDY_MODE) {+ bufattr_markgreedymode(buf_attr(bp));+ }++ /* mark buffer as containing burst mode data if cnode flag set */+ if (VTOC(vp)->c_flag & C_IO_ISOCHRONOUS) {+ bufattr_markisochronous(buf_attr(bp));+ }++#if CONFIG_PROTECT+ error = cp_handle_strategy(bp);++ if (error)+ return error;+#endif++ error = buf_strategy(VTOHFS(vp)->hfs_devvp, ap);++ return error;+}++int+do_hfs_truncate(struct vnode *vp, off_t length, int flags, int truncateflags, vfs_context_t context)+{+ register struct cnode *cp = VTOC(vp);+ struct filefork *fp = VTOF(vp);+ kauth_cred_t cred = vfs_context_ucred(context);+ int retval;+ off_t bytesToAdd;+ off_t actualBytesAdded;+ off_t filebytes;+ u_int32_t fileblocks;+ int blksize;+ struct hfsmount *hfsmp;+ int lockflags;+ int suppress_times = (truncateflags & HFS_TRUNCATE_SKIPTIMES);++ blksize = VTOVCB(vp)->blockSize;+ fileblocks = fp->ff_blocks;+ filebytes = (off_t)fileblocks * (off_t)blksize;++ KERNEL_DEBUG(HFSDBG_TRUNCATE | DBG_FUNC_START,+ (int)length, (int)fp->ff_size, (int)filebytes, 0, 0);++ if (length < 0)+ return (EINVAL);++ /* This should only happen with a corrupt filesystem */+ if ((off_t)fp->ff_size < 0)+ return (EINVAL);++ if ((!ISHFSPLUS(VTOVCB(vp))) && (length > (off_t)MAXHFSFILESIZE))+ return (EFBIG);++ hfsmp = VTOHFS(vp);++ retval = E_NONE;++ /* Files that are changing size are not hot file candidates. */+ if (hfsmp->hfc_stage == HFC_RECORDING) {+ fp->ff_bytesread = 0;+ }++ /*+ * We cannot just check if fp->ff_size == length (as an optimization)+ * since there may be extra physical blocks that also need truncation.+ */+#if QUOTA+ if ((retval = hfs_getinoquota(cp)))+ return(retval);+#endif /* QUOTA */++ /*+ * Lengthen the size of the file. We must ensure that the+ * last byte of the file is allocated. Since the smallest+ * value of ff_size is 0, length will be at least 1.+ */+ if (length > (off_t)fp->ff_size) {+#if QUOTA+ retval = hfs_chkdq(cp, (int64_t)(roundup(length - filebytes, blksize)),+ cred, 0);+ if (retval)+ goto Err_Exit;+#endif /* QUOTA */+ /*+ * If we don't have enough physical space then+ * we need to extend the physical size.+ */+ if (length > filebytes) {+ int eflags;+ u_int32_t blockHint = 0;++ /* All or nothing and don't round up to clumpsize. */+ eflags = kEFAllMask | kEFNoClumpMask;++ if (cred && (suser(cred, NULL) != 0)) {+ eflags |= kEFReserveMask; /* keep a reserve */+ }++ /*+ * Allocate Journal and Quota files in metadata zone.+ */+ if (filebytes == 0 &&+ hfsmp->hfs_flags & HFS_METADATA_ZONE &&+ hfs_virtualmetafile(cp)) {+ eflags |= kEFMetadataMask;+ blockHint = hfsmp->hfs_metazone_start;+ }+ if (hfs_start_transaction(hfsmp) != 0) {+ retval = EINVAL;+ goto Err_Exit;+ }++ /* Protect extents b-tree and allocation bitmap */+ lockflags = SFL_BITMAP;+ if (overflow_extents(fp))+ lockflags |= SFL_EXTENTS;+ lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);++ /*+ * Keep growing the file as long as the current EOF is+ * less than the desired value.+ */+ while ((length > filebytes) && (retval == E_NONE)) {+ bytesToAdd = length - filebytes;+ retval = MacToVFSError(ExtendFileC(VTOVCB(vp),+ (FCB*)fp,+ bytesToAdd,+ blockHint,+ eflags,+ &actualBytesAdded));++ filebytes = (off_t)fp->ff_blocks * (off_t)blksize;+ if (actualBytesAdded == 0 && retval == E_NONE) {+ if (length > filebytes)+ length = filebytes;+ break;+ }+ } /* endwhile */++ hfs_systemfile_unlock(hfsmp, lockflags);++ if (hfsmp->jnl) {+ hfs_update(vp, 0);+ hfs_volupdate(hfsmp, VOL_UPDATE, 0);+ }++ hfs_end_transaction(hfsmp);++ if (retval)+ goto Err_Exit;++ KERNEL_DEBUG(HFSDBG_TRUNCATE | DBG_FUNC_NONE,+ (int)length, (int)fp->ff_size, (int)filebytes, 0, 0);+ }++ if (ISSET(flags, IO_NOZEROFILL)) {+ // An optimisation for the hibernation file+ if (vnode_isswap(vp))+ rl_remove_all(&fp->ff_invalidranges);+ } else {+ if (!vnode_issystem(vp) && retval == E_NONE) {+ if (length > (off_t)fp->ff_size) {+ struct timeval tv;++ /* Extending the file: time to fill out the current last page w. zeroes? */+ if (fp->ff_size & PAGE_MASK_64) {+ /* There might be some valid data at the start of the (current) last page+ of the file, so zero out the remainder of that page to ensure the+ entire page contains valid data. */+ hfs_unlock(cp);+ retval = hfs_zero_eof_page(vp, length);+ hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ if (retval) goto Err_Exit;+ }+ microuptime(&tv);+ rl_add(fp->ff_size, length - 1, &fp->ff_invalidranges);+ cp->c_zftimeout = tv.tv_sec + ZFTIMELIMIT;+ }+ } else {+ panic("hfs_truncate: invoked on non-UBC object?!");+ };+ }+ if (suppress_times == 0) {+ cp->c_touch_modtime = TRUE;+ }+ fp->ff_size = length;++ } else { /* Shorten the size of the file */++ // An optimisation for the hibernation file+ if (ISSET(flags, IO_NOZEROFILL) && vnode_isswap(vp)) {+ rl_remove_all(&fp->ff_invalidranges);+ } else if ((off_t)fp->ff_size > length) {+ /* Any space previously marked as invalid is now irrelevant: */+ rl_remove(length, fp->ff_size - 1, &fp->ff_invalidranges);+ }++ /*+ * Account for any unmapped blocks. Note that the new+ * file length can still end up with unmapped blocks.+ */+ if (fp->ff_unallocblocks > 0) {+ u_int32_t finalblks;+ u_int32_t loanedBlocks;++ hfs_lock_mount(hfsmp);+ loanedBlocks = fp->ff_unallocblocks;+ cp->c_blocks -= loanedBlocks;+ fp->ff_blocks -= loanedBlocks;+ fp->ff_unallocblocks = 0;++ hfsmp->loanedBlocks -= loanedBlocks;++ finalblks = (length + blksize - 1) / blksize;+ if (finalblks > fp->ff_blocks) {+ /* calculate required unmapped blocks */+ loanedBlocks = finalblks - fp->ff_blocks;+ hfsmp->loanedBlocks += loanedBlocks;++ fp->ff_unallocblocks = loanedBlocks;+ cp->c_blocks += loanedBlocks;+ fp->ff_blocks += loanedBlocks;+ }+ hfs_unlock_mount (hfsmp);+ }++ off_t savedbytes = ((off_t)fp->ff_blocks * (off_t)blksize);+ if (hfs_start_transaction(hfsmp) != 0) {+ retval = EINVAL;+ goto Err_Exit;+ }++ if (fp->ff_unallocblocks == 0) {+ /* Protect extents b-tree and allocation bitmap */+ lockflags = SFL_BITMAP;+ if (overflow_extents(fp))+ lockflags |= SFL_EXTENTS;+ lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);++ retval = MacToVFSError(TruncateFileC(VTOVCB(vp), (FCB*)fp, length, 0,+ FORK_IS_RSRC (fp), FTOC(fp)->c_fileid, false));++ hfs_systemfile_unlock(hfsmp, lockflags);+ }+ if (hfsmp->jnl) {+ if (retval == 0) {+ fp->ff_size = length;+ }+ hfs_update(vp, 0);+ hfs_volupdate(hfsmp, VOL_UPDATE, 0);+ }+ hfs_end_transaction(hfsmp);++ filebytes = (off_t)fp->ff_blocks * (off_t)blksize;+ if (retval)+ goto Err_Exit;+#if QUOTA+ /* These are bytesreleased */+ (void) hfs_chkdq(cp, (int64_t)-(savedbytes - filebytes), NOCRED, 0);+#endif /* QUOTA */++ //+ // Unlike when growing a file, we adjust the hotfile block count here+ // instead of deeper down in the block allocation code because we do+ // not necessarily have a vnode or "fcb" at the time we're deleting+ // the file and so we wouldn't know if it was hotfile cached or not+ //+ hfs_hotfile_adjust_blocks(vp, (int64_t)((savedbytes - filebytes) / blksize));+++ /*+ * Only set update flag if the logical length changes & we aren't+ * suppressing modtime updates.+ */+ if (((off_t)fp->ff_size != length) && (suppress_times == 0)) {+ cp->c_touch_modtime = TRUE;+ }+ fp->ff_size = length;+ }+ if (cp->c_mode & (S_ISUID | S_ISGID)) {+ if (!vfs_context_issuser(context))+ cp->c_mode &= ~(S_ISUID | S_ISGID);+ }+ cp->c_flag |= C_MODIFIED;+ cp->c_touch_chgtime = TRUE; /* status changed */+ if (suppress_times == 0) {+ cp->c_touch_modtime = TRUE; /* file data was modified */++ /*+ * If we are not suppressing the modtime update, then+ * update the gen count as well.+ */+ if (S_ISREG(cp->c_attr.ca_mode) || S_ISLNK (cp->c_attr.ca_mode)) {+ hfs_incr_gencount(cp);+ }+ }++ retval = hfs_update(vp, 0);+ if (retval) {+ KERNEL_DEBUG(HFSDBG_TRUNCATE | DBG_FUNC_NONE,+ -1, -1, -1, retval, 0);+ }++Err_Exit:++ KERNEL_DEBUG(HFSDBG_TRUNCATE | DBG_FUNC_END,+ (int)length, (int)fp->ff_size, (int)filebytes, retval, 0);++ return (retval);+}++/*+ * Preparation which must be done prior to deleting the catalog record+ * of a file or directory. In order to make the on-disk as safe as possible,+ * we remove the catalog entry before releasing the bitmap blocks and the+ * overflow extent records. However, some work must be done prior to deleting+ * the catalog record.+ *+ * When calling this function, the cnode must exist both in memory and on-disk.+ * If there are both resource fork and data fork vnodes, this function should+ * be called on both.+ */++int+hfs_prepare_release_storage (struct hfsmount *hfsmp, struct vnode *vp) {++ struct filefork *fp = VTOF(vp);+ struct cnode *cp = VTOC(vp);+#if QUOTA+ int retval = 0;+#endif /* QUOTA */++ /* Cannot truncate an HFS directory! */+ if (vnode_isdir(vp)) {+ return (EISDIR);+ }++ /*+ * See the comment below in hfs_truncate for why we need to call+ * setsize here. Essentially we want to avoid pending IO if we+ * already know that the blocks are going to be released here.+ * This function is only called when totally removing all storage for a file, so+ * we can take a shortcut and immediately setsize (0);+ */+ ubc_setsize(vp, 0);++ /* This should only happen with a corrupt filesystem */+ if ((off_t)fp->ff_size < 0)+ return (EINVAL);++ /*+ * We cannot just check if fp->ff_size == length (as an optimization)+ * since there may be extra physical blocks that also need truncation.+ */+#if QUOTA+ if ((retval = hfs_getinoquota(cp))) {+ return(retval);+ }+#endif /* QUOTA */++ /* Wipe out any invalid ranges which have yet to be backed by disk */+ rl_remove(0, fp->ff_size - 1, &fp->ff_invalidranges);++ /*+ * Account for any unmapped blocks. Since we're deleting the+ * entire file, we don't have to worry about just shrinking+ * to a smaller number of borrowed blocks.+ */+ if (fp->ff_unallocblocks > 0) {+ u_int32_t loanedBlocks;++ hfs_lock_mount (hfsmp);+ loanedBlocks = fp->ff_unallocblocks;+ cp->c_blocks -= loanedBlocks;+ fp->ff_blocks -= loanedBlocks;+ fp->ff_unallocblocks = 0;++ hfsmp->loanedBlocks -= loanedBlocks;++ hfs_unlock_mount (hfsmp);+ }++ return 0;+}+++/*+ * Special wrapper around calling TruncateFileC. This function is useable+ * even when the catalog record does not exist any longer, making it ideal+ * for use when deleting a file. The simplification here is that we know+ * that we are releasing all blocks.+ *+ * Note that this function may be called when there is no vnode backing+ * the file fork in question. We may call this from hfs_vnop_inactive+ * to clear out resource fork data (and may not want to clear out the data+ * fork yet). As a result, we pointer-check both sets of inputs before+ * doing anything with them.+ *+ * The caller is responsible for saving off a copy of the filefork(s)+ * embedded within the cnode prior to calling this function. The pointers+ * supplied as arguments must be valid even if the cnode is no longer valid.+ */++int+hfs_release_storage (struct hfsmount *hfsmp, struct filefork *datafork,+ struct filefork *rsrcfork, u_int32_t fileid) {++ off_t filebytes;+ u_int32_t fileblocks;+ int blksize = 0;+ int error = 0;+ int lockflags;++ blksize = hfsmp->blockSize;++ /* Data Fork */+ if (datafork) {+ off_t prev_filebytes;++ datafork->ff_size = 0;++ fileblocks = datafork->ff_blocks;+ filebytes = (off_t)fileblocks * (off_t)blksize;+ prev_filebytes = filebytes;++ /* We killed invalid ranges and loaned blocks before we removed the catalog entry */++ while (filebytes > 0) {+ if (filebytes > HFS_BIGFILE_SIZE) {+ filebytes -= HFS_BIGFILE_SIZE;+ } else {+ filebytes = 0;+ }++ /* Start a transaction, and wipe out as many blocks as we can in this iteration */+ if (hfs_start_transaction(hfsmp) != 0) {+ error = EINVAL;+ break;+ }++ if (datafork->ff_unallocblocks == 0) {+ /* Protect extents b-tree and allocation bitmap */+ lockflags = SFL_BITMAP;+ if (overflow_extents(datafork))+ lockflags |= SFL_EXTENTS;+ lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);++ error = MacToVFSError(TruncateFileC(HFSTOVCB(hfsmp), datafork, filebytes, 1, 0, fileid, false));++ hfs_systemfile_unlock(hfsmp, lockflags);+ }+ (void) hfs_volupdate(hfsmp, VOL_UPDATE, 0);++ struct cnode *cp = datafork ? FTOC(datafork) : NULL;+ struct vnode *vp;+ vp = cp ? CTOV(cp, 0) : NULL;+ hfs_hotfile_adjust_blocks(vp, (int64_t)((prev_filebytes - filebytes) / blksize));+ prev_filebytes = filebytes;++ /* Finish the transaction and start over if necessary */+ hfs_end_transaction(hfsmp);++ if (error) {+ break;+ }+ }+ }++ /* Resource fork */+ if (error == 0 && rsrcfork) {+ rsrcfork->ff_size = 0;++ fileblocks = rsrcfork->ff_blocks;+ filebytes = (off_t)fileblocks * (off_t)blksize;++ /* We killed invalid ranges and loaned blocks before we removed the catalog entry */++ while (filebytes > 0) {+ if (filebytes > HFS_BIGFILE_SIZE) {+ filebytes -= HFS_BIGFILE_SIZE;+ } else {+ filebytes = 0;+ }++ /* Start a transaction, and wipe out as many blocks as we can in this iteration */+ if (hfs_start_transaction(hfsmp) != 0) {+ error = EINVAL;+ break;+ }++ if (rsrcfork->ff_unallocblocks == 0) {+ /* Protect extents b-tree and allocation bitmap */+ lockflags = SFL_BITMAP;+ if (overflow_extents(rsrcfork))+ lockflags |= SFL_EXTENTS;+ lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);++ error = MacToVFSError(TruncateFileC(HFSTOVCB(hfsmp), rsrcfork, filebytes, 1, 1, fileid, false));++ hfs_systemfile_unlock(hfsmp, lockflags);+ }+ (void) hfs_volupdate(hfsmp, VOL_UPDATE, 0);++ /* Finish the transaction and start over if necessary */+ hfs_end_transaction(hfsmp);++ if (error) {+ break;+ }+ }+ }++ return error;+}++errno_t hfs_ubc_setsize(vnode_t vp, off_t len, bool have_cnode_lock)+{+ errno_t error;++ /*+ * Call ubc_setsize to give the VM subsystem a chance to do+ * whatever it needs to with existing pages before we delete+ * blocks. Note that symlinks don't use the UBC so we'll+ * get back ENOENT in that case.+ */+ if (have_cnode_lock) {+ error = ubc_setsize_ex(vp, len, UBC_SETSIZE_NO_FS_REENTRY);+ if (error == EAGAIN) {+ cnode_t *cp = VTOC(vp);++ if (cp->c_truncatelockowner != current_thread())+ hfs_warn("hfs: hfs_ubc_setsize called without exclusive truncate lock!");++ hfs_unlock(cp);+ error = ubc_setsize_ex(vp, len, 0);+ hfs_lock_always(cp, HFS_EXCLUSIVE_LOCK);+ }+ } else+ error = ubc_setsize_ex(vp, len, 0);++ return error == ENOENT ? 0 : error;+}++/*+ * Truncate a cnode to at most length size, freeing (or adding) the+ * disk blocks.+ */+int+hfs_truncate(struct vnode *vp, off_t length, int flags,+ int truncateflags, vfs_context_t context)+{+ struct filefork *fp = VTOF(vp);+ off_t filebytes;+ u_int32_t fileblocks;+ int blksize;+ errno_t error = 0;+ struct cnode *cp = VTOC(vp);+ hfsmount_t *hfsmp = VTOHFS(vp);++ /* Cannot truncate an HFS directory! */+ if (vnode_isdir(vp)) {+ return (EISDIR);+ }+ /* A swap file cannot change size. */+ if (vnode_isswap(vp) && length && !ISSET(flags, IO_NOAUTH)) {+ return (EPERM);+ }++ blksize = hfsmp->blockSize;+ fileblocks = fp->ff_blocks;+ filebytes = (off_t)fileblocks * (off_t)blksize;++ bool caller_has_cnode_lock = (cp->c_lockowner == current_thread());++ error = hfs_ubc_setsize(vp, length, caller_has_cnode_lock);+ if (error)+ return error;++ if (!caller_has_cnode_lock) {+ error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ if (error)+ return error;+ }++ if (vnode_islnk(vp) && cp->c_datafork->ff_symlinkptr) {+ hfs_free_data(cp->c_datafork->ff_symlinkptr, cp->c_datafork->ff_size);+ cp->c_datafork->ff_symlinkptr = NULL;+ }++ // have to loop truncating or growing files that are+ // really big because otherwise transactions can get+ // enormous and consume too many kernel resources.++ if (length < filebytes) {+ while (filebytes > length) {+ if ((filebytes - length) > HFS_BIGFILE_SIZE) {+ filebytes -= HFS_BIGFILE_SIZE;+ } else {+ filebytes = length;+ }+ error = do_hfs_truncate(vp, filebytes, flags, truncateflags, context);+ if (error)+ break;+ }+ } else if (length > filebytes) {+ kauth_cred_t cred = vfs_context_ucred(context);+ const bool keep_reserve = cred && suser(cred, NULL) != 0;++ if (hfs_freeblks(hfsmp, keep_reserve)+ < howmany(length - filebytes, blksize)) {+ error = ENOSPC;+ } else {+ while (filebytes < length) {+ if ((length - filebytes) > HFS_BIGFILE_SIZE) {+ filebytes += HFS_BIGFILE_SIZE;+ } else {+ filebytes = length;+ }+ error = do_hfs_truncate(vp, filebytes, flags, truncateflags, context);+ if (error)+ break;+ }+ }+ } else /* Same logical size */ {++ error = do_hfs_truncate(vp, length, flags, truncateflags, context);+ }+ /* Files that are changing size are not hot file candidates. */+ if (VTOHFS(vp)->hfc_stage == HFC_RECORDING) {+ fp->ff_bytesread = 0;+ }++#if HFS_CONFIG_KEY_ROLL+ if (!error && cp->c_truncatelockowner == current_thread()) {+ hfs_key_roll_check(cp, true);+ }+#endif++ if (!caller_has_cnode_lock)+ hfs_unlock(cp);++ // Make sure UBC's size matches up (in case we didn't completely succeed)+ errno_t err2 = hfs_ubc_setsize(vp, fp->ff_size, caller_has_cnode_lock);+ if (!error)+ error = err2;++ return error;+}+++/*+ * Preallocate file storage space.+ */+int+hfs_vnop_allocate(struct vnop_allocate_args /* {+ vnode_t a_vp;+ off_t a_length;+ u_int32_t a_flags;+ off_t *a_bytesallocated;+ off_t a_offset;+ vfs_context_t a_context;+ } */ *ap)+{+ struct vnode *vp = ap->a_vp;+ struct cnode *cp;+ struct filefork *fp;+ ExtendedVCB *vcb;+ off_t length = ap->a_length;+ off_t startingPEOF;+ off_t moreBytesRequested;+ off_t actualBytesAdded;+ off_t filebytes;+ u_int32_t fileblocks;+ int retval, retval2;+ u_int32_t blockHint;+ u_int32_t extendFlags; /* For call to ExtendFileC */+ struct hfsmount *hfsmp;+ kauth_cred_t cred = vfs_context_ucred(ap->a_context);+ int lockflags;+ time_t orig_ctime;++ *(ap->a_bytesallocated) = 0;++ if (!vnode_isreg(vp))+ return (EISDIR);+ if (length < (off_t)0)+ return (EINVAL);++ cp = VTOC(vp);++ orig_ctime = VTOC(vp)->c_ctime;++ nspace_snapshot_event(vp, orig_ctime, ap->a_length == 0 ? NAMESPACE_HANDLER_TRUNCATE_OP|NAMESPACE_HANDLER_DELETE_OP : NAMESPACE_HANDLER_TRUNCATE_OP, NULL);++ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);++ if ((retval = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ return (retval);+ }++ fp = VTOF(vp);+ hfsmp = VTOHFS(vp);+ vcb = VTOVCB(vp);++ fileblocks = fp->ff_blocks;+ filebytes = (off_t)fileblocks * (off_t)vcb->blockSize;++ if ((ap->a_flags & ALLOCATEFROMVOL) && (length < filebytes)) {+ retval = EINVAL;+ goto Err_Exit;+ }++ /* Fill in the flags word for the call to Extend the file */++ extendFlags = kEFNoClumpMask;+ if (ap->a_flags & ALLOCATECONTIG)+ extendFlags |= kEFContigMask;+ if (ap->a_flags & ALLOCATEALL)+ extendFlags |= kEFAllMask;+ if (cred && suser(cred, NULL) != 0)+ extendFlags |= kEFReserveMask;+ if (hfs_virtualmetafile(cp))+ extendFlags |= kEFMetadataMask;++ retval = E_NONE;+ blockHint = 0;+ startingPEOF = filebytes;++ if (ap->a_flags & ALLOCATEFROMPEOF)+ length += filebytes;+ else if (ap->a_flags & ALLOCATEFROMVOL)+ blockHint = ap->a_offset / VTOVCB(vp)->blockSize;++ /* If no changes are necesary, then we're done */+ if (filebytes == length)+ goto Std_Exit;++ /*+ * Lengthen the size of the file. We must ensure that the+ * last byte of the file is allocated. Since the smallest+ * value of filebytes is 0, length will be at least 1.+ */+ if (length > filebytes) {+ if (ISSET(extendFlags, kEFAllMask)+ && (hfs_freeblks(hfsmp, ISSET(extendFlags, kEFReserveMask))+ < howmany(length - filebytes, hfsmp->blockSize))) {+ retval = ENOSPC;+ goto Err_Exit;+ }++ off_t total_bytes_added = 0, orig_request_size;++ orig_request_size = moreBytesRequested = length - filebytes;++#if QUOTA+ retval = hfs_chkdq(cp,+ (int64_t)(roundup(moreBytesRequested, vcb->blockSize)),+ cred, 0);+ if (retval)+ goto Err_Exit;++#endif /* QUOTA */+ /*+ * Metadata zone checks.+ */+ if (hfsmp->hfs_flags & HFS_METADATA_ZONE) {+ /*+ * Allocate Journal and Quota files in metadata zone.+ */+ if (hfs_virtualmetafile(cp)) {+ blockHint = hfsmp->hfs_metazone_start;+ } else if ((blockHint >= hfsmp->hfs_metazone_start) &&+ (blockHint <= hfsmp->hfs_metazone_end)) {+ /*+ * Move blockHint outside metadata zone.+ */+ blockHint = hfsmp->hfs_metazone_end + 1;+ }+ }+++ while ((length > filebytes) && (retval == E_NONE)) {+ off_t bytesRequested;++ if (hfs_start_transaction(hfsmp) != 0) {+ retval = EINVAL;+ goto Err_Exit;+ }++ /* Protect extents b-tree and allocation bitmap */+ lockflags = SFL_BITMAP;+ if (overflow_extents(fp))+ lockflags |= SFL_EXTENTS;+ lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);++ if (moreBytesRequested >= HFS_BIGFILE_SIZE) {+ bytesRequested = HFS_BIGFILE_SIZE;+ } else {+ bytesRequested = moreBytesRequested;+ }++ if (extendFlags & kEFContigMask) {+ // if we're on a sparse device, this will force it to do a+ // full scan to find the space needed.+ hfsmp->hfs_flags &= ~HFS_DID_CONTIG_SCAN;+ }++ retval = MacToVFSError(ExtendFileC(vcb,+ (FCB*)fp,+ bytesRequested,+ blockHint,+ extendFlags,+ &actualBytesAdded));++ if (retval == E_NONE) {+ *(ap->a_bytesallocated) += actualBytesAdded;+ total_bytes_added += actualBytesAdded;+ moreBytesRequested -= actualBytesAdded;+ if (blockHint != 0) {+ blockHint += actualBytesAdded / vcb->blockSize;+ }+ }+ filebytes = (off_t)fp->ff_blocks * (off_t)vcb->blockSize;++ hfs_systemfile_unlock(hfsmp, lockflags);++ if (hfsmp->jnl) {+ (void) hfs_update(vp, 0);+ (void) hfs_volupdate(hfsmp, VOL_UPDATE, 0);+ }++ hfs_end_transaction(hfsmp);+ }+++ /*+ * if we get an error and no changes were made then exit+ * otherwise we must do the hfs_update to reflect the changes+ */+ if (retval && (startingPEOF == filebytes))+ goto Err_Exit;++ /*+ * Adjust actualBytesAdded to be allocation block aligned, not+ * clump size aligned.+ * NOTE: So what we are reporting does not affect reality+ * until the file is closed, when we truncate the file to allocation+ * block size.+ */+ if (total_bytes_added != 0 && orig_request_size < total_bytes_added)+ *(ap->a_bytesallocated) =+ roundup(orig_request_size, (off_t)vcb->blockSize);++ } else { /* Shorten the size of the file */++ /*+ * N.B. At present, this code is never called. If and when we+ * do start using it, it looks like there might be slightly+ * strange semantics with the file size: it's possible for the+ * file size to *increase* e.g. if current file size is 5,+ * length is 1024 and filebytes is 4096, the file size will+ * end up being 1024 bytes. This isn't necessarily a problem+ * but it's not consistent with the code above which doesn't+ * change the file size.+ */++ retval = hfs_truncate(vp, length, 0, 0, ap->a_context);+ filebytes = (off_t)fp->ff_blocks * (off_t)vcb->blockSize;++ /*+ * if we get an error and no changes were made then exit+ * otherwise we must do the hfs_update to reflect the changes+ */+ if (retval && (startingPEOF == filebytes)) goto Err_Exit;+#if QUOTA+ /* These are bytesreleased */+ (void) hfs_chkdq(cp, (int64_t)-((startingPEOF - filebytes)), NOCRED,0);+#endif /* QUOTA */++ if (fp->ff_size > filebytes) {+ fp->ff_size = filebytes;++ hfs_ubc_setsize(vp, fp->ff_size, true);+ }+ }++Std_Exit:+ cp->c_flag |= C_MODIFIED;+ cp->c_touch_chgtime = TRUE;+ cp->c_touch_modtime = TRUE;+ retval2 = hfs_update(vp, 0);++ if (retval == 0)+ retval = retval2;+Err_Exit:+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ hfs_unlock(cp);+ return (retval);+}+++/*+ * Pagein for HFS filesystem+ */+int+hfs_vnop_pagein(struct vnop_pagein_args *ap)+/*+ struct vnop_pagein_args {+ vnode_t a_vp,+ upl_t a_pl,+ vm_offset_t a_pl_offset,+ off_t a_f_offset,+ size_t a_size,+ int a_flags+ vfs_context_t a_context;+ };+*/+{+ vnode_t vp;+ struct cnode *cp;+ struct filefork *fp;+ int error = 0;+ upl_t upl;+ upl_page_info_t *pl;+ off_t f_offset;+ off_t page_needed_f_offset;+ int offset;+ int isize;+ int upl_size;+ int pg_index;+ boolean_t truncate_lock_held = FALSE;+ boolean_t file_converted = FALSE;+ kern_return_t kret;++ vp = ap->a_vp;+ cp = VTOC(vp);+ fp = VTOF(vp);++#if CONFIG_PROTECT+ if ((error = cp_handle_vnop(vp, CP_READ_ACCESS | CP_WRITE_ACCESS, 0)) != 0) {+ /*+ * If we errored here, then this means that one of two things occurred:+ * 1. there was a problem with the decryption of the key.+ * 2. the device is locked and we are not allowed to access this particular file.+ *+ * Either way, this means that we need to shut down this upl now. As long as+ * the pl pointer is NULL (meaning that we're supposed to create the UPL ourselves)+ * then we create a upl and immediately abort it.+ */+ if (ap->a_pl == NULL) {+ /* create the upl */+ ubc_create_upl (vp, ap->a_f_offset, ap->a_size, &upl, &pl,+ UPL_UBC_PAGEIN | UPL_RET_ONLY_ABSENT);+ /* mark the range as needed so it doesn't immediately get discarded upon abort */+ ubc_upl_range_needed (upl, ap->a_pl_offset / PAGE_SIZE, 1);++ /* Abort the range */+ ubc_upl_abort_range (upl, 0, ap->a_size, UPL_ABORT_FREE_ON_EMPTY | UPL_ABORT_ERROR);+ }+++ return error;+ }+#endif /* CONFIG_PROTECT */++ if (ap->a_pl != NULL) {+ /*+ * this can only happen for swap files now that+ * we're asking for V2 paging behavior...+ * so don't need to worry about decompression, or+ * keeping track of blocks read or taking the truncate lock+ */+ error = cluster_pagein(vp, ap->a_pl, ap->a_pl_offset, ap->a_f_offset,+ ap->a_size, (off_t)fp->ff_size, ap->a_flags);+ goto pagein_done;+ }++ page_needed_f_offset = ap->a_f_offset + ap->a_pl_offset;++retry_pagein:+ /*+ * take truncate lock (shared/recursive) to guard against+ * zero-fill thru fsync interfering, but only for v2+ *+ * the HFS_RECURSE_TRUNCLOCK arg indicates that we want the+ * lock shared and we are allowed to recurse 1 level if this thread already+ * owns the lock exclusively... this can legally occur+ * if we are doing a shrinking ftruncate against a file+ * that is mapped private, and the pages being truncated+ * do not currently exist in the cache... in that case+ * we will have to page-in the missing pages in order+ * to provide them to the private mapping... we must+ * also call hfs_unlock_truncate with a postive been_recursed+ * arg to indicate that if we have recursed, there is no need to drop+ * the lock. Allowing this simple recursion is necessary+ * in order to avoid a certain deadlock... since the ftruncate+ * already holds the truncate lock exclusively, if we try+ * to acquire it shared to protect the pagein path, we will+ * hang this thread+ *+ * NOTE: The if () block below is a workaround in order to prevent a+ * VM deadlock. See rdar://7853471.+ *+ * If we are in a forced unmount, then launchd will still have the+ * dyld_shared_cache file mapped as it is trying to reboot. If we+ * take the truncate lock here to service a page fault, then our+ * thread could deadlock with the forced-unmount. The forced unmount+ * thread will try to reclaim the dyld_shared_cache vnode, but since it's+ * marked C_DELETED, it will call ubc_setsize(0). As a result, the unmount+ * thread will think it needs to copy all of the data out of the file+ * and into a VM copy object. If we hold the cnode lock here, then that+ * VM operation will not be able to proceed, because we'll set a busy page+ * before attempting to grab the lock. Note that this isn't as simple as "don't+ * call ubc_setsize" because doing that would just shift the problem to the+ * ubc_msync done before the vnode is reclaimed.+ *+ * So, if a forced unmount on this volume is in flight AND the cnode is+ * marked C_DELETED, then just go ahead and do the page in without taking+ * the lock (thus suspending pagein_v2 semantics temporarily). Since it's on a file+ * that is not going to be available on the next mount, this seems like a+ * OK solution from a correctness point of view, even though it is hacky.+ */+ if (vfs_isforce(vnode_mount(vp))) {+ if (cp->c_flag & C_DELETED) {+ /* If we don't get it, then just go ahead and operate without the lock */+ truncate_lock_held = hfs_try_trunclock(cp, HFS_SHARED_LOCK, HFS_LOCK_SKIP_IF_EXCLUSIVE);+ }+ }+ else {+ hfs_lock_truncate(cp, HFS_SHARED_LOCK, HFS_LOCK_SKIP_IF_EXCLUSIVE);+ truncate_lock_held = TRUE;+ }++ kret = ubc_create_upl(vp, ap->a_f_offset, ap->a_size, &upl, &pl, UPL_UBC_PAGEIN | UPL_RET_ONLY_ABSENT);++ if ((kret != KERN_SUCCESS) || (upl == (upl_t) NULL)) {+ error = EINVAL;+ goto pagein_done;+ }+ ubc_upl_range_needed(upl, ap->a_pl_offset / PAGE_SIZE, 1);++ upl_size = isize = ap->a_size;++ /*+ * Scan from the back to find the last page in the UPL, so that we+ * aren't looking at a UPL that may have already been freed by the+ * preceding aborts/completions.+ */+ for (pg_index = ((isize) / PAGE_SIZE); pg_index > 0;) {+ if (upl_page_present(pl, --pg_index))+ break;+ if (pg_index == 0) {+ /*+ * no absent pages were found in the range specified+ * just abort the UPL to get rid of it and then we're done+ */+ ubc_upl_abort_range(upl, 0, isize, UPL_ABORT_FREE_ON_EMPTY);+ goto pagein_done;+ }+ }+ /*+ * initialize the offset variables before we touch the UPL.+ * f_offset is the position into the file, in bytes+ * offset is the position into the UPL, in bytes+ * pg_index is the pg# of the UPL we're operating on+ * isize is the offset into the UPL of the last page that is present.+ */+ isize = ((pg_index + 1) * PAGE_SIZE);+ pg_index = 0;+ offset = 0;+ f_offset = ap->a_f_offset;++ while (isize) {+ int xsize;+ int num_of_pages;++ if ( !upl_page_present(pl, pg_index)) {+ /*+ * we asked for RET_ONLY_ABSENT, so it's possible+ * to get back empty slots in the UPL.+ * just skip over them+ */+ f_offset += PAGE_SIZE;+ offset += PAGE_SIZE;+ isize -= PAGE_SIZE;+ pg_index++;++ continue;+ }+ /*+ * We know that we have at least one absent page.+ * Now checking to see how many in a row we have+ */+ num_of_pages = 1;+ xsize = isize - PAGE_SIZE;++ while (xsize) {+ if ( !upl_page_present(pl, pg_index + num_of_pages))+ break;+ num_of_pages++;+ xsize -= PAGE_SIZE;+ }+ xsize = num_of_pages * PAGE_SIZE;++#if HFS_COMPRESSION+ if (VNODE_IS_RSRC(vp)) {+ /* allow pageins of the resource fork */+ } else {+ int compressed = hfs_file_is_compressed(VTOC(vp), 1); /* 1 == don't take the cnode lock */++ if (compressed) {++ if (truncate_lock_held) {+ /*+ * can't hold the truncate lock when calling into the decmpfs layer+ * since it calls back into this layer... even though we're only+ * holding the lock in shared mode, and the re-entrant path only+ * takes the lock shared, we can deadlock if some other thread+ * tries to grab the lock exclusively in between.+ */+ hfs_unlock_truncate(cp, HFS_LOCK_SKIP_IF_EXCLUSIVE);+ truncate_lock_held = FALSE;+ }+ ap->a_pl = upl;+ ap->a_pl_offset = offset;+ ap->a_f_offset = f_offset;+ ap->a_size = xsize;++ error = decmpfs_pagein_compressed(ap, &compressed, VTOCMP(vp));+ /*+ * note that decpfs_pagein_compressed can change the state of+ * 'compressed'... it will set it to 0 if the file is no longer+ * compressed once the compression lock is successfully taken+ * i.e. we would block on that lock while the file is being inflated+ */+ if (error == 0 && vnode_isfastdevicecandidate(vp)) {+ (void) hfs_addhotfile(vp);+ }+ if (compressed) {+ if (error == 0) {+ /* successful page-in, update the access time */+ VTOC(vp)->c_touch_acctime = TRUE;++ //+ // compressed files are not traditional hot file candidates+ // but they may be for CF (which ignores the ff_bytesread+ // field)+ //+ if (VTOHFS(vp)->hfc_stage == HFC_RECORDING) {+ fp->ff_bytesread = 0;+ }+ } else if (error == EAGAIN) {+ /*+ * EAGAIN indicates someone else already holds the compression lock...+ * to avoid deadlocking, we'll abort this range of pages with an+ * indication that the pagein needs to be redriven+ */+ ubc_upl_abort_range(upl, (upl_offset_t) offset, xsize, UPL_ABORT_FREE_ON_EMPTY | UPL_ABORT_RESTART);+ } else if (error == ENOSPC) {++ if (upl_size == PAGE_SIZE)+ panic("decmpfs_pagein_compressed: couldn't ubc_upl_map a single page\n");++ ubc_upl_abort_range(upl, (upl_offset_t) offset, isize, UPL_ABORT_FREE_ON_EMPTY);++ ap->a_size = PAGE_SIZE;+ ap->a_pl = NULL;+ ap->a_pl_offset = 0;+ ap->a_f_offset = page_needed_f_offset;++ goto retry_pagein;+ } else {+ ubc_upl_abort(upl, UPL_ABORT_FREE_ON_EMPTY | UPL_ABORT_ERROR);+ goto pagein_done;+ }+ goto pagein_next_range;+ }+ else {+ /*+ * Set file_converted only if the file became decompressed while we were+ * paging in. If it were still compressed, we would re-start the loop using the goto+ * in the above block. This avoid us overloading truncate_lock_held as our retry_pagein+ * condition below, since we could have avoided taking the truncate lock to prevent+ * a deadlock in the force unmount case.+ */+ file_converted = TRUE;+ }+ }+ if (file_converted == TRUE) {+ /*+ * the file was converted back to a regular file after we first saw it as compressed+ * we need to abort the upl, retake the truncate lock, recreate the UPL and start over+ * reset a_size so that we consider what remains of the original request+ * and null out a_upl and a_pl_offset.+ *+ * We should only be able to get into this block if the decmpfs_pagein_compressed+ * successfully decompressed the range in question for this file.+ */+ ubc_upl_abort_range(upl, (upl_offset_t) offset, isize, UPL_ABORT_FREE_ON_EMPTY);++ ap->a_size = isize;+ ap->a_pl = NULL;+ ap->a_pl_offset = 0;++ /* Reset file_converted back to false so that we don't infinite-loop. */+ file_converted = FALSE;+ goto retry_pagein;+ }+ }+#endif+ error = cluster_pagein(vp, upl, offset, f_offset, xsize, (off_t)fp->ff_size, ap->a_flags);++ /*+ * Keep track of blocks read.+ */+ if ( !vnode_isswap(vp) && VTOHFS(vp)->hfc_stage == HFC_RECORDING && error == 0) {+ int bytesread;+ int took_cnode_lock = 0;++ if (ap->a_f_offset == 0 && fp->ff_size < PAGE_SIZE)+ bytesread = fp->ff_size;+ else+ bytesread = xsize;++ /* When ff_bytesread exceeds 32-bits, update it behind the cnode lock. */+ if ((fp->ff_bytesread + bytesread) > 0x00000000ffffffff && cp->c_lockowner != current_thread()) {+ hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ took_cnode_lock = 1;+ }+ /*+ * If this file hasn't been seen since the start of+ * the current sampling period then start over.+ */+ if (cp->c_atime < VTOHFS(vp)->hfc_timebase) {+ struct timeval tv;++ fp->ff_bytesread = bytesread;+ microtime(&tv);+ cp->c_atime = tv.tv_sec;+ } else {+ fp->ff_bytesread += bytesread;+ }+ cp->c_touch_acctime = TRUE;++ if (vnode_isfastdevicecandidate(vp)) {+ (void) hfs_addhotfile(vp);+ }+ if (took_cnode_lock)+ hfs_unlock(cp);+ }+pagein_next_range:+ f_offset += xsize;+ offset += xsize;+ isize -= xsize;+ pg_index += num_of_pages;++ error = 0;+ }++pagein_done:+ if (truncate_lock_held == TRUE) {+ /* Note 1 is passed to hfs_unlock_truncate in been_recursed argument */+ hfs_unlock_truncate(cp, HFS_LOCK_SKIP_IF_EXCLUSIVE);+ }++ return (error);+}++/*+ * Pageout for HFS filesystem.+ */+int+hfs_vnop_pageout(struct vnop_pageout_args *ap)+/*+ struct vnop_pageout_args {+ vnode_t a_vp,+ upl_t a_pl,+ vm_offset_t a_pl_offset,+ off_t a_f_offset,+ size_t a_size,+ int a_flags+ vfs_context_t a_context;+ };+*/+{+ vnode_t vp = ap->a_vp;+ struct cnode *cp;+ struct filefork *fp;+ int retval = 0;+ off_t filesize;+ upl_t upl;+ upl_page_info_t* pl = NULL;+ vm_offset_t a_pl_offset;+ int a_flags;+ int is_pageoutv2 = 0;+ kern_return_t kret;++ cp = VTOC(vp);+ fp = VTOF(vp);++ a_flags = ap->a_flags;+ a_pl_offset = ap->a_pl_offset;++ /*+ * we can tell if we're getting the new or old behavior from the UPL+ */+ if ((upl = ap->a_pl) == NULL) {+ int request_flags;++ is_pageoutv2 = 1;+ /*+ * we're in control of any UPL we commit+ * make sure someone hasn't accidentally passed in UPL_NOCOMMIT+ */+ a_flags &= ~UPL_NOCOMMIT;+ a_pl_offset = 0;++ /*+ * For V2 semantics, we want to take the cnode truncate lock+ * shared to guard against the file size changing via zero-filling.+ *+ * However, we have to be careful because we may be invoked+ * via the ubc_msync path to write out dirty mmap'd pages+ * in response to a lock event on a content-protected+ * filesystem (e.g. to write out class A files).+ * As a result, we want to take the truncate lock 'SHARED' with+ * the mini-recursion locktype so that we don't deadlock/panic+ * because we may be already holding the truncate lock exclusive to force any other+ * IOs to have blocked behind us.+ */+ hfs_lock_truncate(cp, HFS_SHARED_LOCK, HFS_LOCK_SKIP_IF_EXCLUSIVE);++ if (a_flags & UPL_MSYNC) {+ request_flags = UPL_UBC_MSYNC | UPL_RET_ONLY_DIRTY;+ }+ else {+ request_flags = UPL_UBC_PAGEOUT | UPL_RET_ONLY_DIRTY;+ }++ kret = ubc_create_upl(vp, ap->a_f_offset, ap->a_size, &upl, &pl, request_flags);++ if ((kret != KERN_SUCCESS) || (upl == (upl_t) NULL)) {+ retval = EINVAL;+ goto pageout_done;+ }+ }+ /*+ * from this point forward upl points at the UPL we're working with+ * it was either passed in or we succesfully created it+ */++ /*+ * Figure out where the file ends, for pageout purposes. If+ * ff_new_size > ff_size, then we're in the middle of extending the+ * file via a write, so it is safe (and necessary) that we be able+ * to pageout up to that point.+ */+ filesize = fp->ff_size;+ if (fp->ff_new_size > filesize)+ filesize = fp->ff_new_size;++ /*+ * Now that HFS is opting into VFC_VFSVNOP_PAGEOUTV2, we may need to operate on our own+ * UPL instead of relying on the UPL passed into us. We go ahead and do that here,+ * scanning for dirty ranges. We'll issue our own N cluster_pageout calls, for+ * N dirty ranges in the UPL. Note that this is almost a direct copy of the+ * logic in vnode_pageout except that we need to do it after grabbing the truncate+ * lock in HFS so that we don't lock invert ourselves.+ *+ * Note that we can still get into this function on behalf of the default pager with+ * non-V2 behavior (swapfiles). However in that case, we did not grab locks above+ * since fsync and other writing threads will grab the locks, then mark the+ * relevant pages as busy. But the pageout codepath marks the pages as busy,+ * and THEN would attempt to grab the truncate lock, which would result in deadlock. So+ * we do not try to grab anything for the pre-V2 case, which should only be accessed+ * by the paging/VM system.+ */++ if (is_pageoutv2) {+ off_t f_offset;+ int offset;+ int isize;+ int pg_index;+ int error;+ int error_ret = 0;++ isize = ap->a_size;+ f_offset = ap->a_f_offset;++ /*+ * Scan from the back to find the last page in the UPL, so that we+ * aren't looking at a UPL that may have already been freed by the+ * preceding aborts/completions.+ */+ for (pg_index = ((isize) / PAGE_SIZE); pg_index > 0;) {+ if (upl_page_present(pl, --pg_index))+ break;+ if (pg_index == 0) {+ ubc_upl_abort_range(upl, 0, isize, UPL_ABORT_FREE_ON_EMPTY);+ goto pageout_done;+ }+ }++ /*+ * initialize the offset variables before we touch the UPL.+ * a_f_offset is the position into the file, in bytes+ * offset is the position into the UPL, in bytes+ * pg_index is the pg# of the UPL we're operating on.+ * isize is the offset into the UPL of the last non-clean page.+ */+ isize = ((pg_index + 1) * PAGE_SIZE);++ offset = 0;+ pg_index = 0;++ while (isize) {+ int xsize;+ int num_of_pages;++ if ( !upl_page_present(pl, pg_index)) {+ /*+ * we asked for RET_ONLY_DIRTY, so it's possible+ * to get back empty slots in the UPL.+ * just skip over them+ */+ f_offset += PAGE_SIZE;+ offset += PAGE_SIZE;+ isize -= PAGE_SIZE;+ pg_index++;++ continue;+ }+ if ( !upl_dirty_page(pl, pg_index)) {+ panic ("hfs_vnop_pageout: unforeseen clean page @ index %d for UPL %p\n", pg_index, upl);+ }++ /*+ * We know that we have at least one dirty page.+ * Now checking to see how many in a row we have+ */+ num_of_pages = 1;+ xsize = isize - PAGE_SIZE;++ while (xsize) {+ if ( !upl_dirty_page(pl, pg_index + num_of_pages))+ break;+ num_of_pages++;+ xsize -= PAGE_SIZE;+ }+ xsize = num_of_pages * PAGE_SIZE;++ if ((error = cluster_pageout(vp, upl, offset, f_offset,+ xsize, filesize, a_flags))) {+ if (error_ret == 0)+ error_ret = error;+ }+ f_offset += xsize;+ offset += xsize;+ isize -= xsize;+ pg_index += num_of_pages;+ }+ /* capture errnos bubbled out of cluster_pageout if they occurred */+ if (error_ret != 0) {+ retval = error_ret;+ }+ } /* end block for v2 pageout behavior */+ else {+ /*+ * just call cluster_pageout for old pre-v2 behavior+ */+ retval = cluster_pageout(vp, upl, a_pl_offset, ap->a_f_offset,+ ap->a_size, filesize, a_flags);+ }++ /*+ * If data was written, update the modification time of the file+ * but only if it's mapped writable; we will have touched the+ * modifcation time for direct writes.+ */+ if (retval == 0 && (ubc_is_mapped_writable(vp)+ || ISSET(cp->c_flag, C_MIGHT_BE_DIRTY_FROM_MAPPING))) {+ hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);++ // Check again with lock+ bool mapped_writable = ubc_is_mapped_writable(vp);+ if (mapped_writable+ || ISSET(cp->c_flag, C_MIGHT_BE_DIRTY_FROM_MAPPING)) {+ cp->c_touch_modtime = TRUE;+ cp->c_touch_chgtime = TRUE;++ /*+ * We only need to increment the generation counter if+ * it's currently mapped writable because we incremented+ * the counter in hfs_vnop_mnomap.+ */+ if (mapped_writable)+ hfs_incr_gencount(VTOC(vp));++ /*+ * If setuid or setgid bits are set and this process is+ * not the superuser then clear the setuid and setgid bits+ * as a precaution against tampering.+ */+ if ((cp->c_mode & (S_ISUID | S_ISGID)) &&+ (vfs_context_suser(ap->a_context) != 0)) {+ cp->c_mode &= ~(S_ISUID | S_ISGID);+ }+ }++ hfs_unlock(cp);+ }++pageout_done:+ if (is_pageoutv2) {+ /*+ * Release the truncate lock. Note that because+ * we may have taken the lock recursively by+ * being invoked via ubc_msync due to lockdown,+ * we should release it recursively, too.+ */+ hfs_unlock_truncate(cp, HFS_LOCK_SKIP_IF_EXCLUSIVE);+ }+ return (retval);+}++/*+ * Intercept B-Tree node writes to unswap them if necessary.+ */+int+hfs_vnop_bwrite(struct vnop_bwrite_args *ap)+{+ int retval = 0;+ register struct buf *bp = ap->a_bp;+ register struct vnode *vp = buf_vnode(bp);+ BlockDescriptor block;++ /* Trap B-Tree writes */+ if ((VTOC(vp)->c_fileid == kHFSExtentsFileID) ||+ (VTOC(vp)->c_fileid == kHFSCatalogFileID) ||+ (VTOC(vp)->c_fileid == kHFSAttributesFileID) ||+ (vp == VTOHFS(vp)->hfc_filevp)) {++ /*+ * Swap and validate the node if it is in native byte order.+ * This is always be true on big endian, so we always validate+ * before writing here. On little endian, the node typically has+ * been swapped and validated when it was written to the journal,+ * so we won't do anything here.+ */+ if (((u_int16_t *)((char *)buf_dataptr(bp) + buf_count(bp) - 2))[0] == 0x000e) {+ /* Prepare the block pointer */+ block.blockHeader = bp;+ block.buffer = (char *)buf_dataptr(bp);+ block.blockNum = buf_lblkno(bp);+ /* not found in cache ==> came from disk */+ block.blockReadFromDisk = (buf_fromcache(bp) == 0);+ block.blockSize = buf_count(bp);++ /* Endian un-swap B-Tree node */+ retval = hfs_swap_BTNode (&block, vp, kSwapBTNodeHostToBig, false);+ if (retval)+ panic("hfs_vnop_bwrite: about to write corrupt node!\n");+ }+ }++ /* This buffer shouldn't be locked anymore but if it is clear it */+ if ((buf_flags(bp) & B_LOCKED)) {+ // XXXdbg+ if (VTOHFS(vp)->jnl) {+ panic("hfs: CLEARING the lock bit on bp %p\n", bp);+ }+ buf_clearflags(bp, B_LOCKED);+ }+ retval = vn_bwrite (ap);++ return (retval);+}+++int+hfs_pin_block_range(struct hfsmount *hfsmp, int pin_state, uint32_t start_block, uint32_t nblocks)+{+ _dk_cs_pin_t pin;+ unsigned ioc;+ int err;++ memset(&pin, 0, sizeof(pin));+ pin.cp_extent.offset = ((uint64_t)start_block) * HFSTOVCB(hfsmp)->blockSize;+ pin.cp_extent.length = ((uint64_t)nblocks) * HFSTOVCB(hfsmp)->blockSize;+ switch (pin_state) {+ case HFS_PIN_IT:+ ioc = _DKIOCCSPINEXTENT;+ pin.cp_flags = _DKIOCCSPINTOFASTMEDIA;+ break;+ case HFS_PIN_IT | HFS_TEMP_PIN:+ ioc = _DKIOCCSPINEXTENT;+ pin.cp_flags = _DKIOCCSPINTOFASTMEDIA | _DKIOCCSTEMPORARYPIN;+ break;+ case HFS_PIN_IT | HFS_DATALESS_PIN:+ ioc = _DKIOCCSPINEXTENT;+ pin.cp_flags = _DKIOCCSPINTOFASTMEDIA | _DKIOCCSPINFORSWAPFILE;+ break;+ case HFS_UNPIN_IT:+ ioc = _DKIOCCSUNPINEXTENT;+ pin.cp_flags = 0;+ break;+ case HFS_UNPIN_IT | HFS_EVICT_PIN:+ ioc = _DKIOCCSPINEXTENT;+ pin.cp_flags = _DKIOCCSPINTOSLOWMEDIA;+ break;+ default:+ return EINVAL;+ }+ err = VNOP_IOCTL(hfsmp->hfs_devvp, ioc, (caddr_t)&pin, 0, vfs_context_kernel());+ return err;+}++//+// The cnode lock should already be held on entry to this function+//+int+hfs_pin_vnode(struct hfsmount *hfsmp, struct vnode *vp, int pin_state, uint32_t *num_blocks_pinned)+{+ struct filefork *fp = VTOF(vp);+ int i, err=0, need_put=0;+ struct vnode *rsrc_vp=NULL;+ uint32_t npinned = 0;+ off_t offset;++ if (num_blocks_pinned) {+ *num_blocks_pinned = 0;+ }++ if (vnode_vtype(vp) != VREG) {+ /* Not allowed to pin directories or symlinks */+ printf("hfs: can't pin vnode of type %d\n", vnode_vtype(vp));+ return (EPERM);+ }++ if (fp->ff_unallocblocks) {+ printf("hfs: can't pin a vnode w/unalloced blocks (%d)\n", fp->ff_unallocblocks);+ return (EINVAL);+ }++ /*+ * It is possible that if the caller unlocked/re-locked the cnode after checking+ * for C_NOEXISTS|C_DELETED that the file could have been deleted while the+ * cnode was unlocked. So check the condition again and return ENOENT so that+ * the caller knows why we failed to pin the vnode.+ */+ if (VTOC(vp)->c_flag & (C_NOEXISTS|C_DELETED)) {+ // makes no sense to pin something that's pending deletion+ return ENOENT;+ }++ if (fp->ff_blocks == 0 && (VTOC(vp)->c_bsdflags & UF_COMPRESSED)) {+ if (!VNODE_IS_RSRC(vp) && hfs_vgetrsrc(hfsmp, vp, &rsrc_vp) == 0) {+ //printf("hfs: fileid %d resource fork nblocks: %d / size: %lld\n", VTOC(vp)->c_fileid,+ // VTOC(rsrc_vp)->c_rsrcfork->ff_blocks,VTOC(rsrc_vp)->c_rsrcfork->ff_size);++ fp = VTOC(rsrc_vp)->c_rsrcfork;+ need_put = 1;+ }+ }+ if (fp->ff_blocks == 0) {+ if (need_put) {+ //+ // use a distinct error code for a compressed file that has no resource fork;+ // we return EALREADY to indicate that the data is already probably hot file+ // cached because it's in an EA and the attributes btree is on the ssd+ //+ err = EALREADY;+ } else {+ err = EINVAL;+ }+ goto out;+ }++ offset = 0;+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ if (fp->ff_extents[i].startBlock == 0) {+ break;+ }++ err = hfs_pin_block_range(hfsmp, pin_state, fp->ff_extents[i].startBlock, fp->ff_extents[i].blockCount);+ if (err) {+ break;+ } else {+ npinned += fp->ff_extents[i].blockCount;+ }+ }++ if (err || npinned == 0) {+ goto out;+ }++ if (fp->ff_extents[kHFSPlusExtentDensity-1].startBlock) {+ uint32_t pblocks;+ uint8_t forktype = 0;++ if (fp == VTOC(vp)->c_rsrcfork) {+ forktype = 0xff;+ }+ /*+ * The file could have overflow extents, better pin them.+ *+ * We assume that since we are holding the cnode lock for this cnode,+ * the files extents cannot be manipulated, but the tree could, so we+ * need to ensure that it doesn't change behind our back as we iterate it.+ */+ int lockflags = hfs_systemfile_lock (hfsmp, SFL_EXTENTS, HFS_SHARED_LOCK);+ err = hfs_pin_overflow_extents(hfsmp, VTOC(vp)->c_fileid, forktype, &pblocks);+ hfs_systemfile_unlock (hfsmp, lockflags);++ if (err) {+ goto out;+ }+ npinned += pblocks;+ }++out:+ if (num_blocks_pinned) {+ *num_blocks_pinned = npinned;+ }++ if (need_put && rsrc_vp) {+ //+ // have to unlock the cnode since it's shared between the+ // resource fork vnode and the data fork vnode (and the+ // vnode_put() may need to re-acquire the cnode lock to+ // reclaim the resource fork vnode)+ //+ hfs_unlock(VTOC(vp));+ vnode_put(rsrc_vp);+ hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ }+ return err;+}+++/*+ * Relocate a file to a new location on disk+ * cnode must be locked on entry+ *+ * Relocation occurs by cloning the file's data from its+ * current set of blocks to a new set of blocks. During+ * the relocation all of the blocks (old and new) are+ * owned by the file.+ *+ * -----------------+ * |///////////////|+ * -----------------+ * 0 N (file offset)+ *+ * ----------------- -----------------+ * |///////////////| | | STEP 1 (acquire new blocks)+ * ----------------- -----------------+ * 0 N N+1 2N+ *+ * ----------------- -----------------+ * |///////////////| |///////////////| STEP 2 (clone data)+ * ----------------- -----------------+ * 0 N N+1 2N+ *+ * -----------------+ * |///////////////| STEP 3 (head truncate blocks)+ * -----------------+ * 0 N+ *+ * During steps 2 and 3 page-outs to file offsets less+ * than or equal to N are suspended.+ *+ * During step 3 page-ins to the file get suspended.+ */+int+hfs_relocate(struct vnode *vp, u_int32_t blockHint, kauth_cred_t cred,+ struct proc *p)+{+ struct cnode *cp;+ struct filefork *fp;+ struct hfsmount *hfsmp;+ u_int32_t headblks;+ u_int32_t datablks;+ u_int32_t blksize;+ u_int32_t growsize;+ u_int32_t nextallocsave;+ daddr64_t sector_a, sector_b;+ int eflags = 0;+ off_t newbytes;+ int retval;+ int lockflags = 0;+ int took_trunc_lock = 0;+ int started_tr = 0;+ enum vtype vnodetype;++ vnodetype = vnode_vtype(vp);+ if (vnodetype != VREG) {+ /* Not allowed to move symlinks. */+ return (EPERM);+ }++ hfsmp = VTOHFS(vp);+ if (hfsmp->hfs_flags & HFS_FRAGMENTED_FREESPACE) {+ return (ENOSPC);+ }++ cp = VTOC(vp);+ fp = VTOF(vp);+ if (fp->ff_unallocblocks)+ return (EINVAL);++#if CONFIG_PROTECT+ /*+ * <rdar://problem/9118426>+ * Disable HFS file relocation on content-protected filesystems+ */+ if (cp_fs_protected (hfsmp->hfs_mp)) {+ return EINVAL;+ }+#endif+ /* If it's an SSD, also disable HFS relocation */+ if (hfsmp->hfs_flags & HFS_SSD) {+ return EINVAL;+ }+++ blksize = hfsmp->blockSize;+ if (blockHint == 0)+ blockHint = hfsmp->nextAllocation;++ if (fp->ff_size > 0x7fffffff) {+ return (EFBIG);+ }++ if (!vnode_issystem(vp) && (vnodetype != VLNK)) {+ hfs_unlock(cp);+ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ /* Force lock since callers expects lock to be held. */+ if ((retval = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS))) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ return (retval);+ }+ /* No need to continue if file was removed. */+ if (cp->c_flag & C_NOEXISTS) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ return (ENOENT);+ }+ took_trunc_lock = 1;+ }+ headblks = fp->ff_blocks;+ datablks = howmany(fp->ff_size, blksize);+ growsize = datablks * blksize;+ eflags = kEFContigMask | kEFAllMask | kEFNoClumpMask;+ if (blockHint >= hfsmp->hfs_metazone_start &&+ blockHint <= hfsmp->hfs_metazone_end)+ eflags |= kEFMetadataMask;++ if (hfs_start_transaction(hfsmp) != 0) {+ if (took_trunc_lock)+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ return (EINVAL);+ }+ started_tr = 1;+ /*+ * Protect the extents b-tree and the allocation bitmap+ * during MapFileBlockC and ExtendFileC operations.+ */+ lockflags = SFL_BITMAP;+ if (overflow_extents(fp))+ lockflags |= SFL_EXTENTS;+ lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);++ retval = MapFileBlockC(hfsmp, (FCB *)fp, 1, growsize - 1, §or_a, NULL);+ if (retval) {+ retval = MacToVFSError(retval);+ goto out;+ }++ /*+ * STEP 1 - acquire new allocation blocks.+ */+ nextallocsave = hfsmp->nextAllocation;+ retval = ExtendFileC(hfsmp, (FCB*)fp, growsize, blockHint, eflags, &newbytes);+ if (eflags & kEFMetadataMask) {+ hfs_lock_mount(hfsmp);+ HFS_UPDATE_NEXT_ALLOCATION(hfsmp, nextallocsave);+ MarkVCBDirty(hfsmp);+ hfs_unlock_mount(hfsmp);+ }++ retval = MacToVFSError(retval);+ if (retval == 0) {+ cp->c_flag |= C_MODIFIED;+ if (newbytes < growsize) {+ retval = ENOSPC;+ goto restore;+ } else if (fp->ff_blocks < (headblks + datablks)) {+ printf("hfs_relocate: allocation failed id=%u, vol=%s\n", cp->c_cnid, hfsmp->vcbVN);+ retval = ENOSPC;+ goto restore;+ }++ retval = MapFileBlockC(hfsmp, (FCB *)fp, 1, growsize, §or_b, NULL);+ if (retval) {+ retval = MacToVFSError(retval);+ } else if ((sector_a + 1) == sector_b) {+ retval = ENOSPC;+ goto restore;+ } else if ((eflags & kEFMetadataMask) &&+ ((((u_int64_t)sector_b * hfsmp->hfs_logical_block_size) / blksize) >+ hfsmp->hfs_metazone_end)) {+#if 0+ const char * filestr;+ char emptystr = '\0';++ if (cp->c_desc.cd_nameptr != NULL) {+ filestr = (const char *)&cp->c_desc.cd_nameptr[0];+ } else if (vnode_name(vp) != NULL) {+ filestr = vnode_name(vp);+ } else {+ filestr = &emptystr;+ }+#endif+ retval = ENOSPC;+ goto restore;+ }+ }+ /* Done with system locks and journal for now. */+ hfs_systemfile_unlock(hfsmp, lockflags);+ lockflags = 0;+ hfs_end_transaction(hfsmp);+ started_tr = 0;++ if (retval) {+ /*+ * Check to see if failure is due to excessive fragmentation.+ */+ if ((retval == ENOSPC) &&+ (hfs_freeblks(hfsmp, 0) > (datablks * 2))) {+ hfsmp->hfs_flags |= HFS_FRAGMENTED_FREESPACE;+ }+ goto out;+ }+ /*+ * STEP 2 - clone file data into the new allocation blocks.+ */++ if (vnodetype == VLNK)+ retval = EPERM;+ else if (vnode_issystem(vp))+ retval = hfs_clonesysfile(vp, headblks, datablks, blksize, cred, p);+ else+ retval = hfs_clonefile(vp, headblks, datablks, blksize);++ /* Start transaction for step 3 or for a restore. */+ if (hfs_start_transaction(hfsmp) != 0) {+ retval = EINVAL;+ goto out;+ }+ started_tr = 1;+ if (retval)+ goto restore;++ /*+ * STEP 3 - switch to cloned data and remove old blocks.+ */+ lockflags = SFL_BITMAP;+ if (overflow_extents(fp))+ lockflags |= SFL_EXTENTS;+ lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);++ retval = HeadTruncateFile(hfsmp, (FCB*)fp, headblks);++ hfs_systemfile_unlock(hfsmp, lockflags);+ lockflags = 0;+ if (retval)+ goto restore;+out:+ if (took_trunc_lock)+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);++ if (lockflags) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ lockflags = 0;+ }++ /* Push cnode's new extent data to disk. */+ if (retval == 0) {+ hfs_update(vp, 0);+ }+ if (hfsmp->jnl) {+ if (cp->c_cnid < kHFSFirstUserCatalogNodeID)+ (void) hfs_flushvolumeheader(hfsmp, HFS_FVH_WAIT | HFS_FVH_WRITE_ALT);+ else+ (void) hfs_flushvolumeheader(hfsmp, 0);+ }+exit:+ if (started_tr)+ hfs_end_transaction(hfsmp);++ return (retval);++restore:+ if (fp->ff_blocks == headblks) {+ if (took_trunc_lock)+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ goto exit;+ }+ /*+ * Give back any newly allocated space.+ */+ if (lockflags == 0) {+ lockflags = SFL_BITMAP;+ if (overflow_extents(fp))+ lockflags |= SFL_EXTENTS;+ lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);+ }++ (void) TruncateFileC(hfsmp, (FCB*)fp, fp->ff_size, 0, FORK_IS_RSRC(fp),+ FTOC(fp)->c_fileid, false);++ hfs_systemfile_unlock(hfsmp, lockflags);+ lockflags = 0;++ if (took_trunc_lock)+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ goto exit;+}+++/*+ * Clone a file's data within the file.+ *+ */+static int+hfs_clonefile(struct vnode *vp, int blkstart, int blkcnt, int blksize)+{+ caddr_t bufp;+ size_t bufsize;+ size_t copysize;+ size_t iosize;+ size_t offset;+ off_t writebase;+ uio_t auio;+ int error = 0;++ writebase = blkstart * blksize;+ copysize = blkcnt * blksize;+ iosize = bufsize = MIN(copysize, 128 * 1024);+ offset = 0;++ hfs_unlock(VTOC(vp));++#if CONFIG_PROTECT+ if ((error = cp_handle_vnop(vp, CP_WRITE_ACCESS, 0)) != 0) {+ hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ return (error);+ }+#endif /* CONFIG_PROTECT */++ bufp = hfs_malloc_data(bufsize);+ auio = uio_create(1, 0, UIO_SYSSPACE, UIO_READ);++ while (offset < copysize) {+ iosize = MIN(copysize - offset, iosize);++ uio_reset(auio, offset, UIO_SYSSPACE, UIO_READ);+ uio_addiov(auio, (uintptr_t)bufp, iosize);++ error = cluster_read(vp, auio, copysize, IO_NOCACHE);+ if (error) {+ printf("hfs_clonefile: cluster_read failed - %d\n", error);+ break;+ }+ if (uio_resid(auio) != 0) {+ printf("hfs_clonefile: cluster_read: uio_resid = %lld\n", (int64_t)uio_resid(auio));+ error = EIO;+ break;+ }++ uio_reset(auio, writebase + offset, UIO_SYSSPACE, UIO_WRITE);+ uio_addiov(auio, (uintptr_t)bufp, iosize);++ error = cluster_write(vp, auio, writebase + offset,+ writebase + offset + iosize,+ uio_offset(auio), 0, IO_NOCACHE | IO_SYNC);+ if (error) {+ printf("hfs_clonefile: cluster_write failed - %d\n", error);+ break;+ }+ if (uio_resid(auio) != 0) {+ printf("hfs_clonefile: cluster_write failed - uio_resid not zero\n");+ error = EIO;+ break;+ }+ offset += iosize;+ }+ uio_free(auio);++ if ((blksize & PAGE_MASK)) {+ /*+ * since the copy may not have started on a PAGE+ * boundary (or may not have ended on one), we+ * may have pages left in the cache since NOCACHE+ * will let partially written pages linger...+ * lets just flush the entire range to make sure+ * we don't have any pages left that are beyond+ * (or intersect) the real LEOF of this file+ */+ ubc_msync(vp, writebase, writebase + offset, NULL, UBC_INVALIDATE | UBC_PUSHDIRTY);+ } else {+ /*+ * No need to call ubc_msync or hfs_invalbuf+ * since the file was copied using IO_NOCACHE and+ * the copy was done starting and ending on a page+ * boundary in the file.+ */+ }+ hfs_free_data(bufp, bufsize);++ hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ return (error);+}++/*+ * Clone a system (metadata) file.+ *+ */+static int+hfs_clonesysfile(struct vnode *vp, int blkstart, int blkcnt, int blksize,+ kauth_cred_t cred, struct proc *p)+{+ caddr_t bufp;+ char * offset;+ size_t bufsize;+ size_t iosize;+ struct buf *bp = NULL;+ daddr64_t blkno;+ daddr64_t blk;+ daddr64_t start_blk;+ daddr64_t last_blk;+ int breadcnt;+ int i;+ int error = 0;+++ iosize = GetLogicalBlockSize(vp);+ bufsize = MIN(blkcnt * blksize, 1024 * 1024) & ~(iosize - 1);+ breadcnt = bufsize / iosize;++ bufp = hfs_malloc_data(bufsize);+ start_blk = ((daddr64_t)blkstart * blksize) / iosize;+ last_blk = ((daddr64_t)blkcnt * blksize) / iosize;+ blkno = 0;++ while (blkno < last_blk) {+ /*+ * Read up to a megabyte+ */+ offset = bufp;+ for (i = 0, blk = blkno; (i < breadcnt) && (blk < last_blk); ++i, ++blk) {+ error = (int)buf_meta_bread(vp, blk, iosize, cred, &bp);+ if (error) {+ printf("hfs_clonesysfile: meta_bread error %d\n", error);+ goto out;+ }+ if (buf_count(bp) != iosize) {+ printf("hfs_clonesysfile: b_bcount is only %d\n", buf_count(bp));+ goto out;+ }+ bcopy((char *)buf_dataptr(bp), offset, iosize);++ buf_markinvalid(bp);+ buf_brelse(bp);+ bp = NULL;++ offset += iosize;+ }++ /*+ * Write up to a megabyte+ */+ offset = bufp;+ for (i = 0; (i < breadcnt) && (blkno < last_blk); ++i, ++blkno) {+ bp = buf_getblk(vp, start_blk + blkno, iosize, 0, 0, BLK_META);+ if (bp == NULL) {+ printf("hfs_clonesysfile: getblk failed on blk %qd\n", start_blk + blkno);+ error = EIO;+ goto out;+ }+ bcopy(offset, (char *)buf_dataptr(bp), iosize);+ error = (int)buf_bwrite(bp);+ bp = NULL;+ if (error)+ goto out;+ offset += iosize;+ }+ }+out:+ if (bp) {+ buf_brelse(bp);+ }++ hfs_free_data(bufp, bufsize);++ error = hfs_fsync(vp, MNT_WAIT, 0, p);++ return (error);+}++errno_t hfs_flush_invalid_ranges(vnode_t vp)+{+ cnode_t *cp = VTOC(vp);++ hfs_assert(cp->c_lockowner == current_thread());+ hfs_assert(cp->c_truncatelockowner == current_thread());++ if (!ISSET(cp->c_flag, C_ZFWANTSYNC) && !cp->c_zftimeout)+ return 0;++ filefork_t *fp = VTOF(vp);++ /*+ * We can't hold the cnode lock whilst we call cluster_write so we+ * need to copy the extents into a local buffer.+ */+ int max_exts = 16;+ struct ext {+ off_t start, end;+ } exts_buf[max_exts]; // 256 bytes+ struct ext *exts = exts_buf;+ int ext_count = 0;+ errno_t ret;++ struct rl_entry *r = TAILQ_FIRST(&fp->ff_invalidranges);++ while (r) {+ /* If we have more than can fit in our stack buffer, switch+ to a heap buffer. */+ if (exts == exts_buf && ext_count == max_exts) {+ max_exts = 256;+ exts = hfs_malloc_data(sizeof(struct ext) * max_exts);+ memcpy(exts, exts_buf, ext_count * sizeof(struct ext));+ }++ struct rl_entry *next = TAILQ_NEXT(r, rl_link);++ exts[ext_count++] = (struct ext){ r->rl_start, r->rl_end };++ if (!next || (ext_count == max_exts && exts != exts_buf)) {+ hfs_unlock(cp);+ for (int i = 0; i < ext_count; ++i) {+ ret = cluster_write(vp, NULL, fp->ff_size, exts[i].end + 1,+ exts[i].start, 0,+ IO_HEADZEROFILL | IO_NOZERODIRTY | IO_NOCACHE);+ if (ret) {+ hfs_lock_always(cp, HFS_EXCLUSIVE_LOCK);+ goto exit;+ }+ }++ if (!next) {+ hfs_lock_always(cp, HFS_EXCLUSIVE_LOCK);+ break;+ }++ /* Push any existing clusters which should clean up our invalid+ ranges as they go through hfs_vnop_blockmap. */+ cluster_push(vp, 0);++ hfs_lock_always(cp, HFS_EXCLUSIVE_LOCK);++ /*+ * Get back to where we were (given we dropped the lock).+ * This shouldn't be many because we pushed above.+ */+ TAILQ_FOREACH(r, &fp->ff_invalidranges, rl_link) {+ if (r->rl_end > exts[ext_count - 1].end)+ break;+ }++ ext_count = 0;+ } else+ r = next;+ }++ ret = 0;++exit:++ if (exts != exts_buf)+ hfs_free_data(exts, sizeof(struct ext) * max_exts);++ return ret;+}diff --git a/xnu/files/bsd/hfs/hfs_resize.c b/xnu/files/bsd/hfs/hfs_resize.cnew file mode 100644index 0000000..c91adb7--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_resize.c@@ -0,0 +1,3432 @@+/*+ * Copyright (c) 2013-2015 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@+ */+#include <sys/systm.h>+#include <sys/kauth.h>+#include <sys/ubc.h>++#include "hfs_journal.h"+#include <miscfs/specfs/specdev.h>++#include "hfs.h"+#include "hfs_catalog.h"+#include "hfs_cnode.h"+#include "hfs_endian.h"+#include "hfs_btreeio.h"+#include "hfs_cprotect.h"++/* Enable/disable debugging code for live volume resizing */+int hfs_resize_debug = 0;++static errno_t hfs_file_extent_overlaps(struct hfsmount *hfsmp, u_int32_t allocLimit,+ struct HFSPlusCatalogFile *filerec, bool *overlaps);+static int hfs_reclaimspace(struct hfsmount *hfsmp, u_int32_t allocLimit, u_int32_t reclaimblks, vfs_context_t context);+static int hfs_extend_journal(struct hfsmount *hfsmp, u_int32_t sector_size, u_int64_t sector_count, vfs_context_t context);++/*+ * Extend a file system.+ */+int+hfs_extendfs(struct hfsmount *hfsmp, u_int64_t newsize, vfs_context_t context)+{+ struct proc *p = vfs_context_proc(context);+ kauth_cred_t cred = vfs_context_ucred(context);+ struct vnode *vp = NULL;+ struct vnode *devvp;+ struct buf *bp;+ struct filefork *fp = NULL;+ ExtendedVCB *vcb;+ struct cat_fork forkdata;+ u_int64_t oldsize;+ uint32_t newblkcnt;+ u_int64_t prev_phys_block_count;+ u_int32_t addblks;+ u_int64_t sector_count;+ u_int32_t sector_size;+ u_int32_t phys_sector_size;+ u_int32_t overage_blocks;+ daddr64_t prev_fs_alt_sector;+ daddr_t bitmapblks;+ int lockflags = 0;+ int error;+ int64_t oldBitmapSize;++ Boolean usedExtendFileC = false;+ int transaction_begun = 0;++ devvp = hfsmp->hfs_devvp;+ vcb = HFSTOVCB(hfsmp);++ /*+ * - HFS Plus file systems only.+ * - Journaling must be enabled.+ * - No embedded volumes.+ */+ if ((vcb->vcbSigWord == kHFSSigWord) ||+ (hfsmp->jnl == NULL) ||+ (vcb->hfsPlusIOPosOffset != 0)) {+ return (EPERM);+ }+ /*+ * If extending file system by non-root, then verify+ * ownership and check permissions.+ */+ if (suser(cred, NULL)) {+ error = hfs_vget(hfsmp, kHFSRootFolderID, &vp, 0, 0);++ if (error)+ return (error);+ error = hfs_owner_rights(hfsmp, VTOC(vp)->c_uid, cred, p, 0);+ if (error == 0) {+ error = hfs_write_access(vp, cred, p, false);+ }+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ if (error)+ return (error);++ error = vnode_authorize(devvp, NULL, KAUTH_VNODE_READ_DATA | KAUTH_VNODE_WRITE_DATA, context);+ if (error)+ return (error);+ }+ if (VNOP_IOCTL(devvp, DKIOCGETBLOCKSIZE, (caddr_t)§or_size, 0, context)) {+ return (ENXIO);+ }+ if (sector_size != hfsmp->hfs_logical_block_size) {+ return (ENXIO);+ }+ if (VNOP_IOCTL(devvp, DKIOCGETBLOCKCOUNT, (caddr_t)§or_count, 0, context)) {+ return (ENXIO);+ }+ /* Check if partition size is correct for new file system size */+ if ((sector_size * sector_count) < newsize) {+ printf("hfs_extendfs: not enough space on device (vol=%s)\n", hfsmp->vcbVN);+ return (ENOSPC);+ }+ error = VNOP_IOCTL(devvp, DKIOCGETPHYSICALBLOCKSIZE, (caddr_t)&phys_sector_size, 0, context);+ if (error) {+ if ((error != ENOTSUP) && (error != ENOTTY)) {+ return (ENXIO);+ }+ /* If ioctl is not supported, force physical and logical sector size to be same */+ phys_sector_size = sector_size;+ }+ oldsize = (u_int64_t)hfsmp->totalBlocks * (u_int64_t)hfsmp->blockSize;++ /*+ * Validate new size.+ */+ if ((newsize <= oldsize) || (newsize % sector_size) || (newsize % phys_sector_size)) {+ printf("hfs_extendfs: invalid size (newsize=%qu, oldsize=%qu)\n", newsize, oldsize);+ return (EINVAL);+ }+ uint64_t cnt = newsize / vcb->blockSize;+ if (cnt > 0xFFFFFFFF) {+ printf ("hfs_extendfs: current blockSize=%u too small for newsize=%qu\n", hfsmp->blockSize, newsize);+ return (EOVERFLOW);+ }++ newblkcnt = (uint32_t)cnt;++ addblks = newblkcnt - vcb->totalBlocks;++ if (hfs_resize_debug) {+ printf ("hfs_extendfs: old: size=%qu, blkcnt=%u\n", oldsize, hfsmp->totalBlocks);+ printf ("hfs_extendfs: new: size=%qu, blkcnt=%u, addblks=%u\n", newsize, newblkcnt, addblks);+ }+ printf("hfs_extendfs: will extend \"%s\" by %d blocks\n", vcb->vcbVN, addblks);++ hfs_lock_mount (hfsmp);+ if (hfsmp->hfs_flags & HFS_RESIZE_IN_PROGRESS) {+ hfs_unlock_mount(hfsmp);+ error = EALREADY;+ goto out;+ }+ hfsmp->hfs_flags |= HFS_RESIZE_IN_PROGRESS;+ hfs_unlock_mount (hfsmp);++ /* Start with a clean journal. */+ hfs_flush(hfsmp, HFS_FLUSH_JOURNAL_META);++ /*+ * Enclose changes inside a transaction.+ */+ if (hfs_start_transaction(hfsmp) != 0) {+ error = EINVAL;+ goto out;+ }+ transaction_begun = 1;+++ /* Update the hfsmp fields for the physical information about the device */+ prev_phys_block_count = hfsmp->hfs_logical_block_count;+ prev_fs_alt_sector = hfsmp->hfs_fs_avh_sector;++ hfsmp->hfs_logical_block_count = sector_count;+ hfsmp->hfs_logical_bytes = (uint64_t) sector_count * (uint64_t) sector_size;++ /*+ * It is possible that the new file system is smaller than the partition size.+ * Therefore, update offsets for AVH accordingly.+ */+ if (hfs_resize_debug) {+ printf ("hfs_extendfs: old: partition_avh_sector=%qu, fs_avh_sector=%qu\n",+ hfsmp->hfs_partition_avh_sector, hfsmp->hfs_fs_avh_sector);+ }+ hfsmp->hfs_partition_avh_sector = (hfsmp->hfsPlusIOPosOffset / sector_size) ++ HFS_ALT_SECTOR(sector_size, hfsmp->hfs_logical_block_count);++ hfsmp->hfs_fs_avh_sector = (hfsmp->hfsPlusIOPosOffset / sector_size) ++ HFS_ALT_SECTOR(sector_size, (newsize/hfsmp->hfs_logical_block_size));+ if (hfs_resize_debug) {+ printf ("hfs_extendfs: new: partition_avh_sector=%qu, fs_avh_sector=%qu\n",+ hfsmp->hfs_partition_avh_sector, hfsmp->hfs_fs_avh_sector);+ }++ /*+ * Note: we take the attributes lock in case we have an attribute data vnode+ * which needs to change size.+ */+ lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE | SFL_EXTENTS | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);+ vp = vcb->allocationsRefNum;+ fp = VTOF(vp);+ bcopy(&fp->ff_data, &forkdata, sizeof(forkdata));++ /*+ * Calculate additional space required (if any) by allocation bitmap.+ */+ oldBitmapSize = fp->ff_size;+ bitmapblks = roundup((newblkcnt+7) / 8, vcb->vcbVBMIOSize) / vcb->blockSize;+ if (bitmapblks > (daddr_t)fp->ff_blocks)+ bitmapblks -= fp->ff_blocks;+ else+ bitmapblks = 0;++ /*+ * The allocation bitmap can contain unused bits that are beyond end of+ * current volume's allocation blocks. Usually they are supposed to be+ * zero'ed out but there can be cases where they might be marked as used.+ * After extending the file system, those bits can represent valid+ * allocation blocks, so we mark all the bits from the end of current+ * volume to end of allocation bitmap as "free".+ *+ * Figure out the number of overage blocks before proceeding though,+ * so we don't add more bytes to our I/O than necessary.+ * First figure out the total number of blocks representable by the+ * end of the bitmap file vs. the total number of blocks in the new FS.+ * Then subtract away the number of blocks in the current FS. This is how much+ * we can mark as free right now without having to grow the bitmap file.+ */+ overage_blocks = fp->ff_blocks * vcb->blockSize * 8;+ overage_blocks = MIN (overage_blocks, newblkcnt);+ overage_blocks -= vcb->totalBlocks;++ BlockMarkFreeUnused(vcb, vcb->totalBlocks, overage_blocks);++ if (bitmapblks > 0) {+ daddr64_t blkno;+ daddr_t blkcnt;+ off_t bytesAdded;++ /*+ * Get the bitmap's current size (in allocation blocks) so we know+ * where to start zero filling once the new space is added. We've+ * got to do this before the bitmap is grown.+ */+ blkno = (daddr64_t)fp->ff_blocks;++ /*+ * Try to grow the allocation file in the normal way, using allocation+ * blocks already existing in the file system. This way, we might be+ * able to grow the bitmap contiguously, or at least in the metadata+ * zone.+ */+ error = ExtendFileC(vcb, fp, bitmapblks * vcb->blockSize, 0,+ kEFAllMask | kEFNoClumpMask | kEFReserveMask+ | kEFMetadataMask | kEFContigMask, &bytesAdded);++ if (error == 0) {+ usedExtendFileC = true;+ } else {+ /*+ * If the above allocation failed, fall back to allocating the new+ * extent of the bitmap from the space we're going to add. Since those+ * blocks don't yet belong to the file system, we have to update the+ * extent list directly, and manually adjust the file size.+ */+ bytesAdded = 0;+ error = AddFileExtent(vcb, fp, vcb->totalBlocks, bitmapblks);+ if (error) {+ printf("hfs_extendfs: error %d adding extents\n", error);+ goto out;+ }+ fp->ff_blocks += bitmapblks;+ VTOC(vp)->c_blocks = fp->ff_blocks;+ VTOC(vp)->c_flag |= C_MODIFIED;+ }++ /*+ * Update the allocation file's size to include the newly allocated+ * blocks. Note that ExtendFileC doesn't do this, which is why this+ * statement is outside the above "if" statement.+ */+ fp->ff_size += (u_int64_t)bitmapblks * (u_int64_t)vcb->blockSize;++ /*+ * Zero out the new bitmap blocks.+ */+ {++ bp = NULL;+ blkcnt = bitmapblks;+ while (blkcnt > 0) {+ error = (int)buf_meta_bread(vp, blkno, vcb->blockSize, NOCRED, &bp);+ if (error) {+ if (bp) {+ buf_brelse(bp);+ }+ break;+ }+ bzero((char *)buf_dataptr(bp), vcb->blockSize);+ buf_markaged(bp);+ error = (int)buf_bwrite(bp);+ if (error)+ break;+ --blkcnt;+ ++blkno;+ }+ }+ if (error) {+ printf("hfs_extendfs: error %d clearing blocks\n", error);+ goto out;+ }+ /*+ * Mark the new bitmap space as allocated.+ *+ * Note that ExtendFileC will have marked any blocks it allocated, so+ * this is only needed if we used AddFileExtent. Also note that this+ * has to come *after* the zero filling of new blocks in the case where+ * we used AddFileExtent (since the part of the bitmap we're touching+ * is in those newly allocated blocks).+ */+ if (!usedExtendFileC) {+ error = BlockMarkAllocated(vcb, vcb->totalBlocks, bitmapblks);+ if (error) {+ printf("hfs_extendfs: error %d setting bitmap\n", error);+ goto out;+ }+ vcb->freeBlocks -= bitmapblks;+ }+ }++ /*+ * Mark the new alternate VH as allocated.+ */+ if (vcb->blockSize == 512)+ error = BlockMarkAllocated(vcb, vcb->totalBlocks + addblks - 2, 2);+ else+ error = BlockMarkAllocated(vcb, vcb->totalBlocks + addblks - 1, 1);+ if (error) {+ printf("hfs_extendfs: error %d setting bitmap (VH)\n", error);+ goto out;+ }++ /*+ * Mark the old alternate VH as free.+ */+ if (vcb->blockSize == 512)+ (void) BlockMarkFree(vcb, vcb->totalBlocks - 2, 2);+ else+ (void) BlockMarkFree(vcb, vcb->totalBlocks - 1, 1);++ /*+ * Adjust file system variables for new space.+ */+ vcb->totalBlocks += addblks;+ vcb->freeBlocks += addblks;+ MarkVCBDirty(vcb);+ error = hfs_flushvolumeheader(hfsmp, HFS_FVH_WAIT | HFS_FVH_WRITE_ALT);+ if (error) {+ printf("hfs_extendfs: couldn't flush volume headers (%d)", error);+ /*+ * Restore to old state.+ */+ if (usedExtendFileC) {+ (void) TruncateFileC(vcb, fp, oldBitmapSize, 0, FORK_IS_RSRC(fp),+ FTOC(fp)->c_fileid, false);+ } else {+ fp->ff_blocks -= bitmapblks;+ fp->ff_size -= (u_int64_t)bitmapblks * (u_int64_t)vcb->blockSize;+ /*+ * No need to mark the excess blocks free since those bitmap blocks+ * are no longer part of the bitmap. But we do need to undo the+ * effect of the "vcb->freeBlocks -= bitmapblks" above.+ */+ vcb->freeBlocks += bitmapblks;+ }+ vcb->totalBlocks -= addblks;+ vcb->freeBlocks -= addblks;+ hfsmp->hfs_logical_block_count = prev_phys_block_count;+ hfsmp->hfs_fs_avh_sector = prev_fs_alt_sector;+ /* Do not revert hfs_partition_avh_sector because the+ * partition size is larger than file system size+ */+ MarkVCBDirty(vcb);+ if (vcb->blockSize == 512) {+ if (BlockMarkAllocated(vcb, vcb->totalBlocks - 2, 2)) {+ hfs_mark_inconsistent(hfsmp, HFS_ROLLBACK_FAILED);+ }+ } else {+ if (BlockMarkAllocated(vcb, vcb->totalBlocks - 1, 1)) {+ hfs_mark_inconsistent(hfsmp, HFS_ROLLBACK_FAILED);+ }+ }+ goto out;+ }+ /*+ * Invalidate the old alternate volume header. We are growing the filesystem so+ * this sector must be returned to the FS as free space.+ */+ bp = NULL;+ if (prev_fs_alt_sector) {+ if (buf_meta_bread(hfsmp->hfs_devvp,+ HFS_PHYSBLK_ROUNDDOWN(prev_fs_alt_sector, hfsmp->hfs_log_per_phys),+ hfsmp->hfs_physical_block_size, NOCRED, &bp) == 0) {+ journal_modify_block_start(hfsmp->jnl, bp);++ bzero((char *)buf_dataptr(bp) + HFS_ALT_OFFSET(hfsmp->hfs_physical_block_size), kMDBSize);++ journal_modify_block_end(hfsmp->jnl, bp, NULL, NULL);+ } else if (bp) {+ buf_brelse(bp);+ }+ }++ /*+ * Update the metadata zone size based on current volume size+ */+ hfs_metadatazone_init(hfsmp, false);++ /*+ * Adjust the size of hfsmp->hfs_attrdata_vp+ */+ if (hfsmp->hfs_attrdata_vp) {+ struct cnode *attr_cp;+ struct filefork *attr_fp;++ if (vnode_get(hfsmp->hfs_attrdata_vp) == 0) {+ attr_cp = VTOC(hfsmp->hfs_attrdata_vp);+ attr_fp = VTOF(hfsmp->hfs_attrdata_vp);++ attr_cp->c_blocks = newblkcnt;+ attr_fp->ff_blocks = newblkcnt;+ attr_fp->ff_extents[0].blockCount = newblkcnt;+ attr_fp->ff_size = (off_t) newblkcnt * hfsmp->blockSize;+ ubc_setsize(hfsmp->hfs_attrdata_vp, attr_fp->ff_size);+ vnode_put(hfsmp->hfs_attrdata_vp);+ }+ }++ /*+ * We only update hfsmp->allocLimit if totalBlocks actually increased.+ */+ if (error == 0) {+ UpdateAllocLimit(hfsmp, hfsmp->totalBlocks);+ }++ /* Release all locks and sync up journal content before+ * checking and extending, if required, the journal+ */+ if (lockflags) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ lockflags = 0;+ }+ if (transaction_begun) {+ hfs_end_transaction(hfsmp);+ hfs_flush(hfsmp, HFS_FLUSH_JOURNAL_META);+ transaction_begun = 0;+ }++ /* Increase the journal size, if required. */+ error = hfs_extend_journal(hfsmp, sector_size, sector_count, context);+ if (error) {+ printf ("hfs_extendfs: Could not extend journal size\n");+ goto out_noalloc;+ }++ /* Log successful extending */+ printf("hfs_extendfs: extended \"%s\" to %d blocks (was %d blocks)\n",+ hfsmp->vcbVN, hfsmp->totalBlocks, (u_int32_t)(oldsize/hfsmp->blockSize));++out:+ if (error && fp) {+ /* Restore allocation fork. */+ bcopy(&forkdata, &fp->ff_data, sizeof(forkdata));+ VTOC(vp)->c_blocks = fp->ff_blocks;++ }++out_noalloc:+ hfs_lock_mount (hfsmp);+ hfsmp->hfs_flags &= ~HFS_RESIZE_IN_PROGRESS;+ hfs_unlock_mount (hfsmp);+ if (lockflags) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ }+ if (transaction_begun) {+ hfs_end_transaction(hfsmp);+ /* Just to be sure, sync all data to the disk */+ int flush_error = hfs_flush(hfsmp, HFS_FLUSH_FULL);+ if (flush_error && !error)+ error = flush_error;+ }+ if (error) {+ printf ("hfs_extentfs: failed error=%d on vol=%s\n", MacToVFSError(error), hfsmp->vcbVN);+ }++ return MacToVFSError(error);+}++#define HFS_MIN_SIZE (32LL * 1024LL * 1024LL)++/*+ * Truncate a file system (while still mounted).+ */+int+hfs_truncatefs(struct hfsmount *hfsmp, u_int64_t newsize, vfs_context_t context)+{+ u_int64_t oldsize;+ u_int32_t newblkcnt;+ u_int32_t reclaimblks = 0;+ int lockflags = 0;+ int transaction_begun = 0;+ Boolean updateFreeBlocks = false;+ Boolean disable_sparse = false;+ int error = 0;++ hfs_lock_mount (hfsmp);+ if (hfsmp->hfs_flags & HFS_RESIZE_IN_PROGRESS) {+ hfs_unlock_mount (hfsmp);+ return (EALREADY);+ }+ hfsmp->hfs_flags |= HFS_RESIZE_IN_PROGRESS;+ hfsmp->hfs_resize_blocksmoved = 0;+ hfsmp->hfs_resize_totalblocks = 0;+ hfsmp->hfs_resize_progress = 0;+ hfs_unlock_mount (hfsmp);++ /*+ * - Journaled HFS Plus volumes only.+ * - No embedded volumes.+ */+ if ((hfsmp->jnl == NULL) ||+ (hfsmp->hfsPlusIOPosOffset != 0)) {+ error = EPERM;+ goto out;+ }+ oldsize = (u_int64_t)hfsmp->totalBlocks * (u_int64_t)hfsmp->blockSize;+ newblkcnt = newsize / hfsmp->blockSize;+ reclaimblks = hfsmp->totalBlocks - newblkcnt;++ if (hfs_resize_debug) {+ printf ("hfs_truncatefs: old: size=%qu, blkcnt=%u, freeblks=%u\n", oldsize, hfsmp->totalBlocks, hfs_freeblks(hfsmp, 1));+ printf ("hfs_truncatefs: new: size=%qu, blkcnt=%u, reclaimblks=%u\n", newsize, newblkcnt, reclaimblks);+ }++ /* Make sure new size is valid. */+ if ((newsize < HFS_MIN_SIZE) ||+ (newsize >= oldsize) ||+ (newsize % hfsmp->hfs_logical_block_size) ||+ (newsize % hfsmp->hfs_physical_block_size)) {+ printf ("hfs_truncatefs: invalid size (newsize=%qu, oldsize=%qu)\n", newsize, oldsize);+ error = EINVAL;+ goto out;+ }++ /*+ * Make sure that the file system has enough free blocks reclaim.+ *+ * Before resize, the disk is divided into four zones -+ * A. Allocated_Stationary - These are allocated blocks that exist+ * before the new end of disk. These blocks will not be+ * relocated or modified during resize.+ * B. Free_Stationary - These are free blocks that exist before the+ * new end of disk. These blocks can be used for any new+ * allocations during resize, including allocation for relocating+ * data from the area of disk being reclaimed.+ * C. Allocated_To-Reclaim - These are allocated blocks that exist+ * beyond the new end of disk. These blocks need to be reclaimed+ * during resize by allocating equal number of blocks in Free+ * Stationary zone and copying the data.+ * D. Free_To-Reclaim - These are free blocks that exist beyond the+ * new end of disk. Nothing special needs to be done to reclaim+ * them.+ *+ * Total number of blocks on the disk before resize:+ * ------------------------------------------------+ * Total Blocks = Allocated_Stationary + Free_Stationary ++ * Allocated_To-Reclaim + Free_To-Reclaim+ *+ * Total number of blocks that need to be reclaimed:+ * ------------------------------------------------+ * Blocks to Reclaim = Allocated_To-Reclaim + Free_To-Reclaim+ *+ * Note that the check below also makes sure that we have enough space+ * to relocate data from Allocated_To-Reclaim to Free_Stationary.+ * Therefore we do not need to check total number of blocks to relocate+ * later in the code.+ *+ * The condition below gets converted to:+ *+ * Allocated To-Reclaim + Free To-Reclaim >= Free Stationary + Free To-Reclaim+ *+ * which is equivalent to:+ *+ * Allocated To-Reclaim >= Free Stationary+ */+ if (reclaimblks >= hfs_freeblks(hfsmp, 1)) {+ printf("hfs_truncatefs: insufficient space (need %u blocks; have %u free blocks)\n", reclaimblks, hfs_freeblks(hfsmp, 1));+ error = ENOSPC;+ goto out;+ }++ /* Start with a clean journal. */+ hfs_flush(hfsmp, HFS_FLUSH_JOURNAL_META);++ if (hfs_start_transaction(hfsmp) != 0) {+ error = EINVAL;+ goto out;+ }+ transaction_begun = 1;++ /* Take the bitmap lock to update the alloc limit field */+ lockflags = hfs_systemfile_lock(hfsmp, SFL_BITMAP, HFS_EXCLUSIVE_LOCK);++ /*+ * Prevent new allocations from using the part we're trying to truncate.+ *+ * NOTE: allocLimit is set to the allocation block number where the new+ * alternate volume header will be. That way there will be no files to+ * interfere with allocating the new alternate volume header, and no files+ * in the allocation blocks beyond (i.e. the blocks we're trying to+ * truncate away.+ */+ if (hfsmp->blockSize == 512) {+ error = UpdateAllocLimit (hfsmp, newblkcnt - 2);+ }+ else {+ error = UpdateAllocLimit (hfsmp, newblkcnt - 1);+ }++ /* Sparse devices use first fit allocation which is not ideal+ * for volume resize which requires best fit allocation. If a+ * sparse device is being truncated, disable the sparse device+ * property temporarily for the duration of resize. Also reset+ * the free extent cache so that it is rebuilt as sorted by+ * totalBlocks instead of startBlock.+ *+ * Note that this will affect all allocations on the volume and+ * ideal fix would be just to modify resize-related allocations,+ * but it will result in complexity like handling of two free+ * extent caches sorted differently, etc. So we stick to this+ * solution for now.+ */+ hfs_lock_mount (hfsmp);+ if (hfsmp->hfs_flags & HFS_HAS_SPARSE_DEVICE) {+ hfsmp->hfs_flags &= ~HFS_HAS_SPARSE_DEVICE;+ ResetVCBFreeExtCache(hfsmp);+ disable_sparse = true;+ }++ /*+ * Update the volume free block count to reflect the total number+ * of free blocks that will exist after a successful resize.+ * Relocation of extents will result in no net change in the total+ * free space on the disk. Therefore the code that allocates+ * space for new extent and deallocates the old extent explicitly+ * prevents updating the volume free block count. It will also+ * prevent false disk full error when the number of blocks in+ * an extent being relocated is more than the free blocks that+ * will exist after the volume is resized.+ */+ hfsmp->reclaimBlocks = reclaimblks;+ hfsmp->freeBlocks -= reclaimblks;+ updateFreeBlocks = true;+ hfs_unlock_mount(hfsmp);++ if (lockflags) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ lockflags = 0;+ }++ /*+ * Update the metadata zone size to match the new volume size,+ * and if it too less, metadata zone might be disabled.+ */+ hfs_metadatazone_init(hfsmp, false);++ /*+ * If some files have blocks at or beyond the location of the+ * new alternate volume header, recalculate free blocks and+ * reclaim blocks. Otherwise just update free blocks count.+ *+ * The current allocLimit is set to the location of new alternate+ * volume header, and reclaimblks are the total number of blocks+ * that need to be reclaimed. So the check below is really+ * ignoring the blocks allocated for old alternate volume header.+ */+ if (hfs_isallocated(hfsmp, hfsmp->allocLimit, reclaimblks)) {+ /*+ * hfs_reclaimspace will use separate transactions when+ * relocating files (so we don't overwhelm the journal).+ */+ hfs_end_transaction(hfsmp);+ transaction_begun = 0;++ /* Attempt to reclaim some space. */+ error = hfs_reclaimspace(hfsmp, hfsmp->allocLimit, reclaimblks, context);+ if (error != 0) {+ printf("hfs_truncatefs: couldn't reclaim space on %s (error=%d)\n", hfsmp->vcbVN, error);+ error = ENOSPC;+ goto out;+ }++ if (hfs_start_transaction(hfsmp) != 0) {+ error = EINVAL;+ goto out;+ }+ transaction_begun = 1;++ /* Check if we're clear now. */+ error = hfs_isallocated(hfsmp, hfsmp->allocLimit, reclaimblks);+ if (error != 0) {+ printf("hfs_truncatefs: didn't reclaim enough space on %s (error=%d)\n", hfsmp->vcbVN, error);+ error = EAGAIN; /* tell client to try again */+ goto out;+ }+ }++ /*+ * Note: we take the attributes lock in case we have an attribute data vnode+ * which needs to change size.+ */+ lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE | SFL_EXTENTS | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);++ /*+ * Allocate last 1KB for alternate volume header.+ */+ error = BlockMarkAllocated(hfsmp, hfsmp->allocLimit, (hfsmp->blockSize == 512) ? 2 : 1);+ if (error) {+ printf("hfs_truncatefs: Error %d allocating new alternate volume header\n", error);+ goto out;+ }++ /*+ * Mark the old alternate volume header as free.+ * We don't bother shrinking allocation bitmap file.+ */+ if (hfsmp->blockSize == 512)+ (void) BlockMarkFree(hfsmp, hfsmp->totalBlocks - 2, 2);+ else+ (void) BlockMarkFree(hfsmp, hfsmp->totalBlocks - 1, 1);++ /* Don't invalidate the old AltVH yet. It is still valid until the partition size is updated ! */++ /* Log successful shrinking. */+ printf("hfs_truncatefs: shrank \"%s\" to %d blocks (was %d blocks)\n",+ hfsmp->vcbVN, newblkcnt, hfsmp->totalBlocks);++ /*+ * Adjust file system variables and flush them to disk.+ *+ * Note that although the logical block size is updated here, it is only+ * done for the benefit/convenience of the partition management software. The+ * logical block count change has not yet actually been propagated to+ * the disk device yet (and we won't get any notification when it does).+ */+ hfsmp->totalBlocks = newblkcnt;+ hfsmp->hfs_logical_block_count = newsize / hfsmp->hfs_logical_block_size;+ hfsmp->hfs_logical_bytes = (uint64_t) hfsmp->hfs_logical_block_count * (uint64_t) hfsmp->hfs_logical_block_size;+ hfsmp->reclaimBlocks = 0;++ /*+ * At this point, a smaller HFS file system exists in a larger volume.+ * As per volume format, the alternate volume header is located 1024 bytes+ * before end of the partition. So, until the partition is also resized,+ * a valid alternate volume header will need to be updated at 1024 bytes+ * before end of the volume. Under normal circumstances, a file system+ * resize is always followed by a volume resize, so we also need to+ * write a copy of the new alternate volume header at 1024 bytes before+ * end of the new file system.+ */+ if (hfs_resize_debug) {+ printf ("hfs_truncatefs: old: partition_avh_sector=%qu, fs_avh_sector=%qu\n",+ hfsmp->hfs_partition_avh_sector, hfsmp->hfs_fs_avh_sector);+ }+ hfsmp->hfs_fs_avh_sector = HFS_ALT_SECTOR(hfsmp->hfs_logical_block_size, hfsmp->hfs_logical_block_count);+ /* Note hfs_partition_avh_sector stays unchanged! partition size has not yet been modified */+ if (hfs_resize_debug) {+ printf ("hfs_truncatefs: new: partition_avh_sector=%qu, fs_avh_sector=%qu\n",+ hfsmp->hfs_partition_avh_sector, hfsmp->hfs_fs_avh_sector);+ }++ MarkVCBDirty(hfsmp);+ error = hfs_flushvolumeheader(hfsmp, HFS_FVH_WAIT | HFS_FVH_WRITE_ALT);+ if (error) {+ panic("hfs_truncatefs: unexpected error flushing volume header (%d)\n", error);+ }++ /*+ * Adjust the size of hfsmp->hfs_attrdata_vp+ */+ if (hfsmp->hfs_attrdata_vp) {+ struct cnode *cp;+ struct filefork *fp;++ if (vnode_get(hfsmp->hfs_attrdata_vp) == 0) {+ cp = VTOC(hfsmp->hfs_attrdata_vp);+ fp = VTOF(hfsmp->hfs_attrdata_vp);++ cp->c_blocks = newblkcnt;+ fp->ff_blocks = newblkcnt;+ fp->ff_extents[0].blockCount = newblkcnt;+ fp->ff_size = (off_t) newblkcnt * hfsmp->blockSize;+ ubc_setsize(hfsmp->hfs_attrdata_vp, fp->ff_size);+ vnode_put(hfsmp->hfs_attrdata_vp);+ }+ }++out:+ /*+ * Update the allocLimit to acknowledge the last one or two blocks now.+ * Add it to the tree as well if necessary.+ */+ UpdateAllocLimit (hfsmp, hfsmp->totalBlocks);++ hfs_lock_mount (hfsmp);+ if (disable_sparse == true) {+ /* Now that resize is completed, set the volume to be sparse+ * device again so that all further allocations will be first+ * fit instead of best fit. Reset free extent cache so that+ * it is rebuilt.+ */+ hfsmp->hfs_flags |= HFS_HAS_SPARSE_DEVICE;+ ResetVCBFreeExtCache(hfsmp);+ }++ if (error && (updateFreeBlocks == true)) {+ hfsmp->freeBlocks += reclaimblks;+ }+ hfsmp->reclaimBlocks = 0;++ if (hfsmp->nextAllocation >= hfsmp->allocLimit) {+ hfsmp->nextAllocation = hfsmp->hfs_metazone_end + 1;+ }+ hfsmp->hfs_flags &= ~HFS_RESIZE_IN_PROGRESS;+ hfs_unlock_mount (hfsmp);++ /* On error, reset the metadata zone for original volume size */+ if (error && (updateFreeBlocks == true)) {+ hfs_metadatazone_init(hfsmp, false);+ }++ if (lockflags) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ }+ if (transaction_begun) {+ hfs_end_transaction(hfsmp);+ /* Just to be sure, sync all data to the disk */+ int flush_error = hfs_flush(hfsmp, HFS_FLUSH_FULL);+ if (flush_error && !error)+ error = flush_error;+ }++ if (error) {+ printf ("hfs_truncatefs: failed error=%d on vol=%s\n", MacToVFSError(error), hfsmp->vcbVN);+ }++ return MacToVFSError(error);+}+++/*+ * Invalidate the physical block numbers associated with buffer cache blocks+ * in the given extent of the given vnode.+ */+struct hfs_inval_blk_no {+ daddr64_t sectorStart;+ daddr64_t sectorCount;+};+static int+hfs_invalidate_block_numbers_callback(buf_t bp, void *args_in)+{+ daddr64_t blkno;+ struct hfs_inval_blk_no *args;++ blkno = buf_blkno(bp);+ args = args_in;++ if (blkno >= args->sectorStart && blkno < args->sectorStart+args->sectorCount)+ buf_setblkno(bp, buf_lblkno(bp));++ return BUF_RETURNED;+}+static void+hfs_invalidate_sectors(struct vnode *vp, daddr64_t sectorStart, daddr64_t sectorCount)+{+ struct hfs_inval_blk_no args;+ args.sectorStart = sectorStart;+ args.sectorCount = sectorCount;++ buf_iterate(vp, hfs_invalidate_block_numbers_callback, BUF_SCAN_DIRTY|BUF_SCAN_CLEAN, &args);+}+++/*+ * Copy the contents of an extent to a new location. Also invalidates the+ * physical block number of any buffer cache block in the copied extent+ * (so that if the block is written, it will go through VNOP_BLOCKMAP to+ * determine the new physical block number).+ *+ * At this point, for regular files, we hold the truncate lock exclusive+ * and the cnode lock exclusive.+ */+static int+hfs_copy_extent(+ struct hfsmount *hfsmp,+ struct vnode *vp, /* The file whose extent is being copied. */+ u_int32_t oldStart, /* The start of the source extent. */+ u_int32_t newStart, /* The start of the destination extent. */+ u_int32_t blockCount, /* The number of allocation blocks to copy. */+ __unused vfs_context_t context)+{+ int err = 0;+ size_t bufferSize;+ void *buffer = NULL;+ struct vfsioattr ioattr;+ buf_t bp = NULL;+ off_t resid;+ size_t ioSize;+ u_int32_t ioSizeSectors; /* Device sectors in this I/O */+ daddr64_t srcSector, destSector;+ u_int32_t sectorsPerBlock = hfsmp->blockSize / hfsmp->hfs_logical_block_size;+#if CONFIG_PROTECT+ int cpenabled = 0;+#endif++ /*+ * Sanity check that we have locked the vnode of the file we're copying.+ *+ * But since hfs_systemfile_lock() doesn't actually take the lock on+ * the allocation file if a journal is active, ignore the check if the+ * file being copied is the allocation file.+ */+ struct cnode *cp = VTOC(vp);+ if (cp != hfsmp->hfs_allocation_cp && cp->c_lockowner != current_thread())+ panic("hfs_copy_extent: vp=%p (cp=%p) not owned?\n", vp, cp);++#if CONFIG_PROTECT+ /*+ * Prepare the CP blob and get it ready for use, if necessary.+ *+ * Note that we specifically *exclude* system vnodes (catalog, bitmap, extents, EAs),+ * because they are implicitly protected via the media key on iOS. As such, they+ * must not be relocated except with the media key. So it is OK to not pass down+ * a special cpentry to the IOMedia/LwVM code for handling.+ */+ if (!vnode_issystem (vp) && vnode_isreg(vp) && cp_fs_protected (hfsmp->hfs_mp)) {+ cpenabled = 1;+ }+#endif++ /*+ * Determine the I/O size to use+ *+ * NOTE: Many external drives will result in an ioSize of 128KB.+ * TODO: Should we use a larger buffer, doing several consecutive+ * reads, then several consecutive writes?+ */+ vfs_ioattr(hfsmp->hfs_mp, &ioattr);+ bufferSize = MIN(ioattr.io_maxreadcnt, ioattr.io_maxwritecnt);+ buffer = hfs_malloc_data(bufferSize);++ /* Get a buffer for doing the I/O */+ bp = buf_alloc(hfsmp->hfs_devvp);+ buf_setdataptr(bp, (uintptr_t)buffer);++ resid = (off_t) blockCount * (off_t) hfsmp->blockSize;+ srcSector = (daddr64_t) oldStart * hfsmp->blockSize / hfsmp->hfs_logical_block_size;+ destSector = (daddr64_t) newStart * hfsmp->blockSize / hfsmp->hfs_logical_block_size;+ while (resid > 0) {+ ioSize = MIN(bufferSize, (size_t) resid);+ ioSizeSectors = ioSize / hfsmp->hfs_logical_block_size;++ /* Prepare the buffer for reading */+ buf_reset(bp, B_READ);+ buf_setsize(bp, ioSize);+ buf_setcount(bp, ioSize);+ buf_setblkno(bp, srcSector);+ buf_setlblkno(bp, srcSector);++ /*+ * Note that because this is an I/O to the device vp+ * it is correct to have lblkno and blkno both point to the+ * start sector being read from. If it were being issued against the+ * underlying file then that would be different.+ */++ /* Attach the new CP blob to the buffer if needed */+#if CONFIG_PROTECT+ if (cpenabled) {+ /* attach the RELOCATION_INFLIGHT flag for the underlying call to VNOP_STRATEGY */+ cp->c_cpentry->cp_flags |= CP_RELOCATION_INFLIGHT;+ bufattr_setcpx(buf_attr(bp), hfsmp->hfs_resize_cpx);++ /* Initialize the content protection file offset to start at 0 */+ bufattr_setcpoff(buf_attr(bp), 0);+ }+#endif++ /* Do the read */+ err = VNOP_STRATEGY(bp);+ if (!err)+ err = buf_biowait(bp);+ if (err) {+#if CONFIG_PROTECT+ /* Turn the flag off in error cases. */+ if (cpenabled) {+ cp->c_cpentry->cp_flags &= ~CP_RELOCATION_INFLIGHT;+ }+#endif+ printf("hfs_copy_extent: Error %d from VNOP_STRATEGY (read)\n", err);+ break;+ }++ /* Prepare the buffer for writing */+ buf_reset(bp, B_WRITE);+ buf_setsize(bp, ioSize);+ buf_setcount(bp, ioSize);+ buf_setblkno(bp, destSector);+ buf_setlblkno(bp, destSector);+ if (vnode_issystem(vp) && journal_uses_fua(hfsmp->jnl))+ buf_markfua(bp);++#if CONFIG_PROTECT+ /* Attach the CP to the buffer if needed */+ if (cpenabled) {+ bufattr_setcpx(buf_attr(bp), hfsmp->hfs_resize_cpx);+ /*+ * The last STRATEGY call may have updated the cp file offset behind our+ * back, so we cannot trust it. Re-initialize the content protection+ * file offset back to 0 before initiating the write portion of this I/O.+ */+ bufattr_setcpoff(buf_attr(bp), 0);+ }+#endif++ /* Do the write */+ vnode_startwrite(hfsmp->hfs_devvp);+ err = VNOP_STRATEGY(bp);+ if (!err) {+ err = buf_biowait(bp);+ }+#if CONFIG_PROTECT+ /* Turn the flag off regardless once the strategy call finishes. */+ if (cpenabled) {+ cp->c_cpentry->cp_flags &= ~CP_RELOCATION_INFLIGHT;+ }+#endif+ if (err) {+ printf("hfs_copy_extent: Error %d from VNOP_STRATEGY (write)\n", err);+ break;+ }++ resid -= ioSize;+ srcSector += ioSizeSectors;+ destSector += ioSizeSectors;+ }+ if (bp)+ buf_free(bp);+ hfs_free_data(buffer, bufferSize);++ /* Make sure all writes have been flushed to disk. */+ if (vnode_issystem(vp) && !journal_uses_fua(hfsmp->jnl)) {++ err = hfs_flush(hfsmp, HFS_FLUSH_CACHE);+ if (err) {+ printf("hfs_copy_extent: hfs_flush failed (%d)\n", err);+ err = 0; /* Don't fail the copy. */+ }+ }++ if (!err)+ hfs_invalidate_sectors(vp, (daddr64_t)oldStart*sectorsPerBlock, (daddr64_t)blockCount*sectorsPerBlock);++ return err;+}+++/* Structure to store state of reclaiming extents from a+ * given file. hfs_reclaim_file()/hfs_reclaim_xattr()+ * initializes the values in this structure which are then+ * used by code that reclaims and splits the extents.+ */+struct hfs_reclaim_extent_info {+ struct vnode *vp;+ u_int32_t fileID;+ u_int8_t forkType;+ u_int8_t is_dirlink; /* Extent belongs to directory hard link */+ u_int8_t is_sysfile; /* Extent belongs to system file */+ u_int8_t is_xattr; /* Extent belongs to extent-based xattr */+ u_int8_t extent_index;+ int lockflags; /* Locks that reclaim and split code should grab before modifying the extent record */+ u_int32_t blocks_relocated; /* Total blocks relocated for this file till now */+ u_int32_t recStartBlock; /* File allocation block number (FABN) for current extent record */+ u_int32_t cur_blockCount; /* Number of allocation blocks that have been checked for reclaim */+ struct filefork *catalog_fp; /* If non-NULL, extent is from catalog record */+ union record {+ HFSPlusExtentRecord overflow;/* Extent record from overflow extents btree */+ HFSPlusAttrRecord xattr; /* Attribute record for large EAs */+ } record;+ HFSPlusExtentDescriptor *extents; /* Pointer to current extent record being processed.+ * For catalog extent record, points to the correct+ * extent information in filefork. For overflow extent+ * record, or xattr record, points to extent record+ * in the structure above+ */+ struct cat_desc *dirlink_desc;+ struct cat_attr *dirlink_attr;+ struct filefork *dirlink_fork; /* For directory hard links, fp points actually to this */+ struct BTreeIterator *iterator; /* Shared read/write iterator, hfs_reclaim_file/xattr()+ * use it for reading and hfs_reclaim_extent()/hfs_split_extent()+ * use it for writing updated extent record+ */+ struct FSBufferDescriptor btdata; /* Shared btdata for reading/writing extent record, same as iterator above */+ u_int16_t recordlen;+ int overflow_count; /* For debugging, counter for overflow extent record */+ FCB *fcb; /* Pointer to the current btree being traversed */+};++/*+ * Split the current extent into two extents, with first extent+ * to contain given number of allocation blocks. Splitting of+ * extent creates one new extent entry which can result in+ * shifting of many entries through all the extent records of a+ * file, and/or creating a new extent record in the overflow+ * extent btree.+ *+ * Example:+ * The diagram below represents two consecutive extent records,+ * for simplicity, lets call them record X and X+1 respectively.+ * Interesting extent entries have been denoted by letters.+ * If the letter is unchanged before and after split, it means+ * that the extent entry was not modified during the split.+ * A '.' means that the entry remains unchanged after the split+ * and is not relevant for our example. A '0' means that the+ * extent entry is empty.+ *+ * If there isn't sufficient contiguous free space to relocate+ * an extent (extent "C" below), we will have to break the one+ * extent into multiple smaller extents, and relocate each of+ * the smaller extents individually. The way we do this is by+ * finding the largest contiguous free space that is currently+ * available (N allocation blocks), and then convert extent "C"+ * into two extents, C1 and C2, that occupy exactly the same+ * allocation blocks as extent C. Extent C1 is the first+ * N allocation blocks of extent C, and extent C2 is the remainder+ * of extent C. Then we can relocate extent C1 since we know+ * we have enough contiguous free space to relocate it in its+ * entirety. We then repeat the process starting with extent C2.+ *+ * In record X, only the entries following entry C are shifted, and+ * the original entry C is replaced with two entries C1 and C2 which+ * are actually two extent entries for contiguous allocation blocks.+ *+ * Note that the entry E from record X is shifted into record X+1 as+ * the new first entry. Since the first entry of record X+1 is updated,+ * the FABN will also get updated with the blockCount of entry E.+ * This also results in shifting of all extent entries in record X+1.+ * Note that the number of empty entries after the split has been+ * changed from 3 to 2.+ *+ * Before:+ * record X record X+1+ * ---------------------===--------- ---------------------------------+ * | A | . | . | . | B | C | D | E | | F | . | . | . | G | 0 | 0 | 0 |+ * ---------------------===--------- ---------------------------------+ *+ * After:+ * ---------------------=======----- ---------------------------------+ * | A | . | . | . | B | C1| C2| D | | E | F | . | . | . | G | 0 | 0 |+ * ---------------------=======----- ---------------------------------+ *+ * C1.startBlock = C.startBlock+ * C1.blockCount = N+ *+ * C2.startBlock = C.startBlock + N+ * C2.blockCount = C.blockCount - N+ *+ * FABN = old FABN - E.blockCount+ *+ * Inputs:+ * extent_info - This is the structure that contains state about+ * the current file, extent, and extent record that+ * is being relocated. This structure is shared+ * among code that traverses through all the extents+ * of the file, code that relocates extents, and+ * code that splits the extent.+ * newBlockCount - The blockCount of the extent to be split after+ * successfully split operation.+ * Output:+ * Zero on success, non-zero on failure.+ */+static int+hfs_split_extent(struct hfs_reclaim_extent_info *extent_info, uint32_t newBlockCount)+{+ int error = 0;+ int index = extent_info->extent_index;+ int i;+ HFSPlusExtentDescriptor shift_extent; /* Extent entry that should be shifted into next extent record */+ HFSPlusExtentDescriptor last_extent;+ HFSPlusExtentDescriptor *extents; /* Pointer to current extent record being manipulated */+ HFSPlusExtentRecord *extents_rec = NULL;+ HFSPlusExtentKey *extents_key = NULL;+ HFSPlusAttrRecord *xattr_rec = NULL;+ HFSPlusAttrKey *xattr_key = NULL;+ struct BTreeIterator iterator;+ struct FSBufferDescriptor btdata;+ uint16_t reclen;+ uint32_t read_recStartBlock; /* Starting allocation block number to read old extent record */+ uint32_t write_recStartBlock; /* Starting allocation block number to insert newly updated extent record */+ Boolean create_record = false;+ Boolean is_xattr;+ struct cnode *cp;++ is_xattr = extent_info->is_xattr;+ extents = extent_info->extents;+ cp = VTOC(extent_info->vp);++ if (newBlockCount == 0) {+ if (hfs_resize_debug) {+ printf ("hfs_split_extent: No splitting required for newBlockCount=0\n");+ }+ return error;+ }++ if (hfs_resize_debug) {+ printf ("hfs_split_extent: Split record:%u recStartBlock=%u %u:(%u,%u) for %u blocks\n", extent_info->overflow_count, extent_info->recStartBlock, index, extents[index].startBlock, extents[index].blockCount, newBlockCount);+ }++ /* Extents overflow btree can not have more than 8 extents.+ * No split allowed if the 8th extent is already used.+ */+ if ((extent_info->fileID == kHFSExtentsFileID) && (extents[kHFSPlusExtentDensity - 1].blockCount != 0)) {+ printf ("hfs_split_extent: Maximum 8 extents allowed for extents overflow btree, cannot split further.\n");+ error = ENOSPC;+ goto out;+ }++ /* Determine the starting allocation block number for the following+ * overflow extent record, if any, before the current record+ * gets modified.+ */+ read_recStartBlock = extent_info->recStartBlock;+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ if (extents[i].blockCount == 0) {+ break;+ }+ read_recStartBlock += extents[i].blockCount;+ }++ /* Shift and split */+ if (index == kHFSPlusExtentDensity-1) {+ /* The new extent created after split will go into following overflow extent record */+ shift_extent.startBlock = extents[index].startBlock + newBlockCount;+ shift_extent.blockCount = extents[index].blockCount - newBlockCount;++ /* Last extent in the record will be split, so nothing to shift */+ } else {+ /* Splitting of extents can result in at most of one+ * extent entry to be shifted into following overflow extent+ * record. So, store the last extent entry for later.+ */+ shift_extent = extents[kHFSPlusExtentDensity-1];+ if ((hfs_resize_debug) && (shift_extent.blockCount != 0)) {+ printf ("hfs_split_extent: Save 7:(%u,%u) to shift into overflow record\n", shift_extent.startBlock, shift_extent.blockCount);+ }++ /* Start shifting extent information from the end of the extent+ * record to the index where we want to insert the new extent.+ * Note that kHFSPlusExtentDensity-1 is already saved above, and+ * does not need to be shifted. The extent entry that is being+ * split does not get shifted.+ */+ for (i = kHFSPlusExtentDensity-2; i > index; i--) {+ if (hfs_resize_debug) {+ if (extents[i].blockCount) {+ printf ("hfs_split_extent: Shift %u:(%u,%u) to %u:(%u,%u)\n", i, extents[i].startBlock, extents[i].blockCount, i+1, extents[i].startBlock, extents[i].blockCount);+ }+ }+ extents[i+1] = extents[i];+ }+ }++ if (index == kHFSPlusExtentDensity-1) {+ /* The second half of the extent being split will be the overflow+ * entry that will go into following overflow extent record. The+ * value has been stored in 'shift_extent' above, so there is+ * nothing to be done here.+ */+ } else {+ /* Update the values in the second half of the extent being split+ * before updating the first half of the split. Note that the+ * extent to split or first half of the split is at index 'index'+ * and a new extent or second half of the split will be inserted at+ * 'index+1' or into following overflow extent record.+ */+ extents[index+1].startBlock = extents[index].startBlock + newBlockCount;+ extents[index+1].blockCount = extents[index].blockCount - newBlockCount;+ }+ /* Update the extent being split, only the block count will change */+ extents[index].blockCount = newBlockCount;++ if (hfs_resize_debug) {+ printf ("hfs_split_extent: Split %u:(%u,%u) and ", index, extents[index].startBlock, extents[index].blockCount);+ if (index != kHFSPlusExtentDensity-1) {+ printf ("%u:(%u,%u)\n", index+1, extents[index+1].startBlock, extents[index+1].blockCount);+ } else {+ printf ("overflow:(%u,%u)\n", shift_extent.startBlock, shift_extent.blockCount);+ }+ }++ /* Write out information about the newly split extent to the disk */+ if (extent_info->catalog_fp) {+ /* (extent_info->catalog_fp != NULL) means the newly split+ * extent exists in the catalog record. This means that+ * the cnode was updated. Therefore, to write out the changes,+ * mark the cnode as modified. We cannot call hfs_update()+ * in this function because the caller hfs_reclaim_extent()+ * is holding the catalog lock currently.+ */+ cp->c_flag |= C_MODIFIED;+ } else {+ /* The newly split extent is for large EAs or is in overflow+ * extent record, so update it directly in the btree using the+ * iterator information from the shared extent_info structure+ */+ error = BTReplaceRecord(extent_info->fcb, extent_info->iterator,+ &(extent_info->btdata), extent_info->recordlen);+ if (error) {+ printf ("hfs_split_extent: fileID=%u BTReplaceRecord returned error=%d\n", extent_info->fileID, error);+ goto out;+ }+ }++ /* No extent entry to be shifted into another extent overflow record */+ if (shift_extent.blockCount == 0) {+ if (hfs_resize_debug) {+ printf ("hfs_split_extent: No extent entry to be shifted into overflow records\n");+ }+ error = 0;+ goto out;+ }++ /* The overflow extent entry has to be shifted into an extent+ * overflow record. This means that we might have to shift+ * extent entries from all subsequent overflow records by one.+ * We start iteration from the first record to the last record,+ * and shift the extent entry from one record to another.+ * We might have to create a new extent record for the last+ * extent entry for the file.+ */++ /* Initialize iterator to search the next record */+ bzero(&iterator, sizeof(iterator));+ if (is_xattr) {+ /* Copy the key from the iterator that was used to update the modified attribute record. */+ xattr_key = (HFSPlusAttrKey *)&(iterator.key);+ bcopy((HFSPlusAttrKey *)&(extent_info->iterator->key), xattr_key, sizeof(HFSPlusAttrKey));+ /* Note: xattr_key->startBlock will be initialized later in the iteration loop */++ xattr_rec = hfs_malloc_type(HFSPlusAttrRecord);++ btdata.bufferAddress = xattr_rec;+ btdata.itemSize = sizeof(HFSPlusAttrRecord);+ btdata.itemCount = 1;+ extents = xattr_rec->overflowExtents.extents;+ } else {+ /* Initialize the extent key for the current file */+ extents_key = (HFSPlusExtentKey *) &(iterator.key);+ extents_key->keyLength = kHFSPlusExtentKeyMaximumLength;+ extents_key->forkType = extent_info->forkType;+ extents_key->fileID = extent_info->fileID;+ /* Note: extents_key->startBlock will be initialized later in the iteration loop */++ extents_rec = hfs_malloc_type(HFSPlusExtentRecord);++ btdata.bufferAddress = extents_rec;+ btdata.itemSize = sizeof(HFSPlusExtentRecord);+ btdata.itemCount = 1;+ extents = extents_rec[0];+ }++ /* The overflow extent entry has to be shifted into an extent+ * overflow record. This means that we might have to shift+ * extent entries from all subsequent overflow records by one.+ * We start iteration from the first record to the last record,+ * examine one extent record in each iteration and shift one+ * extent entry from one record to another. We might have to+ * create a new extent record for the last extent entry for the+ * file.+ *+ * If shift_extent.blockCount is non-zero, it means that there is+ * an extent entry that needs to be shifted into the next+ * overflow extent record. We keep on going till there are no such+ * entries left to be shifted. This will also change the starting+ * allocation block number of the extent record which is part of+ * the key for the extent record in each iteration. Note that+ * because the extent record key is changing while we are searching,+ * the record can not be updated directly, instead it has to be+ * deleted and inserted again.+ */+ while (shift_extent.blockCount) {+ if (hfs_resize_debug) {+ printf ("hfs_split_extent: Will shift (%u,%u) into overflow record with startBlock=%u\n", shift_extent.startBlock, shift_extent.blockCount, read_recStartBlock);+ }++ /* Search if there is any existing overflow extent record+ * that matches the current file and the logical start block+ * number.+ *+ * For this, the logical start block number in the key is+ * the value calculated based on the logical start block+ * number of the current extent record and the total number+ * of blocks existing in the current extent record.+ */+ if (is_xattr) {+ xattr_key->startBlock = read_recStartBlock;+ } else {+ extents_key->startBlock = read_recStartBlock;+ }+ error = BTSearchRecord(extent_info->fcb, &iterator, &btdata, &reclen, &iterator);+ if (error) {+ if (error != btNotFound) {+ printf ("hfs_split_extent: fileID=%u startBlock=%u BTSearchRecord error=%d\n", extent_info->fileID, read_recStartBlock, error);+ goto out;+ }+ /* No matching record was found, so create a new extent record.+ * Note: Since no record was found, we can't rely on the+ * btree key in the iterator any longer. This will be initialized+ * later before we insert the record.+ */+ create_record = true;+ }++ /* The extra extent entry from the previous record is being inserted+ * as the first entry in the current extent record. This will change+ * the file allocation block number (FABN) of the current extent+ * record, which is the startBlock value from the extent record key.+ * Since one extra entry is being inserted in the record, the new+ * FABN for the record will less than old FABN by the number of blocks+ * in the new extent entry being inserted at the start. We have to+ * do this before we update read_recStartBlock to point at the+ * startBlock of the following record.+ */+ write_recStartBlock = read_recStartBlock - shift_extent.blockCount;+ if (hfs_resize_debug) {+ if (create_record) {+ printf ("hfs_split_extent: No records found for startBlock=%u, will create new with startBlock=%u\n", read_recStartBlock, write_recStartBlock);+ }+ }++ /* Now update the read_recStartBlock to account for total number+ * of blocks in this extent record. It will now point to the+ * starting allocation block number for the next extent record.+ */+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ if (extents[i].blockCount == 0) {+ break;+ }+ read_recStartBlock += extents[i].blockCount;+ }++ if (create_record == true) {+ /* Initialize new record content with only one extent entry */+ bzero(extents, sizeof(HFSPlusExtentRecord));+ /* The new record will contain only one extent entry */+ extents[0] = shift_extent;+ /* There are no more overflow extents to be shifted */+ shift_extent.startBlock = shift_extent.blockCount = 0;++ if (is_xattr) {+ /* BTSearchRecord above returned btNotFound,+ * but since the attribute btree is never empty+ * if we are trying to insert new overflow+ * record for the xattrs, the extents_key will+ * contain correct data. So we don't need to+ * re-initialize it again like below.+ */++ /* Initialize the new xattr record */+ xattr_rec->recordType = kHFSPlusAttrExtents;+ xattr_rec->overflowExtents.reserved = 0;+ reclen = sizeof(HFSPlusAttrExtents);+ } else {+ /* BTSearchRecord above returned btNotFound,+ * which means that extents_key content might+ * not correspond to the record that we are+ * trying to create, especially when the extents+ * overflow btree is empty. So we reinitialize+ * the extents_key again always.+ */+ extents_key->keyLength = kHFSPlusExtentKeyMaximumLength;+ extents_key->forkType = extent_info->forkType;+ extents_key->fileID = extent_info->fileID;++ /* Initialize the new extent record */+ reclen = sizeof(HFSPlusExtentRecord);+ }+ } else {+ /* The overflow extent entry from previous record will be+ * the first entry in this extent record. If the last+ * extent entry in this record is valid, it will be shifted+ * into the following extent record as its first entry. So+ * save the last entry before shifting entries in current+ * record.+ */+ last_extent = extents[kHFSPlusExtentDensity-1];++ /* Shift all entries by one index towards the end */+ for (i = kHFSPlusExtentDensity-2; i >= 0; i--) {+ extents[i+1] = extents[i];+ }++ /* Overflow extent entry saved from previous record+ * is now the first entry in the current record.+ */+ extents[0] = shift_extent;++ if (hfs_resize_debug) {+ printf ("hfs_split_extent: Shift overflow=(%u,%u) to record with updated startBlock=%u\n", shift_extent.startBlock, shift_extent.blockCount, write_recStartBlock);+ }++ /* The last entry from current record will be the+ * overflow entry which will be the first entry for+ * the following extent record.+ */+ shift_extent = last_extent;++ /* Since the key->startBlock is being changed for this record,+ * it should be deleted and inserted with the new key.+ */+ error = BTDeleteRecord(extent_info->fcb, &iterator);+ if (error) {+ printf ("hfs_split_extent: fileID=%u startBlock=%u BTDeleteRecord error=%d\n", extent_info->fileID, read_recStartBlock, error);+ goto out;+ }+ if (hfs_resize_debug) {+ printf ("hfs_split_extent: Deleted extent record with startBlock=%u\n", (is_xattr ? xattr_key->startBlock : extents_key->startBlock));+ }+ }++ /* Insert the newly created or modified extent record */+ bzero(&iterator.hint, sizeof(iterator.hint));+ if (is_xattr) {+ xattr_key->startBlock = write_recStartBlock;+ } else {+ extents_key->startBlock = write_recStartBlock;+ }+ error = BTInsertRecord(extent_info->fcb, &iterator, &btdata, reclen);+ if (error) {+ printf ("hfs_split_extent: fileID=%u, startBlock=%u BTInsertRecord error=%d\n", extent_info->fileID, write_recStartBlock, error);+ goto out;+ }+ if (hfs_resize_debug) {+ printf ("hfs_split_extent: Inserted extent record with startBlock=%u\n", write_recStartBlock);+ }+ }++out:+ /*+ * Extents overflow btree or attributes btree headers might have+ * been modified during the split/shift operation, so flush the+ * changes to the disk while we are inside journal transaction.+ * We should only be able to generate I/O that modifies the B-Tree+ * header nodes while we're in the middle of a journal transaction.+ * Otherwise it might result in panic during unmount.+ */+ BTFlushPath(extent_info->fcb);++ hfs_free_type(extents_rec, HFSPlusExtentRecord);+ hfs_free_type(xattr_rec, HFSPlusAttrRecord);+ return error;+}+++/*+ * Relocate an extent if it lies beyond the expected end of volume.+ *+ * This function is called for every extent of the file being relocated.+ * It allocates space for relocation, copies the data, deallocates+ * the old extent, and update corresponding on-disk extent. If the function+ * does not find contiguous space to relocate an extent, it splits the+ * extent in smaller size to be able to relocate it out of the area of+ * disk being reclaimed. As an optimization, if an extent lies partially+ * in the area of the disk being reclaimed, it is split so that we only+ * have to relocate the area that was overlapping with the area of disk+ * being reclaimed.+ *+ * Note that every extent is relocated in its own transaction so that+ * they do not overwhelm the journal. This function handles the extent+ * record that exists in the catalog record, extent record from overflow+ * extents btree, and extents for large EAs.+ *+ * Inputs:+ * extent_info - This is the structure that contains state about+ * the current file, extent, and extent record that+ * is being relocated. This structure is shared+ * among code that traverses through all the extents+ * of the file, code that relocates extents, and+ * code that splits the extent.+ */+static int+hfs_reclaim_extent(struct hfsmount *hfsmp, const u_long allocLimit, struct hfs_reclaim_extent_info *extent_info, vfs_context_t context)+{+ int error = 0;+ int index;+ struct cnode *cp;+ u_int32_t oldStartBlock;+ u_int32_t oldBlockCount;+ u_int32_t newStartBlock = 0;+ u_int32_t newBlockCount;+ u_int32_t roundedBlockCount;+ uint16_t node_size;+ uint32_t remainder_blocks;+ u_int32_t alloc_flags;+ int blocks_allocated = false;++ index = extent_info->extent_index;+ cp = VTOC(extent_info->vp);++ oldStartBlock = extent_info->extents[index].startBlock;+ oldBlockCount = extent_info->extents[index].blockCount;++ if (0 && hfs_resize_debug) {+ printf ("hfs_reclaim_extent: Examine record:%u recStartBlock=%u, %u:(%u,%u)\n", extent_info->overflow_count, extent_info->recStartBlock, index, oldStartBlock, oldBlockCount);+ }++ /* If the current extent lies completely within allocLimit,+ * it does not require any relocation.+ */+ if ((oldStartBlock + oldBlockCount) <= allocLimit) {+ extent_info->cur_blockCount += oldBlockCount;+ return error;+ }++ /* Every extent should be relocated in its own transaction+ * to make sure that we don't overflow the journal buffer.+ */+ error = hfs_start_transaction(hfsmp);+ if (error) {+ return error;+ }+ extent_info->lockflags = hfs_systemfile_lock(hfsmp, extent_info->lockflags, HFS_EXCLUSIVE_LOCK);++ /* Check if the extent lies partially in the area to reclaim,+ * i.e. it starts before allocLimit and ends beyond allocLimit.+ * We have already skipped extents that lie completely within+ * allocLimit in the check above, so we only check for the+ * startBlock. If it lies partially, split it so that we+ * only relocate part of the extent.+ */+ if (oldStartBlock < allocLimit) {+ newBlockCount = allocLimit - oldStartBlock;++ if (hfs_resize_debug) {+ int idx = extent_info->extent_index;+ printf ("hfs_reclaim_extent: Split straddling extent %u:(%u,%u) for %u blocks\n", idx, extent_info->extents[idx].startBlock, extent_info->extents[idx].blockCount, newBlockCount);+ }++ /* If the extent belongs to a btree, check and trim+ * it to be multiple of the node size.+ */+ if (extent_info->is_sysfile) {+ node_size = get_btree_nodesize(extent_info->vp);+ /* If the btree node size is less than the block size,+ * splitting this extent will not split a node across+ * different extents. So we only check and trim if+ * node size is more than the allocation block size.+ */+ if (node_size > hfsmp->blockSize) {+ remainder_blocks = newBlockCount % (node_size / hfsmp->blockSize);+ if (remainder_blocks) {+ newBlockCount -= remainder_blocks;+ if (hfs_resize_debug) {+ printf ("hfs_reclaim_extent: Round-down newBlockCount to be multiple of nodeSize, node_allocblks=%u, old=%u, new=%u\n", node_size/hfsmp->blockSize, newBlockCount + remainder_blocks, newBlockCount);+ }+ }+ }+ /* The newBlockCount is zero because of rounding-down so that+ * btree nodes are not split across extents. Therefore this+ * straddling extent across resize-boundary does not require+ * splitting. Skip over to relocating of complete extent.+ */+ if (newBlockCount == 0) {+ if (hfs_resize_debug) {+ printf ("hfs_reclaim_extent: After round-down newBlockCount=0, skip split, relocate full extent\n");+ }+ goto relocate_full_extent;+ }+ }++ /* Split the extents into two parts --- the first extent lies+ * completely within allocLimit and therefore does not require+ * relocation. The second extent will require relocation which+ * will be handled when the caller calls this function again+ * for the next extent.+ */+ error = hfs_split_extent(extent_info, newBlockCount);+ if (error == 0) {+ /* Split success, no relocation required */+ goto out;+ }+ /* Split failed, so try to relocate entire extent */+ if (hfs_resize_debug) {+ int idx = extent_info->extent_index;+ printf ("hfs_reclaim_extent: Split straddling extent %u:(%u,%u) for %u blocks failed, relocate full extent\n", idx, extent_info->extents[idx].startBlock, extent_info->extents[idx].blockCount, newBlockCount);+ }+ }++relocate_full_extent:+ /* At this point, the current extent requires relocation.+ * We will try to allocate space equal to the size of the extent+ * being relocated first to try to relocate it without splitting.+ * If the allocation fails, we will try to allocate contiguous+ * blocks out of metadata zone. If that allocation also fails,+ * then we will take a whatever contiguous block run is returned+ * by the allocation, split the extent into two parts, and then+ * relocate the first splitted extent.+ */+ alloc_flags = HFS_ALLOC_FORCECONTIG | HFS_ALLOC_SKIPFREEBLKS;+ if (extent_info->is_sysfile) {+ alloc_flags |= HFS_ALLOC_METAZONE;+ }++ error = BlockAllocate(hfsmp, 1, oldBlockCount, oldBlockCount, alloc_flags,+ &newStartBlock, &newBlockCount);+ if ((extent_info->is_sysfile == false) &&+ ((error == dskFulErr) || (error == ENOSPC))) {+ /* For non-system files, try reallocating space in metadata zone */+ alloc_flags |= HFS_ALLOC_METAZONE;+ error = BlockAllocate(hfsmp, 1, oldBlockCount, oldBlockCount,+ alloc_flags, &newStartBlock, &newBlockCount);+ }+ if ((error == dskFulErr) || (error == ENOSPC)) {+ /*+ * We did not find desired contiguous space for this+ * extent, when we asked for it, including the metazone allocations.+ * At this point we are not worrying about getting contiguity anymore.+ *+ * HOWEVER, if we now allow blocks to be used which were recently+ * de-allocated, we may find a contiguous range (though this seems+ * unlikely). As a result, assume that we will have to split the+ * current extent into two pieces, but if we are able to satisfy+ * the request with a single extent, detect that as well.+ */+ alloc_flags &= ~HFS_ALLOC_FORCECONTIG;+ alloc_flags |= HFS_ALLOC_FLUSHTXN;++ error = BlockAllocate(hfsmp, 1, oldBlockCount, oldBlockCount,+ alloc_flags, &newStartBlock, &newBlockCount);+ if (error) {+ printf ("hfs_reclaim_extent: fileID=%u start=%u, %u:(%u,%u) BlockAllocate error=%d\n", extent_info->fileID, extent_info->recStartBlock, index, oldStartBlock, oldBlockCount, error);+ goto out;+ }++ /*+ * Allowing recently deleted extents may now allow us to find+ * a single contiguous extent in the amount & size desired. If so,+ * do NOT split this extent into two pieces. This is technically a+ * check for "< oldBlockCount", but we use != to highlight the point+ * that the special case is when they're equal. The allocator should+ * never vend back more blocks than were requested.+ */+ if (newBlockCount != oldBlockCount) {+ blocks_allocated = true;++ /* The number of blocks allocated is less than the requested+ * number of blocks. For btree extents, check and trim the+ * extent to be multiple of the node size.+ */+ if (extent_info->is_sysfile) {+ node_size = get_btree_nodesize(extent_info->vp);+ if (node_size > hfsmp->blockSize) {+ remainder_blocks = newBlockCount % (node_size / hfsmp->blockSize);+ if (remainder_blocks) {+ roundedBlockCount = newBlockCount - remainder_blocks;+ /* Free tail-end blocks of the newly allocated extent */+ BlockDeallocate(hfsmp, newStartBlock + roundedBlockCount,+ newBlockCount - roundedBlockCount,+ HFS_ALLOC_SKIPFREEBLKS);+ newBlockCount = roundedBlockCount;+ if (hfs_resize_debug) {+ printf ("hfs_reclaim_extent: Fixing extent block count, node_blks=%u, old=%u, new=%u\n", node_size/hfsmp->blockSize, newBlockCount + remainder_blocks, newBlockCount);+ }+ if (newBlockCount == 0) {+ printf ("hfs_reclaim_extent: Not enough contiguous blocks available to relocate fileID=%d\n", extent_info->fileID);+ error = ENOSPC;+ goto out;+ }+ }+ }+ }++ /* The number of blocks allocated is less than the number of+ * blocks requested, so split this extent --- the first extent+ * will be relocated as part of this function call and the caller+ * will handle relocating the second extent by calling this+ * function again for the second extent.+ */+ error = hfs_split_extent(extent_info, newBlockCount);+ if (error) {+ printf ("hfs_reclaim_extent: fileID=%u start=%u, %u:(%u,%u) split error=%d\n", extent_info->fileID, extent_info->recStartBlock, index, oldStartBlock, oldBlockCount, error);+ goto out;+ }+ oldBlockCount = newBlockCount;+ } /* end oldBlockCount != newBlockCount */+ } /* end allocation request for any available free space */++ if (error) {+ printf ("hfs_reclaim_extent: fileID=%u start=%u, %u:(%u,%u) contig BlockAllocate error=%d\n", extent_info->fileID, extent_info->recStartBlock, index, oldStartBlock, oldBlockCount, error);+ goto out;+ }+ blocks_allocated = true;++ /* Copy data from old location to new location */+ error = hfs_copy_extent(hfsmp, extent_info->vp, oldStartBlock,+ newStartBlock, newBlockCount, context);+ if (error) {+ printf ("hfs_reclaim_extent: fileID=%u start=%u, %u:(%u,%u)=>(%u,%u) hfs_copy_extent error=%d\n", extent_info->fileID, extent_info->recStartBlock, index, oldStartBlock, oldBlockCount, newStartBlock, newBlockCount, error);+ goto out;+ }++ /* Update the extent record with the new start block information */+ extent_info->extents[index].startBlock = newStartBlock;++ /* Sync the content back to the disk */+ if (extent_info->catalog_fp) {+ /* Update the extents in catalog record */+ if (extent_info->is_dirlink) {+ error = cat_update_dirlink(hfsmp, extent_info->forkType,+ extent_info->dirlink_desc, extent_info->dirlink_attr,+ &(extent_info->dirlink_fork->ff_data));+ } else {+ cp->c_flag |= C_MODIFIED;+ /* If this is a system file, sync volume headers on disk */+ if (extent_info->is_sysfile) {+ error = hfs_flushvolumeheader(hfsmp, HFS_FVH_WAIT | HFS_FVH_WRITE_ALT);+ }+ }+ } else {+ /* Replace record for extents overflow or extents-based xattrs */+ error = BTReplaceRecord(extent_info->fcb, extent_info->iterator,+ &(extent_info->btdata), extent_info->recordlen);+ }+ if (error) {+ printf ("hfs_reclaim_extent: fileID=%u, update record error=%u\n", extent_info->fileID, error);+ goto out;+ }++ /* Deallocate the old extent */+ error = BlockDeallocate(hfsmp, oldStartBlock, oldBlockCount, HFS_ALLOC_SKIPFREEBLKS);+ if (error) {+ printf ("hfs_reclaim_extent: fileID=%u start=%u, %u:(%u,%u) BlockDeallocate error=%d\n", extent_info->fileID, extent_info->recStartBlock, index, oldStartBlock, oldBlockCount, error);+ goto out;+ }+ extent_info->blocks_relocated += newBlockCount;++ if (hfs_resize_debug) {+ printf ("hfs_reclaim_extent: Relocated record:%u %u:(%u,%u) to (%u,%u)\n", extent_info->overflow_count, index, oldStartBlock, oldBlockCount, newStartBlock, newBlockCount);+ }++out:+ if (error != 0) {+ if (blocks_allocated == true) {+ BlockDeallocate(hfsmp, newStartBlock, newBlockCount, HFS_ALLOC_SKIPFREEBLKS);+ }+ } else {+ /* On success, increment the total allocation blocks processed */+ extent_info->cur_blockCount += newBlockCount;+ }++ hfs_systemfile_unlock(hfsmp, extent_info->lockflags);++ /* For a non-system file, if an extent entry from catalog record+ * was modified, sync the in-memory changes to the catalog record+ * on disk before ending the transaction.+ */+ if ((extent_info->catalog_fp) &&+ (extent_info->is_sysfile == false)) {+ hfs_update(extent_info->vp, 0);+ }++ hfs_end_transaction(hfsmp);++ return error;+}++/* Report intermediate progress during volume resize */+static void+hfs_truncatefs_progress(struct hfsmount *hfsmp)+{+ u_int32_t cur_progress = 0;++ hfs_resize_progress(hfsmp, &cur_progress);+ if (cur_progress > (hfsmp->hfs_resize_progress + 9)) {+ printf("hfs_truncatefs: %d%% done...\n", cur_progress);+ hfsmp->hfs_resize_progress = cur_progress;+ }+ return;+}++/*+ * Reclaim space at the end of a volume for given file and forktype.+ *+ * This routine attempts to move any extent which contains allocation blocks+ * at or after "allocLimit." A separate transaction is used for every extent+ * that needs to be moved. If there is not contiguous space available for+ * moving an extent, it can be split into smaller extents. The contents of+ * any moved extents are read and written via the volume's device vnode --+ * NOT via "vp." During the move, moved blocks which are part of a transaction+ * have their physical block numbers invalidated so they will eventually be+ * written to their new locations.+ *+ * This function is also called for directory hard links. Directory hard links+ * are regular files with no data fork and resource fork that contains alias+ * information for backward compatibility with pre-Leopard systems. However+ * non-Mac OS X implementation can add/modify data fork or resource fork+ * information to directory hard links, so we check, and if required, relocate+ * both data fork and resource fork.+ *+ * Inputs:+ * hfsmp The volume being resized.+ * vp The vnode for the system file.+ * fileID ID of the catalog record that needs to be relocated+ * forktype The type of fork that needs relocated,+ * kHFSResourceForkType for resource fork,+ * kHFSDataForkType for data fork+ * allocLimit Allocation limit for the new volume size,+ * do not use this block or beyond. All extents+ * that use this block or any blocks beyond this limit+ * will be relocated.+ *+ * Side Effects:+ * hfsmp->hfs_resize_blocksmoved is incremented by the number of allocation+ * blocks that were relocated.+ */+static int+hfs_reclaim_file(struct hfsmount *hfsmp, struct vnode *vp, u_int32_t fileID,+ u_int8_t forktype, u_long allocLimit, vfs_context_t context)+{+ int error = 0;+ struct hfs_reclaim_extent_info *extent_info;+ int i;+ int lockflags = 0;+ struct cnode *cp;+ struct filefork *fp;+ int took_truncate_lock = false;+ int release_desc = false;+ HFSPlusExtentKey *key;++ /* If there is no vnode for this file, then there's nothing to do. */+ if (vp == NULL) {+ return 0;+ }++ cp = VTOC(vp);++ if (hfs_resize_debug) {+ const char *filename = (const char *) cp->c_desc.cd_nameptr;+ int namelen = cp->c_desc.cd_namelen;++ if (filename == NULL) {+ filename = "";+ namelen = 0;+ }+ printf("hfs_reclaim_file: reclaiming '%.*s'\n", namelen, filename);+ }++ extent_info = hfs_malloc_type(struct hfs_reclaim_extent_info);++ extent_info->vp = vp;+ extent_info->fileID = fileID;+ extent_info->forkType = forktype;+ extent_info->is_sysfile = vnode_issystem(vp);+ if (vnode_isdir(vp) && (cp->c_flag & C_HARDLINK)) {+ extent_info->is_dirlink = true;+ }+ /* We always need allocation bitmap and extent btree lock */+ lockflags = SFL_BITMAP | SFL_EXTENTS;+ if ((fileID == kHFSCatalogFileID) || (extent_info->is_dirlink == true)) {+ lockflags |= SFL_CATALOG;+ } else if (fileID == kHFSAttributesFileID) {+ lockflags |= SFL_ATTRIBUTE;+ } else if (fileID == kHFSStartupFileID) {+ lockflags |= SFL_STARTUP;+ }+ extent_info->lockflags = lockflags;+ extent_info->fcb = VTOF(hfsmp->hfs_extents_vp);++ /* Flush data associated with current file on disk.+ *+ * If the current vnode is directory hard link, no flushing of+ * journal or vnode is required. The current kernel does not+ * modify data/resource fork of directory hard links, so nothing+ * will be in the cache. If a directory hard link is newly created,+ * the resource fork data is written directly using devvp and+ * the code that actually relocates data (hfs_copy_extent()) also+ * uses devvp for its I/O --- so they will see a consistent copy.+ */+ if (extent_info->is_sysfile) {+ /* If the current vnode is system vnode, flush journal+ * to make sure that all data is written to the disk.+ */+ error = hfs_flush(hfsmp, HFS_FLUSH_JOURNAL_META);+ if (error) {+ printf ("hfs_reclaim_file: journal_flush returned %d\n", error);+ goto out;+ }+ } else if (extent_info->is_dirlink == false) {+ /* Flush all blocks associated with this regular file vnode.+ * Normally there should not be buffer cache blocks for regular+ * files, but for objects like symlinks, we can have buffer cache+ * blocks associated with the vnode. Therefore we call+ * buf_flushdirtyblks() also.+ */+ buf_flushdirtyblks(vp, 0, BUF_SKIP_LOCKED, "hfs_reclaim_file");++ hfs_unlock(cp);+ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ took_truncate_lock = true;+ (void) cluster_push(vp, 0);+ error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ if (error) {+ goto out;+ }++ /* If the file no longer exists, nothing left to do */+ if (cp->c_flag & C_NOEXISTS) {+ error = 0;+ goto out;+ }++ /* Wait for any in-progress writes to this vnode to complete, so that we'll+ * be copying consistent bits. (Otherwise, it's possible that an async+ * write will complete to the old extent after we read from it. That+ * could lead to corruption.)+ */+ error = vnode_waitforwrites(vp, 0, 0, 0, "hfs_reclaim_file");+ if (error) {+ goto out;+ }+ }++ if (hfs_resize_debug) {+ printf("hfs_reclaim_file: === Start reclaiming %sfork for %sid=%u ===\n", (forktype ? "rsrc" : "data"), (extent_info->is_dirlink ? "dirlink" : "file"), fileID);+ }++ if (extent_info->is_dirlink) {+ extent_info->dirlink_desc = hfs_malloc_type(struct cat_desc);+ extent_info->dirlink_attr = hfs_malloc_type(struct cat_attr);+ extent_info->dirlink_fork = hfs_malloc_type(struct filefork);++ /* Lookup catalog record for directory hard link and+ * create a fake filefork for the value looked up from+ * the disk.+ */+ fp = extent_info->dirlink_fork;+ extent_info->dirlink_fork->ff_cp = cp;+ lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);+ error = cat_lookup_dirlink(hfsmp, fileID, forktype,+ extent_info->dirlink_desc, extent_info->dirlink_attr,+ &(extent_info->dirlink_fork->ff_data));+ hfs_systemfile_unlock(hfsmp, lockflags);+ if (error) {+ printf ("hfs_reclaim_file: cat_lookup_dirlink for fileID=%u returned error=%u\n", fileID, error);+ goto out;+ }+ release_desc = true;+ } else {+ fp = VTOF(vp);+ }++ extent_info->catalog_fp = fp;+ extent_info->recStartBlock = 0;+ extent_info->extents = extent_info->catalog_fp->ff_extents;+ /* Relocate extents from the catalog record */+ for (i = 0; i < kHFSPlusExtentDensity; ++i) {+ if (fp->ff_extents[i].blockCount == 0) {+ break;+ }+ extent_info->extent_index = i;+ error = hfs_reclaim_extent(hfsmp, allocLimit, extent_info, context);+ if (error) {+ printf ("hfs_reclaim_file: fileID=%u #%d %u:(%u,%u) hfs_reclaim_extent error=%d\n", fileID, extent_info->overflow_count, i, fp->ff_extents[i].startBlock, fp->ff_extents[i].blockCount, error);+ goto out;+ }+ }++ /* If the number of allocation blocks processed for reclaiming+ * are less than total number of blocks for the file, continuing+ * working on overflow extents record.+ */+ if (fp->ff_blocks <= extent_info->cur_blockCount) {+ if (0 && hfs_resize_debug) {+ printf ("hfs_reclaim_file: Nothing more to relocate, offset=%d, ff_blocks=%u, cur_blockCount=%u\n", i, fp->ff_blocks, extent_info->cur_blockCount);+ }+ goto out;+ }++ if (hfs_resize_debug) {+ printf ("hfs_reclaim_file: Will check overflow records, offset=%d, ff_blocks=%u, cur_blockCount=%u\n", i, fp->ff_blocks, extent_info->cur_blockCount);+ }++ extent_info->iterator = hfs_malloc_type(struct BTreeIterator);+ key = (HFSPlusExtentKey *) &(extent_info->iterator->key);+ key->keyLength = kHFSPlusExtentKeyMaximumLength;+ key->forkType = forktype;+ key->fileID = fileID;+ key->startBlock = extent_info->cur_blockCount;++ extent_info->btdata.bufferAddress = extent_info->record.overflow;+ extent_info->btdata.itemSize = sizeof(HFSPlusExtentRecord);+ extent_info->btdata.itemCount = 1;++ extent_info->catalog_fp = NULL;++ /* Search the first overflow extent with expected startBlock as 'cur_blockCount' */+ lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);+ error = BTSearchRecord(extent_info->fcb, extent_info->iterator,+ &(extent_info->btdata), &(extent_info->recordlen),+ extent_info->iterator);+ hfs_systemfile_unlock(hfsmp, lockflags);+ while (error == 0) {+ extent_info->overflow_count++;+ extent_info->recStartBlock = key->startBlock;+ extent_info->extents = extent_info->record.overflow;+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ if (extent_info->record.overflow[i].blockCount == 0) {+ goto out;+ }+ extent_info->extent_index = i;+ error = hfs_reclaim_extent(hfsmp, allocLimit, extent_info, context);+ if (error) {+ printf ("hfs_reclaim_file: fileID=%u #%d %u:(%u,%u) hfs_reclaim_extent error=%d\n", fileID, extent_info->overflow_count, i, extent_info->record.overflow[i].startBlock, extent_info->record.overflow[i].blockCount, error);+ goto out;+ }+ }++ /* Look for more overflow records */+ lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);+ error = BTIterateRecord(extent_info->fcb, kBTreeNextRecord,+ extent_info->iterator, &(extent_info->btdata),+ &(extent_info->recordlen));+ hfs_systemfile_unlock(hfsmp, lockflags);+ if (error) {+ break;+ }+ /* Stop when we encounter a different file or fork. */+ if ((key->fileID != fileID) || (key->forkType != forktype)) {+ break;+ }+ }+ if (error == fsBTRecordNotFoundErr || error == fsBTEndOfIterationErr) {+ error = 0;+ }++out:+ /* If any blocks were relocated, account them and report progress */+ if (extent_info->blocks_relocated) {+ hfsmp->hfs_resize_blocksmoved += extent_info->blocks_relocated;+ hfs_truncatefs_progress(hfsmp);+ if (fileID < kHFSFirstUserCatalogNodeID) {+ printf ("hfs_reclaim_file: Relocated %u blocks from fileID=%u on \"%s\"\n",+ extent_info->blocks_relocated, fileID, hfsmp->vcbVN);+ }+ }+ if (extent_info->iterator) {+ hfs_free_type(extent_info->iterator, struct BTreeIterator);+ }+ if (release_desc == true) {+ cat_releasedesc(extent_info->dirlink_desc);+ }+ if (extent_info->dirlink_desc) {+ hfs_free_type(extent_info->dirlink_desc, struct cat_desc);+ }+ if (extent_info->dirlink_attr) {+ hfs_free_type(extent_info->dirlink_attr, struct cat_attr);+ }+ if (extent_info->dirlink_fork) {+ hfs_free_type(extent_info->dirlink_fork, struct filefork);+ }+ if ((extent_info->blocks_relocated != 0) && (extent_info->is_sysfile == false)) {+ hfs_update(vp, 0);+ }+ if (took_truncate_lock) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ }+ if (extent_info) {+ hfs_free_type(extent_info, struct hfs_reclaim_extent_info);+ }+ if (hfs_resize_debug) {+ printf("hfs_reclaim_file: === Finished relocating %sfork for fileid=%u (error=%d) ===\n", (forktype ? "rsrc" : "data"), fileID, error);+ }++ return error;+}+++/*+ * This journal_relocate callback updates the journal info block to point+ * at the new journal location. This write must NOT be done using the+ * transaction. We must write the block immediately. We must also force+ * it to get to the media so that the new journal location will be seen by+ * the replay code before we can safely let journaled blocks be written+ * to their normal locations.+ *+ * The tests for journal_uses_fua below are mildly hacky. Since the journal+ * and the file system are both on the same device, I'm leveraging what+ * the journal has decided about FUA.+ */+struct hfs_journal_relocate_args {+ struct hfsmount *hfsmp;+ vfs_context_t context;+ u_int32_t newStartBlock;+ u_int32_t newBlockCount;+};++static errno_t+hfs_journal_relocate_callback(void *_args)+{+ int error;+ struct hfs_journal_relocate_args *args = _args;+ struct hfsmount *hfsmp = args->hfsmp;+ buf_t bp;+ JournalInfoBlock *jibp;++ error = buf_meta_bread(hfsmp->hfs_devvp,+ (uint64_t)hfsmp->vcbJinfoBlock * (hfsmp->blockSize/hfsmp->hfs_logical_block_size),+ hfsmp->blockSize, vfs_context_ucred(args->context), &bp);+ if (error) {+ printf("hfs_journal_relocate_callback: failed to read JIB (%d)\n", error);+ if (bp) {+ buf_brelse(bp);+ }+ return error;+ }+ jibp = (JournalInfoBlock*) buf_dataptr(bp);+ jibp->offset = SWAP_BE64((u_int64_t)args->newStartBlock * hfsmp->blockSize);+ jibp->size = SWAP_BE64((u_int64_t)args->newBlockCount * hfsmp->blockSize);+ if (journal_uses_fua(hfsmp->jnl))+ buf_markfua(bp);+ error = buf_bwrite(bp);+ if (error) {+ printf("hfs_journal_relocate_callback: failed to write JIB (%d)\n", error);+ return error;+ }+ if (!journal_uses_fua(hfsmp->jnl)) {+ error = hfs_flush(hfsmp, HFS_FLUSH_CACHE);+ if (error) {+ printf("hfs_journal_relocate_callback: hfs_flush failed (%d)\n", error);+ error = 0; /* Don't fail the operation. */+ }+ }++ return error;+}+++/* Type of resize operation in progress */+#define HFS_RESIZE_TRUNCATE 1+#define HFS_RESIZE_EXTEND 2++/*+ * Core function to relocate the journal file. This function takes the+ * journal size of the newly relocated journal --- the caller can+ * provide a new journal size if they want to change the size of+ * the journal. The function takes care of updating the journal info+ * block and all other data structures correctly.+ *+ * Note: This function starts a transaction and grabs the btree locks.+ */+static int+hfs_relocate_journal_file(struct hfsmount *hfsmp, u_int32_t jnl_size, int resize_type, vfs_context_t context)+{+ int error;+ int journal_err;+ int lockflags;+ u_int32_t oldStartBlock;+ u_int32_t newStartBlock;+ u_int32_t oldBlockCount;+ u_int32_t newBlockCount;+ u_int32_t jnlBlockCount;+ u_int32_t alloc_skipfreeblks;+ struct cat_desc journal_desc;+ struct cat_attr journal_attr;+ struct cat_fork journal_fork;+ struct hfs_journal_relocate_args callback_args;++ /* Calculate the number of allocation blocks required for the journal */+ jnlBlockCount = howmany(jnl_size, hfsmp->blockSize);++ /*+ * During truncatefs(), the volume free block count is updated+ * before relocating data and reflects the total number of free+ * blocks that will exist on volume after the resize is successful.+ * This means that the allocation blocks required for relocation+ * have already been reserved and accounted for in the free block+ * count. Therefore, block allocation and deallocation routines+ * can skip the free block check by passing HFS_ALLOC_SKIPFREEBLKS+ * flag.+ *+ * This special handling is not required when the file system+ * is being extended as we want all the allocated and deallocated+ * blocks to be accounted for correctly.+ */+ if (resize_type == HFS_RESIZE_TRUNCATE) {+ alloc_skipfreeblks = HFS_ALLOC_SKIPFREEBLKS;+ } else {+ alloc_skipfreeblks = 0;+ }++ error = hfs_start_transaction(hfsmp);+ if (error) {+ printf("hfs_relocate_journal_file: hfs_start_transaction returned %d\n", error);+ return error;+ }+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);++ error = BlockAllocate(hfsmp, 1, jnlBlockCount, jnlBlockCount,+ HFS_ALLOC_METAZONE | HFS_ALLOC_FORCECONTIG | HFS_ALLOC_FLUSHTXN | alloc_skipfreeblks,+ &newStartBlock, &newBlockCount);+ if (error) {+ printf("hfs_relocate_journal_file: BlockAllocate returned %d\n", error);+ goto fail;+ }+ if (newBlockCount != jnlBlockCount) {+ printf("hfs_relocate_journal_file: newBlockCount != jnlBlockCount (%u, %u)\n", newBlockCount, jnlBlockCount);+ goto free_fail;+ }++ error = cat_idlookup(hfsmp, hfsmp->hfs_jnlfileid, 1, 0, &journal_desc, &journal_attr, &journal_fork);+ if (error) {+ printf("hfs_relocate_journal_file: cat_idlookup returned %d\n", error);+ goto free_fail;+ }++ oldStartBlock = journal_fork.cf_extents[0].startBlock;+ oldBlockCount = journal_fork.cf_extents[0].blockCount;+ error = BlockDeallocate(hfsmp, oldStartBlock, oldBlockCount, alloc_skipfreeblks);+ if (error) {+ printf("hfs_relocate_journal_file: BlockDeallocate returned %d\n", error);+ goto free_fail;+ }++ /* Update the catalog record for .journal */+ journal_fork.cf_size = hfs_blk_to_bytes(newBlockCount, hfsmp->blockSize);+ journal_fork.cf_extents[0].startBlock = newStartBlock;+ journal_fork.cf_extents[0].blockCount = newBlockCount;+ journal_fork.cf_blocks = newBlockCount;+ error = cat_update(hfsmp, &journal_desc, &journal_attr, &journal_fork, NULL);+ cat_releasedesc(&journal_desc); /* all done with cat descriptor */+ if (error) {+ printf("hfs_relocate_journal_file: cat_update returned %d\n", error);+ goto free_fail;+ }++ /*+ * If the journal is part of the file system, then tell the journal+ * code about the new location. If the journal is on an external+ * device, then just keep using it as-is.+ */+ if (hfsmp->jvp == hfsmp->hfs_devvp) {+ callback_args.hfsmp = hfsmp;+ callback_args.context = context;+ callback_args.newStartBlock = newStartBlock;+ callback_args.newBlockCount = newBlockCount;++ error = journal_relocate(hfsmp->jnl, (off_t)newStartBlock*hfsmp->blockSize,+ (off_t)newBlockCount*hfsmp->blockSize, 0,+ hfs_journal_relocate_callback, &callback_args);+ if (error) {+ /* NOTE: journal_relocate will mark the journal invalid. */+ printf("hfs_relocate_journal_file: journal_relocate returned %d\n", error);+ goto fail;+ }+ if (hfs_resize_debug) {+ printf ("hfs_relocate_journal_file: Successfully relocated journal from (%u,%u) to (%u,%u)\n", oldStartBlock, oldBlockCount, newStartBlock, newBlockCount);+ }+ hfsmp->jnl_start = newStartBlock;+ hfsmp->jnl_size = (off_t)newBlockCount * hfsmp->blockSize;+ }++ hfs_systemfile_unlock(hfsmp, lockflags);+ error = hfs_end_transaction(hfsmp);+ if (error) {+ printf("hfs_relocate_journal_file: hfs_end_transaction returned %d\n", error);+ }++ return error;++free_fail:+ journal_err = BlockDeallocate(hfsmp, newStartBlock, newBlockCount, HFS_ALLOC_SKIPFREEBLKS);+ if (journal_err) {+ printf("hfs_relocate_journal_file: BlockDeallocate returned %d\n", error);+ hfs_mark_inconsistent(hfsmp, HFS_ROLLBACK_FAILED);+ }+fail:+ hfs_systemfile_unlock(hfsmp, lockflags);+ (void) hfs_end_transaction(hfsmp);+ if (hfs_resize_debug) {+ printf ("hfs_relocate_journal_file: Error relocating journal file (error=%d)\n", error);+ }+ return error;+}+++/*+ * Relocate the journal file when the file system is being truncated.+ * We do not down-size the journal when the file system size is+ * reduced, so we always provide the current journal size to the+ * relocate code.+ */+static int+hfs_reclaim_journal_file(struct hfsmount *hfsmp, u_int32_t allocLimit, vfs_context_t context)+{+ int error = 0;+ u_int32_t startBlock;+ u_int32_t blockCount = hfsmp->jnl_size / hfsmp->blockSize;++ /*+ * Figure out the location of the .journal file. When the journal+ * is on an external device, we need to look up the .journal file.+ */+ if (hfsmp->jvp == hfsmp->hfs_devvp) {+ startBlock = hfsmp->jnl_start;+ blockCount = hfsmp->jnl_size / hfsmp->blockSize;+ } else {+ u_int32_t fileid;+ u_int32_t old_jnlfileid;+ struct cat_attr attr;+ struct cat_fork fork;++ /*+ * The cat_lookup inside GetFileInfo will fail because hfs_jnlfileid+ * is set, and it is trying to hide the .journal file. So temporarily+ * unset the field while calling GetFileInfo.+ */+ old_jnlfileid = hfsmp->hfs_jnlfileid;+ hfsmp->hfs_jnlfileid = 0;+ fileid = GetFileInfo(hfsmp, kHFSRootFolderID, ".journal", &attr, &fork);+ hfsmp->hfs_jnlfileid = old_jnlfileid;+ if (fileid != old_jnlfileid) {+ printf("hfs_reclaim_journal_file: cannot find .journal file!\n");+ return EIO;+ }++ startBlock = fork.cf_extents[0].startBlock;+ blockCount = fork.cf_extents[0].blockCount;+ }++ if (startBlock + blockCount <= allocLimit) {+ /* The journal file does not require relocation */+ return 0;+ }++ error = hfs_relocate_journal_file(hfsmp, hfs_blk_to_bytes(blockCount, hfsmp->blockSize),+ HFS_RESIZE_TRUNCATE, context);+ if (error == 0) {+ hfsmp->hfs_resize_blocksmoved += blockCount;+ hfs_truncatefs_progress(hfsmp);+ printf ("hfs_reclaim_journal_file: Relocated %u blocks from journal on \"%s\"\n",+ blockCount, hfsmp->vcbVN);+ }++ return error;+}+++/*+ * Move the journal info block to a new location. We have to make sure the+ * new copy of the journal info block gets to the media first, then change+ * the field in the volume header and the catalog record.+ */+static int+hfs_reclaim_journal_info_block(struct hfsmount *hfsmp, u_int32_t allocLimit, vfs_context_t context)+{+ int error;+ int journal_err;+ int lockflags;+ u_int32_t oldBlock;+ u_int32_t newBlock;+ u_int32_t blockCount;+ struct cat_desc jib_desc;+ struct cat_attr jib_attr;+ struct cat_fork jib_fork;+ buf_t old_bp, new_bp;++ if (hfsmp->vcbJinfoBlock <= allocLimit) {+ /* The journal info block does not require relocation */+ return 0;+ }++ error = hfs_start_transaction(hfsmp);+ if (error) {+ printf("hfs_reclaim_journal_info_block: hfs_start_transaction returned %d\n", error);+ return error;+ }+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);++ error = BlockAllocate(hfsmp, 1, 1, 1,+ HFS_ALLOC_METAZONE | HFS_ALLOC_FORCECONTIG | HFS_ALLOC_SKIPFREEBLKS | HFS_ALLOC_FLUSHTXN,+ &newBlock, &blockCount);+ if (error) {+ printf("hfs_reclaim_journal_info_block: BlockAllocate returned %d\n", error);+ goto fail;+ }+ if (blockCount != 1) {+ printf("hfs_reclaim_journal_info_block: blockCount != 1 (%u)\n", blockCount);+ goto free_fail;+ }++ /* Copy the old journal info block content to the new location */+ error = buf_meta_bread(hfsmp->hfs_devvp,+ (uint64_t)hfsmp->vcbJinfoBlock * (hfsmp->blockSize/hfsmp->hfs_logical_block_size),+ hfsmp->blockSize, vfs_context_ucred(context), &old_bp);+ if (error) {+ printf("hfs_reclaim_journal_info_block: failed to read JIB (%d)\n", error);+ if (old_bp) {+ buf_brelse(old_bp);+ }+ goto free_fail;+ }+ new_bp = buf_getblk(hfsmp->hfs_devvp,+ (uint64_t)newBlock * (hfsmp->blockSize/hfsmp->hfs_logical_block_size),+ hfsmp->blockSize, 0, 0, BLK_META);+ bcopy((char*)buf_dataptr(old_bp), (char*)buf_dataptr(new_bp), hfsmp->blockSize);+ buf_brelse(old_bp);+ if (journal_uses_fua(hfsmp->jnl))+ buf_markfua(new_bp);+ error = buf_bwrite(new_bp);+ if (error) {+ printf("hfs_reclaim_journal_info_block: failed to write new JIB (%d)\n", error);+ goto free_fail;+ }+ if (!journal_uses_fua(hfsmp->jnl)) {+ error = hfs_flush(hfsmp, HFS_FLUSH_CACHE);+ if (error) {+ printf("hfs_reclaim_journal_info_block: hfs_flush failed (%d)\n", error);+ /* Don't fail the operation. */+ }+ }++ /* Deallocate the old block once the new one has the new valid content */+ error = BlockDeallocate(hfsmp, hfsmp->vcbJinfoBlock, 1, HFS_ALLOC_SKIPFREEBLKS);+ if (error) {+ printf("hfs_reclaim_journal_info_block: BlockDeallocate returned %d\n", error);+ goto free_fail;+ }+++ /* Update the catalog record for .journal_info_block */+ error = cat_idlookup(hfsmp, hfsmp->hfs_jnlinfoblkid, 1, 0, &jib_desc, &jib_attr, &jib_fork);+ if (error) {+ printf("hfs_reclaim_journal_info_block: cat_idlookup returned %d\n", error);+ goto fail;+ }+ oldBlock = jib_fork.cf_extents[0].startBlock;+ jib_fork.cf_size = hfsmp->blockSize;+ jib_fork.cf_extents[0].startBlock = newBlock;+ jib_fork.cf_extents[0].blockCount = 1;+ jib_fork.cf_blocks = 1;+ error = cat_update(hfsmp, &jib_desc, &jib_attr, &jib_fork, NULL);+ cat_releasedesc(&jib_desc); /* all done with cat descriptor */+ if (error) {+ printf("hfs_reclaim_journal_info_block: cat_update returned %d\n", error);+ goto fail;+ }++ /* Update the pointer to the journal info block in the volume header. */+ hfsmp->vcbJinfoBlock = newBlock;+ error = hfs_flushvolumeheader(hfsmp, HFS_FVH_WAIT | HFS_FVH_WRITE_ALT);+ if (error) {+ printf("hfs_reclaim_journal_info_block: hfs_flushvolumeheader returned %d\n", error);+ goto fail;+ }+ hfs_systemfile_unlock(hfsmp, lockflags);+ error = hfs_end_transaction(hfsmp);+ if (error) {+ printf("hfs_reclaim_journal_info_block: hfs_end_transaction returned %d\n", error);+ }+ error = hfs_flush(hfsmp, HFS_FLUSH_JOURNAL);+ if (error) {+ printf("hfs_reclaim_journal_info_block: journal_flush returned %d\n", error);+ }++ /* Account for the block relocated and print progress */+ hfsmp->hfs_resize_blocksmoved += 1;+ hfs_truncatefs_progress(hfsmp);+ if (!error) {+ printf ("hfs_reclaim_journal_info: Relocated 1 block from journal info on \"%s\"\n",+ hfsmp->vcbVN);+ if (hfs_resize_debug) {+ printf ("hfs_reclaim_journal_info_block: Successfully relocated journal info block from (%u,%u) to (%u,%u)\n", oldBlock, blockCount, newBlock, blockCount);+ }+ }+ return error;++free_fail:+ journal_err = BlockDeallocate(hfsmp, newBlock, blockCount, HFS_ALLOC_SKIPFREEBLKS);+ if (journal_err) {+ printf("hfs_reclaim_journal_info_block: BlockDeallocate returned %d\n", error);+ hfs_mark_inconsistent(hfsmp, HFS_ROLLBACK_FAILED);+ }++fail:+ hfs_systemfile_unlock(hfsmp, lockflags);+ (void) hfs_end_transaction(hfsmp);+ if (hfs_resize_debug) {+ printf ("hfs_reclaim_journal_info_block: Error relocating journal info block (error=%d)\n", error);+ }+ return error;+}+++static u_int64_t+calculate_journal_size(struct hfsmount *hfsmp, u_int32_t sector_size, u_int64_t sector_count)+{+ u_int64_t journal_size;+ u_int32_t journal_scale;++#define DEFAULT_JOURNAL_SIZE (8*1024*1024)+#define MAX_JOURNAL_SIZE (512*1024*1024)++ /* Calculate the journal size for this volume. We want+ * at least 8 MB of journal for each 100 GB of disk space.+ * We cap the size at 512 MB, unless the allocation block+ * size is larger, in which case, we use one allocation+ * block.+ */+ journal_scale = (sector_size * sector_count) / ((u_int64_t)100 * 1024 * 1024 * 1024);+ journal_size = DEFAULT_JOURNAL_SIZE * (journal_scale + 1);+ if (journal_size > MAX_JOURNAL_SIZE) {+ journal_size = MAX_JOURNAL_SIZE;+ }+ if (journal_size < hfsmp->blockSize) {+ journal_size = hfsmp->blockSize;+ }+ return journal_size;+}+++/*+ * Calculate the expected journal size based on current partition size.+ * If the size of the current journal is less than the calculated size,+ * force journal relocation with the new journal size.+ */+static int+hfs_extend_journal(struct hfsmount *hfsmp, u_int32_t sector_size, u_int64_t sector_count, vfs_context_t context)+{+ int error = 0;+ u_int64_t calc_journal_size;++ if (hfsmp->jvp != hfsmp->hfs_devvp) {+ if (hfs_resize_debug) {+ printf("hfs_extend_journal: not resizing the journal because it is on an external device.\n");+ }+ return 0;+ }++ calc_journal_size = calculate_journal_size(hfsmp, sector_size, sector_count);+ if (calc_journal_size <= hfsmp->jnl_size) {+ /* The journal size requires no modification */+ goto out;+ }++ if (hfs_resize_debug) {+ printf ("hfs_extend_journal: journal old=%u, new=%qd\n", hfsmp->jnl_size, calc_journal_size);+ }++ /* Extend the journal to the new calculated size */+ error = hfs_relocate_journal_file(hfsmp, calc_journal_size, HFS_RESIZE_EXTEND, context);+ if (error == 0) {+ printf ("hfs_extend_journal: Extended journal size to %u bytes on \"%s\"\n",+ hfsmp->jnl_size, hfsmp->vcbVN);+ }+out:+ return error;+}+++/*+ * This function traverses through all extended attribute records for a given+ * fileID, and calls function that reclaims data blocks that exist in the+ * area of the disk being reclaimed which in turn is responsible for allocating+ * new space, copying extent data, deallocating new space, and if required,+ * splitting the extent.+ *+ * Note: The caller has already acquired the cnode lock on the file. Therefore+ * we are assured that no other thread would be creating/deleting/modifying+ * extended attributes for this file.+ *+ * Side Effects:+ * hfsmp->hfs_resize_blocksmoved is incremented by the number of allocation+ * blocks that were relocated.+ *+ * Returns:+ * 0 on success, non-zero on failure.+ */+static int+hfs_reclaim_xattr(struct hfsmount *hfsmp, struct vnode *vp, u_int32_t fileID, u_int32_t allocLimit, vfs_context_t context)+{+ int error = 0;+ struct hfs_reclaim_extent_info *extent_info;+ int i;+ HFSPlusAttrKey *key;+ int *lockflags;++ if (hfs_resize_debug) {+ printf("hfs_reclaim_xattr: === Start reclaiming xattr for id=%u ===\n", fileID);+ }++ extent_info = hfs_malloc_type(struct hfs_reclaim_extent_info);+ extent_info->vp = vp;+ extent_info->fileID = fileID;+ extent_info->is_xattr = true;+ extent_info->is_sysfile = vnode_issystem(vp);+ extent_info->fcb = VTOF(hfsmp->hfs_attribute_vp);+ lockflags = &(extent_info->lockflags);+ *lockflags = SFL_ATTRIBUTE | SFL_BITMAP;++ /* Initialize iterator from the extent_info structure */+ extent_info->iterator = hfs_malloc_type(struct BTreeIterator);++ /* Build attribute key */+ key = (HFSPlusAttrKey *)&(extent_info->iterator->key);+ error = hfs_buildattrkey(fileID, NULL, key);+ if (error) {+ goto out;+ }++ /* Initialize btdata from extent_info structure. Note that the+ * buffer pointer actually points to the xattr record from the+ * extent_info structure itself.+ */+ extent_info->btdata.bufferAddress = &(extent_info->record.xattr);+ extent_info->btdata.itemSize = sizeof(HFSPlusAttrRecord);+ extent_info->btdata.itemCount = 1;++ /*+ * Sync all extent-based attribute data to the disk.+ *+ * All extent-based attribute data I/O is performed via cluster+ * I/O using a virtual file that spans across entire file system+ * space.+ */+ hfs_lock_truncate(VTOC(hfsmp->hfs_attrdata_vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ (void)cluster_push(hfsmp->hfs_attrdata_vp, 0);+ error = vnode_waitforwrites(hfsmp->hfs_attrdata_vp, 0, 0, 0, "hfs_reclaim_xattr");+ hfs_unlock_truncate(VTOC(hfsmp->hfs_attrdata_vp), HFS_LOCK_DEFAULT);+ if (error) {+ goto out;+ }++ /* Search for extended attribute for current file. This+ * will place the iterator before the first matching record.+ */+ *lockflags = hfs_systemfile_lock(hfsmp, *lockflags, HFS_EXCLUSIVE_LOCK);+ error = BTSearchRecord(extent_info->fcb, extent_info->iterator,+ &(extent_info->btdata), &(extent_info->recordlen),+ extent_info->iterator);+ hfs_systemfile_unlock(hfsmp, *lockflags);+ if (error) {+ if (error != btNotFound) {+ goto out;+ }+ /* btNotFound is expected here, so just mask it */+ error = 0;+ }++ while (1) {+ /* Iterate to the next record */+ *lockflags = hfs_systemfile_lock(hfsmp, *lockflags, HFS_EXCLUSIVE_LOCK);+ error = BTIterateRecord(extent_info->fcb, kBTreeNextRecord,+ extent_info->iterator, &(extent_info->btdata),+ &(extent_info->recordlen));+ hfs_systemfile_unlock(hfsmp, *lockflags);++ /* Stop the iteration if we encounter end of btree or xattr with different fileID */+ if (error || key->fileID != fileID) {+ if (error == fsBTRecordNotFoundErr || error == fsBTEndOfIterationErr) {+ error = 0;+ }+ break;+ }++ /* We only care about extent-based EAs */+ if ((extent_info->record.xattr.recordType != kHFSPlusAttrForkData) &&+ (extent_info->record.xattr.recordType != kHFSPlusAttrExtents)) {+ continue;+ }++ if (extent_info->record.xattr.recordType == kHFSPlusAttrForkData) {+ extent_info->overflow_count = 0;+ extent_info->extents = extent_info->record.xattr.forkData.theFork.extents;+ } else if (extent_info->record.xattr.recordType == kHFSPlusAttrExtents) {+ extent_info->overflow_count++;+ extent_info->extents = extent_info->record.xattr.overflowExtents.extents;+ }++ extent_info->recStartBlock = key->startBlock;+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ if (extent_info->extents[i].blockCount == 0) {+ break;+ }+ extent_info->extent_index = i;+ error = hfs_reclaim_extent(hfsmp, allocLimit, extent_info, context);+ if (error) {+ printf ("hfs_reclaim_xattr: fileID=%u hfs_reclaim_extent error=%d\n", fileID, error);+ goto out;+ }+ }+ }++out:+ /* If any blocks were relocated, account them and report progress */+ if (extent_info->blocks_relocated) {+ hfsmp->hfs_resize_blocksmoved += extent_info->blocks_relocated;+ hfs_truncatefs_progress(hfsmp);+ }+ if (extent_info->iterator) {+ hfs_free_type(extent_info->iterator, BTreeIterator);+ }+ if (extent_info) {+ hfs_free_type(extent_info, struct hfs_reclaim_extent_info);+ }+ if (hfs_resize_debug) {+ printf("hfs_reclaim_xattr: === Finished relocating xattr for fileid=%u (error=%d) ===\n", fileID, error);+ }+ return error;+}++/*+ * Reclaim any extent-based extended attributes allocation blocks from+ * the area of the disk that is being truncated.+ *+ * The function traverses the attribute btree to find out the fileIDs+ * of the extended attributes that need to be relocated. For every+ * file whose large EA requires relocation, it looks up the cnode and+ * calls hfs_reclaim_xattr() to do all the work for allocating+ * new space, copying data, deallocating old space, and if required,+ * splitting the extents.+ *+ * Inputs:+ * allocLimit - starting block of the area being reclaimed+ *+ * Returns:+ * returns 0 on success, non-zero on failure.+ */+static int+hfs_reclaim_xattrspace(struct hfsmount *hfsmp, u_int32_t allocLimit, vfs_context_t context)+{+ int error = 0;+ FCB *fcb;+ struct BTreeIterator *iterator = NULL;+ struct FSBufferDescriptor btdata;+ HFSPlusAttrKey *key;+ HFSPlusAttrRecord rec;+ int lockflags = 0;+ cnid_t prev_fileid = 0;+ struct vnode *vp;+ int need_relocate;+ int btree_operation;+ u_int32_t files_moved = 0;+ u_int32_t prev_blocksmoved;+ int i;++ fcb = VTOF(hfsmp->hfs_attribute_vp);+ /* Store the value to print total blocks moved by this function in end */+ prev_blocksmoved = hfsmp->hfs_resize_blocksmoved;++ iterator = hfs_malloc_type(struct BTreeIterator);+ key = (HFSPlusAttrKey *)&iterator->key;+ btdata.bufferAddress = &rec;+ btdata.itemSize = sizeof(rec);+ btdata.itemCount = 1;++ need_relocate = false;+ btree_operation = kBTreeFirstRecord;+ /* Traverse the attribute btree to find extent-based EAs to reclaim */+ while (1) {+ lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE, HFS_SHARED_LOCK);+ error = BTIterateRecord(fcb, btree_operation, iterator, &btdata, NULL);+ hfs_systemfile_unlock(hfsmp, lockflags);+ if (error) {+ if (error == fsBTRecordNotFoundErr || error == fsBTEndOfIterationErr) {+ error = 0;+ }+ break;+ }+ btree_operation = kBTreeNextRecord;++ /* If the extents of current fileID were already relocated, skip it */+ if (prev_fileid == key->fileID) {+ continue;+ }++ /* Check if any of the extents in the current record need to be relocated */+ need_relocate = false;+ switch(rec.recordType) {+ case kHFSPlusAttrForkData:+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ if (rec.forkData.theFork.extents[i].blockCount == 0) {+ break;+ }+ if ((rec.forkData.theFork.extents[i].startBlock ++ rec.forkData.theFork.extents[i].blockCount) > allocLimit) {+ need_relocate = true;+ break;+ }+ }+ break;++ case kHFSPlusAttrExtents:+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ if (rec.overflowExtents.extents[i].blockCount == 0) {+ break;+ }+ if ((rec.overflowExtents.extents[i].startBlock ++ rec.overflowExtents.extents[i].blockCount) > allocLimit) {+ need_relocate = true;+ break;+ }+ }+ break;+ };++ /* Continue iterating to next attribute record */+ if (need_relocate == false) {+ continue;+ }++ /* Look up the vnode for corresponding file. The cnode+ * will be locked which will ensure that no one modifies+ * the xattrs when we are relocating them.+ *+ * We want to allow open-unlinked files to be moved,+ * so provide allow_deleted == 1 for hfs_vget().+ */+ if (hfs_vget(hfsmp, key->fileID, &vp, 0, 1) != 0) {+ continue;+ }++ error = hfs_reclaim_xattr(hfsmp, vp, key->fileID, allocLimit, context);+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ if (error) {+ printf ("hfs_reclaim_xattrspace: Error relocating xattrs for fileid=%u (error=%d)\n", key->fileID, error);+ break;+ }+ prev_fileid = key->fileID;+ files_moved++;+ }++ if (files_moved) {+ printf("hfs_reclaim_xattrspace: Relocated %u xattr blocks from %u files on \"%s\"\n",+ (hfsmp->hfs_resize_blocksmoved - prev_blocksmoved),+ files_moved, hfsmp->vcbVN);+ }++ hfs_free_type(iterator, struct BTreeIterator);+ return error;+}++/*+ * Reclaim blocks from regular files.+ *+ * This function iterates over all the record in catalog btree looking+ * for files with extents that overlap into the space we're trying to+ * free up. If a file extent requires relocation, it looks up the vnode+ * and calls function to relocate the data.+ *+ * Returns:+ * Zero on success, non-zero on failure.+ */+static int+hfs_reclaim_filespace(struct hfsmount *hfsmp, u_int32_t allocLimit, vfs_context_t context)+{+ int error;+ FCB *fcb;+ struct BTreeIterator *iterator = NULL;+ struct FSBufferDescriptor btdata;+ int btree_operation;+ int lockflags;+ struct HFSPlusCatalogFile filerec;+ struct vnode *vp;+ struct vnode *rvp;+ struct filefork *datafork;+ u_int32_t files_moved = 0;+ u_int32_t prev_blocksmoved;++#if CONFIG_PROTECT+ int keys_generated = 0;+#endif++ fcb = VTOF(hfsmp->hfs_catalog_vp);+ /* Store the value to print total blocks moved by this function at the end */+ prev_blocksmoved = hfsmp->hfs_resize_blocksmoved;++#if CONFIG_PROTECT+ /*+ * For content-protected filesystems, we may need to relocate files that+ * are encrypted. If they use the new-style offset-based IVs, then+ * we can move them regardless of the lock state. We create a temporary+ * key here that we use to read/write the data, then we discard it at the+ * end of the function.+ */+ if (cp_fs_protected (hfsmp->hfs_mp)) {+ error = cpx_gentempkeys(&hfsmp->hfs_resize_cpx, hfsmp);+ if (error == 0) {+ keys_generated = 1;+ }++ if (error) {+ printf("hfs_reclaimspace: Error generating temporary keys for resize (%d)\n", error);+ goto reclaim_filespace_done;+ }+ }++#endif++ iterator = hfs_malloc_type(struct BTreeIterator);++ btdata.bufferAddress = &filerec;+ btdata.itemSize = sizeof(filerec);+ btdata.itemCount = 1;++ btree_operation = kBTreeFirstRecord;+ while (1) {+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);+ error = BTIterateRecord(fcb, btree_operation, iterator, &btdata, NULL);+ hfs_systemfile_unlock(hfsmp, lockflags);+ if (error) {+ if (error == fsBTRecordNotFoundErr || error == fsBTEndOfIterationErr) {+ error = 0;+ }+ break;+ }+ btree_operation = kBTreeNextRecord;++ if (filerec.recordType != kHFSPlusFileRecord) {+ continue;+ }++ /* Check if any of the extents require relocation */+ bool overlaps;+ error = hfs_file_extent_overlaps(hfsmp, allocLimit, &filerec, &overlaps);+ if (error)+ break;++ if (!overlaps)+ continue;++ /* We want to allow open-unlinked files to be moved, so allow_deleted == 1 */+ if (hfs_vget(hfsmp, filerec.fileID, &vp, 0, 1) != 0) {+ if (hfs_resize_debug) {+ printf("hfs_reclaim_filespace: hfs_vget(%u) failed.\n", filerec.fileID);+ }+ continue;+ }++ /* If data fork exists or item is a directory hard link, relocate blocks */+ datafork = VTOF(vp);+ if ((datafork && datafork->ff_blocks > 0) || vnode_isdir(vp)) {+ error = hfs_reclaim_file(hfsmp, vp, filerec.fileID,+ kHFSDataForkType, allocLimit, context);+ if (error) {+ printf ("hfs_reclaimspace: Error reclaiming datafork blocks of fileid=%u (error=%d)\n", filerec.fileID, error);+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ break;+ }+ }++ /* If resource fork exists or item is a directory hard link, relocate blocks */+ if (((VTOC(vp)->c_blocks - (datafork ? datafork->ff_blocks : 0)) > 0) || vnode_isdir(vp)) {+ if (vnode_isdir(vp)) {+ /* Resource fork vnode lookup is invalid for directory hard link.+ * So we fake data fork vnode as resource fork vnode.+ */+ rvp = vp;+ } else {+ error = hfs_vgetrsrc(hfsmp, vp, &rvp);+ if (error) {+ printf ("hfs_reclaimspace: Error looking up rvp for fileid=%u (error=%d)\n", filerec.fileID, error);+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ break;+ }+ VTOC(rvp)->c_flag |= C_NEED_RVNODE_PUT;+ }++ error = hfs_reclaim_file(hfsmp, rvp, filerec.fileID,+ kHFSResourceForkType, allocLimit, context);+ if (error) {+ printf ("hfs_reclaimspace: Error reclaiming rsrcfork blocks of fileid=%u (error=%d)\n", filerec.fileID, error);+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ break;+ }+ }++ /* The file forks were relocated successfully, now drop the+ * cnode lock and vnode reference, and continue iterating to+ * next catalog record.+ */+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ files_moved++;+ }++ if (files_moved) {+ printf("hfs_reclaim_filespace: Relocated %u blocks from %u files on \"%s\"\n",+ (hfsmp->hfs_resize_blocksmoved - prev_blocksmoved),+ files_moved, hfsmp->vcbVN);+ }++#if CONFIG_PROTECT+reclaim_filespace_done:++ if (keys_generated) {+ cpx_free(hfsmp->hfs_resize_cpx);+ hfsmp->hfs_resize_cpx = NULL;+ }+#endif++ hfs_free_type(iterator, struct BTreeIterator);++ return error;+}++/*+ * Reclaim space at the end of a file system.+ *+ * Inputs -+ * allocLimit - start block of the space being reclaimed+ * reclaimblks - number of allocation blocks to reclaim+ */+static int+hfs_reclaimspace(struct hfsmount *hfsmp, u_int32_t allocLimit, u_int32_t reclaimblks, vfs_context_t context)+{+ int error = 0;++ /*+ * Preflight the bitmap to find out total number of blocks that need+ * relocation.+ *+ * Note: Since allocLimit is set to the location of new alternate volume+ * header, the check below does not account for blocks allocated for old+ * alternate volume header.+ */+ error = hfs_count_allocated(hfsmp, allocLimit, reclaimblks, &(hfsmp->hfs_resize_totalblocks));+ if (error) {+ printf ("hfs_reclaimspace: Unable to determine total blocks to reclaim error=%d\n", error);+ return error;+ }+ if (hfs_resize_debug) {+ printf ("hfs_reclaimspace: Total number of blocks to reclaim = %u\n", hfsmp->hfs_resize_totalblocks);+ }++ /* Just to be safe, sync the content of the journal to the disk before we proceed */+ hfs_flush(hfsmp, HFS_FLUSH_JOURNAL_META);++ /* First, relocate journal file blocks if they're in the way.+ * Doing this first will make sure that journal relocate code+ * gets access to contiguous blocks on disk first. The journal+ * file has to be contiguous on the disk, otherwise resize will+ * fail.+ */+ error = hfs_reclaim_journal_file(hfsmp, allocLimit, context);+ if (error) {+ printf("hfs_reclaimspace: hfs_reclaim_journal_file failed (%d)\n", error);+ return error;+ }++ /* Relocate journal info block blocks if they're in the way. */+ error = hfs_reclaim_journal_info_block(hfsmp, allocLimit, context);+ if (error) {+ printf("hfs_reclaimspace: hfs_reclaim_journal_info_block failed (%d)\n", error);+ return error;+ }++ /* Relocate extents of the Extents B-tree if they're in the way.+ * Relocating extents btree before other btrees is important as+ * this will provide access to largest contiguous block range on+ * the disk for relocating extents btree. Note that extents btree+ * can only have maximum of 8 extents.+ */+ error = hfs_reclaim_file(hfsmp, hfsmp->hfs_extents_vp, kHFSExtentsFileID,+ kHFSDataForkType, allocLimit, context);+ if (error) {+ printf("hfs_reclaimspace: reclaim extents b-tree returned %d\n", error);+ return error;+ }++ /* Relocate extents of the Allocation file if they're in the way. */+ error = hfs_reclaim_file(hfsmp, hfsmp->hfs_allocation_vp, kHFSAllocationFileID,+ kHFSDataForkType, allocLimit, context);+ if (error) {+ printf("hfs_reclaimspace: reclaim allocation file returned %d\n", error);+ return error;+ }++ /* Relocate extents of the Catalog B-tree if they're in the way. */+ error = hfs_reclaim_file(hfsmp, hfsmp->hfs_catalog_vp, kHFSCatalogFileID,+ kHFSDataForkType, allocLimit, context);+ if (error) {+ printf("hfs_reclaimspace: reclaim catalog b-tree returned %d\n", error);+ return error;+ }++ /* Relocate extents of the Attributes B-tree if they're in the way. */+ error = hfs_reclaim_file(hfsmp, hfsmp->hfs_attribute_vp, kHFSAttributesFileID,+ kHFSDataForkType, allocLimit, context);+ if (error) {+ printf("hfs_reclaimspace: reclaim attribute b-tree returned %d\n", error);+ return error;+ }++ /* Relocate extents of the Startup File if there is one and they're in the way. */+ error = hfs_reclaim_file(hfsmp, hfsmp->hfs_startup_vp, kHFSStartupFileID,+ kHFSDataForkType, allocLimit, context);+ if (error) {+ printf("hfs_reclaimspace: reclaim startup file returned %d\n", error);+ return error;+ }++ /*+ * We need to make sure the alternate volume header gets flushed if we moved+ * any extents in the volume header. But we need to do that before+ * shrinking the size of the volume, or else the journal code will panic+ * with an invalid (too large) block number.+ *+ * Note that blks_moved will be set if ANY extent was moved, even+ * if it was just an overflow extent. In this case, the journal_flush isn't+ * strictly required, but shouldn't hurt.+ */+ if (hfsmp->hfs_resize_blocksmoved) {+ hfs_flush(hfsmp, HFS_FLUSH_JOURNAL_META);+ }++ /* Reclaim extents from catalog file records */+ error = hfs_reclaim_filespace(hfsmp, allocLimit, context);+ if (error) {+ printf ("hfs_reclaimspace: hfs_reclaim_filespace returned error=%d\n", error);+ return error;+ }++ /* Reclaim extents from extent-based extended attributes, if any */+ error = hfs_reclaim_xattrspace(hfsmp, allocLimit, context);+ if (error) {+ printf ("hfs_reclaimspace: hfs_reclaim_xattrspace returned error=%d\n", error);+ return error;+ }++ /*+ * Make sure reserved ranges in the region we're to allocate don't+ * overlap.+ */+ struct rl_entry *range;+again:;+ int lockf = hfs_systemfile_lock(hfsmp, SFL_BITMAP, HFS_SHARED_LOCK);+ TAILQ_FOREACH(range, &hfsmp->hfs_reserved_ranges[HFS_LOCKED_BLOCKS], rl_link) {+ if (rl_overlap(range, hfsmp->allocLimit, RL_INFINITY) != RL_NOOVERLAP) {+ // Wait 100ms+ hfs_systemfile_unlock(hfsmp, lockf);+ msleep(hfs_reclaimspace, NULL, PINOD, "waiting on reserved blocks",+ &(struct timespec){ 0, 100 * 1000000 });+ goto again;+ }+ }+ hfs_systemfile_unlock(hfsmp, lockf);++ return error;+}+++/*+ * Check if there are any extents (including overflow extents) that overlap+ * into the disk space that is being reclaimed.+ *+ * Output -+ * true - One of the extents need to be relocated+ * false - No overflow extents need to be relocated, or there was an error+ */+static errno_t+hfs_file_extent_overlaps(struct hfsmount *hfsmp, u_int32_t allocLimit,+ struct HFSPlusCatalogFile *filerec, bool *overlaps)+{+ struct BTreeIterator * iterator = NULL;+ struct FSBufferDescriptor btdata;+ HFSPlusExtentRecord extrec;+ HFSPlusExtentKey *extkeyptr;+ FCB *fcb;+ int i, j;+ int error;+ int lockflags = 0;+ u_int32_t endblock;+ errno_t ret = 0;++ /* Check if data fork overlaps the target space */+ for (i = 0; i < kHFSPlusExtentDensity; ++i) {+ if (filerec->dataFork.extents[i].blockCount == 0) {+ break;+ }+ endblock = filerec->dataFork.extents[i].startBlock ++ filerec->dataFork.extents[i].blockCount;+ if (endblock > allocLimit) {+ *overlaps = true;+ goto out;+ }+ }++ /* Check if resource fork overlaps the target space */+ for (j = 0; j < kHFSPlusExtentDensity; ++j) {+ if (filerec->resourceFork.extents[j].blockCount == 0) {+ break;+ }+ endblock = filerec->resourceFork.extents[j].startBlock ++ filerec->resourceFork.extents[j].blockCount;+ if (endblock > allocLimit) {+ *overlaps = true;+ goto out;+ }+ }++ /* Return back if there are no overflow extents for this file */+ if ((i < kHFSPlusExtentDensity) && (j < kHFSPlusExtentDensity)) {+ *overlaps = false;+ goto out;+ }++ iterator = hfs_malloc_type(struct BTreeIterator);++ bzero(iterator, sizeof(*iterator));+ extkeyptr = (HFSPlusExtentKey *)&iterator->key;+ extkeyptr->keyLength = kHFSPlusExtentKeyMaximumLength;+ extkeyptr->forkType = 0;+ extkeyptr->fileID = filerec->fileID;+ extkeyptr->startBlock = 0;++ btdata.bufferAddress = &extrec;+ btdata.itemSize = sizeof(extrec);+ btdata.itemCount = 1;++ fcb = VTOF(hfsmp->hfs_extents_vp);++ lockflags = hfs_systemfile_lock(hfsmp, SFL_EXTENTS, HFS_SHARED_LOCK);++ /* This will position the iterator just before the first overflow+ * extent record for given fileID. It will always return btNotFound,+ * so we special case the error code.+ */+ error = BTSearchRecord(fcb, iterator, &btdata, NULL, iterator);+ if (error && (error != btNotFound)) {+ ret = MacToVFSError(error);+ goto out;+ }++ /* BTIterateRecord() might return error if the btree is empty, and+ * therefore we return that the extent does not overflow to the caller+ */+ error = BTIterateRecord(fcb, kBTreeNextRecord, iterator, &btdata, NULL);+ while (error == 0) {+ /* Stop when we encounter a different file. */+ if (extkeyptr->fileID != filerec->fileID) {+ break;+ }+ /* Check if any of the forks exist in the target space. */+ for (i = 0; i < kHFSPlusExtentDensity; ++i) {+ if (extrec[i].blockCount == 0) {+ break;+ }+ endblock = extrec[i].startBlock + extrec[i].blockCount;+ if (endblock > allocLimit) {+ *overlaps = true;+ goto out;+ }+ }+ /* Look for more records. */+ error = BTIterateRecord(fcb, kBTreeNextRecord, iterator, &btdata, NULL);+ }++ if (error && error != btNotFound) {+ ret = MacToVFSError(error);+ goto out;+ }++ *overlaps = false;++out:+ if (lockflags) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ }++ hfs_free_type(iterator, struct BTreeIterator);++ return ret;+}+++/*+ * Calculate the progress of a file system resize operation.+ */+int+hfs_resize_progress(struct hfsmount *hfsmp, u_int32_t *progress)+{+ if ((hfsmp->hfs_flags & HFS_RESIZE_IN_PROGRESS) == 0) {+ return (ENXIO);+ }++ if (hfsmp->hfs_resize_totalblocks > 0) {+ *progress = (u_int32_t)((hfsmp->hfs_resize_blocksmoved * 100ULL) / hfsmp->hfs_resize_totalblocks);+ } else {+ *progress = 0;+ }++ return (0);+}diff --git a/xnu/files/bsd/hfs/hfs_search.c b/xnu/files/bsd/hfs/hfs_search.cnew file mode 100644index 0000000..fef65fb--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_search.c@@ -0,0 +1,1285 @@+/*+ * Copyright (c) 1997-2015 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@+ *+ * @(#)hfs_search.c+ */+/*+ * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce+ * support for mandatory and extensible security protections. This notice+ * is included in support of clause 2.2 (b) of the Apple Public License,+ * Version 2.0.+ */++#include <sys/param.h>+#include <sys/systm.h>+#include <sys/kernel.h>+#include <sys/file.h>+#include <sys/proc.h>+#include <sys/conf.h>+#include <mach/machine/vm_types.h>+#include <sys/vnode.h>+#include <sys/malloc.h>+#include <sys/signalvar.h>+#include <sys/attr.h>+#include <sys/utfconv.h>+#include <sys/kauth.h>+#include <sys/vm.h>++#if CONFIG_MACF+#include <security/mac_framework.h>+#endif++#include "hfs.h"+#include "hfs_dbg.h"+#include "hfs_catalog.h"+#include "hfs_attrlist.h"+#include "hfs_endian.h"++#include "FileMgrInternal.h"+#include "HFSUnicodeWrappers.h"+#include "BTreesPrivate.h"+#include "BTreeScanner.h"+#include "CatalogPrivate.h"++#if CONFIG_SEARCHFS++/* Search criterea. */+struct directoryInfoSpec+{+ u_int32_t numFiles;+};++struct fileInfoSpec+{+ off_t dataLogicalLength;+ off_t dataPhysicalLength;+ off_t resourceLogicalLength;+ off_t resourcePhysicalLength;+};++struct searchinfospec+{+ u_char name[kHFSPlusMaxFileNameBytes];+ u_int32_t nameLength;+ char attributes; // see IM:Files 2-100+ u_int32_t nodeID;+ u_int32_t parentDirID;+ struct timespec creationDate;+ struct timespec modificationDate;+ struct timespec changeDate;+ struct timespec accessDate;+ struct timespec lastBackupDate;+ u_int8_t finderInfo[32];+ uid_t uid;+ gid_t gid;+ mode_t mask;+ struct fileInfoSpec f;+ struct directoryInfoSpec d;+};+typedef struct searchinfospec searchinfospec_t;++static void ResolveHardlink(struct hfsmount *hfsmp, HFSPlusCatalogFile *recp);+++static int UnpackSearchAttributeBlock(struct hfsmount *hfsmp, struct attrlist *alist,+ searchinfospec_t *searchInfo, void *attributeBuffer, int firstblock);++static int CheckCriteria( ExtendedVCB *vcb,+ u_long searchBits,+ struct attrlist *attrList,+ CatalogRecord *rec,+ CatalogKey *key,+ searchinfospec_t *searchInfo1,+ searchinfospec_t *searchInfo2,+ struct vfs_context *ctx);++static int CheckAccess(ExtendedVCB *vcb, u_long searchBits, CatalogKey *key, struct vfs_context *ctx);++static int InsertMatch(struct hfsmount *hfsmp, uio_t a_uio, CatalogRecord *rec,+ CatalogKey *key, struct attrlist *returnAttrList,+ void *attributesBuffer, void *variableBuffer,+ uint32_t * nummatches );++static Boolean CompareRange(u_long val, u_long low, u_long high);+static Boolean CompareWideRange(u_int64_t val, u_int64_t low, u_int64_t high);++static Boolean CompareRange( u_long val, u_long low, u_long high )+{+ return( (val >= low) && (val <= high) );+}++static Boolean CompareWideRange( u_int64_t val, u_int64_t low, u_int64_t high )+{+ return( (val >= low) && (val <= high) );+}+//#define CompareRange(val, low, high) ((val >= low) && (val <= high))+++/************************************************************************/+/* Entry for searchfs() */+/************************************************************************/++#define errSearchBufferFull 101 /* Internal search errors */+/*+#+#% searchfs vp L L L+#+vnop_searchfs {+ IN struct vnode *vp;+ IN off_t length;+ IN int flags;+ IN kauth_cred_t cred;+ IN struct proc *p;+};+*/++int+hfs_vnop_search(ap)+ struct vnop_searchfs_args *ap; /*+ struct vnodeop_desc *a_desc;+ struct vnode *a_vp;+ void *a_searchparams1;+ void *a_searchparams2;+ struct attrlist *a_searchattrs;+ u_long a_maxmatches;+ struct timeval *a_timelimit;+ struct attrlist *a_returnattrs;+ u_long *a_nummatches;+ u_long a_scriptcode;+ u_long a_options;+ struct uio *a_uio;+ struct searchstate *a_searchstate;+ vfs_context_t a_context;+ */+{+ ExtendedVCB *vcb = VTOVCB(ap->a_vp);+ struct hfsmount *hfsmp;+ FCB * catalogFCB;+ searchinfospec_t searchInfo1;+ searchinfospec_t searchInfo2;+ void *attributesBuffer = NULL;+ void *variableBuffer;+ u_int32_t fixedBlockSize;+ u_int32_t eachReturnBufferSize;+ struct proc *p = current_proc();+ int err = E_NONE;+ int isHFSPlus;+ CatalogKey * myCurrentKeyPtr;+ CatalogRecord * myCurrentDataPtr;+ CatPosition * myCatPositionPtr;+ BTScanState myBTScanState;+ user_addr_t user_start = 0;+ user_size_t user_len = 0;+ int32_t searchTime;+ int lockflags;+ boolean_t timerExpired = FALSE;++ /* XXX Parameter check a_searchattrs? */++ *(ap->a_nummatches) = 0;++ if (ap->a_options & ~SRCHFS_VALIDOPTIONSMASK) {+ return (EINVAL);+ }++ /*+ * Fail requests for attributes that HFS does not support for the+ * items that match the search criteria. Note that these checks+ * are for the OUTBOUND attributes to be returned (not search criteria).+ */+ if ((ap->a_returnattrs->commonattr & ~HFS_ATTR_CMN_VALID) ||+ (ap->a_returnattrs->volattr != 0) ||+ (ap->a_returnattrs->dirattr & ~HFS_ATTR_DIR_VALID) ||+ (ap->a_returnattrs->fileattr & ~HFS_ATTR_FILE_VALID) ||+ (ap->a_returnattrs->forkattr != 0)) {++ return (EINVAL);+ }++ /* SRCHFS_SKIPLINKS requires root access.+ * This option cannot be used with either+ * the ATTR_CMN_NAME or ATTR_CMN_PAROBJID+ * attributes.+ */+ if (ap->a_options & SRCHFS_SKIPLINKS) {+ attrgroup_t attrs;++ attrs = ap->a_searchattrs->commonattr | ap->a_returnattrs->commonattr;+ if (attrs & (ATTR_CMN_NAME | ATTR_CMN_PAROBJID)) {+ return (EINVAL);+ }++ if ((err = vfs_context_suser(ap->a_context))) {+ return (err);+ }+ }++ // If both 32-bit and 64-bit parent ids or file ids are given+ // then return an error.++ attrgroup_t test_attrs=ap->a_searchattrs->commonattr;++ if (((test_attrs & ATTR_CMN_OBJID) && (test_attrs & ATTR_CMN_FILEID)) ||+ ((test_attrs & ATTR_CMN_PARENTID) && (test_attrs & ATTR_CMN_PAROBJID))) {+ return (EINVAL);+ }++ if (uio_resid(ap->a_uio) <= 0) {+ return (EINVAL);+ }++ isHFSPlus = (vcb->vcbSigWord == kHFSPlusSigWord);+ hfsmp = VTOHFS(ap->a_vp);++ searchTime = kMaxMicroSecsInKernel;+ if (ap->a_timelimit->tv_sec == 0 &&+ ap->a_timelimit->tv_usec > 0 &&+ ap->a_timelimit->tv_usec < kMaxMicroSecsInKernel) {+ searchTime = ap->a_timelimit->tv_usec;+ }++ /* UnPack the search boundries, searchInfo1, searchInfo2 */+ err = UnpackSearchAttributeBlock(hfsmp, ap->a_searchattrs,+ &searchInfo1, ap->a_searchparams1, 1);+ if (err) {+ return err;+ }+ err = UnpackSearchAttributeBlock(hfsmp, ap->a_searchattrs,+ &searchInfo2, ap->a_searchparams2, 0);+ if (err) {+ return err;+ }+ //shadow search bits if 64-bit file/parent ids are used+ if (ap->a_searchattrs->commonattr & ATTR_CMN_FILEID)+ ap->a_searchattrs->commonattr |= ATTR_CMN_OBJID;+ if (ap->a_searchattrs->commonattr & ATTR_CMN_PARENTID)+ ap->a_searchattrs->commonattr |= ATTR_CMN_PAROBJID;++ fixedBlockSize = sizeof(u_int32_t) + hfs_attrblksize(ap->a_returnattrs); /* u_int32_t for length word */++ eachReturnBufferSize = fixedBlockSize;++ if ( ap->a_returnattrs->commonattr & ATTR_CMN_NAME ) /* XXX should be more robust! */+ eachReturnBufferSize += kHFSPlusMaxFileNameBytes + 1;++ attributesBuffer = hfs_malloc_data(eachReturnBufferSize);+ variableBuffer = (void*)((char*) attributesBuffer + fixedBlockSize);++ // XXXdbg - have to lock the user's buffer so we don't fault+ // while holding the shared catalog file lock. see the comment+ // in hfs_readdir() for more details.+ //+ if (hfsmp->jnl && uio_isuserspace(ap->a_uio)) {+ user_start = uio_curriovbase(ap->a_uio);+ user_len = uio_curriovlen(ap->a_uio);++ if ((err = vslock(user_start, user_len)) != 0) {+ user_start = 0;+ goto ExitThisRoutine;+ }+ }++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);++ catalogFCB = GetFileControlBlock(vcb->catalogRefNum);+ myCurrentKeyPtr = NULL;+ myCurrentDataPtr = NULL;+ myCatPositionPtr = (CatPosition *)ap->a_searchstate;++ if (ap->a_options & SRCHFS_START) {+ /* Starting a new search. */+ /* Make sure the on-disk Catalog file is current */+ (void) hfs_fsync(vcb->catalogRefNum, MNT_WAIT, 0, p);+ if (hfsmp->jnl) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ hfs_flush(hfsmp, HFS_FLUSH_JOURNAL);+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);+ }++ ap->a_options &= ~SRCHFS_START;+ bzero((caddr_t)myCatPositionPtr, sizeof(*myCatPositionPtr));+ err = BTScanInitialize(catalogFCB, 0, 0, 0, kCatSearchBufferSize, &myBTScanState);+ if (err) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ goto ExitThisRoutine;+ }+ } else {+ /* Resuming a search. */+ err = BTScanInitialize(catalogFCB, myCatPositionPtr->nextNode,+ myCatPositionPtr->nextRecord,+ myCatPositionPtr->recordsFound,+ kCatSearchBufferSize,+ &myBTScanState);+ /* Make sure Catalog hasn't changed. */+ if (err == 0+ && myCatPositionPtr->writeCount != myBTScanState.btcb->writeCount) {+ myCatPositionPtr->writeCount = myBTScanState.btcb->writeCount;+ err = EBUSY; /* catChangedErr */+ }+ }+ hfs_systemfile_unlock(hfsmp, lockflags);++ if (err)+ goto ExitThisRoutine;++ /*+ * Check all the catalog btree records...+ * return the attributes for matching items+ */+ for (;;) {+ struct timeval myCurrentTime;+ struct timeval myElapsedTime;++ err = BTScanNextRecord(&myBTScanState, timerExpired,+ (void **)&myCurrentKeyPtr, (void **)&myCurrentDataPtr,+ NULL);+ if (err)+ break;++ /* Resolve any hardlinks */+ if (isHFSPlus && (ap->a_options & SRCHFS_SKIPLINKS) == 0) {+ ResolveHardlink(vcb, (HFSPlusCatalogFile *)myCurrentDataPtr);+ }+ if (CheckCriteria( vcb, ap->a_options, ap->a_searchattrs, myCurrentDataPtr,+ myCurrentKeyPtr, &searchInfo1, &searchInfo2, ap->a_context )+ && CheckAccess(vcb, ap->a_options, myCurrentKeyPtr, ap->a_context)) {+ err = InsertMatch(hfsmp, ap->a_uio, myCurrentDataPtr,+ myCurrentKeyPtr, ap->a_returnattrs,+ attributesBuffer, variableBuffer, ap->a_nummatches);+ if (err) {+ /*+ * The last match didn't fit so come back+ * to this record on the next trip.+ */+ --myBTScanState.recordsFound;+ --myBTScanState.recordNum;+ break;+ }++ if (*(ap->a_nummatches) >= ap->a_maxmatches)+ break;+ }+ if (timerExpired == FALSE) {+ /*+ * Check our elapsed time and bail if we've hit the max.+ * The idea here is to throttle the amount of time we+ * spend in the kernel.+ */+ microuptime(&myCurrentTime);+ timersub(&myCurrentTime, &myBTScanState.startTime, &myElapsedTime);+ /*+ * Note: assumes kMaxMicroSecsInKernel is less than 1,000,000+ */+ if (myElapsedTime.tv_sec > 0+ || myElapsedTime.tv_usec >= searchTime) {+ timerExpired = TRUE;+ } else if (throttle_io_will_be_throttled(-1, HFSTOVFS(hfsmp)))+ timerExpired = TRUE;+ }+ }++ /* Update catalog position */+ myCatPositionPtr->writeCount = myBTScanState.btcb->writeCount;++ BTScanTerminate(&myBTScanState, &myCatPositionPtr->nextNode,+ &myCatPositionPtr->nextRecord,+ &myCatPositionPtr->recordsFound);++ if ( err == E_NONE ) {+ err = EAGAIN; /* signal to the user to call searchfs again */+ } else if ( err == errSearchBufferFull ) {+ if ( *(ap->a_nummatches) > 0 )+ err = EAGAIN;+ else+ err = ENOBUFS;+ } else if ( err == btNotFound ) {+ err = E_NONE; /* the entire disk has been searched */+ } else if ( err == fsBTTimeOutErr ) {+ err = EAGAIN;+ }++ExitThisRoutine:+ if (attributesBuffer)+ hfs_free_data(attributesBuffer, eachReturnBufferSize);++ if (user_start) {+ vsunlock(user_start, user_len, TRUE);+ }++ return (MacToVFSError(err));+}+++static void+ResolveHardlink(struct hfsmount *hfsmp, HFSPlusCatalogFile *recp)+{+ u_int32_t type, creator;+ int isdirlink = 0;+ int isfilelink = 0;+ time_t filecreatedate;++ if (recp->recordType != kHFSPlusFileRecord) {+ return;+ }+ type = SWAP_BE32(recp->userInfo.fdType);+ creator = SWAP_BE32(recp->userInfo.fdCreator);+ filecreatedate = to_bsd_time(recp->createDate);++ if ((type == kHardLinkFileType && creator == kHFSPlusCreator) &&+ (filecreatedate == (time_t)hfsmp->hfs_itime ||+ filecreatedate == (time_t)hfsmp->hfs_metadata_createdate)) {+ isfilelink = 1;+ } else if ((type == kHFSAliasType && creator == kHFSAliasCreator) &&+ (recp->flags & kHFSHasLinkChainMask) &&+ (filecreatedate == (time_t)hfsmp->hfs_itime ||+ filecreatedate == (time_t)hfsmp->hfs_metadata_createdate)) {+ isdirlink = 1;+ }++ if (isfilelink || isdirlink) {+ cnid_t saved_cnid;+ int lockflags;++ /* Export link's cnid (a unique value) instead of inode's cnid */+ saved_cnid = recp->fileID;+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);++ (void) cat_resolvelink(hfsmp, recp->hl_linkReference, isdirlink, recp);++ recp->fileID = saved_cnid;+ hfs_systemfile_unlock(hfsmp, lockflags);+ }+}+++static Boolean+CompareMasked(const u_int32_t *thisValue, const u_int32_t *compareData,+ const u_int32_t *compareMask, u_int32_t count)+{+ Boolean matched;+ u_int32_t i;++ matched = true; /* Assume it will all match */++ for (i=0; i<count; i++) {+ if (((*thisValue++ ^ *compareData++) & *compareMask++) != 0) {+ matched = false;+ break;+ }+ }++ return matched;+}+++static Boolean+ComparePartialUnicodeName (register ConstUniCharArrayPtr str, register ItemCount s_len,+ register ConstUniCharArrayPtr find, register ItemCount f_len, int caseSensitive )+{+ if (f_len == 0 || s_len == 0) {+ return FALSE;+ }++ if (caseSensitive) {+ do {+ if (s_len-- < f_len)+ return FALSE;+ } while (UnicodeBinaryCompare(str++, f_len, find, f_len) != 0);+ }+ else {+ do {+ if (s_len-- < f_len)+ return FALSE;+ } while (FastUnicodeCompare(str++, f_len, find, f_len) != 0);+ }++ return TRUE;+}+++/*+ * Check to see if caller has access rights to this item+ */++static int+CheckAccess(ExtendedVCB *theVCBPtr, u_long searchBits, CatalogKey *theKeyPtr, struct vfs_context *ctx)+{+ Boolean isHFSPlus;+ int myErr;+ int myResult;+ HFSCatalogNodeID myNodeID = 0;+ hfsmount_t * hfsmp;+ struct FndrDirInfo *finfop;+ struct vnode * vp = NULL;++ myResult = 0; /* default to "no access" */++ if (!vfs_context_suser(ctx)) {+ myResult = 1; /* allow access */+ goto ExitThisRoutine; /* root always has access */+ }++ hfsmp = VCBTOHFS( theVCBPtr );+ isHFSPlus = ( theVCBPtr->vcbSigWord == kHFSPlusSigWord );+ if ( isHFSPlus )+ myNodeID = theKeyPtr->hfsPlus.parentID;++ while ( myNodeID >= kRootDirID ) {+ cnode_t * cp;++ /* now go get catalog data for this directory */+ myErr = hfs_vget(hfsmp, myNodeID, &vp, 0, 0);+ if ( myErr ) {+ goto ExitThisRoutine; /* no access */+ }++ cp = VTOC(vp);+ finfop = (struct FndrDirInfo *)&cp->c_attr.ca_finderinfo[0];++ if ( searchBits & SRCHFS_SKIPPACKAGES ) {+ if ( (SWAP_BE16(finfop->frFlags) & kHasBundle)+ || (cp->c_desc.cd_nameptr != NULL+ && is_package_name((const char *)cp->c_desc.cd_nameptr, cp->c_desc.cd_namelen)) ) {+ myResult = 0;+ goto ExitThisRoutine;+ }+ }++ if ( searchBits & SRCHFS_SKIPINAPPROPRIATE ) {+ if ( cp->c_parentcnid == kRootDirID && cp->c_desc.cd_nameptr != NULL &&+ vn_searchfs_inappropriate_name((const char *)cp->c_desc.cd_nameptr, cp->c_desc.cd_namelen) ) {+ myResult = 0;+ goto ExitThisRoutine;+ }+ }++ if ( (searchBits & SRCHFS_SKIPINVISIBLE) &&+ (SWAP_BE16(finfop->frFlags) & kIsInvisible) ) {+ myResult = 0;+ goto ExitThisRoutine;+ }++ myNodeID = cp->c_parentcnid; /* move up the hierarchy */+ hfs_unlock(VTOC(vp));++#if CONFIG_MACF+ if (vp->v_type == VDIR) {+ myErr = mac_vnode_check_readdir(ctx, vp);+ } else {+ myErr = mac_vnode_check_stat(ctx, NOCRED, vp);+ }+ if (myErr) {+ vnode_put(vp);+ vp = NULL;+ goto ExitThisRoutine;+ }+#endif /* MAC */++ if (vnode_vtype(vp) == VDIR) {+ myErr = vnode_authorize(vp, NULL, (KAUTH_VNODE_SEARCH | KAUTH_VNODE_LIST_DIRECTORY), ctx);+ } else {+ myErr = vnode_authorize(vp, NULL, (KAUTH_VNODE_SEARCH), ctx);+ }+ vnode_put(vp);+ vp = NULL;+ if ( myErr ) {+ goto ExitThisRoutine; /* no access */+ }+ }+ myResult = 1; /* allow access */++ExitThisRoutine:+ if ( vp != NULL ) {+ hfs_unlock(VTOC(vp));+ vnode_put(vp);+ }+ return ( myResult );++}++static int+CheckCriteria( ExtendedVCB *vcb,+ u_long searchBits,+ struct attrlist *attrList,+ CatalogRecord *rec,+ CatalogKey *key,+ searchinfospec_t *searchInfo1,+ searchinfospec_t *searchInfo2,+ struct vfs_context *ctx)+{+ Boolean matched, atleastone;+ Boolean isHFSPlus;+ attrgroup_t searchAttributes;+ struct cat_attr c_attr;+ struct cat_fork datafork;+ struct cat_fork rsrcfork;+ int force_case_sensitivity = proc_is_forcing_hfs_case_sensitivity(vfs_context_proc(ctx));++ bzero(&c_attr, sizeof(c_attr));+ isHFSPlus = (vcb->vcbSigWord == kHFSPlusSigWord);++ switch (rec->recordType) {+ case kHFSPlusFolderRecord:+ if ( (searchBits & SRCHFS_MATCHDIRS) == 0 ) { /* If we are NOT searching folders */+ matched = false;+ goto TestDone;+ }+ break;++ case kHFSPlusFileRecord:+ /* Check if hardlink links should be skipped. */+ if (searchBits & SRCHFS_SKIPLINKS) {+ cnid_t parid = key->hfsPlus.parentID;+ HFSPlusCatalogFile *filep = (HFSPlusCatalogFile *)rec;++ if ((SWAP_BE32(filep->userInfo.fdType) == kHardLinkFileType) &&+ (SWAP_BE32(filep->userInfo.fdCreator) == kHFSPlusCreator)) {+ return (false); /* skip over file link records */+ } else if ((parid == vcb->hfs_private_desc[FILE_HARDLINKS].cd_cnid) &&+ (filep->bsdInfo.special.linkCount == 0)) {+ return (false); /* skip over unlinked files */+ } else if ((SWAP_BE32(filep->userInfo.fdType) == kHFSAliasType) &&+ (SWAP_BE32(filep->userInfo.fdCreator) == kHFSAliasCreator) &&+ (filep->flags & kHFSHasLinkChainMask)) {+ return (false); /* skip over dir link records */+ }+ } else if (key->hfsPlus.parentID == vcb->hfs_private_desc[FILE_HARDLINKS].cd_cnid) {+ return (false); /* skip over private files */+ } else if (key->hfsPlus.parentID == vcb->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {+ return (false); /* skip over private files */+ }++ if ( (searchBits & SRCHFS_MATCHFILES) == 0 ) { /* If we are NOT searching files */+ matched = false;+ goto TestDone;+ }+ break;++ default: /* Never match a thread record or any other type. */+ return( false ); /* Not a file or folder record, so can't search it */+ }++ matched = true; /* Assume we got a match */+ atleastone = false; /* Dont insert unless we match at least one criteria */++ /* First, attempt to match the name -- either partial or complete */+ if ( attrList->commonattr & ATTR_CMN_NAME ) {+ if (isHFSPlus) {+ int case_sensitive = 0;++ /*+ * Longstanding default behavior here is to use a non-case-sensitive+ * search, even on case-sensitive filesystems.+ *+ * We only force case sensitivity if the controlling process has explicitly+ * asked for it in the proc flags, and only if they are not doing+ * a partial name match. Consider that if you are doing a partial+ * name match ("all files that begin with 'image'"), the likelihood is+ * high that you would want to see all matches, even those that do not+ * explicitly match the case.+ */+ if (force_case_sensitivity) {+ case_sensitive = 1;+ }++ /* Check for partial/full HFS Plus name match */++ if ( searchBits & SRCHFS_MATCHPARTIALNAMES ) {+ /* always use a case-INSENSITIVE search here */+ matched = ComparePartialUnicodeName(key->hfsPlus.nodeName.unicode,+ key->hfsPlus.nodeName.length,+ (UniChar*)searchInfo1->name,+ searchInfo1->nameLength, 0);+ }+ else {+ /* Full name match. Are we HFSX (case sensitive) or HFS+ ? */+ if (case_sensitive) {+ matched = (UnicodeBinaryCompare(key->hfsPlus.nodeName.unicode,+ key->hfsPlus.nodeName.length,+ (UniChar*)searchInfo1->name,+ searchInfo1->nameLength ) == 0);+ }+ else {+ matched = (FastUnicodeCompare(key->hfsPlus.nodeName.unicode,+ key->hfsPlus.nodeName.length,+ (UniChar*)searchInfo1->name,+ searchInfo1->nameLength ) == 0);+ }+ }+ }++ if ( matched == false || (searchBits & ~SRCHFS_MATCHPARTIALNAMES) == 0 )+ goto TestDone; /* no match, or nothing more to compare */++ atleastone = true;+ }++ /* Convert catalog record into cat_attr format. */+ cat_convertattr(VCBTOHFS(vcb), rec, &c_attr, &datafork, &rsrcfork);++ if (searchBits & SRCHFS_SKIPINVISIBLE) {+ int flags;++ switch (rec->recordType) {+ case kHFSPlusFolderRecord:+ {+ struct FndrDirInfo *finder_info;++ finder_info = (struct FndrDirInfo *)&c_attr.ca_finderinfo[0];+ flags = SWAP_BE16(finder_info->frFlags);+ break;+ }++ case kHFSPlusFileRecord:+ {+ struct FndrFileInfo *finder_info;++ finder_info = (struct FndrFileInfo *)&c_attr.ca_finderinfo[0];+ flags = SWAP_BE16(finder_info->fdFlags);+ break;+ }++ default:+ {+ flags = kIsInvisible;+ break;+ }+ }++ if (flags & kIsInvisible) {+ matched = false;+ goto TestDone;+ }+ }++++ /* Now that we have a record worth searching, see if it matches the search attributes */+ if (rec->recordType == kHFSPlusFileRecord) {+ if ((attrList->fileattr & ~ATTR_FILE_VALIDMASK) != 0) { /* attr we do know about */+ matched = false;+ goto TestDone;+ }+ else if ((attrList->fileattr & ATTR_FILE_VALIDMASK) != 0) {+ searchAttributes = attrList->fileattr;++#if HFS_COMPRESSION+ if ( c_attr.ca_flags & UF_COMPRESSED ) {+ /* for compressed files, set the data length to the uncompressed data size */+ if (( searchAttributes & ATTR_FILE_DATALENGTH ) ||+ ( searchAttributes & ATTR_FILE_DATAALLOCSIZE ) ) {+ if ( 0 == hfs_uncompressed_size_of_compressed_file(vcb, NULL, c_attr.ca_fileid, &datafork.cf_size, 1) ) { /* 1 == don't take the cnode lock */+ datafork.cf_blocks = rsrcfork.cf_blocks;+ }+ }+ /* treat compressed files as if their resource fork is empty */+ if (( searchAttributes & ATTR_FILE_RSRCLENGTH ) ||+ ( searchAttributes & ATTR_FILE_RSRCALLOCSIZE ) ) {+ rsrcfork.cf_size = 0;+ rsrcfork.cf_blocks = 0;+ }+ }+#endif /* HFS_COMPRESSION */++ /* File logical length (data fork) */+ if ( searchAttributes & ATTR_FILE_DATALENGTH ) {+ matched = CompareWideRange(+ datafork.cf_size,+ searchInfo1->f.dataLogicalLength,+ searchInfo2->f.dataLogicalLength);+ if (matched == false) goto TestDone;+ atleastone = true;+ }++ /* File physical length (data fork) */+ if ( searchAttributes & ATTR_FILE_DATAALLOCSIZE ) {+ matched = CompareWideRange(+ (u_int64_t)datafork.cf_blocks * (u_int64_t)vcb->blockSize,+ searchInfo1->f.dataPhysicalLength,+ searchInfo2->f.dataPhysicalLength);+ if (matched == false) goto TestDone;+ atleastone = true;+ }++ /* File logical length (resource fork) */+ if ( searchAttributes & ATTR_FILE_RSRCLENGTH ) {+ matched = CompareWideRange(+ rsrcfork.cf_size,+ searchInfo1->f.resourceLogicalLength,+ searchInfo2->f.resourceLogicalLength);+ if (matched == false) goto TestDone;+ atleastone = true;+ }++ /* File physical length (resource fork) */+ if ( searchAttributes & ATTR_FILE_RSRCALLOCSIZE ) {+ matched = CompareWideRange(+ (u_int64_t)rsrcfork.cf_blocks * (u_int64_t)vcb->blockSize,+ searchInfo1->f.resourcePhysicalLength,+ searchInfo2->f.resourcePhysicalLength);+ if (matched == false) goto TestDone;+ atleastone = true;+ }+ }+ else {+ atleastone = true; /* to match SRCHFS_MATCHFILES */+ }+ }+ /*+ * Check the directory attributes+ */+ else if (rec->recordType == kHFSPlusFolderRecord) {+ if ((attrList->dirattr & ~ATTR_DIR_VALIDMASK) != 0) { /* attr we do know about */+ matched = false;+ goto TestDone;+ }+ else if ((attrList->dirattr & ATTR_DIR_VALIDMASK) != 0) {+ searchAttributes = attrList->dirattr;++ /* Directory valence */+ if ( searchAttributes & ATTR_DIR_ENTRYCOUNT ) {+ matched = CompareRange(c_attr.ca_entries,+ searchInfo1->d.numFiles,+ searchInfo2->d.numFiles );+ if (matched == false) goto TestDone;+ atleastone = true;+ }+ }+ else {+ atleastone = true; /* to match SRCHFS_MATCHDIRS */+ }+ }++ /*+ * Check the common attributes+ */+ searchAttributes = attrList->commonattr;+ if ( (searchAttributes & ATTR_CMN_VALIDMASK) != 0 ) {+ /* node ID */+ if ( searchAttributes & ATTR_CMN_OBJID ) {+ matched = CompareRange(c_attr.ca_fileid,+ searchInfo1->nodeID,+ searchInfo2->nodeID );+ if (matched == false) goto TestDone;+ atleastone = true;+ }++ /* Parent ID */+ if ( searchAttributes & ATTR_CMN_PAROBJID ) {+ HFSCatalogNodeID parentID = 0;++ if (isHFSPlus)+ parentID = key->hfsPlus.parentID;++ matched = CompareRange(parentID, searchInfo1->parentDirID,+ searchInfo2->parentDirID );+ if (matched == false) goto TestDone;+ atleastone = true;+ }++ /* Finder Info & Extended Finder Info where extFinderInfo is last 32 bytes */+ if ( searchAttributes & ATTR_CMN_FNDRINFO ) {+ u_int32_t *thisValue;+ thisValue = (u_int32_t *) &c_attr.ca_finderinfo;++ /*+ * Note: ioFlFndrInfo and ioDrUsrWds have the same offset in search info, so+ * no need to test the object type here.+ */+ matched = CompareMasked(thisValue,+ (u_int32_t *)&searchInfo1->finderInfo,+ (u_int32_t *) &searchInfo2->finderInfo, 8);+ if (matched == false) goto TestDone;+ atleastone = true;+ }++ /* Create date */+ if ( searchAttributes & ATTR_CMN_CRTIME ) {+ matched = CompareRange(c_attr.ca_itime,+ searchInfo1->creationDate.tv_sec,+ searchInfo2->creationDate.tv_sec);+ if (matched == false) goto TestDone;+ atleastone = true;+ }++ /* Mod date */+ if ( searchAttributes & ATTR_CMN_MODTIME ) {+ matched = CompareRange(c_attr.ca_mtime,+ searchInfo1->modificationDate.tv_sec,+ searchInfo2->modificationDate.tv_sec);+ if (matched == false) goto TestDone;+ atleastone = true;+ }++ /* Change Time */+ if ( searchAttributes & ATTR_CMN_CHGTIME ) {+ matched = CompareRange(c_attr.ca_ctime,+ searchInfo1->changeDate.tv_sec,+ searchInfo2->changeDate.tv_sec);+ if (matched == false) goto TestDone;+ atleastone = true;+ }++ /* Access date */+ if ( searchAttributes & ATTR_CMN_ACCTIME ) {+ matched = CompareRange(c_attr.ca_atime,+ searchInfo1->accessDate.tv_sec,+ searchInfo2->accessDate.tv_sec);+ if (matched == false) goto TestDone;+ atleastone = true;+ }++ /* Backup date */+ if ( searchAttributes & ATTR_CMN_BKUPTIME ) {+ matched = CompareRange(c_attr.ca_btime,+ searchInfo1->lastBackupDate.tv_sec,+ searchInfo2->lastBackupDate.tv_sec);+ if (matched == false) goto TestDone;+ atleastone = true;+ }++ /* User ID */+ if ( searchAttributes & ATTR_CMN_OWNERID ) {+ matched = CompareRange(c_attr.ca_uid,+ searchInfo1->uid, searchInfo2->uid);+ if (matched == false) goto TestDone;+ atleastone = true;+ }++ /* Group ID */+ if ( searchAttributes & ATTR_CMN_GRPID ) {+ matched = CompareRange(c_attr.ca_gid,+ searchInfo1->gid, searchInfo2->gid);+ if (matched == false) goto TestDone;+ atleastone = true;+ }++ /* mode */+ if ( searchAttributes & ATTR_CMN_ACCESSMASK ) {+ matched = CompareRange((u_int32_t)c_attr.ca_mode,+ (u_int32_t)searchInfo1->mask,+ (u_int32_t)searchInfo2->mask);+ if (matched == false) goto TestDone;+ atleastone = true;+ }+ }++ /* If we got here w/o matching any, then set to false */+ if (! atleastone)+ matched = false;++TestDone:+ /*+ * Finally, determine whether we need to negate the sense of the match+ * (i.e. find all objects that DON'T match).+ */+ if ( searchBits & SRCHFS_NEGATEPARAMS )+ matched = !matched;++ return( matched );+}+++/*+ * Adds another record to the packed array for output+ */+static int+InsertMatch(struct hfsmount *hfsmp, uio_t a_uio, CatalogRecord *rec,+ CatalogKey *key, struct attrlist *returnAttrList,+ void *attributesBuffer, void *variableBuffer, uint32_t * nummatches)+{+ int err;+ void *rovingAttributesBuffer;+ void *rovingVariableBuffer;+ long packedBufferSize;+ struct attrblock attrblk;+ struct cat_desc c_desc;+ struct cat_attr c_attr;+ struct cat_fork datafork;+ struct cat_fork rsrcfork;++ bzero(&c_desc, sizeof(c_desc));+ bzero(&c_attr, sizeof(c_attr));+ rovingAttributesBuffer = (char*)attributesBuffer + sizeof(u_int32_t); /* Reserve space for length field */+ rovingVariableBuffer = variableBuffer;++ /* Convert catalog record into cat_attr format. */+ cat_convertattr(hfsmp, rec, &c_attr, &datafork, &rsrcfork);++ /* Hide our private meta data directories */+ if (c_attr.ca_fileid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid ||+ c_attr.ca_fileid == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {+ err = 0;+ goto exit;+ }++ /* Hide the private journal files */+ if (hfsmp->jnl &&+ ((c_attr.ca_fileid == hfsmp->hfs_jnlfileid) ||+ (c_attr.ca_fileid == hfsmp->hfs_jnlinfoblkid))) {+ err = 0;+ goto exit;+ }++ if (returnAttrList->commonattr & ATTR_CMN_NAME) {+ err = cat_convertkey(hfsmp, key, rec, &c_desc);+ if (err) {+ /* This means that we probably had a CNID error */+ goto exit;+ }+ } else {+ c_desc.cd_cnid = c_attr.ca_fileid;+ if ((hfsmp->hfs_flags & HFS_STANDARD) == 0)+ c_desc.cd_parentcnid = key->hfsPlus.parentID;++ }++ attrblk.ab_attrlist = returnAttrList;+ attrblk.ab_attrbufpp = &rovingAttributesBuffer;+ attrblk.ab_varbufpp = &rovingVariableBuffer;+ attrblk.ab_flags = 0;+ attrblk.ab_blocksize = 0;+ attrblk.ab_context = vfs_context_current();++ hfs_packattrblk(&attrblk, hfsmp, NULL, &c_desc, &c_attr, &datafork, &rsrcfork, vfs_context_current());++ packedBufferSize = (char*)rovingVariableBuffer - (char*)attributesBuffer;++ if ( packedBufferSize > uio_resid(a_uio) )+ return( errSearchBufferFull );++ (* nummatches)++;++ *((u_int32_t *)attributesBuffer) = packedBufferSize; /* Store length of fixed + var block */++ err = uiomove( (caddr_t)attributesBuffer, packedBufferSize, a_uio );+exit:+ cat_releasedesc(&c_desc);++ return( err );+}+++static int+UnpackSearchAttributeBlock( struct hfsmount *hfsmp, struct attrlist *alist,+ searchinfospec_t *searchInfo, void *attributeBuffer, int firstblock)+{+ attrgroup_t a;+ u_int32_t bufferSize;+ boolean_t is_64_bit;++ hfs_assert(searchInfo != NULL);++ is_64_bit = proc_is64bit(current_proc());++ bufferSize = *((u_int32_t *)attributeBuffer);+ if (bufferSize == 0)+ return (EINVAL); /* XXX -DJB is a buffer size of zero ever valid for searchfs? */++ attributeBuffer = (u_int32_t *)attributeBuffer + 1; /* advance past the size */++ /*+ * UnPack common attributes+ */+ a = alist->commonattr;+ if ( a != 0 ) {+ if ( a & ATTR_CMN_NAME ) {+ if (firstblock) {+ /* Only use the attrreference_t for the first searchparams */+ char *s;+ u_int32_t len;++ s = (char*) attributeBuffer + ((attrreference_t *) attributeBuffer)->attr_dataoffset;+ len = ((attrreference_t *) attributeBuffer)->attr_length;++ if (len > sizeof(searchInfo->name))+ return (EINVAL);+++ if ((hfsmp->hfs_flags & HFS_STANDARD) == 0) {+ size_t ucslen;+ /* Convert name to Unicode to match HFS Plus B-Tree names */++ if (len > 0) {+ if (utf8_decodestr((u_int8_t *)s, len-1, (UniChar*)searchInfo->name, &ucslen,+ sizeof(searchInfo->name), ':', UTF_DECOMPOSED | UTF_ESCAPE_ILLEGAL))+ return (EINVAL);++ searchInfo->nameLength = ucslen / sizeof(UniChar);+ } else {+ searchInfo->nameLength = 0;+ }+ }+ }+ attributeBuffer = (attrreference_t*) attributeBuffer +1;+ }+ if ( a & ATTR_CMN_OBJID ) {+ searchInfo->nodeID = ((fsobj_id_t *) attributeBuffer)->fid_objno; /* ignore fid_generation */+ attributeBuffer = (fsobj_id_t *)attributeBuffer + 1;+ }+ if ( a & ATTR_CMN_PAROBJID ) {+ searchInfo->parentDirID = ((fsobj_id_t *) attributeBuffer)->fid_objno; /* ignore fid_generation */+ attributeBuffer = (fsobj_id_t *)attributeBuffer + 1;+ }++ if ( a & ATTR_CMN_CRTIME ) {+ if (is_64_bit) {+ struct user64_timespec tmp;+ tmp = *((struct user64_timespec *)attributeBuffer);+ searchInfo->creationDate.tv_sec = (time_t)tmp.tv_sec;+ searchInfo->creationDate.tv_nsec = tmp.tv_nsec;+ attributeBuffer = (struct user64_timespec *)attributeBuffer + 1;+ }+ else {+ struct user32_timespec tmp;+ tmp = *((struct user32_timespec *)attributeBuffer);+ searchInfo->creationDate.tv_sec = (time_t)tmp.tv_sec;+ searchInfo->creationDate.tv_nsec = tmp.tv_nsec;+ attributeBuffer = (struct user32_timespec *)attributeBuffer + 1;+ }+ }+ if ( a & ATTR_CMN_MODTIME ) {+ if (is_64_bit) {+ struct user64_timespec tmp;+ tmp = *((struct user64_timespec *)attributeBuffer);+ searchInfo->modificationDate.tv_sec = (time_t)tmp.tv_sec;+ searchInfo->modificationDate.tv_nsec = tmp.tv_nsec;+ attributeBuffer = (struct user64_timespec *)attributeBuffer + 1;+ }+ else {+ struct user32_timespec tmp;+ tmp = *((struct user32_timespec *)attributeBuffer);+ searchInfo->modificationDate.tv_sec = (time_t)tmp.tv_sec;+ searchInfo->modificationDate.tv_nsec = tmp.tv_nsec;+ attributeBuffer = (struct user32_timespec *)attributeBuffer + 1;+ }+ }+ if ( a & ATTR_CMN_CHGTIME ) {+ if (is_64_bit) {+ struct user64_timespec tmp;+ tmp = *((struct user64_timespec *)attributeBuffer);+ searchInfo->changeDate.tv_sec = (time_t)tmp.tv_sec;+ searchInfo->changeDate.tv_nsec = tmp.tv_nsec;+ attributeBuffer = (struct user64_timespec *)attributeBuffer + 1;+ }+ else {+ struct user32_timespec tmp;+ tmp = *((struct user32_timespec *)attributeBuffer);+ searchInfo->changeDate.tv_sec = (time_t)tmp.tv_sec;+ searchInfo->changeDate.tv_nsec = tmp.tv_nsec;+ attributeBuffer = (struct user32_timespec *)attributeBuffer + 1;+ }+ }+ if ( a & ATTR_CMN_ACCTIME ) {+ if (is_64_bit) {+ struct user64_timespec tmp;+ tmp = *((struct user64_timespec *)attributeBuffer);+ searchInfo->accessDate.tv_sec = (time_t)tmp.tv_sec;+ searchInfo->accessDate.tv_nsec = tmp.tv_nsec;+ attributeBuffer = (struct user64_timespec *)attributeBuffer + 1;+ }+ else {+ struct user32_timespec tmp;+ tmp = *((struct user32_timespec *)attributeBuffer);+ searchInfo->accessDate.tv_sec = (time_t)tmp.tv_sec;+ searchInfo->accessDate.tv_nsec = tmp.tv_nsec;+ attributeBuffer = (struct user32_timespec *)attributeBuffer + 1;+ }+ }+ if ( a & ATTR_CMN_BKUPTIME ) {+ if (is_64_bit) {+ struct user64_timespec tmp;+ tmp = *((struct user64_timespec *)attributeBuffer);+ searchInfo->lastBackupDate.tv_sec = (time_t)tmp.tv_sec;+ searchInfo->lastBackupDate.tv_nsec = tmp.tv_nsec;+ attributeBuffer = (struct user64_timespec *)attributeBuffer + 1;+ }+ else {+ struct user32_timespec tmp;+ tmp = *((struct user32_timespec *)attributeBuffer);+ searchInfo->lastBackupDate.tv_sec = (time_t)tmp.tv_sec;+ searchInfo->lastBackupDate.tv_nsec = tmp.tv_nsec;+ attributeBuffer = (struct user32_timespec *)attributeBuffer + 1;+ }+ }+ if ( a & ATTR_CMN_FNDRINFO ) {+ bcopy( attributeBuffer, searchInfo->finderInfo, sizeof(searchInfo->finderInfo) );+ attributeBuffer = (u_int8_t *)attributeBuffer + 32;+ }+ if ( a & ATTR_CMN_OWNERID ) {+ searchInfo->uid = *((uid_t *)attributeBuffer);+ attributeBuffer = (uid_t *)attributeBuffer + 1;+ }+ if ( a & ATTR_CMN_GRPID ) {+ searchInfo->gid = *((gid_t *)attributeBuffer);+ attributeBuffer = (gid_t *)attributeBuffer + 1;+ }+ if ( a & ATTR_CMN_ACCESSMASK ) {+ searchInfo->mask = *((mode_t *)attributeBuffer);+ attributeBuffer = (mode_t *)attributeBuffer + 1;+ }+ if ( a & ATTR_CMN_FILEID ) {+ searchInfo->nodeID = (u_int32_t)*((u_int64_t *) attributeBuffer);+ attributeBuffer = (u_int64_t *)attributeBuffer + 1;+ }+ if ( a & ATTR_CMN_PARENTID ) {+ searchInfo->parentDirID = (u_int32_t)*((u_int64_t *) attributeBuffer);+ attributeBuffer = (u_int64_t *)attributeBuffer + 1;+ }+ }++ a = alist->dirattr;+ if ( a != 0 ) {+ if ( a & ATTR_DIR_ENTRYCOUNT ) {+ searchInfo->d.numFiles = *((u_int32_t *)attributeBuffer);+ attributeBuffer = (u_int32_t *)attributeBuffer + 1;+ }+ }++ a = alist->fileattr;+ if ( a != 0 ) {+ if ( a & ATTR_FILE_DATALENGTH ) {+ searchInfo->f.dataLogicalLength = *((off_t *)attributeBuffer);+ attributeBuffer = (off_t *)attributeBuffer + 1;+ }+ if ( a & ATTR_FILE_DATAALLOCSIZE ) {+ searchInfo->f.dataPhysicalLength = *((off_t *)attributeBuffer);+ attributeBuffer = (off_t *)attributeBuffer + 1;+ }+ if ( a & ATTR_FILE_RSRCLENGTH ) {+ searchInfo->f.resourceLogicalLength = *((off_t *)attributeBuffer);+ attributeBuffer = (off_t *)attributeBuffer + 1;+ }+ if ( a & ATTR_FILE_RSRCALLOCSIZE ) {+ searchInfo->f.resourcePhysicalLength = *((off_t *)attributeBuffer);+ attributeBuffer = (off_t *)attributeBuffer + 1;+ }+ }++ return (0);+}+#endif /* CONFIG_SEARCHFS */diff --git a/xnu/files/bsd/hfs/hfs_unistr.h b/xnu/files/bsd/hfs/hfs_unistr.hnew file mode 100644index 0000000..5b300a2--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_unistr.h@@ -0,0 +1,64 @@+/*+ * Copyright (c) 2013 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@+ */++#ifndef __HFS_UNISTR__+#define __HFS_UNISTR__++#include <sys/types.h>++/*+ * hfs_unitstr.h+ *+ * This file contains definition of the unicode string used for HFS Plus+ * files and folder names, as described by the on-disk format.+ *+ */++#ifdef __cplusplus+extern "C" {+#endif+++#ifndef _HFSUNISTR255_DEFINED_+#define _HFSUNISTR255_DEFINED_+/* Unicode strings are used for HFS Plus file and folder names */+struct HFSUniStr255 {+ u_int16_t length; /* number of unicode characters */+ u_int16_t unicode[255]; /* unicode characters */+} __attribute__((aligned(2), packed));+typedef struct HFSUniStr255 HFSUniStr255;+typedef const HFSUniStr255 *ConstHFSUniStr255Param;+#endif /* _HFSUNISTR255_DEFINED_ */+++#ifdef __cplusplus+}+#endif+++#endif /* __HFS_UNISTR__ */diff --git a/xnu/files/bsd/hfs/hfs_vfsops.c b/xnu/files/bsd/hfs/hfs_vfsops.cnew file mode 100644index 0000000..0bf29c1--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_vfsops.c@@ -0,0 +1,4549 @@+/*+ * Copyright (c) 1999-2017 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@+ */+/*+ * Copyright (c) 1991, 1993, 1994+ * The Regents of the University of California. All rights reserved.+ * (c) UNIX System Laboratories, Inc.+ * All or some portions of this file are derived from material licensed+ * to the University of California by American Telephone and Telegraph+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with+ * the permission of UNIX System Laboratories, Inc.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions+ * are met:+ * 1. Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * 2. Redistributions in binary form must reproduce the above copyright+ * notice, this list of conditions and the following disclaimer in the+ * documentation and/or other materials provided with the distribution.+ * 3. All advertising materials mentioning features or use of this software+ * must display the following acknowledgement:+ * This product includes software developed by the University of+ * California, Berkeley and its contributors.+ * 4. Neither the name of the University nor the names of its contributors+ * may be used to endorse or promote products derived from this software+ * without specific prior written permission.+ *+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF+ * SUCH DAMAGE.+ *+ * hfs_vfsops.c+ * derived from @(#)ufs_vfsops.c 8.8 (Berkeley) 5/20/95+ *+ * (c) Copyright 1997-2002 Apple Inc. All rights reserved.+ *+ * hfs_vfsops.c -- VFS layer for loadable HFS file system.+ *+ */+#include <sys/param.h>+#include <sys/systm.h>+#include <sys/kauth.h>++#include <sys/ubc.h>+#include <sys/sysctl.h>+#include <sys/malloc.h>+#include <sys/stat.h>+#include <sys/quota.h>+#include <sys/disk.h>+#include <sys/paths.h>+#include <sys/utfconv.h>+#include <sys/kdebug.h>+#include <sys/fslog.h>+#include <sys/ubc.h>+#include <libkern/OSKextLib.h>+#include <libkern/OSAtomic.h>++/* for parsing boot-args */+#include <pexpert/pexpert.h>+++#include <kern/locks.h>++#include "hfs_journal.h"++#include <miscfs/specfs/specdev.h>+#include "hfs_mount.h"++#include <libkern/crypto/md5.h>+#include <uuid/uuid.h>++#include "hfs_iokit.h"+#include "hfs.h"+#include "hfs_catalog.h"+#include "hfs_cnode.h"+#include "hfs_dbg.h"+#include "hfs_endian.h"+#include "hfs_hotfiles.h"+#include "hfs_quota.h"+#include "hfs_btreeio.h"+#include "hfs_kdebug.h"+#include "hfs_cprotect.h"++#include "FileMgrInternal.h"+#include "BTreesInternal.h"++#define HFS_MOUNT_DEBUG 1++/* Enable/disable debugging code for live volume resizing, defined in hfs_resize.c */+extern int hfs_resize_debug;++lck_grp_attr_t * hfs_group_attr;+lck_attr_t * hfs_lock_attr;+lck_grp_t * hfs_mutex_group;+lck_grp_t * hfs_rwlock_group;+lck_grp_t * hfs_spinlock_group;++// variables to manage HFS kext retain count -- only supported on Macs+#if TARGET_OS_OSX+int hfs_active_mounts = 0;+#endif++extern struct vnodeopv_desc hfs_vnodeop_opv_desc;++/* not static so we can re-use in hfs_readwrite.c for vn_getpath_ext calls */+int hfs_vfs_vget(struct mount *mp, ino64_t ino, struct vnode **vpp, vfs_context_t context);++static int hfs_changefs(struct mount *mp, struct hfs_mount_args *args);+static int hfs_fhtovp(struct mount *mp, int fhlen, unsigned char *fhp, struct vnode **vpp, vfs_context_t context);+static int hfs_flushfiles(struct mount *, int, struct proc *);+static int hfs_init(struct vfsconf *vfsp);+static void hfs_locks_destroy(struct hfsmount *hfsmp);+static int hfs_quotactl(struct mount *, int, uid_t, caddr_t, vfs_context_t context);+static int hfs_start(struct mount *mp, int flags, vfs_context_t context);+static int hfs_vptofh(struct vnode *vp, int *fhlenp, unsigned char *fhp, vfs_context_t context);+static void hfs_syncer_free(struct hfsmount *hfsmp);++void hfs_initialize_allocator (struct hfsmount *hfsmp);+int hfs_teardown_allocator (struct hfsmount *hfsmp);++int hfs_mount(struct mount *mp, vnode_t devvp, user_addr_t data, vfs_context_t context);+int hfs_mountfs(struct vnode *devvp, struct mount *mp, struct hfs_mount_args *args, int journal_replay_only, vfs_context_t context);+int hfs_reload(struct mount *mp);+int hfs_statfs(struct mount *mp, register struct vfsstatfs *sbp, vfs_context_t context);+int hfs_sync(struct mount *mp, int waitfor, vfs_context_t context);+int hfs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,+ user_addr_t newp, size_t newlen, vfs_context_t context);+int hfs_unmount(struct mount *mp, int mntflags, vfs_context_t context);++static int hfs_journal_replay(vnode_t devvp, vfs_context_t context);++#if HFS_LEAK_DEBUG+#include <IOKit/IOLib.h>+#endif++/*+ * VFS Operations.+ *+ * mount system call+ */++int+hfs_mount(struct mount *mp, vnode_t devvp, user_addr_t data, vfs_context_t context)+{++#if HFS_LEAK_DEBUG++#warning HFS_LEAK_DEBUG is on++ hfs_alloc_trace_enable();++#endif++ struct proc *p = vfs_context_proc(context);+ struct hfsmount *hfsmp = NULL;+ struct hfs_mount_args args;+ int retval = E_NONE;+ u_int32_t cmdflags;++ if (data && (retval = copyin(data, (caddr_t)&args, sizeof(args)))) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mount: copyin returned %d for fs\n", retval);+ }+ return (retval);+ }+ cmdflags = (u_int32_t)vfs_flags(mp) & MNT_CMDFLAGS;+ if (cmdflags & MNT_UPDATE) {+ hfs_assert(data);++ hfsmp = VFSTOHFS(mp);++ /* Reload incore data after an fsck. */+ if (cmdflags & MNT_RELOAD) {+ if (vfs_isrdonly(mp)) {+ int error = hfs_reload(mp);+ if (error && HFS_MOUNT_DEBUG) {+ printf("hfs_mount: hfs_reload returned %d on %s \n", error, hfsmp->vcbVN);+ }+ return error;+ }+ else {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mount: MNT_RELOAD not supported on rdwr filesystem %s\n", hfsmp->vcbVN);+ }+ return (EINVAL);+ }+ }++ /* Change to a read-only file system. */+ if (((hfsmp->hfs_flags & HFS_READ_ONLY) == 0) &&+ vfs_isrdonly(mp)) {+ int flags;++ /* Set flag to indicate that a downgrade to read-only+ * is in progress and therefore block any further+ * modifications to the file system.+ */+ hfs_lock_global (hfsmp, HFS_EXCLUSIVE_LOCK);+ hfsmp->hfs_flags |= HFS_RDONLY_DOWNGRADE;+ hfsmp->hfs_downgrading_thread = current_thread();+ hfs_unlock_global (hfsmp);+ hfs_syncer_free(hfsmp);++ /* use hfs_sync to push out System (btree) files */+ retval = hfs_sync(mp, MNT_WAIT, context);+ if (retval && ((cmdflags & MNT_FORCE) == 0)) {+ hfsmp->hfs_flags &= ~HFS_RDONLY_DOWNGRADE;+ hfsmp->hfs_downgrading_thread = NULL;+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mount: VFS_SYNC returned %d during b-tree sync of %s \n", retval, hfsmp->vcbVN);+ }+ goto out;+ }++ flags = WRITECLOSE;+ if (cmdflags & MNT_FORCE)+ flags |= FORCECLOSE;++ if ((retval = hfs_flushfiles(mp, flags, p))) {+ hfsmp->hfs_flags &= ~HFS_RDONLY_DOWNGRADE;+ hfsmp->hfs_downgrading_thread = NULL;+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mount: hfs_flushfiles returned %d on %s \n", retval, hfsmp->vcbVN);+ }+ goto out;+ }++ /* mark the volume cleanly unmounted */+ hfsmp->vcbAtrb |= kHFSVolumeUnmountedMask;+ retval = hfs_flushvolumeheader(hfsmp, HFS_FVH_WAIT);+ hfsmp->hfs_flags |= HFS_READ_ONLY;++ /*+ * Close down the journal.+ *+ * NOTE: It is critically important to close down the journal+ * and have it issue all pending I/O prior to calling VNOP_FSYNC below.+ * In a journaled environment it is expected that the journal be+ * the only actor permitted to issue I/O for metadata blocks in HFS.+ * If we were to call VNOP_FSYNC prior to closing down the journal,+ * we would inadvertantly issue (and wait for) the I/O we just+ * initiated above as part of the flushvolumeheader call.+ *+ * To avoid this, we follow the same order of operations as in+ * unmount and issue the journal_close prior to calling VNOP_FSYNC.+ */++ if (hfsmp->jnl) {+ hfs_lock_global (hfsmp, HFS_EXCLUSIVE_LOCK);++ journal_close(hfsmp->jnl);+ hfsmp->jnl = NULL;++ // Note: we explicitly don't want to shutdown+ // access to the jvp because we may need+ // it later if we go back to being read-write.++ hfs_unlock_global (hfsmp);++ vfs_clearflags(hfsmp->hfs_mp, MNT_JOURNALED);+ }++ /*+ * Write out any pending I/O still outstanding against the device node+ * now that the journal has been closed.+ */+ if (retval == 0) {+ vnode_get(hfsmp->hfs_devvp);+ retval = VNOP_FSYNC(hfsmp->hfs_devvp, MNT_WAIT, context);+ vnode_put(hfsmp->hfs_devvp);+ }++ if (retval) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mount: FSYNC on devvp returned %d for fs %s\n", retval, hfsmp->vcbVN);+ }+ hfsmp->hfs_flags &= ~HFS_RDONLY_DOWNGRADE;+ hfsmp->hfs_downgrading_thread = NULL;+ hfsmp->hfs_flags &= ~HFS_READ_ONLY;+ goto out;+ }++ if (hfsmp->hfs_flags & HFS_SUMMARY_TABLE) {+ if (hfsmp->hfs_summary_table) {+ int err = 0;+ /*+ * Take the bitmap lock to serialize against a concurrent bitmap scan still in progress+ */+ if (hfsmp->hfs_allocation_vp) {+ err = hfs_lock (VTOC(hfsmp->hfs_allocation_vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ }+ hfs_free_data(hfsmp->hfs_summary_table, hfsmp->hfs_summary_bytes);+ hfsmp->hfs_summary_table = NULL;+ hfsmp->hfs_flags &= ~HFS_SUMMARY_TABLE;+ if (err == 0 && hfsmp->hfs_allocation_vp){+ hfs_unlock (VTOC(hfsmp->hfs_allocation_vp));+ }+ }+ }++ hfsmp->hfs_downgrading_thread = NULL;+ }++ /* Change to a writable file system. */+ if (vfs_iswriteupgrade(mp)) {+ /*+ * On inconsistent disks, do not allow read-write mount+ * unless it is the boot volume being mounted.+ */+ if (!(vfs_flags(mp) & MNT_ROOTFS) &&+ (hfsmp->vcbAtrb & kHFSVolumeInconsistentMask)) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mount: attempting to mount inconsistent non-root volume %s\n", (hfsmp->vcbVN));+ }+ retval = EINVAL;+ goto out;+ }++ // If the journal was shut-down previously because we were+ // asked to be read-only, let's start it back up again now++ if ( (HFSTOVCB(hfsmp)->vcbAtrb & kHFSVolumeJournaledMask)+ && hfsmp->jnl == NULL+ && hfsmp->jvp != NULL) {+ int jflags;++ if (hfsmp->hfs_flags & HFS_NEED_JNL_RESET) {+ jflags = JOURNAL_RESET;+ } else {+ jflags = 0;+ }++ hfs_lock_global (hfsmp, HFS_EXCLUSIVE_LOCK);++ /* We provide the mount point twice here: The first is used as+ * an opaque argument to be passed back when hfs_sync_metadata+ * is called. The second is provided to the throttling code to+ * indicate which mount's device should be used when accounting+ * for metadata writes.+ */+ hfsmp->jnl = journal_open(hfsmp->jvp,+ hfs_blk_to_bytes(hfsmp->jnl_start, HFSTOVCB(hfsmp)->blockSize) + (off_t)HFSTOVCB(hfsmp)->hfsPlusIOPosOffset,+ hfsmp->jnl_size,+ hfsmp->hfs_devvp,+ hfsmp->hfs_logical_block_size,+ jflags,+ 0,+ hfs_sync_metadata, hfsmp->hfs_mp,+ hfsmp->hfs_mp);++ /*+ * Set up the trim callback function so that we can add+ * recently freed extents to the free extent cache once+ * the transaction that freed them is written to the+ * journal on disk.+ */+ if (hfsmp->jnl)+ journal_trim_set_callback(hfsmp->jnl, hfs_trim_callback, hfsmp);++ hfs_unlock_global (hfsmp);++ if (hfsmp->jnl == NULL) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mount: journal_open == NULL; couldn't be opened on %s \n", (hfsmp->vcbVN));+ }+ retval = EINVAL;+ goto out;+ } else {+ hfsmp->hfs_flags &= ~HFS_NEED_JNL_RESET;+ vfs_setflags(hfsmp->hfs_mp, MNT_JOURNALED);+ }+ }++ /* See if we need to erase unused Catalog nodes due to <rdar://problem/6947811>. */+ retval = hfs_erase_unused_nodes(hfsmp);+ if (retval != E_NONE) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mount: hfs_erase_unused_nodes returned %d for fs %s\n", retval, hfsmp->vcbVN);+ }+ goto out;+ }++ /* If this mount point was downgraded from read-write+ * to read-only, clear that information as we are now+ * moving back to read-write.+ */+ hfsmp->hfs_flags &= ~HFS_RDONLY_DOWNGRADE;+ hfsmp->hfs_downgrading_thread = NULL;++ /* mark the volume dirty (clear clean unmount bit) */+ hfsmp->vcbAtrb &= ~kHFSVolumeUnmountedMask;++ retval = hfs_flushvolumeheader(hfsmp, HFS_FVH_WAIT);+ if (retval != E_NONE) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mount: hfs_flushvolumeheader returned %d for fs %s\n", retval, hfsmp->vcbVN);+ }+ goto out;+ }++ /* Only clear HFS_READ_ONLY after a successful write */+ hfsmp->hfs_flags &= ~HFS_READ_ONLY;+++ if (!(hfsmp->hfs_flags & (HFS_READ_ONLY | HFS_STANDARD))) {+ /* Setup private/hidden directories for hardlinks. */+ hfs_privatedir_init(hfsmp, FILE_HARDLINKS);+ hfs_privatedir_init(hfsmp, DIR_HARDLINKS);++ hfs_remove_orphans(hfsmp);++ /*+ * Since we're upgrading to a read-write mount, allow+ * hot file clustering if conditions allow.+ *+ * Note: this normally only would happen if you booted+ * single-user and upgraded the mount to read-write+ *+ * Note: at this point we are not allowed to fail the+ * mount operation because the HotFile init code+ * in hfs_recording_init() will lookup vnodes with+ * VNOP_LOOKUP() which hangs vnodes off the mount+ * (and if we were to fail, VFS is not prepared to+ * clean that up at this point. Since HotFiles are+ * optional, this is not a big deal.+ */+ if (ISSET(hfsmp->hfs_flags, HFS_METADATA_ZONE)+ && (!ISSET(hfsmp->hfs_flags, HFS_SSD)+ || ISSET(hfsmp->hfs_flags, HFS_CS_HOTFILE_PIN))) {+ hfs_recording_init(hfsmp);+ }+ /* Force ACLs on HFS+ file systems. */+ if (vfs_extendedsecurity(HFSTOVFS(hfsmp)) == 0) {+ vfs_setextendedsecurity(HFSTOVFS(hfsmp));+ }+ }+ }++ /* Update file system parameters. */+ retval = hfs_changefs(mp, &args);+ if (retval && HFS_MOUNT_DEBUG) {+ printf("hfs_mount: hfs_changefs returned %d for %s\n", retval, hfsmp->vcbVN);+ }++ } else /* not an update request */ {+ if (devvp == NULL) {+ retval = EINVAL;+ goto out;+ }+ /* Set the mount flag to indicate that we support volfs */+ vfs_setflags(mp, (u_int64_t)((unsigned int)MNT_DOVOLFS));++ retval = hfs_mountfs(devvp, mp, data ? &args : NULL, 0, context);+ if (retval) {+ const char *name = vnode_getname(devvp);+ printf("hfs_mount: hfs_mountfs returned error=%d for device %s\n", retval, (name ? name : "unknown-dev"));+ if (name) {+ vnode_putname(name);+ }+ goto out;+ }++ /* After hfs_mountfs succeeds, we should have valid hfsmp */+ hfsmp = VFSTOHFS(mp);++ /* Set up the maximum defrag file size */+ hfsmp->hfs_defrag_max = HFS_INITIAL_DEFRAG_SIZE;+++ if (!data) {+ // Root mount++ hfsmp->hfs_uid = UNKNOWNUID;+ hfsmp->hfs_gid = UNKNOWNGID;+ hfsmp->hfs_dir_mask = (S_IRWXU | S_IRGRP|S_IXGRP | S_IROTH|S_IXOTH); /* 0755 */+ hfsmp->hfs_file_mask = (S_IRWXU | S_IRGRP|S_IXGRP | S_IROTH|S_IXOTH); /* 0755 */++ /* Establish the free block reserve. */+ hfsmp->reserveBlocks = ((u_int64_t)hfsmp->totalBlocks * HFS_MINFREE) / 100;+ hfsmp->reserveBlocks = MIN(hfsmp->reserveBlocks, HFS_MAXRESERVE / hfsmp->blockSize);+ }+#if TARGET_OS_OSX+ // increment kext retain count+ OSIncrementAtomic(&hfs_active_mounts);+ OSKextRetainKextWithLoadTag(OSKextGetCurrentLoadTag());+ if (hfs_active_mounts <= 0 && panic_on_assert)+ panic("hfs_mount: error - kext resource count is non-positive: %d but at least one active mount\n", hfs_active_mounts);+#endif+ }++out:+ if (retval == 0) {+ (void)hfs_statfs(mp, vfs_statfs(mp), context);+ }+ return (retval);+}+++struct hfs_changefs_cargs {+ struct hfsmount *hfsmp;+ int namefix;+ int permfix;+ int permswitch;+};++static int+hfs_changefs_callback(struct vnode *vp, void *cargs)+{+ ExtendedVCB *vcb;+ struct cnode *cp;+ struct cat_desc cndesc;+ struct cat_attr cnattr;+ struct hfs_changefs_cargs *args;+ int lockflags;+ int error;++ args = (struct hfs_changefs_cargs *)cargs;++ cp = VTOC(vp);+ vcb = HFSTOVCB(args->hfsmp);++ lockflags = hfs_systemfile_lock(args->hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);+ error = cat_lookup(args->hfsmp, &cp->c_desc, 0, 0, &cndesc, &cnattr, NULL, NULL);+ hfs_systemfile_unlock(args->hfsmp, lockflags);+ if (error) {+ /*+ * If we couldn't find this guy skip to the next one+ */+ if (args->namefix)+ cache_purge(vp);++ return (VNODE_RETURNED);+ }+ /*+ * Get the real uid/gid and perm mask from disk.+ */+ if (args->permswitch || args->permfix) {+ cp->c_uid = cnattr.ca_uid;+ cp->c_gid = cnattr.ca_gid;+ cp->c_mode = cnattr.ca_mode;+ }+ /*+ * If we're switching name converters then...+ * Remove the existing entry from the namei cache.+ * Update name to one based on new encoder.+ */+ if (args->namefix) {+ cache_purge(vp);+ replace_desc(cp, &cndesc);++ if (cndesc.cd_cnid == kHFSRootFolderID) {+ strlcpy((char *)vcb->vcbVN, (const char *)cp->c_desc.cd_nameptr, NAME_MAX+1);+ cp->c_desc.cd_encoding = args->hfsmp->hfs_encoding;+ }+ } else {+ cat_releasedesc(&cndesc);+ }+ return (VNODE_RETURNED);+}++/* Change fs mount parameters */+static int+hfs_changefs(struct mount *mp, struct hfs_mount_args *args)+{+ int retval = 0;+ int namefix, permfix, permswitch;+ struct hfsmount *hfsmp;+ ExtendedVCB *vcb;+ struct hfs_changefs_cargs cargs;+ u_int32_t mount_flags;++ hfsmp = VFSTOHFS(mp);+ vcb = HFSTOVCB(hfsmp);+ mount_flags = (unsigned int)vfs_flags(mp);++ hfsmp->hfs_flags |= HFS_IN_CHANGEFS;++ permswitch = (((hfsmp->hfs_flags & HFS_UNKNOWN_PERMS) &&+ ((mount_flags & MNT_UNKNOWNPERMISSIONS) == 0)) ||+ (((hfsmp->hfs_flags & HFS_UNKNOWN_PERMS) == 0) &&+ (mount_flags & MNT_UNKNOWNPERMISSIONS)));++ /* The root filesystem must operate with actual permissions: */+ if (permswitch && (mount_flags & MNT_ROOTFS) && (mount_flags & MNT_UNKNOWNPERMISSIONS)) {+ vfs_clearflags(mp, (u_int64_t)((unsigned int)MNT_UNKNOWNPERMISSIONS)); /* Just say "No". */+ retval = EINVAL;+ goto exit;+ }+ if (mount_flags & MNT_UNKNOWNPERMISSIONS)+ hfsmp->hfs_flags |= HFS_UNKNOWN_PERMS;+ else+ hfsmp->hfs_flags &= ~HFS_UNKNOWN_PERMS;++ namefix = permfix = 0;++ /*+ * Tracking of hot files requires up-to-date access times. So if+ * access time updates are disabled, we must also disable hot files.+ */+ if (mount_flags & MNT_NOATIME) {+ (void) hfs_recording_suspend(hfsmp);+ }++ /* Change the timezone (Note: this affects all hfs volumes and hfs+ volume create dates) */+ if (args->hfs_timezone.tz_minuteswest != VNOVAL) {+ gTimeZone = args->hfs_timezone;+ }++ /* Change the default uid, gid and/or mask */+ if ((args->hfs_uid != (uid_t)VNOVAL) && (hfsmp->hfs_uid != args->hfs_uid)) {+ hfsmp->hfs_uid = args->hfs_uid;+ if (vcb->vcbSigWord == kHFSPlusSigWord)+ ++permfix;+ }+ if ((args->hfs_gid != (gid_t)VNOVAL) && (hfsmp->hfs_gid != args->hfs_gid)) {+ hfsmp->hfs_gid = args->hfs_gid;+ if (vcb->vcbSigWord == kHFSPlusSigWord)+ ++permfix;+ }+ if (args->hfs_mask != (mode_t)VNOVAL) {+ if (hfsmp->hfs_dir_mask != (args->hfs_mask & ALLPERMS)) {+ hfsmp->hfs_dir_mask = args->hfs_mask & ALLPERMS;+ hfsmp->hfs_file_mask = args->hfs_mask & ALLPERMS;+ if ((args->flags != VNOVAL) && (args->flags & HFSFSMNT_NOXONFILES))+ hfsmp->hfs_file_mask = (args->hfs_mask & DEFFILEMODE);+ if (vcb->vcbSigWord == kHFSPlusSigWord)+ ++permfix;+ }+ }++ if (!(namefix || permfix || permswitch))+ goto exit;++ /* XXX 3762912 hack to support HFS filesystem 'owner' */+ if (permfix) {+ vfs_setowner(mp,+ hfsmp->hfs_uid == UNKNOWNUID ? KAUTH_UID_NONE : hfsmp->hfs_uid,+ hfsmp->hfs_gid == UNKNOWNGID ? KAUTH_GID_NONE : hfsmp->hfs_gid);+ }++ /*+ * For each active vnode fix things that changed+ *+ * Note that we can visit a vnode more than once+ * and we can race with fsync.+ *+ * hfs_changefs_callback will be called for each vnode+ * hung off of this mount point+ *+ * The vnode will be properly referenced and unreferenced+ * around the callback+ */+ cargs.hfsmp = hfsmp;+ cargs.namefix = namefix;+ cargs.permfix = permfix;+ cargs.permswitch = permswitch;++ vnode_iterate(mp, 0, hfs_changefs_callback, (void *)&cargs);++exit:+ hfsmp->hfs_flags &= ~HFS_IN_CHANGEFS;+ return (retval);+}+++struct hfs_reload_cargs {+ struct hfsmount *hfsmp;+ int error;+};++static int+hfs_reload_callback(struct vnode *vp, void *cargs)+{+ struct cnode *cp;+ struct hfs_reload_cargs *args;+ int lockflags;++ args = (struct hfs_reload_cargs *)cargs;+ /*+ * flush all the buffers associated with this node+ */+ (void) buf_invalidateblks(vp, 0, 0, 0);++ cp = VTOC(vp);+ /*+ * Remove any directory hints+ */+ if (vnode_isdir(vp))+ hfs_reldirhints(cp, 0);++ /*+ * Re-read cnode data for all active vnodes (non-metadata files).+ */+ if (!vnode_issystem(vp) && !VNODE_IS_RSRC(vp) && (cp->c_fileid >= kHFSFirstUserCatalogNodeID)) {+ struct cat_fork *datafork;+ struct cat_desc desc;++ datafork = cp->c_datafork ? &cp->c_datafork->ff_data : NULL;++ /* lookup by fileID since name could have changed */+ lockflags = hfs_systemfile_lock(args->hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);+ args->error = cat_idlookup(args->hfsmp, cp->c_fileid, 0, 0, &desc, &cp->c_attr, datafork);+ hfs_systemfile_unlock(args->hfsmp, lockflags);+ if (args->error) {+ return (VNODE_RETURNED_DONE);+ }++ /* update cnode's catalog descriptor */+ (void) replace_desc(cp, &desc);+ }+ return (VNODE_RETURNED);+}++/*+ * Reload all incore data for a filesystem (used after running fsck on+ * the root filesystem and finding things to fix). The filesystem must+ * be mounted read-only.+ *+ * Things to do to update the mount:+ * invalidate all cached meta-data.+ * invalidate all inactive vnodes.+ * invalidate all cached file data.+ * re-read volume header from disk.+ * re-load meta-file info (extents, file size).+ * re-load B-tree header data.+ * re-read cnode data for all active vnodes.+ */+int+hfs_reload(struct mount *mountp)+{+ register struct vnode *devvp;+ struct buf *bp;+ int error, i;+ struct hfsmount *hfsmp;+ struct HFSPlusVolumeHeader *vhp;+ ExtendedVCB *vcb;+ struct filefork *forkp;+ struct cat_desc cndesc;+ struct hfs_reload_cargs args;+ daddr64_t priIDSector;++ hfsmp = VFSTOHFS(mountp);+ vcb = HFSTOVCB(hfsmp);++ if (vcb->vcbSigWord == kHFSSigWord)+ return (EINVAL); /* rooting from HFS is not supported! */++ /*+ * Invalidate all cached meta-data.+ */+ devvp = hfsmp->hfs_devvp;+ if (buf_invalidateblks(devvp, 0, 0, 0))+ panic("hfs_reload: dirty1");++ args.hfsmp = hfsmp;+ args.error = 0;+ /*+ * hfs_reload_callback will be called for each vnode+ * hung off of this mount point that can't be recycled...+ * vnode_iterate will recycle those that it can (the VNODE_RELOAD option)+ * the vnode will be in an 'unbusy' state (VNODE_WAIT) and+ * properly referenced and unreferenced around the callback+ */+ vnode_iterate(mountp, VNODE_RELOAD | VNODE_WAIT, hfs_reload_callback, (void *)&args);++ if (args.error)+ return (args.error);++ /*+ * Re-read VolumeHeader from disk.+ */+ priIDSector = (daddr64_t)((vcb->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) ++ HFS_PRI_SECTOR(hfsmp->hfs_logical_block_size));++ error = (int)buf_meta_bread(hfsmp->hfs_devvp,+ HFS_PHYSBLK_ROUNDDOWN(priIDSector, hfsmp->hfs_log_per_phys),+ hfsmp->hfs_physical_block_size, NOCRED, &bp);+ if (error) {+ if (bp != NULL)+ buf_brelse(bp);+ return (error);+ }++ vhp = (HFSPlusVolumeHeader *) (buf_dataptr(bp) + HFS_PRI_OFFSET(hfsmp->hfs_physical_block_size));++ /* Do a quick sanity check */+ if ((SWAP_BE16(vhp->signature) != kHFSPlusSigWord &&+ SWAP_BE16(vhp->signature) != kHFSXSigWord) ||+ (SWAP_BE16(vhp->version) != kHFSPlusVersion &&+ SWAP_BE16(vhp->version) != kHFSXVersion) ||+ SWAP_BE32(vhp->blockSize) != vcb->blockSize) {+ buf_brelse(bp);+ return (EIO);+ }++ vcb->vcbLsMod = to_bsd_time(SWAP_BE32(vhp->modifyDate));+ vcb->vcbAtrb = SWAP_BE32 (vhp->attributes);+ vcb->vcbJinfoBlock = SWAP_BE32(vhp->journalInfoBlock);+ vcb->vcbClpSiz = SWAP_BE32 (vhp->rsrcClumpSize);+ vcb->vcbNxtCNID = SWAP_BE32 (vhp->nextCatalogID);+ vcb->vcbVolBkUp = to_bsd_time(SWAP_BE32(vhp->backupDate));+ vcb->vcbWrCnt = SWAP_BE32 (vhp->writeCount);+ vcb->vcbFilCnt = SWAP_BE32 (vhp->fileCount);+ vcb->vcbDirCnt = SWAP_BE32 (vhp->folderCount);+ HFS_UPDATE_NEXT_ALLOCATION(vcb, SWAP_BE32 (vhp->nextAllocation));+ vcb->totalBlocks = SWAP_BE32 (vhp->totalBlocks);+ vcb->freeBlocks = SWAP_BE32 (vhp->freeBlocks);+ vcb->encodingsBitmap = SWAP_BE64 (vhp->encodingsBitmap);+ bcopy(vhp->finderInfo, vcb->vcbFndrInfo, sizeof(vhp->finderInfo));+ vcb->localCreateDate = SWAP_BE32 (vhp->createDate); /* hfs+ create date is in local time */++ /*+ * Re-load meta-file vnode data (extent info, file size, etc).+ */+ forkp = VTOF((struct vnode *)vcb->extentsRefNum);+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ forkp->ff_extents[i].startBlock =+ SWAP_BE32 (vhp->extentsFile.extents[i].startBlock);+ forkp->ff_extents[i].blockCount =+ SWAP_BE32 (vhp->extentsFile.extents[i].blockCount);+ }+ forkp->ff_size = SWAP_BE64 (vhp->extentsFile.logicalSize);+ forkp->ff_blocks = SWAP_BE32 (vhp->extentsFile.totalBlocks);+ forkp->ff_clumpsize = SWAP_BE32 (vhp->extentsFile.clumpSize);+++ forkp = VTOF((struct vnode *)vcb->catalogRefNum);+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ forkp->ff_extents[i].startBlock =+ SWAP_BE32 (vhp->catalogFile.extents[i].startBlock);+ forkp->ff_extents[i].blockCount =+ SWAP_BE32 (vhp->catalogFile.extents[i].blockCount);+ }+ forkp->ff_size = SWAP_BE64 (vhp->catalogFile.logicalSize);+ forkp->ff_blocks = SWAP_BE32 (vhp->catalogFile.totalBlocks);+ forkp->ff_clumpsize = SWAP_BE32 (vhp->catalogFile.clumpSize);++ if (hfsmp->hfs_attribute_vp) {+ forkp = VTOF(hfsmp->hfs_attribute_vp);+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ forkp->ff_extents[i].startBlock =+ SWAP_BE32 (vhp->attributesFile.extents[i].startBlock);+ forkp->ff_extents[i].blockCount =+ SWAP_BE32 (vhp->attributesFile.extents[i].blockCount);+ }+ forkp->ff_size = SWAP_BE64 (vhp->attributesFile.logicalSize);+ forkp->ff_blocks = SWAP_BE32 (vhp->attributesFile.totalBlocks);+ forkp->ff_clumpsize = SWAP_BE32 (vhp->attributesFile.clumpSize);+ }++ forkp = VTOF((struct vnode *)vcb->allocationsRefNum);+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ forkp->ff_extents[i].startBlock =+ SWAP_BE32 (vhp->allocationFile.extents[i].startBlock);+ forkp->ff_extents[i].blockCount =+ SWAP_BE32 (vhp->allocationFile.extents[i].blockCount);+ }+ forkp->ff_size = SWAP_BE64 (vhp->allocationFile.logicalSize);+ forkp->ff_blocks = SWAP_BE32 (vhp->allocationFile.totalBlocks);+ forkp->ff_clumpsize = SWAP_BE32 (vhp->allocationFile.clumpSize);++ buf_brelse(bp);+ vhp = NULL;++ /*+ * Re-load B-tree header data+ */+ forkp = VTOF((struct vnode *)vcb->extentsRefNum);+ if ( (error = MacToVFSError( BTReloadData((FCB*)forkp) )) )+ return (error);++ forkp = VTOF((struct vnode *)vcb->catalogRefNum);+ if ( (error = MacToVFSError( BTReloadData((FCB*)forkp) )) )+ return (error);++ if (hfsmp->hfs_attribute_vp) {+ forkp = VTOF(hfsmp->hfs_attribute_vp);+ if ( (error = MacToVFSError( BTReloadData((FCB*)forkp) )) )+ return (error);+ }++ /* Reload the volume name */+ if ((error = cat_idlookup(hfsmp, kHFSRootFolderID, 0, 0, &cndesc, NULL, NULL)))+ return (error);+ vcb->volumeNameEncodingHint = cndesc.cd_encoding;+ bcopy(cndesc.cd_nameptr, vcb->vcbVN, min(255, cndesc.cd_namelen));+ cat_releasedesc(&cndesc);++ /* Re-establish private/hidden directories. */+ hfs_privatedir_init(hfsmp, FILE_HARDLINKS);+ hfs_privatedir_init(hfsmp, DIR_HARDLINKS);++ /* In case any volume information changed to trigger a notification */+ hfs_generate_volume_notifications(hfsmp);++ return (0);+}++__unused+static uint64_t tv_to_usecs(struct timeval *tv)+{+ return tv->tv_sec * 1000000ULL + tv->tv_usec;+}++// Returns TRUE if b - a >= usecs+static bool hfs_has_elapsed (const struct timeval *a,+ const struct timeval *b,+ uint64_t usecs)+{+ struct timeval diff;+ timersub(b, a, &diff);+ return diff.tv_sec * 1000000ULL + diff.tv_usec >= usecs;+}++void hfs_syncer(void *arg, __unused wait_result_t wr)+{+ struct hfsmount *hfsmp = arg;+ struct timeval now;++ KDBG(HFSDBG_SYNCER | DBG_FUNC_START, obfuscate_addr(hfsmp));++ hfs_syncer_lock(hfsmp);++ while (ISSET(hfsmp->hfs_flags, HFS_RUN_SYNCER)+ && timerisset(&hfsmp->hfs_sync_req_oldest)) {++ hfs_syncer_wait(hfsmp, &HFS_META_DELAY_TS);++ if (!ISSET(hfsmp->hfs_flags, HFS_RUN_SYNCER)+ || !timerisset(&hfsmp->hfs_sync_req_oldest)) {+ break;+ }++ /* Check to see whether we should flush now: either the oldest+ is > HFS_MAX_META_DELAY or HFS_META_DELAY has elapsed since+ the request and there are no pending writes. */++ microuptime(&now);+ uint64_t idle_time = vfs_idle_time(hfsmp->hfs_mp);++ if (!hfs_has_elapsed(&hfsmp->hfs_sync_req_oldest, &now,+ HFS_MAX_META_DELAY)+ && idle_time < HFS_META_DELAY) {+ continue;+ }++ timerclear(&hfsmp->hfs_sync_req_oldest);++ hfs_syncer_unlock(hfsmp);++ KDBG(HFSDBG_SYNCER_TIMED | DBG_FUNC_START, obfuscate_addr(hfsmp));++ /*+ * We intentionally do a synchronous flush (of the journal or entire volume) here.+ * For journaled volumes, this means we wait until the metadata blocks are written+ * to both the journal and their final locations (in the B-trees, etc.).+ *+ * This tends to avoid interleaving the metadata writes with other writes (for+ * example, user data, or to the journal when a later transaction notices that+ * an earlier transaction has finished its async writes, and then updates the+ * journal start in the journal header). Avoiding interleaving of writes is+ * very good for performance on simple flash devices like SD cards, thumb drives;+ * and on devices like floppies. Since removable devices tend to be this kind of+ * simple device, doing a synchronous flush actually improves performance in+ * practice.+ *+ * NOTE: For non-journaled volumes, the call to hfs_sync will also cause dirty+ * user data to be written.+ */+ if (hfsmp->jnl) {+ hfs_flush(hfsmp, HFS_FLUSH_JOURNAL_META);+ } else {+ hfs_sync(hfsmp->hfs_mp, MNT_WAIT, vfs_context_current());+ }++ KDBG(HFSDBG_SYNCER_TIMED | DBG_FUNC_END);++ hfs_syncer_lock(hfsmp);+ } // while (...)++ hfsmp->hfs_syncer_thread = NULL;+ hfs_syncer_unlock(hfsmp);+ hfs_syncer_wakeup(hfsmp);++ /* BE CAREFUL WHAT YOU ADD HERE: at this point hfs_unmount is free+ to continue and therefore hfsmp might be invalid. */++ KDBG(HFSDBG_SYNCER | DBG_FUNC_END);+}++/*+ * Call into the allocator code and perform a full scan of the bitmap file.+ *+ * This allows us to TRIM unallocated ranges if needed, and also to build up+ * an in-memory summary table of the state of the allocated blocks.+ */+void hfs_scan_blocks (struct hfsmount *hfsmp) {+ /*+ * Take the allocation file lock. Journal transactions will block until+ * we're done here.+ */++ int flags = hfs_systemfile_lock(hfsmp, SFL_BITMAP, HFS_EXCLUSIVE_LOCK);++ /*+ * We serialize here with the HFS mount lock as we're mounting.+ *+ * The mount can only proceed once this thread has acquired the bitmap+ * lock, since we absolutely do not want someone else racing in and+ * getting the bitmap lock, doing a read/write of the bitmap file,+ * then us getting the bitmap lock.+ *+ * To prevent this, the mount thread takes the HFS mount mutex, starts us+ * up, then immediately msleeps on the scan_var variable in the mount+ * point as a condition variable. This serialization is safe since+ * if we race in and try to proceed while they're still holding the lock,+ * we'll block trying to acquire the global lock. Since the mount thread+ * acquires the HFS mutex before starting this function in a new thread,+ * any lock acquisition on our part must be linearizably AFTER the mount thread's.+ *+ * Note that the HFS mount mutex is always taken last, and always for only+ * a short time. In this case, we just take it long enough to mark the+ * scan-in-flight bit.+ */+ (void) hfs_lock_mount (hfsmp);+ hfsmp->scan_var |= HFS_ALLOCATOR_SCAN_INFLIGHT;+ wakeup((caddr_t) &hfsmp->scan_var);+ hfs_unlock_mount (hfsmp);++ /* Initialize the summary table */+ if (hfs_init_summary (hfsmp)) {+ printf("hfs: could not initialize summary table for %s\n", hfsmp->vcbVN);+ }++ /*+ * ScanUnmapBlocks assumes that the bitmap lock is held when you+ * call the function. We don't care if there were any errors issuing unmaps.+ *+ * It will also attempt to build up the summary table for subsequent+ * allocator use, as configured.+ */+ (void) ScanUnmapBlocks(hfsmp);++ (void) hfs_lock_mount (hfsmp);+ hfsmp->scan_var &= ~HFS_ALLOCATOR_SCAN_INFLIGHT;+ hfsmp->scan_var |= HFS_ALLOCATOR_SCAN_COMPLETED;+ wakeup((caddr_t) &hfsmp->scan_var);+ hfs_unlock_mount (hfsmp);++ buf_invalidateblks(hfsmp->hfs_allocation_vp, 0, 0, 0);++ hfs_systemfile_unlock(hfsmp, flags);++}++/*+ * Common code for mount and mountroot+ */+int+hfs_mountfs(struct vnode *devvp, struct mount *mp, struct hfs_mount_args *args,+ int journal_replay_only, vfs_context_t context)+{+ struct proc *p = vfs_context_proc(context);+ int retval = E_NONE;+ struct hfsmount *hfsmp = NULL;+ struct buf *bp;+ dev_t dev;+ HFSMasterDirectoryBlock *mdbp = NULL;+ int ronly;+#if QUOTA+ int i;+#endif+ int mntwrapper;+ kauth_cred_t cred;+ u_int64_t disksize;+ daddr64_t log_blkcnt;+ u_int32_t log_blksize;+ u_int32_t phys_blksize;+ u_int32_t minblksize;+ u_int32_t iswritable;+ daddr64_t mdb_offset;+ int isvirtual = 0;+ int isroot = !journal_replay_only && args == NULL;+ u_int32_t device_features = 0;+ int isssd;++ ronly = mp && vfs_isrdonly(mp);+ dev = vnode_specrdev(devvp);+ cred = p ? vfs_context_ucred(context) : NOCRED;+ mntwrapper = 0;++ bp = NULL;+ hfsmp = NULL;+ mdbp = NULL;+ minblksize = kHFSBlockSize;++ /* Advisory locking should be handled at the VFS layer */+ if (mp)+ vfs_setlocklocal(mp);++ /* Get the logical block size (treated as physical block size everywhere) */+ if (VNOP_IOCTL(devvp, DKIOCGETBLOCKSIZE, (caddr_t)&log_blksize, 0, context)) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: DKIOCGETBLOCKSIZE failed\n");+ }+ retval = ENXIO;+ goto error_exit;+ }+ if (log_blksize == 0 || log_blksize > 1024*1024*1024) {+ printf("hfs: logical block size 0x%x looks bad. Not mounting.\n", log_blksize);+ retval = ENXIO;+ goto error_exit;+ }++ /* Get the physical block size. */+ retval = VNOP_IOCTL(devvp, DKIOCGETPHYSICALBLOCKSIZE, (caddr_t)&phys_blksize, 0, context);+ if (retval) {+ if ((retval != ENOTSUP) && (retval != ENOTTY)) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: DKIOCGETPHYSICALBLOCKSIZE failed\n");+ }+ retval = ENXIO;+ goto error_exit;+ }+ /* If device does not support this ioctl, assume that physical+ * block size is same as logical block size+ */+ phys_blksize = log_blksize;+ }+ if (phys_blksize == 0 || phys_blksize > MAXBSIZE) {+ printf("hfs: physical block size 0x%x looks bad. Not mounting.\n", phys_blksize);+ retval = ENXIO;+ goto error_exit;+ }++ if (phys_blksize < log_blksize) {+ /*+ * In the off chance that the phys_blksize is SMALLER than the logical+ * then don't let that happen. Pretend that the PHYSICALBLOCKSIZE+ * ioctl was not supported.+ */+ phys_blksize = log_blksize;+ }+++ /* Switch to 512 byte sectors (temporarily) */+ if (log_blksize > 512) {+ u_int32_t size512 = 512;++ if (VNOP_IOCTL(devvp, DKIOCSETBLOCKSIZE, (caddr_t)&size512, FWRITE, context)) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: DKIOCSETBLOCKSIZE failed \n");+ }+ retval = ENXIO;+ goto error_exit;+ }+ }+ /* Get the number of 512 byte physical blocks. */+ if (VNOP_IOCTL(devvp, DKIOCGETBLOCKCOUNT, (caddr_t)&log_blkcnt, 0, context)) {+ /* resetting block size may fail if getting block count did */+ (void)VNOP_IOCTL(devvp, DKIOCSETBLOCKSIZE, (caddr_t)&log_blksize, FWRITE, context);+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: DKIOCGETBLOCKCOUNT failed\n");+ }+ retval = ENXIO;+ goto error_exit;+ }+ /* Compute an accurate disk size (i.e. within 512 bytes) */+ disksize = (u_int64_t)log_blkcnt * (u_int64_t)512;++ /*+ * On Tiger it is not necessary to switch the device+ * block size to be 4k if there are more than 31-bits+ * worth of blocks but to insure compatibility with+ * pre-Tiger systems we have to do it.+ *+ * If the device size is not a multiple of 4K (8 * 512), then+ * switching the logical block size isn't going to help because+ * we will be unable to write the alternate volume header.+ * In this case, just leave the logical block size unchanged.+ */+ if (log_blkcnt > 0x000000007fffffff && (log_blkcnt & 7) == 0) {+ minblksize = log_blksize = 4096;+ if (phys_blksize < log_blksize)+ phys_blksize = log_blksize;+ }++ /*+ * The cluster layer is not currently prepared to deal with a logical+ * block size larger than the system's page size. (It can handle+ * blocks per page, but not multiple pages per block.) So limit the+ * logical block size to the page size.+ */+ if (log_blksize > PAGE_SIZE) {+ log_blksize = PAGE_SIZE;+ }++ /* Now switch to our preferred physical block size. */+ if (log_blksize > 512) {+ if (VNOP_IOCTL(devvp, DKIOCSETBLOCKSIZE, (caddr_t)&log_blksize, FWRITE, context)) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: DKIOCSETBLOCKSIZE (2) failed\n");+ }+ retval = ENXIO;+ goto error_exit;+ }+ /* Get the count of physical blocks. */+ if (VNOP_IOCTL(devvp, DKIOCGETBLOCKCOUNT, (caddr_t)&log_blkcnt, 0, context)) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: DKIOCGETBLOCKCOUNT (2) failed\n");+ }+ retval = ENXIO;+ goto error_exit;+ }+ }++ /*+ * At this point:+ * minblksize is the minimum physical block size+ * log_blksize has our preferred physical block size+ * log_blkcnt has the total number of physical blocks+ */++ mdb_offset = (daddr64_t)HFS_PRI_SECTOR(log_blksize);++ if ((retval = (int)buf_meta_bread(devvp,+ HFS_PHYSBLK_ROUNDDOWN(mdb_offset, (phys_blksize/log_blksize)),+ phys_blksize, cred, &bp))) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: buf_meta_bread failed with %d\n", retval);+ }+ goto error_exit;+ }+ mdbp = hfs_malloc_data(kMDBSize);+ bcopy((char *)buf_dataptr(bp) + HFS_PRI_OFFSET(phys_blksize), mdbp, kMDBSize);+ buf_brelse(bp);+ bp = NULL;++ hfsmp = hfs_malloc_type(struct hfsmount);++ hfs_chashinit_finish(hfsmp);++ /* Init the ID lookup hashtable */+ hfs_idhash_init (hfsmp);++ /*+ * See if the disk supports unmap (trim).+ *+ * NOTE: vfs_init_io_attributes has not been called yet, so we can't use the io_flags field+ * returned by vfs_ioattr. We need to call VNOP_IOCTL ourselves.+ */+ if (VNOP_IOCTL(devvp, DKIOCGETFEATURES, (caddr_t)&device_features, 0, context) == 0) {+ if (device_features & DK_FEATURE_UNMAP) {+ hfsmp->hfs_flags |= HFS_UNMAP;+ }++ if(device_features & DK_FEATURE_BARRIER)+ hfsmp->hfs_flags |= HFS_FEATURE_BARRIER;+ }++ /*+ * See if the disk is a solid state device, too. We need this to decide what to do about+ * hotfiles.+ */+ if (VNOP_IOCTL(devvp, DKIOCISSOLIDSTATE, (caddr_t)&isssd, 0, context) == 0) {+ if (isssd) {+ hfsmp->hfs_flags |= HFS_SSD;+ }+ }++ /* See if the underlying device is Core Storage or not */+ dk_corestorage_info_t cs_info;+ memset(&cs_info, 0, sizeof(dk_corestorage_info_t));+ if (VNOP_IOCTL(devvp, DKIOCCORESTORAGE, (caddr_t)&cs_info, 0, context) == 0) {+ hfsmp->hfs_flags |= HFS_CS;+ if (isroot && (cs_info.flags & DK_CORESTORAGE_PIN_YOUR_METADATA)) {+ hfsmp->hfs_flags |= HFS_CS_METADATA_PIN;+ }+ if (isroot && (cs_info.flags & DK_CORESTORAGE_ENABLE_HOTFILES)) {+ hfsmp->hfs_flags |= HFS_CS_HOTFILE_PIN;+ hfsmp->hfs_cs_hotfile_size = cs_info.hotfile_size;+ }+ if ((cs_info.flags & DK_CORESTORAGE_PIN_YOUR_SWAPFILE)) {+ hfsmp->hfs_flags |= HFS_CS_SWAPFILE_PIN;++ struct vfsioattr ioattr;+ vfs_ioattr(mp, &ioattr);+ ioattr.io_flags |= VFS_IOATTR_FLAGS_SWAPPIN_SUPPORTED;+ ioattr.io_max_swappin_available = cs_info.swapfile_pinning;+ vfs_setioattr(mp, &ioattr);+ }+ }++ /*+ * Init the volume information structure+ */++ lck_mtx_init(&hfsmp->hfs_mutex, hfs_mutex_group, hfs_lock_attr);+ lck_mtx_init(&hfsmp->hfc_mutex, hfs_mutex_group, hfs_lock_attr);+ lck_rw_init(&hfsmp->hfs_global_lock, hfs_rwlock_group, hfs_lock_attr);+ lck_spin_init(&hfsmp->vcbFreeExtLock, hfs_spinlock_group, hfs_lock_attr);+#if NEW_XATTR+ lck_spin_init(&hfsmp->hfs_xattr_io.lock, hfs_spinlock_group, hfs_lock_attr);+#endif++ if (mp)+ vfs_setfsprivate(mp, hfsmp);+ hfsmp->hfs_mp = mp; /* Make VFSTOHFS work */+ hfsmp->hfs_raw_dev = vnode_specrdev(devvp);+ hfsmp->hfs_devvp = devvp;+ vnode_ref(devvp); /* Hold a ref on the device, dropped when hfsmp is freed. */+ hfsmp->hfs_logical_block_size = log_blksize;+ hfsmp->hfs_logical_block_count = log_blkcnt;+ hfsmp->hfs_logical_bytes = (uint64_t) log_blksize * (uint64_t) log_blkcnt;+ hfsmp->hfs_physical_block_size = phys_blksize;+ hfsmp->hfs_log_per_phys = (phys_blksize / log_blksize);+ hfsmp->hfs_flags |= HFS_WRITEABLE_MEDIA;+ if (ronly)+ hfsmp->hfs_flags |= HFS_READ_ONLY;+ if (mp && ((unsigned int)vfs_flags(mp)) & MNT_UNKNOWNPERMISSIONS)+ hfsmp->hfs_flags |= HFS_UNKNOWN_PERMS;++#if QUOTA+ for (i = 0; i < MAXQUOTAS; i++)+ dqfileinit(&hfsmp->hfs_qfiles[i]);+#endif++ if (args) {+ hfsmp->hfs_uid = (args->hfs_uid == (uid_t)VNOVAL) ? UNKNOWNUID : args->hfs_uid;+ if (hfsmp->hfs_uid == 0xfffffffd) hfsmp->hfs_uid = UNKNOWNUID;+ hfsmp->hfs_gid = (args->hfs_gid == (gid_t)VNOVAL) ? UNKNOWNGID : args->hfs_gid;+ if (hfsmp->hfs_gid == 0xfffffffd) hfsmp->hfs_gid = UNKNOWNGID;+ vfs_setowner(mp, hfsmp->hfs_uid, hfsmp->hfs_gid); /* tell the VFS */+ if (args->hfs_mask != (mode_t)VNOVAL) {+ hfsmp->hfs_dir_mask = args->hfs_mask & ALLPERMS;+ if (args->flags & HFSFSMNT_NOXONFILES) {+ hfsmp->hfs_file_mask = (args->hfs_mask & DEFFILEMODE);+ } else {+ hfsmp->hfs_file_mask = args->hfs_mask & ALLPERMS;+ }+ } else {+ hfsmp->hfs_dir_mask = UNKNOWNPERMISSIONS & ALLPERMS; /* 0777: rwx---rwx */+ hfsmp->hfs_file_mask = UNKNOWNPERMISSIONS & DEFFILEMODE; /* 0666: no --x by default? */+ }+ if ((args->flags != (int)VNOVAL) && (args->flags & HFSFSMNT_WRAPPER))+ mntwrapper = 1;+ } else {+ /* Even w/o explicit mount arguments, MNT_UNKNOWNPERMISSIONS requires setting up uid, gid, and mask: */+ if (mp && ((unsigned int)vfs_flags(mp)) & MNT_UNKNOWNPERMISSIONS) {+ hfsmp->hfs_uid = UNKNOWNUID;+ hfsmp->hfs_gid = UNKNOWNGID;+ vfs_setowner(mp, hfsmp->hfs_uid, hfsmp->hfs_gid); /* tell the VFS */+ hfsmp->hfs_dir_mask = UNKNOWNPERMISSIONS & ALLPERMS; /* 0777: rwx---rwx */+ hfsmp->hfs_file_mask = UNKNOWNPERMISSIONS & DEFFILEMODE; /* 0666: no --x by default? */+ }+ }++ /* Find out if disk media is writable. */+ if (VNOP_IOCTL(devvp, DKIOCISWRITABLE, (caddr_t)&iswritable, 0, context) == 0) {+ if (iswritable)+ hfsmp->hfs_flags |= HFS_WRITEABLE_MEDIA;+ else+ hfsmp->hfs_flags &= ~HFS_WRITEABLE_MEDIA;+ }++ // Reservations+ rl_init(&hfsmp->hfs_reserved_ranges[0]);+ rl_init(&hfsmp->hfs_reserved_ranges[1]);++ // record the current time at which we're mounting this volume+ struct timeval tv;+ microtime(&tv);+ hfsmp->hfs_mount_time = tv.tv_sec;++ /* Mount a standard HFS disk */+ if ((SWAP_BE16(mdbp->drSigWord) == kHFSSigWord) &&+ (mntwrapper || (SWAP_BE16(mdbp->drEmbedSigWord) != kHFSPlusSigWord))) {+ /* On platforms where HFS Standard is not supported, deny the mount altogether */+ retval = EINVAL;+ goto error_exit;++ }+ else { /* Mount an HFS Plus disk */+ HFSPlusVolumeHeader *vhp;+ off_t embeddedOffset;+ int jnl_disable = 0;++ /* Get the embedded Volume Header */+ if (SWAP_BE16(mdbp->drEmbedSigWord) == kHFSPlusSigWord) {+ embeddedOffset = SWAP_BE16(mdbp->drAlBlSt) * kHFSBlockSize;+ embeddedOffset += (u_int64_t)SWAP_BE16(mdbp->drEmbedExtent.startBlock) *+ (u_int64_t)SWAP_BE32(mdbp->drAlBlkSiz);++ /*+ * Cooperative Fusion is not allowed on embedded HFS++ * filesystems (HFS+ inside HFS standard wrapper)+ */+ hfsmp->hfs_flags &= ~HFS_CS_METADATA_PIN;++ /*+ * If the embedded volume doesn't start on a block+ * boundary, then switch the device to a 512-byte+ * block size so everything will line up on a block+ * boundary.+ */+ if ((embeddedOffset % log_blksize) != 0) {+ printf("hfs_mountfs: embedded volume offset not"+ " a multiple of physical block size (%d);"+ " switching to 512\n", log_blksize);+ log_blksize = 512;+ if (VNOP_IOCTL(devvp, DKIOCSETBLOCKSIZE,+ (caddr_t)&log_blksize, FWRITE, context)) {++ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: DKIOCSETBLOCKSIZE (3) failed\n");+ }+ retval = ENXIO;+ goto error_exit;+ }+ if (VNOP_IOCTL(devvp, DKIOCGETBLOCKCOUNT,+ (caddr_t)&log_blkcnt, 0, context)) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: DKIOCGETBLOCKCOUNT (3) failed\n");+ }+ retval = ENXIO;+ goto error_exit;+ }+ /* Note: relative block count adjustment */+ hfsmp->hfs_logical_block_count *=+ hfsmp->hfs_logical_block_size / log_blksize;++ /* Update logical /physical block size */+ hfsmp->hfs_logical_block_size = log_blksize;+ hfsmp->hfs_physical_block_size = log_blksize;++ phys_blksize = log_blksize;+ hfsmp->hfs_log_per_phys = 1;+ }++ disksize = (u_int64_t)SWAP_BE16(mdbp->drEmbedExtent.blockCount) *+ (u_int64_t)SWAP_BE32(mdbp->drAlBlkSiz);++ hfsmp->hfs_logical_block_count = disksize / log_blksize;++ hfsmp->hfs_logical_bytes = (uint64_t) hfsmp->hfs_logical_block_count * (uint64_t) hfsmp->hfs_logical_block_size;++ mdb_offset = (daddr64_t)((embeddedOffset / log_blksize) + HFS_PRI_SECTOR(log_blksize));++ if (bp) {+ buf_markinvalid(bp);+ buf_brelse(bp);+ bp = NULL;+ }+ retval = (int)buf_meta_bread(devvp, HFS_PHYSBLK_ROUNDDOWN(mdb_offset, hfsmp->hfs_log_per_phys),+ phys_blksize, cred, &bp);+ if (retval) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: buf_meta_bread (2) failed with %d\n", retval);+ }+ goto error_exit;+ }+ bcopy((char *)buf_dataptr(bp) + HFS_PRI_OFFSET(phys_blksize), mdbp, 512);+ buf_brelse(bp);+ bp = NULL;+ vhp = (HFSPlusVolumeHeader*) mdbp;++ }+ else { /* pure HFS+ */+ embeddedOffset = 0;+ vhp = (HFSPlusVolumeHeader*) mdbp;+ }++ retval = hfs_ValidateHFSPlusVolumeHeader(hfsmp, vhp);+ if (retval)+ goto error_exit;++ /*+ * If allocation block size is less than the physical block size,+ * invalidate the buffer read in using native physical block size+ * to ensure data consistency.+ *+ * HFS Plus reserves one allocation block for the Volume Header.+ * If the physical size is larger, then when we read the volume header,+ * we will also end up reading in the next allocation block(s).+ * If those other allocation block(s) is/are modified, and then the volume+ * header is modified, the write of the volume header's buffer will write+ * out the old contents of the other allocation blocks.+ *+ * We assume that the physical block size is same as logical block size.+ * The physical block size value is used to round down the offsets for+ * reading and writing the primary and alternate volume headers.+ *+ * The same logic is also in hfs_MountHFSPlusVolume to ensure that+ * hfs_mountfs, hfs_MountHFSPlusVolume and later are doing the I/Os+ * using same block size.+ */+ if (SWAP_BE32(vhp->blockSize) < hfsmp->hfs_physical_block_size) {+ phys_blksize = hfsmp->hfs_logical_block_size;+ hfsmp->hfs_physical_block_size = hfsmp->hfs_logical_block_size;+ hfsmp->hfs_log_per_phys = 1;+ // There should be one bp associated with devvp in buffer cache.+ retval = buf_invalidateblks(devvp, 0, 0, 0);+ if (retval)+ goto error_exit;+ }++ if (isroot && ((SWAP_BE32(vhp->attributes) & kHFSVolumeUnmountedMask) != 0)) {+ vfs_set_root_unmounted_cleanly();+ }++ /*+ * On inconsistent disks, do not allow read-write mount+ * unless it is the boot volume being mounted. We also+ * always want to replay the journal if the journal_replay_only+ * flag is set because that will (most likely) get the+ * disk into a consistent state before fsck_hfs starts+ * looking at it.+ */+ if (!journal_replay_only+ && !(vfs_flags(mp) & MNT_ROOTFS)+ && (SWAP_BE32(vhp->attributes) & kHFSVolumeInconsistentMask)+ && !(hfsmp->hfs_flags & HFS_READ_ONLY)) {++ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: failed to mount non-root inconsistent disk\n");+ }+ retval = EINVAL;+ goto error_exit;+ }+++ // XXXdbg+ //+ hfsmp->jnl = NULL;+ hfsmp->jvp = NULL;+ if (args != NULL && (args->flags & HFSFSMNT_EXTENDED_ARGS) &&+ args->journal_disable) {+ jnl_disable = 1;+ }++ //+ // We only initialize the journal here if the last person+ // to mount this volume was journaling aware. Otherwise+ // we delay journal initialization until later at the end+ // of hfs_MountHFSPlusVolume() because the last person who+ // mounted it could have messed things up behind our back+ // (so we need to go find the .journal file, make sure it's+ // the right size, re-sync up if it was moved, etc).+ //+ if ( (SWAP_BE32(vhp->lastMountedVersion) == kHFSJMountVersion)+ && (SWAP_BE32(vhp->attributes) & kHFSVolumeJournaledMask)+ && !jnl_disable) {++ // if we're able to init the journal, mark the mount+ // point as journaled.+ //+ if ((retval = hfs_early_journal_init(hfsmp, vhp, args, embeddedOffset, mdb_offset, mdbp, cred)) == 0) {+ if (mp)+ vfs_setflags(mp, (u_int64_t)((unsigned int)MNT_JOURNALED));+ } else {+ if (retval == EROFS) {+ // EROFS is a special error code that means the volume has an external+ // journal which we couldn't find. in that case we do not want to+ // rewrite the volume header - we'll just refuse to mount the volume.+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: hfs_early_journal_init indicated external jnl \n");+ }+ retval = EINVAL;+ goto error_exit;+ }++ // if the journal failed to open, then set the lastMountedVersion+ // to be "FSK!" which fsck_hfs will see and force the fsck instead+ // of just bailing out because the volume is journaled.+ if (!ronly) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: hfs_early_journal_init failed, setting to FSK \n");+ }++ HFSPlusVolumeHeader *jvhp;++ hfsmp->hfs_flags |= HFS_NEED_JNL_RESET;++ if (mdb_offset == 0) {+ mdb_offset = (daddr64_t)((embeddedOffset / log_blksize) + HFS_PRI_SECTOR(log_blksize));+ }++ bp = NULL;+ retval = (int)buf_meta_bread(devvp,+ HFS_PHYSBLK_ROUNDDOWN(mdb_offset, hfsmp->hfs_log_per_phys),+ phys_blksize, cred, &bp);+ if (retval == 0) {+ jvhp = (HFSPlusVolumeHeader *)(buf_dataptr(bp) + HFS_PRI_OFFSET(phys_blksize));++ if (SWAP_BE16(jvhp->signature) == kHFSPlusSigWord || SWAP_BE16(jvhp->signature) == kHFSXSigWord) {+ printf ("hfs(1): Journal replay fail. Writing lastMountVersion as FSK!\n");+ jvhp->lastMountedVersion = SWAP_BE32(kFSKMountVersion);+ buf_bwrite(bp);+ } else {+ buf_brelse(bp);+ }+ bp = NULL;+ } else if (bp) {+ buf_brelse(bp);+ // clear this so the error exit path won't try to use it+ bp = NULL;+ }+ }++ // if this isn't the root device just bail out.+ // If it is the root device we just continue on+ // in the hopes that fsck_hfs will be able to+ // fix any damage that exists on the volume.+ if (mp && !(vfs_flags(mp) & MNT_ROOTFS)) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: hfs_early_journal_init failed, erroring out \n");+ }+ retval = EINVAL;+ goto error_exit;+ }+ }+ }++ /* Either the journal is replayed successfully, or there+ * was nothing to replay, or no journal exists. In any case,+ * return success.+ */+ if (journal_replay_only) {+ retval = 0;+ goto error_exit;+ }++ retval = hfs_MountHFSPlusVolume(hfsmp, vhp, embeddedOffset, disksize, p, args, cred);+ /*+ * If the backend didn't like our physical blocksize+ * then retry with physical blocksize of 512.+ */+ if ((retval == ENXIO) && (log_blksize > 512) && (log_blksize != minblksize)) {+ printf("hfs_mountfs: could not use physical block size "+ "(%d) switching to 512\n", log_blksize);+ log_blksize = 512;+ if (VNOP_IOCTL(devvp, DKIOCSETBLOCKSIZE, (caddr_t)&log_blksize, FWRITE, context)) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: DKIOCSETBLOCKSIZE (4) failed \n");+ }+ retval = ENXIO;+ goto error_exit;+ }+ if (VNOP_IOCTL(devvp, DKIOCGETBLOCKCOUNT, (caddr_t)&log_blkcnt, 0, context)) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: DKIOCGETBLOCKCOUNT (4) failed \n");+ }+ retval = ENXIO;+ goto error_exit;+ }+ set_fsblocksize(devvp);+ /* Note: relative block count adjustment (in case this is an embedded volume). */+ hfsmp->hfs_logical_block_count *= hfsmp->hfs_logical_block_size / log_blksize;+ hfsmp->hfs_logical_block_size = log_blksize;+ hfsmp->hfs_log_per_phys = hfsmp->hfs_physical_block_size / log_blksize;++ hfsmp->hfs_logical_bytes = (uint64_t) hfsmp->hfs_logical_block_count * (uint64_t) hfsmp->hfs_logical_block_size;++ if (hfsmp->jnl && hfsmp->jvp == devvp) {+ // close and re-open this with the new block size+ journal_close(hfsmp->jnl);+ hfsmp->jnl = NULL;+ if (hfs_early_journal_init(hfsmp, vhp, args, embeddedOffset, mdb_offset, mdbp, cred) == 0) {+ vfs_setflags(mp, (u_int64_t)((unsigned int)MNT_JOURNALED));+ } else {+ // if the journal failed to open, then set the lastMountedVersion+ // to be "FSK!" which fsck_hfs will see and force the fsck instead+ // of just bailing out because the volume is journaled.+ if (!ronly) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: hfs_early_journal_init (2) resetting.. \n");+ }+ HFSPlusVolumeHeader *jvhp;++ hfsmp->hfs_flags |= HFS_NEED_JNL_RESET;++ if (mdb_offset == 0) {+ mdb_offset = (daddr64_t)((embeddedOffset / log_blksize) + HFS_PRI_SECTOR(log_blksize));+ }++ bp = NULL;+ retval = (int)buf_meta_bread(devvp, HFS_PHYSBLK_ROUNDDOWN(mdb_offset, hfsmp->hfs_log_per_phys),+ phys_blksize, cred, &bp);+ if (retval == 0) {+ jvhp = (HFSPlusVolumeHeader *)(buf_dataptr(bp) + HFS_PRI_OFFSET(phys_blksize));++ if (SWAP_BE16(jvhp->signature) == kHFSPlusSigWord || SWAP_BE16(jvhp->signature) == kHFSXSigWord) {+ printf ("hfs(2): Journal replay fail. Writing lastMountVersion as FSK!\n");+ jvhp->lastMountedVersion = SWAP_BE32(kFSKMountVersion);+ buf_bwrite(bp);+ } else {+ buf_brelse(bp);+ }+ bp = NULL;+ } else if (bp) {+ buf_brelse(bp);+ // clear this so the error exit path won't try to use it+ bp = NULL;+ }+ }++ // if this isn't the root device just bail out.+ // If it is the root device we just continue on+ // in the hopes that fsck_hfs will be able to+ // fix any damage that exists on the volume.+ if ( !(vfs_flags(mp) & MNT_ROOTFS)) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: hfs_early_journal_init (2) failed \n");+ }+ retval = EINVAL;+ goto error_exit;+ }+ }+ }++ /* Try again with a smaller block size... */+ retval = hfs_MountHFSPlusVolume(hfsmp, vhp, embeddedOffset, disksize, p, args, cred);+ if (retval && HFS_MOUNT_DEBUG) {+ printf("hfs_MountHFSPlusVolume (late) returned %d\n",retval);+ }+ }+ }++ // save off a snapshot of the mtime from the previous mount+ // (for matador).+ hfsmp->hfs_last_mounted_mtime = hfsmp->hfs_mtime;++ if ( retval ) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mountfs: encountered failure %d \n", retval);+ }+ goto error_exit;+ }++ struct vfsstatfs *vsfs = vfs_statfs(mp);+ vsfs->f_fsid.val[0] = dev;+ vsfs->f_fsid.val[1] = vfs_typenum(mp);++ vfs_setmaxsymlen(mp, 0);++ if (args) {+ /*+ * Set the free space warning levels for a non-root volume:+ *+ * Set the "danger" limit to 1% of the volume size or 150MB, whichever is less.+ * Set the "warning" limit to 2% of the volume size or 500MB, whichever is less.+ * Set the "near warning" limit to 10% of the volume size or 1GB, whichever is less.+ * And last, set the "desired" freespace level to to 12% of the volume size or 1.2GB,+ * whichever is less.+ */+ hfsmp->hfs_freespace_notify_dangerlimit =+ MIN(HFS_VERYLOWDISKTRIGGERLEVEL / HFSTOVCB(hfsmp)->blockSize,+ (HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_VERYLOWDISKTRIGGERFRACTION);+ hfsmp->hfs_freespace_notify_warninglimit =+ MIN(HFS_LOWDISKTRIGGERLEVEL / HFSTOVCB(hfsmp)->blockSize,+ (HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_LOWDISKTRIGGERFRACTION);+ hfsmp->hfs_freespace_notify_nearwarninglimit =+ MIN(HFS_NEARLOWDISKTRIGGERLEVEL / HFSTOVCB(hfsmp)->blockSize,+ (HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_NEARLOWDISKTRIGGERFRACTION);+ hfsmp->hfs_freespace_notify_desiredlevel =+ MIN(HFS_LOWDISKSHUTOFFLEVEL / HFSTOVCB(hfsmp)->blockSize,+ (HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_LOWDISKSHUTOFFFRACTION);+ } else {+ /*+ * Set the free space warning levels for the root volume:+ *+ * Set the "danger" limit to 5% of the volume size or 512MB, whichever is less.+ * Set the "warning" limit to 10% of the volume size or 1GB, whichever is less.+ * Set the "near warning" limit to 10.5% of the volume size or 1.1GB, whichever is less.+ * And last, set the "desired" freespace level to to 11% of the volume size or 1.25GB,+ * whichever is less.+ *+ * NOTE: While those are the default limits, KernelEventAgent (as of 3/2016)+ * will unilaterally override these to the following on OSX only:+ * Danger: 3GB+ * Warning: Min (2% of root volume, 10GB), with a floor of 10GB+ * Desired: Warning Threshold + 1.5GB+ */+ hfsmp->hfs_freespace_notify_dangerlimit =+ MIN(HFS_ROOTVERYLOWDISKTRIGGERLEVEL / HFSTOVCB(hfsmp)->blockSize,+ (HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_ROOTVERYLOWDISKTRIGGERFRACTION);+ hfsmp->hfs_freespace_notify_warninglimit =+ MIN(HFS_ROOTLOWDISKTRIGGERLEVEL / HFSTOVCB(hfsmp)->blockSize,+ (HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_ROOTLOWDISKTRIGGERFRACTION);+ hfsmp->hfs_freespace_notify_nearwarninglimit =+ MIN(HFS_ROOTNEARLOWDISKTRIGGERLEVEL / HFSTOVCB(hfsmp)->blockSize,+ (HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_ROOTNEARLOWDISKTRIGGERFRACTION);+ hfsmp->hfs_freespace_notify_desiredlevel =+ MIN(HFS_ROOTLOWDISKSHUTOFFLEVEL / HFSTOVCB(hfsmp)->blockSize,+ (HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_ROOTLOWDISKSHUTOFFFRACTION);+ };++ /* Check if the file system exists on virtual device, like disk image */+ if (VNOP_IOCTL(devvp, DKIOCISVIRTUAL, (caddr_t)&isvirtual, 0, context) == 0) {+ if (isvirtual) {+ hfsmp->hfs_flags |= HFS_VIRTUAL_DEVICE;+ }+ }++ if (!isroot+ && !ISSET(hfsmp->hfs_flags, HFS_VIRTUAL_DEVICE)+ && hfs_is_ejectable(vfs_statfs(mp)->f_mntfromname)) {+ SET(hfsmp->hfs_flags, HFS_RUN_SYNCER);+ }++ const char *dev_name = (hfsmp->hfs_devvp+ ? vnode_getname_printable(hfsmp->hfs_devvp) : NULL);++ printf("hfs: mounted %s on device %s\n",+ (hfsmp->vcbVN[0] ? (const char*) hfsmp->vcbVN : "unknown"),+ dev_name ?: "unknown device");++ if (dev_name)+ vnode_putname_printable(dev_name);++ /*+ * Start looking for free space to drop below this level and generate a+ * warning immediately if needed:+ */+ hfsmp->hfs_notification_conditions = 0;+ hfs_generate_volume_notifications(hfsmp);++ if (ronly == 0) {+ (void) hfs_flushvolumeheader(hfsmp, HFS_FVH_WAIT);+ }+ hfs_free_data(mdbp, kMDBSize);+ return (0);++error_exit:+ if (bp)+ buf_brelse(bp);++ hfs_free_data(mdbp, kMDBSize);++ hfs_close_jvp(hfsmp);++ if (hfsmp) {+ if (hfsmp->hfs_devvp) {+ vnode_rele(hfsmp->hfs_devvp);+ }+ hfs_locks_destroy(hfsmp);+ hfs_delete_chash(hfsmp);+ hfs_idhash_destroy (hfsmp);++ hfs_free_type(hfsmp, struct hfsmount);+ if (mp)+ vfs_setfsprivate(mp, NULL);+ }+ return (retval);+}+++/*+ * Make a filesystem operational.+ * Nothing to do at the moment.+ */+/* ARGSUSED */+static int+hfs_start(__unused struct mount *mp, __unused int flags, __unused vfs_context_t context)+{+ return (0);+}+++/*+ * unmount system call+ */+int+hfs_unmount(struct mount *mp, int mntflags, vfs_context_t context)+{+ struct proc *p = vfs_context_proc(context);+ struct hfsmount *hfsmp = VFSTOHFS(mp);+ int retval = E_NONE;+ int flags;+ int force;+ int started_tr = 0;++ flags = 0;+ force = 0;+ if (mntflags & MNT_FORCE) {+ flags |= FORCECLOSE;+ force = 1;+ }++ const char *dev_name = (hfsmp->hfs_devvp+ ? vnode_getname_printable(hfsmp->hfs_devvp) : NULL);++ printf("hfs: unmount initiated on %s on device %s\n",+ (hfsmp->vcbVN[0] ? (const char*) hfsmp->vcbVN : "unknown"),+ dev_name ?: "unknown device");++ if (dev_name)+ vnode_putname_printable(dev_name);++ if ((retval = hfs_flushfiles(mp, flags, p)) && !force)+ return (retval);++ if (hfsmp->hfs_flags & HFS_METADATA_ZONE)+ (void) hfs_recording_suspend(hfsmp);++ hfs_syncer_free(hfsmp);++ if (hfsmp->hfs_flags & HFS_SUMMARY_TABLE) {+ if (hfsmp->hfs_summary_table) {+ int err = 0;+ /*+ * Take the bitmap lock to serialize against a concurrent bitmap scan still in progress+ */+ if (hfsmp->hfs_allocation_vp) {+ err = hfs_lock (VTOC(hfsmp->hfs_allocation_vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ }+ hfs_free_data(hfsmp->hfs_summary_table, hfsmp->hfs_summary_bytes);+ hfsmp->hfs_summary_table = NULL;+ hfsmp->hfs_flags &= ~HFS_SUMMARY_TABLE;++ if (err == 0 && hfsmp->hfs_allocation_vp){+ hfs_unlock (VTOC(hfsmp->hfs_allocation_vp));+ }++ }+ }++ /*+ * Flush out the b-trees, volume bitmap and Volume Header+ */+ if ((hfsmp->hfs_flags & HFS_READ_ONLY) == 0) {+ retval = hfs_start_transaction(hfsmp);+ if (retval == 0) {+ started_tr = 1;+ } else if (!force) {+ goto err_exit;+ }++ if (hfsmp->hfs_startup_vp) {+ (void) hfs_lock(VTOC(hfsmp->hfs_startup_vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ retval = hfs_fsync(hfsmp->hfs_startup_vp, MNT_WAIT, 0, p);+ hfs_unlock(VTOC(hfsmp->hfs_startup_vp));+ if (retval && !force)+ goto err_exit;+ }++ if (hfsmp->hfs_attribute_vp) {+ (void) hfs_lock(VTOC(hfsmp->hfs_attribute_vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ retval = hfs_fsync(hfsmp->hfs_attribute_vp, MNT_WAIT, 0, p);+ hfs_unlock(VTOC(hfsmp->hfs_attribute_vp));+ if (retval && !force)+ goto err_exit;+ }++ (void) hfs_lock(VTOC(hfsmp->hfs_catalog_vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ retval = hfs_fsync(hfsmp->hfs_catalog_vp, MNT_WAIT, 0, p);+ hfs_unlock(VTOC(hfsmp->hfs_catalog_vp));+ if (retval && !force)+ goto err_exit;++ (void) hfs_lock(VTOC(hfsmp->hfs_extents_vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ retval = hfs_fsync(hfsmp->hfs_extents_vp, MNT_WAIT, 0, p);+ hfs_unlock(VTOC(hfsmp->hfs_extents_vp));+ if (retval && !force)+ goto err_exit;++ if (hfsmp->hfs_allocation_vp) {+ (void) hfs_lock(VTOC(hfsmp->hfs_allocation_vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ retval = hfs_fsync(hfsmp->hfs_allocation_vp, MNT_WAIT, 0, p);+ hfs_unlock(VTOC(hfsmp->hfs_allocation_vp));+ if (retval && !force)+ goto err_exit;+ }++ if (hfsmp->hfc_filevp && vnode_issystem(hfsmp->hfc_filevp)) {+ retval = hfs_fsync(hfsmp->hfc_filevp, MNT_WAIT, 0, p);+ if (retval && !force)+ goto err_exit;+ }++ /* If runtime corruption was detected, indicate that the volume+ * was not unmounted cleanly.+ */+ if (hfsmp->vcbAtrb & kHFSVolumeInconsistentMask) {+ HFSTOVCB(hfsmp)->vcbAtrb &= ~kHFSVolumeUnmountedMask;+ } else {+ HFSTOVCB(hfsmp)->vcbAtrb |= kHFSVolumeUnmountedMask;+ }++ if (hfsmp->hfs_flags & HFS_HAS_SPARSE_DEVICE) {+ int i;+ u_int32_t min_start = hfsmp->totalBlocks;++ // set the nextAllocation pointer to the smallest free block number+ // we've seen so on the next mount we won't rescan unnecessarily+ lck_spin_lock(&hfsmp->vcbFreeExtLock);+ for(i=0; i < (int)hfsmp->vcbFreeExtCnt; i++) {+ if (hfsmp->vcbFreeExt[i].startBlock < min_start) {+ min_start = hfsmp->vcbFreeExt[i].startBlock;+ }+ }+ lck_spin_unlock(&hfsmp->vcbFreeExtLock);+ if (min_start < hfsmp->nextAllocation) {+ hfsmp->nextAllocation = min_start;+ }+ }++ retval = hfs_flushvolumeheader(hfsmp, HFS_FVH_WAIT);+ if (retval) {+ HFSTOVCB(hfsmp)->vcbAtrb &= ~kHFSVolumeUnmountedMask;+ if (!force)+ goto err_exit; /* could not flush everything */+ }++ if (started_tr) {+ hfs_end_transaction(hfsmp);+ started_tr = 0;+ }+ }++ if (hfsmp->jnl) {+ hfs_flush(hfsmp, HFS_FLUSH_FULL);+ }++ /*+ * Invalidate our caches and release metadata vnodes+ */+ (void) hfsUnmount(hfsmp, p);++ // XXXdbg+ if (hfsmp->jnl) {+ journal_close(hfsmp->jnl);+ hfsmp->jnl = NULL;+ }++ VNOP_FSYNC(hfsmp->hfs_devvp, MNT_WAIT, context);++ hfs_close_jvp(hfsmp);++ /*+ * Last chance to dump unreferenced system files.+ */+ (void) vflush(mp, NULLVP, FORCECLOSE);++#if HFS_SPARSE_DEV+ /* Drop our reference on the backing fs (if any). */+ if ((hfsmp->hfs_flags & HFS_HAS_SPARSE_DEVICE) && hfsmp->hfs_backingvp) {+ struct vnode * tmpvp;++ hfsmp->hfs_flags &= ~HFS_HAS_SPARSE_DEVICE;+ tmpvp = hfsmp->hfs_backingvp;+ hfsmp->hfs_backingvp = NULLVP;+ vnode_rele(tmpvp);+ }+#endif /* HFS_SPARSE_DEV */++ vnode_rele(hfsmp->hfs_devvp);++ hfs_locks_destroy(hfsmp);+ hfs_delete_chash(hfsmp);+ hfs_idhash_destroy(hfsmp);++ hfs_assert(TAILQ_EMPTY(&hfsmp->hfs_reserved_ranges[HFS_TENTATIVE_BLOCKS])+ && TAILQ_EMPTY(&hfsmp->hfs_reserved_ranges[HFS_LOCKED_BLOCKS]));+ hfs_assert(!hfsmp->lockedBlocks);++ hfs_free_type(hfsmp, struct hfsmount);++ // decrement kext retain count+#if TARGET_OS_OSX+ OSDecrementAtomic(&hfs_active_mounts);+ OSKextReleaseKextWithLoadTag(OSKextGetCurrentLoadTag());+#endif++#if HFS_LEAK_DEBUG && TARGET_OS_OSX+ if (hfs_active_mounts == 0) {+ if (hfs_dump_allocations())+ Debugger(NULL);+ else {+ printf("hfs: last unmount and nothing was leaked!\n");+ msleep(hfs_unmount, NULL, PINOD, "hfs_unmount",+ &(struct timespec){ 5, 0 });+ }+ }+#endif++ return (0);++ err_exit:+ if (started_tr) {+ hfs_end_transaction(hfsmp);+ }+ return retval;+}+++/*+ * Return the root of a filesystem.+ */+int hfs_vfs_root(struct mount *mp, struct vnode **vpp, __unused vfs_context_t context)+{+ return hfs_vget(VFSTOHFS(mp), (cnid_t)kHFSRootFolderID, vpp, 1, 0);+}+++/*+ * Do operations associated with quotas+ */+#if !QUOTA+static int+hfs_quotactl(__unused struct mount *mp, __unused int cmds, __unused uid_t uid, __unused caddr_t datap, __unused vfs_context_t context)+{+ return (ENOTSUP);+}+#else+static int+hfs_quotactl(struct mount *mp, int cmds, uid_t uid, caddr_t datap, vfs_context_t context)+{+ struct proc *p = vfs_context_proc(context);+ int cmd, type, error;++ if (uid == ~0U)+ uid = kauth_cred_getuid(vfs_context_ucred(context));+ cmd = cmds >> SUBCMDSHIFT;++ switch (cmd) {+ case Q_SYNC:+ case Q_QUOTASTAT:+ break;+ case Q_GETQUOTA:+ if (uid == kauth_cred_getuid(vfs_context_ucred(context)))+ break;+ /* fall through */+ default:+ if ( (error = vfs_context_suser(context)) )+ return (error);+ }++ type = cmds & SUBCMDMASK;+ if ((u_int)type >= MAXQUOTAS)+ return (EINVAL);+ if ((error = vfs_busy(mp, LK_NOWAIT)) != 0)+ return (error);++ switch (cmd) {++ case Q_QUOTAON:+ error = hfs_quotaon(p, mp, type, datap);+ break;++ case Q_QUOTAOFF:+ error = hfs_quotaoff(p, mp, type);+ break;++ case Q_SETQUOTA:+ error = hfs_setquota(mp, uid, type, datap);+ break;++ case Q_SETUSE:+ error = hfs_setuse(mp, uid, type, datap);+ break;++ case Q_GETQUOTA:+ error = hfs_getquota(mp, uid, type, datap);+ break;++ case Q_SYNC:+ error = hfs_qsync(mp);+ break;++ case Q_QUOTASTAT:+ error = hfs_quotastat(mp, type, datap);+ break;++ default:+ error = EINVAL;+ break;+ }+ vfs_unbusy(mp);++ return (error);+}+#endif /* QUOTA */++/* Subtype is composite of bits */+#define HFS_SUBTYPE_JOURNALED 0x01+#define HFS_SUBTYPE_CASESENSITIVE 0x02+/* bits 2 - 6 reserved */+#define HFS_SUBTYPE_STANDARDHFS 0x80++/*+ * Get file system statistics.+ */+int+hfs_statfs(struct mount *mp, register struct vfsstatfs *sbp, __unused vfs_context_t context)+{+ ExtendedVCB *vcb = VFSTOVCB(mp);+ struct hfsmount *hfsmp = VFSTOHFS(mp);+ u_int16_t subtype = 0;++ sbp->f_bsize = (u_int32_t)vcb->blockSize;+ sbp->f_iosize = (size_t)cluster_max_io_size(mp, 0);+ sbp->f_blocks = (u_int64_t)((u_int32_t)vcb->totalBlocks);+ sbp->f_bfree = (u_int64_t)((u_int32_t )hfs_freeblks(hfsmp, 0));+ sbp->f_bavail = (u_int64_t)((u_int32_t )hfs_freeblks(hfsmp, 1));+ sbp->f_files = (u_int64_t)HFS_MAX_FILES;+ sbp->f_ffree = (u_int64_t)hfs_free_cnids(hfsmp);++ /*+ * Subtypes (flavors) for HFS+ * 0: Mac OS Extended+ * 1: Mac OS Extended (Journaled)+ * 2: Mac OS Extended (Case Sensitive)+ * 3: Mac OS Extended (Case Sensitive, Journaled)+ * 4 - 127: Reserved+ * 128: Mac OS Standard+ *+ */+ if ((hfsmp->hfs_flags & HFS_STANDARD) == 0) {+ /* HFS+ & variants */+ if (hfsmp->jnl) {+ subtype |= HFS_SUBTYPE_JOURNALED;+ }+ if (hfsmp->hfs_flags & HFS_CASE_SENSITIVE) {+ subtype |= HFS_SUBTYPE_CASESENSITIVE;+ }+ }+ sbp->f_fssubtype = subtype;++ return (0);+}+++//+// XXXdbg -- this is a callback to be used by the journal to+// get meta data blocks flushed out to disk.+//+// XXXdbg -- be smarter and don't flush *every* block on each+// call. try to only flush some so we don't wind up+// being too synchronous.+//+void+hfs_sync_metadata(void *arg)+{+ struct mount *mp = (struct mount *)arg;+ struct hfsmount *hfsmp;+ ExtendedVCB *vcb;+ buf_t bp;+ int retval;+ daddr64_t priIDSector;+ hfsmp = VFSTOHFS(mp);+ vcb = HFSTOVCB(hfsmp);++ // now make sure the super block is flushed+ priIDSector = (daddr64_t)((vcb->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) ++ HFS_PRI_SECTOR(hfsmp->hfs_logical_block_size));++ retval = (int)buf_meta_bread(hfsmp->hfs_devvp,+ HFS_PHYSBLK_ROUNDDOWN(priIDSector, hfsmp->hfs_log_per_phys),+ hfsmp->hfs_physical_block_size, NOCRED, &bp);+ if ((retval != 0 ) && (retval != ENXIO)) {+ printf("hfs_sync_metadata: can't read volume header at %d! (retval 0x%x)\n",+ (int)priIDSector, retval);+ }++ if (retval == 0 && ((buf_flags(bp) & (B_DELWRI | B_LOCKED)) == B_DELWRI)) {+ buf_bwrite(bp);+ } else if (bp) {+ buf_brelse(bp);+ }++ /* Note that these I/Os bypass the journal (no calls to journal_start_modify_block) */++ // the alternate super block...+ // XXXdbg - we probably don't need to do this each and every time.+ // hfs_btreeio.c:FlushAlternate() should flag when it was+ // written...+ if (hfsmp->hfs_partition_avh_sector) {+ retval = (int)buf_meta_bread(hfsmp->hfs_devvp,+ HFS_PHYSBLK_ROUNDDOWN(hfsmp->hfs_partition_avh_sector, hfsmp->hfs_log_per_phys),+ hfsmp->hfs_physical_block_size, NOCRED, &bp);+ if (retval == 0 && ((buf_flags(bp) & (B_DELWRI | B_LOCKED)) == B_DELWRI)) {+ /*+ * note this I/O can fail if the partition shrank behind our backs!+ * So failure should be OK here.+ */+ buf_bwrite(bp);+ } else if (bp) {+ buf_brelse(bp);+ }+ }++ /* Is the FS's idea of the AVH different than the partition ? */+ if ((hfsmp->hfs_fs_avh_sector) && (hfsmp->hfs_partition_avh_sector != hfsmp->hfs_fs_avh_sector)) {+ retval = (int)buf_meta_bread(hfsmp->hfs_devvp,+ HFS_PHYSBLK_ROUNDDOWN(hfsmp->hfs_fs_avh_sector, hfsmp->hfs_log_per_phys),+ hfsmp->hfs_physical_block_size, NOCRED, &bp);+ if (retval == 0 && ((buf_flags(bp) & (B_DELWRI | B_LOCKED)) == B_DELWRI)) {+ buf_bwrite(bp);+ } else if (bp) {+ buf_brelse(bp);+ }+ }++}+++struct hfs_sync_cargs {+ kauth_cred_t cred;+ struct proc *p;+ int waitfor;+ int error;+ int atime_only_syncs;+ time_t sync_start_time;+};+++static int+hfs_sync_callback(struct vnode *vp, void *cargs)+{+ struct cnode *cp = VTOC(vp);+ struct hfs_sync_cargs *args;+ int error;++ args = (struct hfs_sync_cargs *)cargs;++ if (hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0) {+ return (VNODE_RETURNED);+ }++ hfs_dirty_t dirty_state = hfs_is_dirty(cp);++ bool sync = dirty_state == HFS_DIRTY || vnode_hasdirtyblks(vp);++ if (!sync && dirty_state == HFS_DIRTY_ATIME+ && args->atime_only_syncs < 256) {+ // We only update if the atime changed more than 60s ago+ if (args->sync_start_time - cp->c_attr.ca_atime > 60) {+ sync = true;+ ++args->atime_only_syncs;+ }+ }++ if (sync) {+ error = hfs_fsync(vp, args->waitfor, 0, args->p);++ if (error)+ args->error = error;+ } else if (cp->c_touch_acctime)+ hfs_touchtimes(VTOHFS(vp), cp);++ hfs_unlock(cp);+ return (VNODE_RETURNED);+}++++/*+ * Go through the disk queues to initiate sandbagged IO;+ * go through the inodes to write those that have been modified;+ * initiate the writing of the super block if it has been modified.+ *+ * Note: we are always called with the filesystem marked `MPBUSY'.+ */+int+hfs_sync(struct mount *mp, int waitfor, vfs_context_t context)+{+ struct proc *p = vfs_context_proc(context);+ struct cnode *cp;+ struct hfsmount *hfsmp;+ ExtendedVCB *vcb;+ struct vnode *meta_vp[4];+ int i;+ int error, allerror = 0;+ struct hfs_sync_cargs args;++ hfsmp = VFSTOHFS(mp);++ // Back off if hfs_changefs or a freeze is underway+ hfs_lock_mount(hfsmp);+ if ((hfsmp->hfs_flags & HFS_IN_CHANGEFS)+ || hfsmp->hfs_freeze_state != HFS_THAWED) {+ hfs_unlock_mount(hfsmp);+ return 0;+ }++ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ hfs_unlock_mount(hfsmp);+ return (EROFS);+ }++ ++hfsmp->hfs_syncers;+ hfs_unlock_mount(hfsmp);++ args.cred = kauth_cred_get();+ args.waitfor = waitfor;+ args.p = p;+ args.error = 0;+ args.atime_only_syncs = 0;++ struct timeval tv;+ microtime(&tv);++ args.sync_start_time = tv.tv_sec;++ /*+ * hfs_sync_callback will be called for each vnode+ * hung off of this mount point... the vnode will be+ * properly referenced and unreferenced around the callback+ */+ vnode_iterate(mp, 0, hfs_sync_callback, (void *)&args);++ if (args.error)+ allerror = args.error;++ vcb = HFSTOVCB(hfsmp);++ meta_vp[0] = vcb->extentsRefNum;+ meta_vp[1] = vcb->catalogRefNum;+ meta_vp[2] = vcb->allocationsRefNum; /* This is NULL for standard HFS */+ meta_vp[3] = hfsmp->hfs_attribute_vp; /* Optional file */++ /* Now sync our three metadata files */+ for (i = 0; i < 4; ++i) {+ struct vnode *btvp;++ btvp = meta_vp[i];;+ if ((btvp==0) || (vnode_mount(btvp) != mp))+ continue;++ /* XXX use hfs_systemfile_lock instead ? */+ (void) hfs_lock(VTOC(btvp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ cp = VTOC(btvp);++ if (!hfs_is_dirty(cp) && !vnode_hasdirtyblks(btvp)) {+ hfs_unlock(VTOC(btvp));+ continue;+ }+ error = vnode_get(btvp);+ if (error) {+ hfs_unlock(VTOC(btvp));+ continue;+ }+ if ((error = hfs_fsync(btvp, waitfor, 0, p)))+ allerror = error;++ hfs_unlock(cp);+ vnode_put(btvp);+ };+++#if QUOTA+ hfs_qsync(mp);+#endif /* QUOTA */++ hfs_hotfilesync(hfsmp, vfs_context_kernel());++ /*+ * Write back modified superblock.+ */+ if (IsVCBDirty(vcb)) {+ error = hfs_flushvolumeheader(hfsmp, waitfor == MNT_WAIT ? HFS_FVH_WAIT : 0);+ if (error)+ allerror = error;+ }++ if (hfsmp->jnl) {+ hfs_flush(hfsmp, HFS_FLUSH_JOURNAL);+ }++ hfs_lock_mount(hfsmp);+ boolean_t wake = (!--hfsmp->hfs_syncers+ && hfsmp->hfs_freeze_state == HFS_WANT_TO_FREEZE);+ hfs_unlock_mount(hfsmp);+ if (wake)+ wakeup(&hfsmp->hfs_freeze_state);++ return (allerror);+}+++/*+ * File handle to vnode+ *+ * Have to be really careful about stale file handles:+ * - check that the cnode id is valid+ * - call hfs_vget() to get the locked cnode+ * - check for an unallocated cnode (i_mode == 0)+ * - check that the given client host has export rights and return+ * those rights via. exflagsp and credanonp+ */+static int+hfs_fhtovp(struct mount *mp, int fhlen, unsigned char *fhp, struct vnode **vpp, __unused vfs_context_t context)+{+ struct hfsfid *hfsfhp;+ struct vnode *nvp;+ int result;++ *vpp = NULL;+ hfsfhp = (struct hfsfid *)fhp;++ if (fhlen < (int)sizeof(struct hfsfid))+ return (EINVAL);++ result = hfs_vget(VFSTOHFS(mp), ntohl(hfsfhp->hfsfid_cnid), &nvp, 0, 0);+ if (result) {+ if (result == ENOENT)+ result = ESTALE;+ return result;+ }++ /*+ * We used to use the create time as the gen id of the file handle,+ * but it is not static enough because it can change at any point+ * via system calls. We still don't have another volume ID or other+ * unique identifier to use for a generation ID across reboots that+ * persists until the file is removed. Using only the CNID exposes+ * us to the potential wrap-around case, but as of 2/2008, it would take+ * over 2 months to wrap around if the machine did nothing but allocate+ * CNIDs. Using some kind of wrap counter would only be effective if+ * each file had the wrap counter associated with it. For now,+ * we use only the CNID to identify the file as it's good enough.+ */++ *vpp = nvp;++ hfs_unlock(VTOC(nvp));+ return (0);+}+++/*+ * Vnode pointer to File handle+ */+/* ARGSUSED */+static int+hfs_vptofh(struct vnode *vp, int *fhlenp, unsigned char *fhp, __unused vfs_context_t context)+{+ struct cnode *cp;+ struct hfsfid *hfsfhp;++ if (ISHFS(VTOVCB(vp)))+ return (ENOTSUP); /* hfs standard is not exportable */++ if (*fhlenp < (int)sizeof(struct hfsfid))+ return (EOVERFLOW);++ cp = VTOC(vp);+ hfsfhp = (struct hfsfid *)fhp;+ /* only the CNID is used to identify the file now */+ hfsfhp->hfsfid_cnid = htonl(cp->c_fileid);+ hfsfhp->hfsfid_gen = htonl(cp->c_fileid);+ *fhlenp = sizeof(struct hfsfid);++ return (0);+}+++/*+ * Initialize HFS filesystems, done only once per boot.+ *+ * HFS is not a kext-based file system. This makes it difficult to find+ * out when the last HFS file system was unmounted and call hfs_uninit()+ * to deallocate data structures allocated in hfs_init(). Therefore we+ * never deallocate memory allocated by lock attribute and group initializations+ * in this function.+ */+static int+hfs_init(__unused struct vfsconf *vfsp)+{+ static int done = 0;++ if (done)+ return (0);+ done = 1;+ hfs_chashinit();++ BTReserveSetup();++ hfs_lock_attr = lck_attr_alloc_init();+ hfs_group_attr = lck_grp_attr_alloc_init();+ hfs_mutex_group = lck_grp_alloc_init("hfs-mutex", hfs_group_attr);+ hfs_rwlock_group = lck_grp_alloc_init("hfs-rwlock", hfs_group_attr);+ hfs_spinlock_group = lck_grp_alloc_init("hfs-spinlock", hfs_group_attr);++#if HFS_COMPRESSION+ decmpfs_init();+#endif++ journal_init();++ /* HakiOS: built in, so what the kext's start() did after vfs_fsadd() is done here */+ hfs_init_zones();+ hfs_sysctl_register();++ return (0);+}+++/*+ * Destroy all locks, mutexes and spinlocks in hfsmp on unmount or failed mount+ */+static void+hfs_locks_destroy(struct hfsmount *hfsmp)+{++ lck_mtx_destroy(&hfsmp->hfs_mutex, hfs_mutex_group);+ lck_mtx_destroy(&hfsmp->hfc_mutex, hfs_mutex_group);+ lck_rw_destroy(&hfsmp->hfs_global_lock, hfs_rwlock_group);+ lck_spin_destroy(&hfsmp->vcbFreeExtLock, hfs_spinlock_group);+#if NEW_XATTR+ lck_spin_destroy(&hfsmp->hfs_xattr_io.lock, hfs_spinlock_group);+#endif++ return;+}+++static int+hfs_getmountpoint(struct vnode *vp, struct hfsmount **hfsmpp)+{+ struct hfsmount * hfsmp;+ char fstypename[MFSNAMELEN];++ if (vp == NULL)+ return (EINVAL);++ if (!vnode_isvroot(vp))+ return (EINVAL);++ vnode_vfsname(vp, fstypename);+ if (strncmp(fstypename, "hfs", sizeof(fstypename)) != 0)+ return (EINVAL);++ hfsmp = VTOHFS(vp);++ if (HFSTOVCB(hfsmp)->vcbSigWord == kHFSSigWord)+ return (EINVAL);++ *hfsmpp = hfsmp;++ return (0);+}++// Replace user-space value+static errno_t ureplace(user_addr_t oldp, size_t *oldlenp,+ user_addr_t newp, size_t newlen,+ void *data, size_t len)+{+ errno_t error;+ if (!oldlenp)+ return EFAULT;+ if (oldp && *oldlenp < len)+ return ENOMEM;+ if (newp && newlen != len)+ return EINVAL;+ *oldlenp = len;+ if (oldp) {+ error = copyout(data, oldp, len);+ if (error)+ return error;+ }+ return newp ? copyin(newp, data, len) : 0;+}++#define UREPLACE(oldp, oldlenp, newp, newlenp, v) \+ ureplace(oldp, oldlenp, newp, newlenp, &v, sizeof(v))++static hfsmount_t *hfs_mount_from_cwd(vfs_context_t ctx)+{+ vnode_t vp = vfs_context_cwd(ctx);++ if (!vp)+ return NULL;++ /*+ * We could use vnode_tag, but it is probably more future proof to+ * compare fstypename.+ */+ char fstypename[MFSNAMELEN];+ vnode_vfsname(vp, fstypename);++ if (strcmp(fstypename, "hfs"))+ return NULL;++ return VTOHFS(vp);+}++/*+ * HFS filesystem related variables.+ */+int+hfs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,+ user_addr_t newp, size_t newlen, vfs_context_t context)+{+ int error;+ struct hfsmount *hfsmp;+ struct proc *p = NULL;++ /* all sysctl names at this level are terminal */+#if TARGET_OS_OSX+ p = vfs_context_proc(context);+ if (name[0] == HFS_ENCODINGBIAS) {+ int bias;++ bias = hfs_getencodingbias();++ error = UREPLACE(oldp, oldlenp, newp, newlen, bias);+ if (error || !newp)+ return error;++ hfs_setencodingbias(bias);++ return 0;+ } else+#endif //OSX+ if (name[0] == HFS_EXTEND_FS) {+ u_int64_t newsize = 0;+ vnode_t vp = vfs_context_cwd(context);++ if (newp == USER_ADDR_NULL || vp == NULLVP+ || newlen != sizeof(quad_t) || !oldlenp)+ return EINVAL;+ if ((error = hfs_getmountpoint(vp, &hfsmp)))+ return (error);++ /* Start with the 'size' set to the current number of bytes in the filesystem */+ newsize = ((uint64_t)hfsmp->totalBlocks) * ((uint64_t)hfsmp->blockSize);++ error = UREPLACE(oldp, oldlenp, newp, newlen, newsize);+ if (error)+ return error;++ return hfs_extendfs(hfsmp, newsize, context);+ } else if (name[0] == HFS_ENABLE_JOURNALING) {+ // make the file system journaled...+ vnode_t jvp;+ ExtendedVCB *vcb;+ struct cat_attr jnl_attr;+ struct cat_attr jinfo_attr;+ struct cat_fork jnl_fork;+ struct cat_fork jinfo_fork;+ buf_t jib_buf;+ uint64_t jib_blkno;+ uint32_t tmpblkno;+ uint64_t journal_byte_offset;+ uint64_t journal_size;+ vnode_t jib_vp = NULLVP;+ struct JournalInfoBlock local_jib;+ int err = 0;+ void *jnl = NULL;+ int lockflags;++ /* Only root can enable journaling */+ if (!kauth_cred_issuser(kauth_cred_get())) {+ return (EPERM);+ }+ if (namelen != 4)+ return EINVAL;+ hfsmp = hfs_mount_from_cwd(context);+ if (!hfsmp)+ return EINVAL;++ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return EROFS;+ }+ if (HFSTOVCB(hfsmp)->vcbSigWord == kHFSSigWord) {+ printf("hfs: can't make a plain hfs volume journaled.\n");+ return EINVAL;+ }++ if (hfsmp->jnl) {+ printf("hfs: volume %s is already journaled!\n", hfsmp->vcbVN);+ return EAGAIN;+ }+ vcb = HFSTOVCB(hfsmp);++ /* Set up local copies of the initialization info */+ tmpblkno = (uint32_t) name[1];+ jib_blkno = (uint64_t) tmpblkno;+ journal_byte_offset = (uint64_t) name[2];+ journal_byte_offset *= hfsmp->blockSize;+ journal_byte_offset += hfsmp->hfsPlusIOPosOffset;+ journal_size = (uint64_t)((unsigned)name[3]);++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_EXTENTS, HFS_EXCLUSIVE_LOCK);+ if (BTHasContiguousNodes(VTOF(vcb->catalogRefNum)) == 0 ||+ BTHasContiguousNodes(VTOF(vcb->extentsRefNum)) == 0) {++ printf("hfs: volume has a btree w/non-contiguous nodes. can not enable journaling.\n");+ hfs_systemfile_unlock(hfsmp, lockflags);+ return EINVAL;+ }+ hfs_systemfile_unlock(hfsmp, lockflags);++ // make sure these both exist!+ if ( GetFileInfo(vcb, kHFSRootFolderID, ".journal_info_block", &jinfo_attr, &jinfo_fork) == 0+ || GetFileInfo(vcb, kHFSRootFolderID, ".journal", &jnl_attr, &jnl_fork) == 0) {++ return EINVAL;+ }++ /*+ * At this point, we have a copy of the metadata that lives in the catalog for the+ * journal info block. Compare that the journal info block's single extent matches+ * that which was passed into this sysctl.+ *+ * If it is different, deny the journal enable call.+ */+ if (jinfo_fork.cf_blocks > 1) {+ /* too many blocks */+ return EINVAL;+ }++ if (jinfo_fork.cf_extents[0].startBlock != jib_blkno) {+ /* Wrong block */+ return EINVAL;+ }++ /*+ * We want to immediately purge the vnode for the JIB.+ *+ * Because it was written to from userland, there's probably+ * a vnode somewhere in the vnode cache (possibly with UBC backed blocks).+ * So we bring the vnode into core, then immediately do whatever+ * we can to flush/vclean it out. This is because those blocks will be+ * interpreted as user data, which may be treated separately on some platforms+ * than metadata. If the vnode is gone, then there cannot be backing blocks+ * in the UBC.+ */+ if (hfs_vget (hfsmp, jinfo_attr.ca_fileid, &jib_vp, 1, 0)) {+ return EINVAL;+ }+ /*+ * Now we have a vnode for the JIB. recycle it. Because we hold an iocount+ * on the vnode, we'll just mark it for termination when the last iocount+ * (hopefully ours), is dropped.+ */+ vnode_recycle (jib_vp);+ err = vnode_put (jib_vp);+ if (err) {+ return EINVAL;+ }++ /* Initialize the local copy of the JIB (just like hfs.util) */+ memset (&local_jib, 'Z', sizeof(struct JournalInfoBlock));+ local_jib.flags = SWAP_BE32(kJIJournalInFSMask);+ /* Note that the JIB's offset is in bytes */+ local_jib.offset = SWAP_BE64(journal_byte_offset);+ local_jib.size = SWAP_BE64(journal_size);++ /*+ * Now write out the local JIB. This essentially overwrites the userland+ * copy of the JIB. Read it as BLK_META to treat it as a metadata read/write.+ */+ jib_buf = buf_getblk (hfsmp->hfs_devvp,+ jib_blkno * (hfsmp->blockSize / hfsmp->hfs_logical_block_size),+ hfsmp->blockSize, 0, 0, BLK_META);+ char* buf_ptr = (char*) buf_dataptr (jib_buf);++ /* Zero out the portion of the block that won't contain JIB data */+ memset (buf_ptr, 0, hfsmp->blockSize);++ bcopy(&local_jib, buf_ptr, sizeof(local_jib));+ if (buf_bwrite (jib_buf)) {+ return EIO;+ }++ /* Force a flush track cache */+ hfs_flush(hfsmp, HFS_FLUSH_CACHE);++ /* Now proceed with full volume sync */+ hfs_sync(hfsmp->hfs_mp, MNT_WAIT, context);++ printf("hfs: Initializing the journal (joffset 0x%llx sz 0x%llx)...\n",+ (off_t)name[2], (off_t)name[3]);++ //+ // XXXdbg - note that currently (Sept, 08) hfs_util does not support+ // enabling the journal on a separate device so it is safe+ // to just copy hfs_devvp here. If hfs_util gets the ability+ // to dynamically enable the journal on a separate device then+ // we will have to do the same thing as hfs_early_journal_init()+ // to locate and open the journal device.+ //+ jvp = hfsmp->hfs_devvp;+ jnl = journal_create(jvp, journal_byte_offset, journal_size,+ hfsmp->hfs_devvp,+ hfsmp->hfs_logical_block_size,+ 0,+ 0,+ hfs_sync_metadata, hfsmp->hfs_mp,+ hfsmp->hfs_mp);++ /*+ * Set up the trim callback function so that we can add+ * recently freed extents to the free extent cache once+ * the transaction that freed them is written to the+ * journal on disk.+ */+ if (jnl)+ journal_trim_set_callback(jnl, hfs_trim_callback, hfsmp);++ if (jnl == NULL) {+ printf("hfs: FAILED to create the journal!\n");+ return EIO;+ }++ hfs_lock_global (hfsmp, HFS_EXCLUSIVE_LOCK);++ /*+ * Flush all dirty metadata buffers.+ */+ buf_flushdirtyblks(hfsmp->hfs_devvp, TRUE, 0, "hfs_sysctl");+ buf_flushdirtyblks(hfsmp->hfs_extents_vp, TRUE, 0, "hfs_sysctl");+ buf_flushdirtyblks(hfsmp->hfs_catalog_vp, TRUE, 0, "hfs_sysctl");+ buf_flushdirtyblks(hfsmp->hfs_allocation_vp, TRUE, 0, "hfs_sysctl");+ if (hfsmp->hfs_attribute_vp)+ buf_flushdirtyblks(hfsmp->hfs_attribute_vp, TRUE, 0, "hfs_sysctl");++ HFSTOVCB(hfsmp)->vcbJinfoBlock = name[1];+ HFSTOVCB(hfsmp)->vcbAtrb |= kHFSVolumeJournaledMask;+ hfsmp->jvp = jvp;+ hfsmp->jnl = jnl;++ // save this off for the hack-y check in hfs_remove()+ hfsmp->jnl_start = (u_int32_t)name[2];+ hfsmp->jnl_size = (off_t)((unsigned)name[3]);+ hfsmp->hfs_jnlinfoblkid = jinfo_attr.ca_fileid;+ hfsmp->hfs_jnlfileid = jnl_attr.ca_fileid;++ vfs_setflags(hfsmp->hfs_mp, (u_int64_t)((unsigned int)MNT_JOURNALED));++ hfs_unlock_global (hfsmp);+ hfs_flushvolumeheader(hfsmp, HFS_FVH_WAIT | HFS_FVH_WRITE_ALT);++ {+ fsid_t fsid;++ fsid.val[0] = (int32_t)hfsmp->hfs_raw_dev;+ fsid.val[1] = (int32_t)vfs_typenum(HFSTOVFS(hfsmp));+ vfs_event_signal(&fsid, VQ_UPDATE, (intptr_t)NULL);+ }+ return 0;+ } else if (name[0] == HFS_DISABLE_JOURNALING) {+ // clear the journaling bit++ /* Only root can disable journaling */+ if (!kauth_cred_issuser(kauth_cred_get())) {+ return (EPERM);+ }++ hfsmp = hfs_mount_from_cwd(context);+ if (!hfsmp)+ return EINVAL;++ /*+ * Disabling journaling is disallowed on volumes with directory hard links+ * because we have not tested the relevant code path.+ */+ if (hfsmp->hfs_private_attr[DIR_HARDLINKS].ca_entries != 0){+ printf("hfs: cannot disable journaling on volumes with directory hardlinks\n");+ return EPERM;+ }++ printf("hfs: disabling journaling for %s\n", hfsmp->vcbVN);++ hfs_lock_global (hfsmp, HFS_EXCLUSIVE_LOCK);++ // Lights out for you buddy!+ journal_close(hfsmp->jnl);+ hfsmp->jnl = NULL;++ hfs_close_jvp(hfsmp);+ vfs_clearflags(hfsmp->hfs_mp, (u_int64_t)((unsigned int)MNT_JOURNALED));+ hfsmp->jnl_start = 0;+ hfsmp->hfs_jnlinfoblkid = 0;+ hfsmp->hfs_jnlfileid = 0;++ HFSTOVCB(hfsmp)->vcbAtrb &= ~kHFSVolumeJournaledMask;++ hfs_unlock_global (hfsmp);++ hfs_flushvolumeheader(hfsmp, HFS_FVH_WAIT | HFS_FVH_WRITE_ALT);++ {+ fsid_t fsid;++ fsid.val[0] = (int32_t)hfsmp->hfs_raw_dev;+ fsid.val[1] = (int32_t)vfs_typenum(HFSTOVFS(hfsmp));+ vfs_event_signal(&fsid, VQ_UPDATE, (intptr_t)NULL);+ }+ return 0;+ } else if (name[0] == VFS_CTL_QUERY) {+#if TARGET_OS_IPHONE+ return EPERM;+#else //!TARGET_OS_IPHONE+ struct sysctl_req *req;+ union union_vfsidctl vc;+ struct mount *mp;+ struct vfsquery vq;++ req = CAST_DOWN(struct sysctl_req *, oldp); /* we're new style vfs sysctl. */+ if (req == NULL) {+ return EFAULT;+ }++ error = SYSCTL_IN(req, &vc, proc_is64bit(p)? sizeof(vc.vc64):sizeof(vc.vc32));+ if (error) return (error);++ mp = vfs_getvfs(&vc.vc32.vc_fsid); /* works for 32 and 64 */+ if (mp == NULL) return (ENOENT);++ hfsmp = VFSTOHFS(mp);+ bzero(&vq, sizeof(vq));+ vq.vq_flags = hfsmp->hfs_notification_conditions;+ return SYSCTL_OUT(req, &vq, sizeof(vq));;+#endif // TARGET_OS_IPHONE+ } else if (name[0] == HFS_REPLAY_JOURNAL) {+ vnode_t devvp = NULL;+ int device_fd;+ if (namelen != 2) {+ return (EINVAL);+ }+ device_fd = name[1];+ error = file_vnode(device_fd, &devvp);+ if (error) {+ return error;+ }+ error = vnode_getwithref(devvp);+ if (error) {+ file_drop(device_fd);+ return error;+ }+ error = hfs_journal_replay(devvp, context);+ file_drop(device_fd);+ vnode_put(devvp);+ return error;+ }+#if DEBUG || TARGET_OS_OSX+ else if (name[0] == HFS_ENABLE_RESIZE_DEBUG) {+ if (!kauth_cred_issuser(kauth_cred_get())) {+ return (EPERM);+ }++ int old = hfs_resize_debug;++ int res = UREPLACE(oldp, oldlenp, newp, newlen, hfs_resize_debug);++ if (old != hfs_resize_debug) {+ printf("hfs: %s resize debug\n",+ hfs_resize_debug ? "enabled" : "disabled");+ }++ return res;+ }+#endif // DEBUG || OSX++ return (ENOTSUP);+}++/*+ * hfs_vfs_vget is not static since it is used in hfs_readwrite.c to support+ * the vn_getpath_ext. We use it to leverage the code below that updates+ * the origin list cache if necessary+ */++int+hfs_vfs_vget(struct mount *mp, ino64_t ino, struct vnode **vpp, __unused vfs_context_t context)+{+ int error;+ int lockflags;+ struct hfsmount *hfsmp;++ hfsmp = VFSTOHFS(mp);++ error = hfs_vget(hfsmp, (cnid_t)ino, vpp, 1, 0);+ if (error)+ return error;++ /*+ * If the look-up was via the object ID (rather than the link ID),+ * then we make sure there's a parent here. We can't leave this+ * until hfs_vnop_getattr because if there's a problem getting the+ * parent at that point, all the caller will do is call+ * hfs_vfs_vget again and we'll end up in an infinite loop.+ */++ cnode_t *cp = VTOC(*vpp);++ if (ISSET(cp->c_flag, C_HARDLINK) && ino == cp->c_fileid) {+ hfs_lock_always(cp, HFS_SHARED_LOCK);++ if (!hfs_haslinkorigin(cp)) {+ if (!hfs_lock_upgrade(cp))+ hfs_lock_always(cp, HFS_EXCLUSIVE_LOCK);++ if (cp->c_cnid == cp->c_fileid) {+ /*+ * Descriptor is stale, so we need to refresh it. We+ * pick the first link.+ */+ cnid_t link_id;++ error = hfs_first_link(hfsmp, cp, &link_id);++ if (!error) {+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);+ error = cat_findname(hfsmp, link_id, &cp->c_desc);+ hfs_systemfile_unlock(hfsmp, lockflags);+ }+ } else {+ // We'll use whatever link the descriptor happens to have+ error = 0;+ }+ if (!error)+ hfs_savelinkorigin(cp, cp->c_parentcnid);+ }++ hfs_unlock(cp);++ if (error) {+ vnode_put(*vpp);+ *vpp = NULL;+ }+ }++ return error;+}+++/*+ * Look up an HFS object by ID.+ *+ * The object is returned with an iocount reference and the cnode locked.+ *+ * If the object is a file then it will represent the data fork.+ */+int+hfs_vget(struct hfsmount *hfsmp, cnid_t cnid, struct vnode **vpp, int skiplock, int allow_deleted)+{+ struct vnode *vp = NULLVP;+ struct cat_desc cndesc;+ struct cat_attr cnattr;+ struct cat_fork cnfork;+ u_int32_t linkref = 0;+ int error;++ /* Check for cnids that should't be exported. */+ if ((cnid < kHFSFirstUserCatalogNodeID) &&+ (cnid != kHFSRootFolderID && cnid != kHFSRootParentID)) {+ return (ENOENT);+ }+ /* Don't export our private directories. */+ if (cnid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid ||+ cnid == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {+ return (ENOENT);+ }+ /*+ * Check the hash first+ */+ vp = hfs_chash_getvnode(hfsmp, cnid, 0, skiplock, allow_deleted);+ if (vp) {+ *vpp = vp;+ return(0);+ }++ bzero(&cndesc, sizeof(cndesc));+ bzero(&cnattr, sizeof(cnattr));+ bzero(&cnfork, sizeof(cnfork));++ /*+ * Not in hash, lookup in catalog+ */+ if (cnid == kHFSRootParentID) {+ static char hfs_rootname[] = "/";++ cndesc.cd_nameptr = (const u_int8_t *)&hfs_rootname[0];+ cndesc.cd_namelen = 1;+ cndesc.cd_parentcnid = kHFSRootParentID;+ cndesc.cd_cnid = kHFSRootFolderID;+ cndesc.cd_flags = CD_ISDIR;++ cnattr.ca_fileid = kHFSRootFolderID;+ cnattr.ca_linkcount = 1;+ cnattr.ca_entries = 1;+ cnattr.ca_dircount = 1;+ cnattr.ca_mode = (S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO);+ } else {+ int lockflags;+ cnid_t pid;+ const char *nameptr;++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);+ error = cat_idlookup(hfsmp, cnid, 0, 0, &cndesc, &cnattr, &cnfork);+ hfs_systemfile_unlock(hfsmp, lockflags);++ if (error) {+ *vpp = NULL;+ return (error);+ }++ /*+ * Check for a raw hardlink inode and save its linkref.+ */+ pid = cndesc.cd_parentcnid;+ nameptr = (const char *)cndesc.cd_nameptr;++ if ((pid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid) &&+ cndesc.cd_namelen > HFS_INODE_PREFIX_LEN &&+ (bcmp(nameptr, HFS_INODE_PREFIX, HFS_INODE_PREFIX_LEN) == 0)) {+ linkref = strtoul(&nameptr[HFS_INODE_PREFIX_LEN], NULL, 10);++ } else if ((pid == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) &&+ cndesc.cd_namelen > HFS_DIRINODE_PREFIX_LEN &&+ (bcmp(nameptr, HFS_DIRINODE_PREFIX, HFS_DIRINODE_PREFIX_LEN) == 0)) {+ linkref = strtoul(&nameptr[HFS_DIRINODE_PREFIX_LEN], NULL, 10);++ } else if ((pid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid) &&+ cndesc.cd_namelen > HFS_DELETE_PREFIX_LEN &&+ (bcmp(nameptr, HFS_DELETE_PREFIX, HFS_DELETE_PREFIX_LEN) == 0)) {+ *vpp = NULL;+ cat_releasedesc(&cndesc);+ return (ENOENT); /* open unlinked file */+ }+ }++ /*+ * Finish initializing cnode descriptor for hardlinks.+ *+ * We need a valid name and parent for reverse lookups.+ */+ if (linkref) {+ cnid_t lastid;+ struct cat_desc linkdesc;+ int linkerr = 0;++ cnattr.ca_linkref = linkref;+ bzero (&linkdesc, sizeof (linkdesc));++ /*+ * If the caller supplied the raw inode value, then we don't know exactly+ * which hardlink they wanted. It's likely that they acquired the raw inode+ * value BEFORE the item became a hardlink, in which case, they probably+ * want the oldest link. So request the oldest link from the catalog.+ *+ * Unfortunately, this requires that we iterate through all N hardlinks. On the plus+ * side, since we know that we want the last linkID, we can also have this one+ * call give us back the name of the last ID, since it's going to have it in-hand...+ */+ linkerr = hfs_lookup_lastlink (hfsmp, linkref, &lastid, &linkdesc);+ if ((linkerr == 0) && (lastid != 0)) {+ /*+ * Release any lingering buffers attached to our local descriptor.+ * Then copy the name and other business into the cndesc+ */+ cat_releasedesc (&cndesc);+ bcopy (&linkdesc, &cndesc, sizeof(linkdesc));+ }+ /* If it failed, the linkref code will just use whatever it had in-hand below. */+ }++ if (linkref) {+ int newvnode_flags = 0;++ error = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr,+ &cnfork, &vp, &newvnode_flags);+ if (error == 0) {+ VTOC(vp)->c_flag |= C_HARDLINK;+ vnode_setmultipath(vp);+ }+ } else {+ int newvnode_flags = 0;++ void *buf = hfs_malloc_data(MAXPATHLEN);++ /* Supply hfs_getnewvnode with a component name. */+ struct componentname cn = {+ .cn_nameiop = LOOKUP,+ .cn_flags = ISLASTCN,+ .cn_pnlen = MAXPATHLEN,+ .cn_namelen = cndesc.cd_namelen,+ .cn_pnbuf = buf,+ .cn_nameptr = buf+ };++ bcopy(cndesc.cd_nameptr, cn.cn_nameptr, cndesc.cd_namelen + 1);++ error = hfs_getnewvnode(hfsmp, NULLVP, &cn, &cndesc, 0, &cnattr,+ &cnfork, &vp, &newvnode_flags);++ if (error == 0 && (VTOC(vp)->c_flag & C_HARDLINK)) {+ hfs_savelinkorigin(VTOC(vp), cndesc.cd_parentcnid);+ }++ hfs_free_data(buf, MAXPATHLEN);+ }+ cat_releasedesc(&cndesc);++ *vpp = vp;+ if (vp && skiplock) {+ hfs_unlock(VTOC(vp));+ }+ return (error);+}+++/*+ * Flush out all the files in a filesystem.+ */+static int+#if QUOTA+hfs_flushfiles(struct mount *mp, int flags, struct proc *p)+#else+hfs_flushfiles(struct mount *mp, int flags, __unused struct proc *p)+#endif /* QUOTA */+{+ struct hfsmount *hfsmp;+ struct vnode *skipvp = NULLVP;+ int error;+ int accounted_root_usecounts;+#if QUOTA+ int i;+#endif++ hfsmp = VFSTOHFS(mp);++ accounted_root_usecounts = 0;+#if QUOTA+ /*+ * The open quota files have an indirect reference on+ * the root directory vnode. We must account for this+ * extra reference when doing the intial vflush.+ */+ if (((unsigned int)vfs_flags(mp)) & MNT_QUOTA) {+ /* Find out how many quota files we have open. */+ for (i = 0; i < MAXQUOTAS; i++) {+ if (hfsmp->hfs_qfiles[i].qf_vp != NULLVP)+ ++accounted_root_usecounts;+ }+ }+#endif /* QUOTA */++ if (accounted_root_usecounts > 0) {+ /* Obtain the root vnode so we can skip over it. */+ skipvp = hfs_chash_getvnode(hfsmp, kHFSRootFolderID, 0, 0, 0);+ }++ error = vflush(mp, skipvp, SKIPSYSTEM | SKIPSWAP | flags);+ if (error != 0)+ return(error);++ error = vflush(mp, skipvp, SKIPSYSTEM | flags);++ if (skipvp) {+ /*+ * See if there are additional references on the+ * root vp besides the ones obtained from the open+ * quota files and CoreStorage.+ */+ if ((error == 0) &&+ (vnode_isinuse(skipvp, accounted_root_usecounts))) {+ error = EBUSY; /* root directory is still open */+ }+ hfs_unlock(VTOC(skipvp));+ /* release the iocount from the hfs_chash_getvnode call above. */+ vnode_put(skipvp);+ }+ if (error && (flags & FORCECLOSE) == 0)+ return (error);++#if QUOTA+ if (((unsigned int)vfs_flags(mp)) & MNT_QUOTA) {+ for (i = 0; i < MAXQUOTAS; i++) {+ if (hfsmp->hfs_qfiles[i].qf_vp == NULLVP)+ continue;+ hfs_quotaoff(p, mp, i);+ }+ }+#endif /* QUOTA */++ if (skipvp) {+ error = vflush(mp, NULLVP, SKIPSYSTEM | flags);+ }++ return (error);+}++/*+ * Update volume encoding bitmap (HFS Plus only)+ *+ * Mark a legacy text encoding as in-use (as needed)+ * in the volume header of this HFS+ filesystem.+ */+void+hfs_setencodingbits(struct hfsmount *hfsmp, u_int32_t encoding)+{+#define kIndexMacUkrainian 48 /* MacUkrainian encoding is 152 */+#define kIndexMacFarsi 49 /* MacFarsi encoding is 140 */++ u_int32_t index;++ switch (encoding) {+ case kTextEncodingMacUkrainian:+ index = kIndexMacUkrainian;+ break;+ case kTextEncodingMacFarsi:+ index = kIndexMacFarsi;+ break;+ default:+ index = encoding;+ break;+ }++ /* Only mark the encoding as in-use if it wasn't already set */+ if (index < 64 && (hfsmp->encodingsBitmap & (u_int64_t)(1ULL << index)) == 0) {+ hfs_lock_mount (hfsmp);+ hfsmp->encodingsBitmap |= (u_int64_t)(1ULL << index);+ MarkVCBDirty(hfsmp);+ hfs_unlock_mount(hfsmp);+ }+}++/*+ * Update volume stats+ *+ * On journal volumes this will cause a volume header flush+ */+int+hfs_volupdate(struct hfsmount *hfsmp, enum volop op, int inroot)+{+ struct timeval tv;++ microtime(&tv);++ hfs_lock_mount (hfsmp);++ MarkVCBDirty(hfsmp);+ hfsmp->hfs_mtime = tv.tv_sec;++ switch (op) {+ case VOL_UPDATE:+ break;+ case VOL_MKDIR:+ if (hfsmp->hfs_dircount != 0xFFFFFFFF)+ ++hfsmp->hfs_dircount;+ if (inroot && hfsmp->vcbNmRtDirs != 0xFFFF)+ ++hfsmp->vcbNmRtDirs;+ break;+ case VOL_RMDIR:+ if (hfsmp->hfs_dircount != 0)+ --hfsmp->hfs_dircount;+ if (inroot && hfsmp->vcbNmRtDirs != 0xFFFF)+ --hfsmp->vcbNmRtDirs;+ break;+ case VOL_MKFILE:+ if (hfsmp->hfs_filecount != 0xFFFFFFFF)+ ++hfsmp->hfs_filecount;+ if (inroot && hfsmp->vcbNmFls != 0xFFFF)+ ++hfsmp->vcbNmFls;+ break;+ case VOL_RMFILE:+ if (hfsmp->hfs_filecount != 0)+ --hfsmp->hfs_filecount;+ if (inroot && hfsmp->vcbNmFls != 0xFFFF)+ --hfsmp->vcbNmFls;+ break;+ }++ hfs_unlock_mount (hfsmp);++ if (hfsmp->jnl) {+ hfs_flushvolumeheader(hfsmp, 0);+ }++ return (0);+}+++/*+ * Flush any dirty in-memory mount data to the on-disk+ * volume header.+ *+ * Note: the on-disk volume signature is intentionally+ * not flushed since the on-disk "H+" and "HX" signatures+ * are always stored in-memory as "H+".+ */+int+hfs_flushvolumeheader(struct hfsmount *hfsmp,+ hfs_flush_volume_header_options_t options)+{+ ExtendedVCB *vcb = HFSTOVCB(hfsmp);+ struct filefork *fp;+ HFSPlusVolumeHeader *volumeHeader, *altVH;+ int retval;+ struct buf *bp, *alt_bp;+ int i;+ daddr64_t priIDSector;+ bool critical = false;+ u_int16_t signature;+ u_int16_t hfsversion;+ daddr64_t avh_sector;+ bool altflush = ISSET(options, HFS_FVH_WRITE_ALT);++ if (ISSET(options, HFS_FVH_FLUSH_IF_DIRTY)+ && !hfs_header_needs_flushing(hfsmp)) {+ return 0;+ }++ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return(0);+ }+ priIDSector = (daddr64_t)((vcb->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) ++ HFS_PRI_SECTOR(hfsmp->hfs_logical_block_size));++ if (hfs_start_transaction(hfsmp) != 0) {+ return EINVAL;+ }++ bp = NULL;+ alt_bp = NULL;++ retval = (int)buf_meta_bread(hfsmp->hfs_devvp,+ HFS_PHYSBLK_ROUNDDOWN(priIDSector, hfsmp->hfs_log_per_phys),+ hfsmp->hfs_physical_block_size, NOCRED, &bp);+ if (retval) {+ printf("hfs: err %d reading VH blk (vol=%s)\n", retval, vcb->vcbVN);+ goto err_exit;+ }++ volumeHeader = (HFSPlusVolumeHeader *)((char *)buf_dataptr(bp) ++ HFS_PRI_OFFSET(hfsmp->hfs_physical_block_size));++ /*+ * Sanity check what we just read. If it's bad, try the alternate+ * instead.+ */+ signature = SWAP_BE16 (volumeHeader->signature);+ hfsversion = SWAP_BE16 (volumeHeader->version);+ if ((signature != kHFSPlusSigWord && signature != kHFSXSigWord) ||+ (hfsversion < kHFSPlusVersion) || (hfsversion > 100) ||+ (SWAP_BE32 (volumeHeader->blockSize) != vcb->blockSize)) {+ printf("hfs: corrupt VH on %s, sig 0x%04x, ver %d, blksize %d\n",+ vcb->vcbVN, signature, hfsversion,+ SWAP_BE32 (volumeHeader->blockSize));+ hfs_mark_inconsistent(hfsmp, HFS_INCONSISTENCY_DETECTED);++ /* Almost always we read AVH relative to the partition size */+ avh_sector = hfsmp->hfs_partition_avh_sector;++ if (hfsmp->hfs_partition_avh_sector != hfsmp->hfs_fs_avh_sector) {+ /*+ * The two altVH offsets do not match --- which means that a smaller file+ * system exists in a larger partition. Verify that we have the correct+ * alternate volume header sector as per the current parititon size.+ * The GPT device that we are mounted on top could have changed sizes+ * without us knowing.+ *+ * We're in a transaction, so it's safe to modify the partition_avh_sector+ * field if necessary.+ */++ uint64_t sector_count;++ /* Get underlying device block count */+ if ((retval = VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCGETBLOCKCOUNT,+ (caddr_t)§or_count, 0, vfs_context_current()))) {+ printf("hfs_flushVH: err %d getting block count (%s) \n", retval, vcb->vcbVN);+ retval = ENXIO;+ goto err_exit;+ }++ /* Partition size was changed without our knowledge */+ if (sector_count != (uint64_t)hfsmp->hfs_logical_block_count) {+ hfsmp->hfs_partition_avh_sector = (hfsmp->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) ++ HFS_ALT_SECTOR(hfsmp->hfs_logical_block_size, sector_count);+ /* Note: hfs_fs_avh_sector will remain unchanged */+ printf ("hfs_flushVH: partition size changed, partition_avh_sector=%qu, fs_avh_sector=%qu\n",+ hfsmp->hfs_partition_avh_sector, hfsmp->hfs_fs_avh_sector);++ /*+ * We just updated the offset for AVH relative to+ * the partition size, so the content of that AVH+ * will be invalid. But since we are also maintaining+ * a valid AVH relative to the file system size, we+ * can read it since primary VH and partition AVH+ * are not valid.+ */+ avh_sector = hfsmp->hfs_fs_avh_sector;+ }+ }++ printf ("hfs: trying alternate (for %s) avh_sector=%qu\n",+ (avh_sector == hfsmp->hfs_fs_avh_sector) ? "file system" : "partition", avh_sector);++ if (avh_sector) {+ retval = buf_meta_bread(hfsmp->hfs_devvp,+ HFS_PHYSBLK_ROUNDDOWN(avh_sector, hfsmp->hfs_log_per_phys),+ hfsmp->hfs_physical_block_size, NOCRED, &alt_bp);+ if (retval) {+ printf("hfs: err %d reading alternate VH (%s)\n", retval, vcb->vcbVN);+ goto err_exit;+ }++ altVH = (HFSPlusVolumeHeader *)((char *)buf_dataptr(alt_bp) ++ HFS_ALT_OFFSET(hfsmp->hfs_physical_block_size));+ signature = SWAP_BE16(altVH->signature);+ hfsversion = SWAP_BE16(altVH->version);++ if ((signature != kHFSPlusSigWord && signature != kHFSXSigWord) ||+ (hfsversion < kHFSPlusVersion) || (kHFSPlusVersion > 100) ||+ (SWAP_BE32(altVH->blockSize) != vcb->blockSize)) {+ printf("hfs: corrupt alternate VH on %s, sig 0x%04x, ver %d, blksize %d\n",+ vcb->vcbVN, signature, hfsversion,+ SWAP_BE32(altVH->blockSize));+ retval = EIO;+ goto err_exit;+ }++ /* The alternate is plausible, so use it. */+ bcopy(altVH, volumeHeader, kMDBSize);+ buf_brelse(alt_bp);+ alt_bp = NULL;+ } else {+ /* No alternate VH, nothing more we can do. */+ retval = EIO;+ goto err_exit;+ }+ }++ if (hfsmp->jnl) {+ journal_modify_block_start(hfsmp->jnl, bp);+ }++ /*+ * For embedded HFS+ volumes, update create date if it changed+ * (ie from a setattrlist call)+ */+ if ((vcb->hfsPlusIOPosOffset != 0) &&+ (SWAP_BE32 (volumeHeader->createDate) != vcb->localCreateDate)) {+ struct buf *bp2;+ HFSMasterDirectoryBlock *mdb;++ retval = (int)buf_meta_bread(hfsmp->hfs_devvp,+ HFS_PHYSBLK_ROUNDDOWN(HFS_PRI_SECTOR(hfsmp->hfs_logical_block_size), hfsmp->hfs_log_per_phys),+ hfsmp->hfs_physical_block_size, NOCRED, &bp2);+ if (retval) {+ if (bp2)+ buf_brelse(bp2);+ retval = 0;+ } else {+ mdb = (HFSMasterDirectoryBlock *)(buf_dataptr(bp2) ++ HFS_PRI_OFFSET(hfsmp->hfs_physical_block_size));++ if ( SWAP_BE32 (mdb->drCrDate) != vcb->localCreateDate )+ {+ if (hfsmp->jnl) {+ journal_modify_block_start(hfsmp->jnl, bp2);+ }++ mdb->drCrDate = SWAP_BE32 (vcb->localCreateDate); /* pick up the new create date */++ if (hfsmp->jnl) {+ journal_modify_block_end(hfsmp->jnl, bp2, NULL, NULL);+ } else {+ (void) VNOP_BWRITE(bp2); /* write out the changes */+ }+ }+ else+ {+ buf_brelse(bp2); /* just release it */+ }+ }+ }++ hfs_lock_mount (hfsmp);++ /* Note: only update the lower 16 bits worth of attributes */+ volumeHeader->attributes = SWAP_BE32 (vcb->vcbAtrb);+ volumeHeader->journalInfoBlock = SWAP_BE32 (vcb->vcbJinfoBlock);+ if (hfsmp->jnl) {+ volumeHeader->lastMountedVersion = SWAP_BE32 (kHFSJMountVersion);+ } else {+ volumeHeader->lastMountedVersion = SWAP_BE32 (kHFSPlusMountVersion);+ }+ volumeHeader->createDate = SWAP_BE32 (vcb->localCreateDate); /* volume create date is in local time */+ volumeHeader->modifyDate = SWAP_BE32 (to_hfs_time(vcb->vcbLsMod));+ volumeHeader->backupDate = SWAP_BE32 (to_hfs_time(vcb->vcbVolBkUp));+ volumeHeader->fileCount = SWAP_BE32 (vcb->vcbFilCnt);+ volumeHeader->folderCount = SWAP_BE32 (vcb->vcbDirCnt);+ volumeHeader->totalBlocks = SWAP_BE32 (vcb->totalBlocks);+ volumeHeader->freeBlocks = SWAP_BE32 (vcb->freeBlocks + vcb->reclaimBlocks);+ volumeHeader->nextAllocation = SWAP_BE32 (vcb->nextAllocation);+ volumeHeader->rsrcClumpSize = SWAP_BE32 (vcb->vcbClpSiz);+ volumeHeader->dataClumpSize = SWAP_BE32 (vcb->vcbClpSiz);+ volumeHeader->nextCatalogID = SWAP_BE32 (vcb->vcbNxtCNID);+ volumeHeader->writeCount = SWAP_BE32 (vcb->vcbWrCnt);+ volumeHeader->encodingsBitmap = SWAP_BE64 (vcb->encodingsBitmap);++ if (bcmp(vcb->vcbFndrInfo, volumeHeader->finderInfo, sizeof(volumeHeader->finderInfo)) != 0) {+ bcopy(vcb->vcbFndrInfo, volumeHeader->finderInfo, sizeof(volumeHeader->finderInfo));+ critical = true;+ }++ if (!altflush && !ISSET(options, HFS_FVH_FLUSH_IF_DIRTY)) {+ goto done;+ }++ /* Sync Extents over-flow file meta data */+ fp = VTOF(vcb->extentsRefNum);+ if (FTOC(fp)->c_flag & C_MODIFIED) {+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ volumeHeader->extentsFile.extents[i].startBlock =+ SWAP_BE32 (fp->ff_extents[i].startBlock);+ volumeHeader->extentsFile.extents[i].blockCount =+ SWAP_BE32 (fp->ff_extents[i].blockCount);+ }+ volumeHeader->extentsFile.logicalSize = SWAP_BE64 (fp->ff_size);+ volumeHeader->extentsFile.totalBlocks = SWAP_BE32 (fp->ff_blocks);+ volumeHeader->extentsFile.clumpSize = SWAP_BE32 (fp->ff_clumpsize);+ FTOC(fp)->c_flag &= ~C_MODIFIED;+ altflush = true;+ }++ /* Sync Catalog file meta data */+ fp = VTOF(vcb->catalogRefNum);+ if (FTOC(fp)->c_flag & C_MODIFIED) {+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ volumeHeader->catalogFile.extents[i].startBlock =+ SWAP_BE32 (fp->ff_extents[i].startBlock);+ volumeHeader->catalogFile.extents[i].blockCount =+ SWAP_BE32 (fp->ff_extents[i].blockCount);+ }+ volumeHeader->catalogFile.logicalSize = SWAP_BE64 (fp->ff_size);+ volumeHeader->catalogFile.totalBlocks = SWAP_BE32 (fp->ff_blocks);+ volumeHeader->catalogFile.clumpSize = SWAP_BE32 (fp->ff_clumpsize);+ FTOC(fp)->c_flag &= ~C_MODIFIED;+ altflush = true;+ }++ /* Sync Allocation file meta data */+ fp = VTOF(vcb->allocationsRefNum);+ if (FTOC(fp)->c_flag & C_MODIFIED) {+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ volumeHeader->allocationFile.extents[i].startBlock =+ SWAP_BE32 (fp->ff_extents[i].startBlock);+ volumeHeader->allocationFile.extents[i].blockCount =+ SWAP_BE32 (fp->ff_extents[i].blockCount);+ }+ volumeHeader->allocationFile.logicalSize = SWAP_BE64 (fp->ff_size);+ volumeHeader->allocationFile.totalBlocks = SWAP_BE32 (fp->ff_blocks);+ volumeHeader->allocationFile.clumpSize = SWAP_BE32 (fp->ff_clumpsize);+ FTOC(fp)->c_flag &= ~C_MODIFIED;+ altflush = true;+ }++ /* Sync Attribute file meta data */+ if (hfsmp->hfs_attribute_vp) {+ fp = VTOF(hfsmp->hfs_attribute_vp);+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ volumeHeader->attributesFile.extents[i].startBlock =+ SWAP_BE32 (fp->ff_extents[i].startBlock);+ volumeHeader->attributesFile.extents[i].blockCount =+ SWAP_BE32 (fp->ff_extents[i].blockCount);+ }+ if (ISSET(FTOC(fp)->c_flag, C_MODIFIED)) {+ FTOC(fp)->c_flag &= ~C_MODIFIED;+ altflush = true;+ }+ volumeHeader->attributesFile.logicalSize = SWAP_BE64 (fp->ff_size);+ volumeHeader->attributesFile.totalBlocks = SWAP_BE32 (fp->ff_blocks);+ volumeHeader->attributesFile.clumpSize = SWAP_BE32 (fp->ff_clumpsize);+ }++ /* Sync Startup file meta data */+ if (hfsmp->hfs_startup_vp) {+ fp = VTOF(hfsmp->hfs_startup_vp);+ if (FTOC(fp)->c_flag & C_MODIFIED) {+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ volumeHeader->startupFile.extents[i].startBlock =+ SWAP_BE32 (fp->ff_extents[i].startBlock);+ volumeHeader->startupFile.extents[i].blockCount =+ SWAP_BE32 (fp->ff_extents[i].blockCount);+ }+ volumeHeader->startupFile.logicalSize = SWAP_BE64 (fp->ff_size);+ volumeHeader->startupFile.totalBlocks = SWAP_BE32 (fp->ff_blocks);+ volumeHeader->startupFile.clumpSize = SWAP_BE32 (fp->ff_clumpsize);+ FTOC(fp)->c_flag &= ~C_MODIFIED;+ altflush = true;+ }+ }++ if (altflush)+ critical = true;++done:+ MarkVCBClean(hfsmp);+ hfs_unlock_mount (hfsmp);++ /* If requested, flush out the alternate volume header */+ if (altflush) {+ /*+ * The two altVH offsets do not match --- which means that a smaller file+ * system exists in a larger partition. Verify that we have the correct+ * alternate volume header sector as per the current parititon size.+ * The GPT device that we are mounted on top could have changed sizes+ * without us knowning.+ *+ * We're in a transaction, so it's safe to modify the partition_avh_sector+ * field if necessary.+ */+ if (hfsmp->hfs_partition_avh_sector != hfsmp->hfs_fs_avh_sector) {+ uint64_t sector_count;++ /* Get underlying device block count */+ if ((retval = VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCGETBLOCKCOUNT,+ (caddr_t)§or_count, 0, vfs_context_current()))) {+ printf("hfs_flushVH: err %d getting block count (%s) \n", retval, vcb->vcbVN);+ retval = ENXIO;+ goto err_exit;+ }++ /* Partition size was changed without our knowledge */+ if (sector_count != (uint64_t)hfsmp->hfs_logical_block_count) {+ hfsmp->hfs_partition_avh_sector = (hfsmp->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) ++ HFS_ALT_SECTOR(hfsmp->hfs_logical_block_size, sector_count);+ /* Note: hfs_fs_avh_sector will remain unchanged */+ printf ("hfs_flushVH: altflush: partition size changed, partition_avh_sector=%qu, fs_avh_sector=%qu\n",+ hfsmp->hfs_partition_avh_sector, hfsmp->hfs_fs_avh_sector);+ }+ }++ /*+ * First see if we need to write I/O to the "secondary" AVH+ * located at FS Size - 1024 bytes, because this one will+ * always go into the journal. We put this AVH into the journal+ * because even if the filesystem size has shrunk, this LBA should be+ * reachable after the partition-size modification has occurred.+ * The one where we need to be careful is partitionsize-1024, since the+ * partition size should hopefully shrink.+ *+ * Most of the time this block will not execute.+ */+ if ((hfsmp->hfs_fs_avh_sector) &&+ (hfsmp->hfs_partition_avh_sector != hfsmp->hfs_fs_avh_sector)) {+ if (buf_meta_bread(hfsmp->hfs_devvp,+ HFS_PHYSBLK_ROUNDDOWN(hfsmp->hfs_fs_avh_sector, hfsmp->hfs_log_per_phys),+ hfsmp->hfs_physical_block_size, NOCRED, &alt_bp) == 0) {+ if (hfsmp->jnl) {+ journal_modify_block_start(hfsmp->jnl, alt_bp);+ }++ bcopy(volumeHeader, (char *)buf_dataptr(alt_bp) ++ HFS_ALT_OFFSET(hfsmp->hfs_physical_block_size),+ kMDBSize);++ if (hfsmp->jnl) {+ journal_modify_block_end(hfsmp->jnl, alt_bp, NULL, NULL);+ } else {+ (void) VNOP_BWRITE(alt_bp);+ }+ } else if (alt_bp) {+ buf_brelse(alt_bp);+ }+ }++ /*+ * Flush out alternate volume header located at 1024 bytes before+ * end of the partition as part of journal transaction. In+ * most cases, this will be the only alternate volume header+ * that we need to worry about because the file system size is+ * same as the partition size, therefore hfs_fs_avh_sector is+ * same as hfs_partition_avh_sector. This is the "priority" AVH.+ *+ * However, do not always put this I/O into the journal. If we skipped the+ * FS-Size AVH write above, then we will put this I/O into the journal as+ * that indicates the two were in sync. However, if the FS size is+ * not the same as the partition size, we are tracking two. We don't+ * put it in the journal in that case, since if the partition+ * size changes between uptimes, and we need to replay the journal,+ * this I/O could generate an EIO if during replay it is now trying+ * to access blocks beyond the device EOF.+ */+ if (hfsmp->hfs_partition_avh_sector) {+ if (buf_meta_bread(hfsmp->hfs_devvp,+ HFS_PHYSBLK_ROUNDDOWN(hfsmp->hfs_partition_avh_sector, hfsmp->hfs_log_per_phys),+ hfsmp->hfs_physical_block_size, NOCRED, &alt_bp) == 0) {++ /* only one AVH, put this I/O in the journal. */+ if ((hfsmp->jnl) && (hfsmp->hfs_partition_avh_sector == hfsmp->hfs_fs_avh_sector)) {+ journal_modify_block_start(hfsmp->jnl, alt_bp);+ }++ bcopy(volumeHeader, (char *)buf_dataptr(alt_bp) ++ HFS_ALT_OFFSET(hfsmp->hfs_physical_block_size),+ kMDBSize);++ /* If journaled and we only have one AVH to track */+ if ((hfsmp->jnl) && (hfsmp->hfs_partition_avh_sector == hfsmp->hfs_fs_avh_sector)) {+ journal_modify_block_end (hfsmp->jnl, alt_bp, NULL, NULL);+ } else {+ /*+ * If we don't have a journal or there are two AVH's at the+ * moment, then this one doesn't go in the journal. Note that+ * this one may generate I/O errors, since the partition+ * can be resized behind our backs at any moment and this I/O+ * may now appear to be beyond the device EOF.+ */+ (void) VNOP_BWRITE(alt_bp);+ hfs_flush(hfsmp, HFS_FLUSH_CACHE);+ }+ } else if (alt_bp) {+ buf_brelse(alt_bp);+ }+ }+ }++ /* Finish modifying the block for the primary VH */+ if (hfsmp->jnl) {+ journal_modify_block_end(hfsmp->jnl, bp, NULL, NULL);+ } else {+ if (!ISSET(options, HFS_FVH_WAIT)) {+ buf_bawrite(bp);+ } else {+ retval = VNOP_BWRITE(bp);+ /* When critical data changes, flush the device cache */+ if (critical && (retval == 0)) {+ hfs_flush(hfsmp, HFS_FLUSH_CACHE);+ }+ }+ }+ hfs_end_transaction(hfsmp);++ return (retval);++err_exit:+ if (alt_bp)+ buf_brelse(alt_bp);+ if (bp)+ buf_brelse(bp);+ hfs_end_transaction(hfsmp);+ return retval;+}+++/*+ * Creates a UUID from a unique "name" in the HFS UUID Name space.+ * See version 3 UUID.+ */+void+hfs_getvoluuid(struct hfsmount *hfsmp, uuid_t result_uuid)+{++ if (uuid_is_null(hfsmp->hfs_full_uuid)) {+ uuid_t result;++ MD5_CTX md5c;+ uint8_t rawUUID[8];++ ((uint32_t *)rawUUID)[0] = hfsmp->vcbFndrInfo[6];+ ((uint32_t *)rawUUID)[1] = hfsmp->vcbFndrInfo[7];++ MD5Init( &md5c );+ MD5Update( &md5c, HFS_UUID_NAMESPACE_ID, sizeof( uuid_t ) );+ MD5Update( &md5c, rawUUID, sizeof (rawUUID) );+ MD5Final( result, &md5c );++ result[6] = 0x30 | ( result[6] & 0x0F );+ result[8] = 0x80 | ( result[8] & 0x3F );++ uuid_copy(hfsmp->hfs_full_uuid, result);+ }+ uuid_copy (result_uuid, hfsmp->hfs_full_uuid);++}++/*+ * Get file system attributes.+ */+static int+hfs_vfs_getattr(struct mount *mp, struct vfs_attr *fsap, __unused vfs_context_t context)+{+#define HFS_ATTR_FILE_VALIDMASK (ATTR_FILE_VALIDMASK & ~(ATTR_FILE_FILETYPE | ATTR_FILE_FORKCOUNT | ATTR_FILE_FORKLIST | ATTR_FILE_CLUMPSIZE))+#define HFS_ATTR_CMN_VOL_VALIDMASK (ATTR_CMN_VALIDMASK & ~(ATTR_CMN_DATA_PROTECT_FLAGS))+#define HFS_ATTR_VOL_VALIDMASK ATTR_VOL_FSTYPE | \+ ATTR_VOL_SIGNATURE | \+ ATTR_VOL_SIZE | \+ ATTR_VOL_SPACEFREE | \+ ATTR_VOL_SPACEAVAIL | \+ ATTR_VOL_MINALLOCATION | \+ ATTR_VOL_ALLOCATIONCLUMP | \+ ATTR_VOL_IOBLOCKSIZE | \+ ATTR_VOL_OBJCOUNT | \+ ATTR_VOL_FILECOUNT | \+ ATTR_VOL_DIRCOUNT | \+ ATTR_VOL_MAXOBJCOUNT | \+ ATTR_VOL_MOUNTPOINT | \+ ATTR_VOL_NAME | \+ ATTR_VOL_MOUNTFLAGS | \+ ATTR_VOL_MOUNTEDDEVICE | \+ ATTR_VOL_ENCODINGSUSED | \+ ATTR_VOL_CAPABILITIES | \+ ATTR_VOL_UUID | \+ ATTR_VOL_ATTRIBUTES+++ ExtendedVCB *vcb = VFSTOVCB(mp);+ struct hfsmount *hfsmp = VFSTOHFS(mp);++ int searchfs_on = 0;+ int exchangedata_on = 1;++#if CONFIG_SEARCHFS+ searchfs_on = 1;+#endif++#if CONFIG_PROTECT+ if (cp_fs_protected(mp)) {+ exchangedata_on = 0;+ }+#endif++ /*+ * Some of these attributes can be expensive to query if we're+ * backed by a disk image; hfs_freeblks() has to ask the backing+ * store, and this might involve a trip to a network file server.+ * Only ask for them if the caller really wants them. Preserve old+ * behavior for file systems not backed by a disk image.+ */+#if HFS_SPARSE_DEV+ const int diskimage = (hfsmp->hfs_backingvp != NULL);+#else+ const int diskimage = 0;+#endif++ VFSATTR_RETURN(fsap, f_objcount, (u_int64_t)hfsmp->vcbFilCnt + (u_int64_t)hfsmp->vcbDirCnt);+ VFSATTR_RETURN(fsap, f_filecount, (u_int64_t)hfsmp->vcbFilCnt);+ VFSATTR_RETURN(fsap, f_dircount, (u_int64_t)hfsmp->vcbDirCnt);+ VFSATTR_RETURN(fsap, f_maxobjcount, (u_int64_t)0xFFFFFFFF);+ VFSATTR_RETURN(fsap, f_iosize, (size_t)cluster_max_io_size(mp, 0));+ VFSATTR_RETURN(fsap, f_blocks, (u_int64_t)hfsmp->totalBlocks);+ if (VFSATTR_WANTED(fsap, f_bfree) || !diskimage) {+ VFSATTR_RETURN(fsap, f_bfree, (u_int64_t)hfs_freeblks(hfsmp, 0));+ }+ if (VFSATTR_WANTED(fsap, f_bavail) || !diskimage) {+ VFSATTR_RETURN(fsap, f_bavail, (u_int64_t)hfs_freeblks(hfsmp, 1));+ }+ VFSATTR_RETURN(fsap, f_bsize, (u_int32_t)vcb->blockSize);+ /* XXX needs clarification */+ if (VFSATTR_WANTED(fsap, f_bused) || !diskimage) {+ VFSATTR_RETURN(fsap, f_bused, hfsmp->totalBlocks - hfs_freeblks(hfsmp, 1));+ }+ VFSATTR_RETURN(fsap, f_files, (u_int64_t)HFS_MAX_FILES);+ VFSATTR_RETURN(fsap, f_ffree, (u_int64_t)hfs_free_cnids(hfsmp));++ fsap->f_fsid.val[0] = hfsmp->hfs_raw_dev;+ fsap->f_fsid.val[1] = vfs_typenum(mp);+ VFSATTR_SET_SUPPORTED(fsap, f_fsid);++ VFSATTR_RETURN(fsap, f_signature, vcb->vcbSigWord);+ VFSATTR_RETURN(fsap, f_carbon_fsid, 0);++ if (VFSATTR_IS_ACTIVE(fsap, f_capabilities)) {+ vol_capabilities_attr_t *cap;++ cap = &fsap->f_capabilities;++ if ((hfsmp->hfs_flags & HFS_STANDARD) == 0) {+ /* HFS+ & variants */+ cap->capabilities[VOL_CAPABILITIES_FORMAT] =+ VOL_CAP_FMT_PERSISTENTOBJECTIDS |+ VOL_CAP_FMT_SYMBOLICLINKS |+ VOL_CAP_FMT_HARDLINKS |+ VOL_CAP_FMT_JOURNAL |+ VOL_CAP_FMT_ZERO_RUNS |+ (hfsmp->jnl ? VOL_CAP_FMT_JOURNAL_ACTIVE : 0) |+ (hfsmp->hfs_flags & HFS_CASE_SENSITIVE ? VOL_CAP_FMT_CASE_SENSITIVE : 0) |+ VOL_CAP_FMT_CASE_PRESERVING |+ VOL_CAP_FMT_FAST_STATFS |+ VOL_CAP_FMT_2TB_FILESIZE |+ VOL_CAP_FMT_HIDDEN_FILES |+#if HFS_COMPRESSION+ VOL_CAP_FMT_DECMPFS_COMPRESSION |+#endif+#if CONFIG_HFS_DIRLINK+ VOL_CAP_FMT_DIR_HARDLINKS |+#endif+#ifdef VOL_CAP_FMT_DOCUMENT_ID+ VOL_CAP_FMT_DOCUMENT_ID |+#endif /* VOL_CAP_FMT_DOCUMENT_ID */+#ifdef VOL_CAP_FMT_WRITE_GENERATION_COUNT+ VOL_CAP_FMT_WRITE_GENERATION_COUNT |+#endif /* VOL_CAP_FMT_WRITE_GENERATION_COUNT */+ VOL_CAP_FMT_PATH_FROM_ID;+ }++ /*+ * The capabilities word in 'cap' tell you whether or not+ * this particular filesystem instance has feature X enabled.+ */++ cap->capabilities[VOL_CAPABILITIES_INTERFACES] =+ VOL_CAP_INT_ATTRLIST |+ VOL_CAP_INT_NFSEXPORT |+ VOL_CAP_INT_READDIRATTR |+ VOL_CAP_INT_ALLOCATE |+ VOL_CAP_INT_VOL_RENAME |+ VOL_CAP_INT_ADVLOCK |+ VOL_CAP_INT_FLOCK |+#if VOL_CAP_INT_RENAME_EXCL+ VOL_CAP_INT_RENAME_EXCL |+#endif+#if NAMEDSTREAMS+ VOL_CAP_INT_EXTENDED_ATTR |+ VOL_CAP_INT_NAMEDSTREAMS;+#else+ VOL_CAP_INT_EXTENDED_ATTR;+#endif++ /* HFS may conditionally support searchfs and exchangedata depending on the runtime */++ if (searchfs_on) {+ cap->capabilities[VOL_CAPABILITIES_INTERFACES] |= VOL_CAP_INT_SEARCHFS;+ }+ if (exchangedata_on) {+ cap->capabilities[VOL_CAPABILITIES_INTERFACES] |= VOL_CAP_INT_EXCHANGEDATA;+ }++ cap->capabilities[VOL_CAPABILITIES_RESERVED1] = 0;+ cap->capabilities[VOL_CAPABILITIES_RESERVED2] = 0;++ cap->valid[VOL_CAPABILITIES_FORMAT] =+ VOL_CAP_FMT_PERSISTENTOBJECTIDS |+ VOL_CAP_FMT_SYMBOLICLINKS |+ VOL_CAP_FMT_HARDLINKS |+ VOL_CAP_FMT_JOURNAL |+ VOL_CAP_FMT_JOURNAL_ACTIVE |+ VOL_CAP_FMT_NO_ROOT_TIMES |+ VOL_CAP_FMT_SPARSE_FILES |+ VOL_CAP_FMT_ZERO_RUNS |+ VOL_CAP_FMT_CASE_SENSITIVE |+ VOL_CAP_FMT_CASE_PRESERVING |+ VOL_CAP_FMT_FAST_STATFS |+ VOL_CAP_FMT_2TB_FILESIZE |+ VOL_CAP_FMT_OPENDENYMODES |+ VOL_CAP_FMT_HIDDEN_FILES |+ VOL_CAP_FMT_PATH_FROM_ID |+ VOL_CAP_FMT_DECMPFS_COMPRESSION |+#ifdef VOL_CAP_FMT_DOCUMENT_ID+ VOL_CAP_FMT_DOCUMENT_ID |+#endif /* VOL_CAP_FMT_DOCUMENT_ID */+#ifdef VOL_CAP_FMT_WRITE_GENERATION_COUNT+ VOL_CAP_FMT_WRITE_GENERATION_COUNT |+#endif /* VOL_CAP_FMT_WRITE_GENERATION_COUNT */+ VOL_CAP_FMT_DIR_HARDLINKS;++ /*+ * Bits in the "valid" field tell you whether or not the on-disk+ * format supports feature X.+ */++ cap->valid[VOL_CAPABILITIES_INTERFACES] =+ VOL_CAP_INT_ATTRLIST |+ VOL_CAP_INT_NFSEXPORT |+ VOL_CAP_INT_READDIRATTR |+ VOL_CAP_INT_COPYFILE |+ VOL_CAP_INT_ALLOCATE |+ VOL_CAP_INT_VOL_RENAME |+ VOL_CAP_INT_ADVLOCK |+ VOL_CAP_INT_FLOCK |+ VOL_CAP_INT_MANLOCK |+#if VOL_CAP_INT_RENAME_EXCL+ VOL_CAP_INT_RENAME_EXCL |+#endif++#if NAMEDSTREAMS+ VOL_CAP_INT_EXTENDED_ATTR |+ VOL_CAP_INT_NAMEDSTREAMS;+#else+ VOL_CAP_INT_EXTENDED_ATTR;+#endif++ /* HFS always supports exchangedata and searchfs in the on-disk format natively */+ cap->valid[VOL_CAPABILITIES_INTERFACES] |= (VOL_CAP_INT_SEARCHFS | VOL_CAP_INT_EXCHANGEDATA);+++ cap->valid[VOL_CAPABILITIES_RESERVED1] = 0;+ cap->valid[VOL_CAPABILITIES_RESERVED2] = 0;+ VFSATTR_SET_SUPPORTED(fsap, f_capabilities);+ }+ if (VFSATTR_IS_ACTIVE(fsap, f_attributes)) {+ vol_attributes_attr_t *attrp = &fsap->f_attributes;++ attrp->validattr.commonattr = HFS_ATTR_CMN_VOL_VALIDMASK;+#if CONFIG_PROTECT+ attrp->validattr.commonattr |= ATTR_CMN_DATA_PROTECT_FLAGS;+#endif // CONFIG_PROTECT++ attrp->validattr.volattr = HFS_ATTR_VOL_VALIDMASK;+ attrp->validattr.dirattr = ATTR_DIR_VALIDMASK;+ attrp->validattr.fileattr = HFS_ATTR_FILE_VALIDMASK;+ attrp->validattr.forkattr = 0;++ attrp->nativeattr.commonattr = HFS_ATTR_CMN_VOL_VALIDMASK;+#if CONFIG_PROTECT+ attrp->nativeattr.commonattr |= ATTR_CMN_DATA_PROTECT_FLAGS;+#endif // CONFIG_PROTECT++ attrp->nativeattr.volattr = HFS_ATTR_VOL_VALIDMASK;+ attrp->nativeattr.dirattr = ATTR_DIR_VALIDMASK;+ attrp->nativeattr.fileattr = HFS_ATTR_FILE_VALIDMASK;+ attrp->nativeattr.forkattr = 0;+ VFSATTR_SET_SUPPORTED(fsap, f_attributes);+ }+ fsap->f_create_time.tv_sec = hfsmp->hfs_itime;+ fsap->f_create_time.tv_nsec = 0;+ VFSATTR_SET_SUPPORTED(fsap, f_create_time);+ fsap->f_modify_time.tv_sec = hfsmp->vcbLsMod;+ fsap->f_modify_time.tv_nsec = 0;+ VFSATTR_SET_SUPPORTED(fsap, f_modify_time);+ // We really don't have volume access time, they should check the root node, fake it up+ if (VFSATTR_IS_ACTIVE(fsap, f_access_time)) {+ struct timeval tv;++ microtime(&tv);+ fsap->f_access_time.tv_sec = tv.tv_sec;+ fsap->f_access_time.tv_nsec = 0;+ VFSATTR_SET_SUPPORTED(fsap, f_access_time);+ }++ fsap->f_backup_time.tv_sec = hfsmp->vcbVolBkUp;+ fsap->f_backup_time.tv_nsec = 0;+ VFSATTR_SET_SUPPORTED(fsap, f_backup_time);++ if (VFSATTR_IS_ACTIVE(fsap, f_fssubtype)) {+ u_int16_t subtype = 0;++ /*+ * Subtypes (flavors) for HFS+ * 0: Mac OS Extended+ * 1: Mac OS Extended (Journaled)+ * 2: Mac OS Extended (Case Sensitive)+ * 3: Mac OS Extended (Case Sensitive, Journaled)+ * 4 - 127: Reserved+ * 128: Mac OS Standard+ *+ */+ if ((hfsmp->hfs_flags & HFS_STANDARD) == 0) {+ if (hfsmp->jnl) {+ subtype |= HFS_SUBTYPE_JOURNALED;+ }+ if (hfsmp->hfs_flags & HFS_CASE_SENSITIVE) {+ subtype |= HFS_SUBTYPE_CASESENSITIVE;+ }+ }+ fsap->f_fssubtype = subtype;+ VFSATTR_SET_SUPPORTED(fsap, f_fssubtype);+ }++ if (VFSATTR_IS_ACTIVE(fsap, f_vol_name)) {+ strlcpy(fsap->f_vol_name, (char *) hfsmp->vcbVN, MAXPATHLEN);+ VFSATTR_SET_SUPPORTED(fsap, f_vol_name);+ }+ if (VFSATTR_IS_ACTIVE(fsap, f_uuid)) {+ hfs_getvoluuid(hfsmp, fsap->f_uuid);+ VFSATTR_SET_SUPPORTED(fsap, f_uuid);+ }+ return (0);+}++/*+ * Perform a volume rename. Requires the FS' root vp.+ */+static int+hfs_rename_volume(struct vnode *vp, const char *name, proc_t p)+{+ ExtendedVCB *vcb = VTOVCB(vp);+ struct cnode *cp = VTOC(vp);+ struct hfsmount *hfsmp = VTOHFS(vp);+ struct cat_desc to_desc;+ struct cat_desc todir_desc;+ struct cat_desc new_desc;+ cat_cookie_t cookie;+ int lockflags;+ int error = 0;+ char converted_volname[256];+ size_t volname_length = 0;+ size_t conv_volname_length = 0;+++ /*+ * Ignore attempts to rename a volume to a zero-length name.+ */+ if (name[0] == 0)+ return(0);++ bzero(&to_desc, sizeof(to_desc));+ bzero(&todir_desc, sizeof(todir_desc));+ bzero(&new_desc, sizeof(new_desc));+ bzero(&cookie, sizeof(cookie));++ todir_desc.cd_parentcnid = kHFSRootParentID;+ todir_desc.cd_cnid = kHFSRootFolderID;+ todir_desc.cd_flags = CD_ISDIR;++ to_desc.cd_nameptr = (const u_int8_t *)name;+ to_desc.cd_namelen = strlen(name);+ to_desc.cd_parentcnid = kHFSRootParentID;+ to_desc.cd_cnid = cp->c_cnid;+ to_desc.cd_flags = CD_ISDIR;++ if ((error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT)) == 0) {+ if ((error = hfs_start_transaction(hfsmp)) == 0) {+ if ((error = cat_preflight(hfsmp, CAT_RENAME, &cookie, p)) == 0) {+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);++ error = cat_rename(hfsmp, &cp->c_desc, &todir_desc, &to_desc, &new_desc);++ /*+ * If successful, update the name in the VCB, ensure it's terminated.+ */+ if (error == 0) {+ strlcpy((char *)vcb->vcbVN, name, sizeof(vcb->vcbVN));++ volname_length = strlen ((const char*)vcb->vcbVN);+ /* Send the volume name down to CoreStorage if necessary */+ error = utf8_normalizestr(vcb->vcbVN, volname_length, (u_int8_t*)converted_volname, &conv_volname_length, 256, UTF_PRECOMPOSED);+ if (error == 0) {+ (void) VNOP_IOCTL (hfsmp->hfs_devvp, _DKIOCCSSETLVNAME, converted_volname, 0, vfs_context_current());+ }+ error = 0;+ }++ hfs_systemfile_unlock(hfsmp, lockflags);+ cat_postflight(hfsmp, &cookie, p);++ if (error)+ MarkVCBDirty(vcb);+ (void) hfs_flushvolumeheader(hfsmp, HFS_FVH_WAIT);+ }+ hfs_end_transaction(hfsmp);+ }+ if (!error) {+ /* Release old allocated name buffer */+ if (cp->c_desc.cd_flags & CD_HASBUF) {+ const char *tmp_name = (const char *)cp->c_desc.cd_nameptr;++ cp->c_desc.cd_nameptr = 0;+ cp->c_desc.cd_namelen = 0;+ cp->c_desc.cd_flags &= ~CD_HASBUF;+ vfs_removename(tmp_name);+ }+ /* Update cnode's catalog descriptor */+ replace_desc(cp, &new_desc);+ vcb->volumeNameEncodingHint = new_desc.cd_encoding;+ cp->c_touch_chgtime = TRUE;+ }++ hfs_unlock(cp);+ }++ return(error);+}++/*+ * Get file system attributes.+ */+static int+hfs_vfs_setattr(struct mount *mp, struct vfs_attr *fsap, vfs_context_t context)+{+ kauth_cred_t cred = vfs_context_ucred(context);+ int error = 0;++ /*+ * Must be superuser or owner of filesystem to change volume attributes+ */+ if (!kauth_cred_issuser(cred) && (kauth_cred_getuid(cred) != vfs_statfs(mp)->f_owner))+ return(EACCES);++ if (VFSATTR_IS_ACTIVE(fsap, f_vol_name)) {+ vnode_t root_vp;++ error = hfs_vfs_root(mp, &root_vp, context);+ if (error)+ goto out;++ error = hfs_rename_volume(root_vp, fsap->f_vol_name, vfs_context_proc(context));+ (void) vnode_put(root_vp);+ if (error)+ goto out;++ VFSATTR_SET_SUPPORTED(fsap, f_vol_name);+ }++out:+ return error;+}++/* If a runtime corruption is detected, set the volume inconsistent+ * bit in the volume attributes. The volume inconsistent bit is a persistent+ * bit which represents that the volume is corrupt and needs repair.+ * The volume inconsistent bit can be set from the kernel when it detects+ * runtime corruption or from file system repair utilities like fsck_hfs when+ * a repair operation fails. The bit should be cleared only from file system+ * verify/repair utility like fsck_hfs when a verify/repair succeeds.+ */+void hfs_mark_inconsistent(struct hfsmount *hfsmp,+ hfs_inconsistency_reason_t reason)+{+ hfs_lock_mount (hfsmp);+ if ((hfsmp->vcbAtrb & kHFSVolumeInconsistentMask) == 0) {+ hfsmp->vcbAtrb |= kHFSVolumeInconsistentMask;+ MarkVCBDirty(hfsmp);+ }+ if ((hfsmp->hfs_flags & HFS_READ_ONLY)==0) {+ switch (reason) {+ case HFS_INCONSISTENCY_DETECTED:+ printf("hfs_mark_inconsistent: Runtime corruption detected on %s, fsck will be forced on next mount.\n",+ hfsmp->vcbVN);+ break;+ case HFS_ROLLBACK_FAILED:+ printf("hfs_mark_inconsistent: Failed to roll back; volume `%s' might be inconsistent; fsck will be forced on next mount.\n",+ hfsmp->vcbVN);+ break;+ case HFS_OP_INCOMPLETE:+ printf("hfs_mark_inconsistent: Failed to complete operation; volume `%s' might be inconsistent; fsck will be forced on next mount.\n",+ hfsmp->vcbVN);+ break;+ case HFS_FSCK_FORCED:+ printf("hfs_mark_inconsistent: fsck requested for `%s'; fsck will be forced on next mount.\n",+ hfsmp->vcbVN);+ break;+ }+ }+ hfs_unlock_mount (hfsmp);+}++/* Replay the journal on the device node provided. Returns zero if+ * journal replay succeeded or no journal was supposed to be replayed.+ */+static int hfs_journal_replay(vnode_t devvp, vfs_context_t context)+{+ int retval = 0;+ int error = 0;++ /* Replay allowed only on raw devices */+ if (!vnode_ischr(devvp) && !vnode_isblk(devvp))+ return EINVAL;++ retval = hfs_mountfs(devvp, NULL, NULL, /* journal_replay_only: */ 1, context);+ buf_flushdirtyblks(devvp, TRUE, 0, "hfs_journal_replay");++ /* FSYNC the devnode to be sure all data has been flushed */+ error = VNOP_FSYNC(devvp, MNT_WAIT, context);+ if (error) {+ retval = error;+ }++ return retval;+}+++/*+ * Cancel the syncer+ */+static void+hfs_syncer_free(struct hfsmount *hfsmp)+{+ if (hfsmp && ISSET(hfsmp->hfs_flags, HFS_RUN_SYNCER)) {+ hfs_syncer_lock(hfsmp);+ CLR(hfsmp->hfs_flags, HFS_RUN_SYNCER);+ hfs_syncer_unlock(hfsmp);++ // Wait for the syncer thread to finish+ if (hfsmp->hfs_syncer_thread) {+ hfs_syncer_wakeup(hfsmp);+ hfs_syncer_lock(hfsmp);+ while (hfsmp->hfs_syncer_thread)+ hfs_syncer_wait(hfsmp, NULL);+ hfs_syncer_unlock(hfsmp);+ }+ }+}++static int hfs_vfs_ioctl(struct mount *mp, u_long command, caddr_t data,+ __unused int flags, __unused vfs_context_t context)+{+ switch (command) {+#if CONFIG_PROTECT+ case FIODEVICELOCKED:+ cp_device_locked_callback(mp, (cp_lock_state_t)data);+ return 0;+#endif+ }+ return ENOTTY;+}++/*+ * hfs vfs operations.+ */+const struct vfsops hfs_vfsops = {+ .vfs_mount = hfs_mount,+ .vfs_start = hfs_start,+ .vfs_unmount = hfs_unmount,+ .vfs_root = hfs_vfs_root,+ .vfs_quotactl = hfs_quotactl,+ .vfs_getattr = hfs_vfs_getattr,+ .vfs_sync = hfs_sync,+ .vfs_vget = hfs_vfs_vget,+ .vfs_fhtovp = hfs_fhtovp,+ .vfs_vptofh = hfs_vptofh,+ .vfs_init = hfs_init,+ .vfs_sysctl = hfs_sysctl,+ .vfs_setattr = hfs_vfs_setattr,+ .vfs_ioctl = hfs_vfs_ioctl,+};diff --git a/xnu/files/bsd/hfs/hfs_vfsutils.c b/xnu/files/bsd/hfs/hfs_vfsutils.cnew file mode 100644index 0000000..5734b67--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_vfsutils.c@@ -0,0 +1,3917 @@+/*+ * Copyright (c) 2000-2015 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@+ */+/* @(#)hfs_vfsutils.c 4.0+*+* (c) 1997-2002 Apple Inc. All Rights Reserved+*+* hfs_vfsutils.c -- Routines that go between the HFS layer and the VFS.+*+*/+#include <sys/param.h>+#include <sys/systm.h>+#include <sys/kernel.h>+#include <sys/malloc.h>+#include <sys/stat.h>+#include <sys/mount.h>+#include <sys/vm.h>+#include <sys/buf.h>+#include <sys/ubc.h>+#include <sys/unistd.h>+#include <sys/utfconv.h>+#include <sys/kauth.h>+#include <sys/fcntl.h>+#include <sys/fsctl.h>+#include <sys/mount.h>+#include <sys/sysctl.h>+#include <kern/clock.h>+#include <stdbool.h>+#include <miscfs/specfs/specdev.h>+#include <libkern/OSAtomic.h>+#include <IOKit/IOLib.h>++/* for parsing boot-args */+#include <pexpert/pexpert.h>+#include <kern/kalloc.h>+#include <kern/zalloc.h>++#include "hfs_iokit.h"+#include "hfs.h"+#include "hfs_catalog.h"+#include "hfs_dbg.h"+#include "hfs_mount.h"+#include "hfs_endian.h"+#include "hfs_cnode.h"+#include "hfs_fsctl.h"+#include "hfs_cprotect.h"++#include "FileMgrInternal.h"+#include "BTreesInternal.h"+#include "HFSUnicodeWrappers.h"++/* Enable/disable debugging code for live volume resizing, defined in hfs_resize.c */+extern int hfs_resize_debug;++static void ReleaseMetaFileVNode(struct vnode *vp);+static int hfs_late_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, void *_args);++static u_int32_t hfs_hotfile_freeblocks(struct hfsmount *);+static void hfs_thaw_locked(struct hfsmount *hfsmp);++#define HFS_MOUNT_DEBUG 1+++//*******************************************************************************+// Note: Finder information in the HFS/HFS+ metadata are considered opaque and+// hence are not in the right byte order on little endian machines. It is+// the responsibility of the finder and other clients to swap the data.+//*******************************************************************************++//*******************************************************************************+// Routine: hfs_MountHFSVolume+//+//+//*******************************************************************************+unsigned char hfs_catname[] = "Catalog B-tree";+unsigned char hfs_extname[] = "Extents B-tree";+unsigned char hfs_vbmname[] = "Volume Bitmap";+unsigned char hfs_attrname[] = "Attribute B-tree";+unsigned char hfs_startupname[] = "Startup File";+++//*******************************************************************************+//+// Sanity check Volume Header Block:+// Input argument *vhp is a pointer to a HFSPlusVolumeHeader block that has+// not been endian-swapped and represents the on-disk contents of this sector.+// This routine will not change the endianness of vhp block.+//+//*******************************************************************************+OSErr hfs_ValidateHFSPlusVolumeHeader(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp)+{+ u_int16_t signature;+ u_int16_t hfs_version;+ u_int32_t blockSize;++ signature = SWAP_BE16(vhp->signature);+ hfs_version = SWAP_BE16(vhp->version);++ if (signature == kHFSPlusSigWord) {+ if (hfs_version != kHFSPlusVersion) {+ printf("hfs_ValidateHFSPlusVolumeHeader: invalid HFS+ version: %x\n", hfs_version);+ return (EINVAL);+ }+ } else if (signature == kHFSXSigWord) {+ if (hfs_version != kHFSXVersion) {+ printf("hfs_ValidateHFSPlusVolumeHeader: invalid HFSX version: %x\n", hfs_version);+ return (EINVAL);+ }+ } else {+ /* Removed printf for invalid HFS+ signature because it gives+ * false error for UFS root volume+ */+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_ValidateHFSPlusVolumeHeader: unknown Volume Signature : %x\n", signature);+ }+ return (EINVAL);+ }++ /* Block size must be at least 512 and a power of 2 */+ blockSize = SWAP_BE32(vhp->blockSize);+ if (blockSize < 512 || !powerof2(blockSize)) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_ValidateHFSPlusVolumeHeader: invalid blocksize (%d) \n", blockSize);+ }+ return (EINVAL);+ }++ if (blockSize < hfsmp->hfs_logical_block_size) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_ValidateHFSPlusVolumeHeader: invalid physical blocksize (%d), hfs_logical_blocksize (%d) \n",+ blockSize, hfsmp->hfs_logical_block_size);+ }+ return (EINVAL);+ }+ return 0;+}++//*******************************************************************************+// Routine: hfs_MountHFSPlusVolume+//+//+//*******************************************************************************++OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,+ off_t embeddedOffset, u_int64_t disksize, __unused struct proc *p, void *args, kauth_cred_t cred)+{+ register ExtendedVCB *vcb;+ struct cat_desc cndesc;+ struct cat_attr cnattr;+ struct cat_fork cfork;+ u_int32_t blockSize;+ daddr64_t spare_sectors;+ struct BTreeInfoRec btinfo;+ u_int16_t signature;+ u_int16_t hfs_version;+ int newvnode_flags = 0;+ int i;+ OSErr retval;+ char converted_volname[256];+ size_t volname_length = 0;+ size_t conv_volname_length = 0;+ bool async_bitmap_scan;++ signature = SWAP_BE16(vhp->signature);+ hfs_version = SWAP_BE16(vhp->version);++ retval = hfs_ValidateHFSPlusVolumeHeader(hfsmp, vhp);+ if (retval)+ return retval;++ if (signature == kHFSXSigWord) {+ /* The in-memory signature is always 'H+'. */+ signature = kHFSPlusSigWord;+ hfsmp->hfs_flags |= HFS_X;+ }++ blockSize = SWAP_BE32(vhp->blockSize);+ /* don't mount a writable volume if its dirty, it must be cleaned by fsck_hfs */+ if ((hfsmp->hfs_flags & HFS_READ_ONLY) == 0 && hfsmp->jnl == NULL &&+ (SWAP_BE32(vhp->attributes) & kHFSVolumeUnmountedMask) == 0) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mounthfsplus: cannot mount dirty non-journaled volumes\n");+ }+ return (EINVAL);+ }++ /* Make sure we can live with the physical block size. */+ if ((disksize & (hfsmp->hfs_logical_block_size - 1)) ||+ (embeddedOffset & (hfsmp->hfs_logical_block_size - 1))) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mounthfsplus: hfs_logical_blocksize (%d) \n",+ hfsmp->hfs_logical_block_size);+ }+ return (ENXIO);+ }++ /*+ * If allocation block size is less than the physical block size,+ * same data could be cached in two places and leads to corruption.+ *+ * HFS Plus reserves one allocation block for the Volume Header.+ * If the physical size is larger, then when we read the volume header,+ * we will also end up reading in the next allocation block(s).+ * If those other allocation block(s) is/are modified, and then the volume+ * header is modified, the write of the volume header's buffer will write+ * out the old contents of the other allocation blocks.+ *+ * We assume that the physical block size is same as logical block size.+ * The physical block size value is used to round down the offsets for+ * reading and writing the primary and alternate volume headers.+ *+ * The same logic to ensure good hfs_physical_block_size is also in+ * hfs_mountfs so that hfs_mountfs, hfs_MountHFSPlusVolume and+ * later are doing the I/Os using same block size.+ */+ if (blockSize < hfsmp->hfs_physical_block_size) {+ hfsmp->hfs_physical_block_size = hfsmp->hfs_logical_block_size;+ hfsmp->hfs_log_per_phys = 1;+ }++ /*+ * The VolumeHeader seems OK: transfer info from it into VCB+ * Note - the VCB starts out clear (all zeros)+ */+ vcb = HFSTOVCB(hfsmp);++ vcb->vcbSigWord = signature;+ vcb->vcbJinfoBlock = SWAP_BE32(vhp->journalInfoBlock);+ vcb->vcbLsMod = to_bsd_time(SWAP_BE32(vhp->modifyDate));+ vcb->vcbAtrb = SWAP_BE32(vhp->attributes);+ vcb->vcbClpSiz = SWAP_BE32(vhp->rsrcClumpSize);+ vcb->vcbNxtCNID = SWAP_BE32(vhp->nextCatalogID);+ vcb->vcbVolBkUp = to_bsd_time(SWAP_BE32(vhp->backupDate));+ vcb->vcbWrCnt = SWAP_BE32(vhp->writeCount);+ vcb->vcbFilCnt = SWAP_BE32(vhp->fileCount);+ vcb->vcbDirCnt = SWAP_BE32(vhp->folderCount);++ /* copy 32 bytes of Finder info */+ bcopy(vhp->finderInfo, vcb->vcbFndrInfo, sizeof(vhp->finderInfo));++ vcb->vcbAlBlSt = 0; /* hfs+ allocation blocks start at first block of volume */+ if ((hfsmp->hfs_flags & HFS_READ_ONLY) == 0)+ vcb->vcbWrCnt++; /* compensate for write of Volume Header on last flush */++ /* Now fill in the Extended VCB info */+ vcb->nextAllocation = SWAP_BE32(vhp->nextAllocation);+ vcb->totalBlocks = SWAP_BE32(vhp->totalBlocks);+ vcb->allocLimit = vcb->totalBlocks;+ vcb->freeBlocks = SWAP_BE32(vhp->freeBlocks);+ vcb->blockSize = blockSize;+ vcb->encodingsBitmap = SWAP_BE64(vhp->encodingsBitmap);+ vcb->localCreateDate = SWAP_BE32(vhp->createDate);++ vcb->hfsPlusIOPosOffset = embeddedOffset;++ /* Default to no free block reserve */+ vcb->reserveBlocks = 0;++ /*+ * Update the logical block size in the mount struct+ * (currently set up from the wrapper MDB) using the+ * new blocksize value:+ */+ hfsmp->hfs_logBlockSize = BestBlockSizeFit(vcb->blockSize, MAXBSIZE, hfsmp->hfs_logical_block_size);+ vcb->vcbVBMIOSize = min(vcb->blockSize, MAXPHYSIO);++ /*+ * Validate and initialize the location of the alternate volume header.+ *+ * Note that there may be spare sectors beyond the end of the filesystem that still+ * belong to our partition.+ */++ spare_sectors = hfsmp->hfs_logical_block_count -+ (((daddr64_t)vcb->totalBlocks * blockSize) /+ hfsmp->hfs_logical_block_size);++ /*+ * Differentiate between "innocuous" spare sectors and the more unusual+ * degenerate case:+ *+ * *** Innocuous spare sectors exist if:+ *+ * A) the number of bytes assigned to the partition (by multiplying logical+ * block size * logical block count) is greater than the filesystem size+ * (by multiplying allocation block count and allocation block size)+ *+ * and+ *+ * B) the remainder is less than the size of a full allocation block's worth of bytes.+ *+ * This handles the normal case where there may be a few extra sectors, but the two+ * are fundamentally in sync.+ *+ * *** Degenerate spare sectors exist if:+ * A) The number of bytes assigned to the partition (by multiplying logical+ * block size * logical block count) is greater than the filesystem size+ * (by multiplying allocation block count and block size).+ *+ * and+ *+ * B) the remainder is greater than a full allocation's block worth of bytes.+ * In this case, a smaller file system exists in a larger partition.+ * This can happen in various ways, including when volume is resized but the+ * partition is yet to be resized. Under this condition, we have to assume that+ * a partition management software may resize the partition to match+ * the file system size in the future. Therefore we should update+ * alternate volume header at two locations on the disk,+ * a. 1024 bytes before end of the partition+ * b. 1024 bytes before end of the file system+ */++ if (spare_sectors > (daddr64_t)(blockSize / hfsmp->hfs_logical_block_size)) {+ /*+ * Handle the degenerate case above. FS < partition size.+ * AVH located at 1024 bytes from the end of the partition+ */+ hfsmp->hfs_partition_avh_sector = (hfsmp->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) ++ HFS_ALT_SECTOR(hfsmp->hfs_logical_block_size, hfsmp->hfs_logical_block_count);++ /* AVH located at 1024 bytes from the end of the filesystem */+ hfsmp->hfs_fs_avh_sector = (hfsmp->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) ++ HFS_ALT_SECTOR(hfsmp->hfs_logical_block_size,+ (((daddr64_t)vcb->totalBlocks * blockSize) / hfsmp->hfs_logical_block_size));+ }+ else {+ /* Innocuous spare sectors; Partition & FS notion are in sync */+ hfsmp->hfs_partition_avh_sector = (hfsmp->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) ++ HFS_ALT_SECTOR(hfsmp->hfs_logical_block_size, hfsmp->hfs_logical_block_count);++ hfsmp->hfs_fs_avh_sector = hfsmp->hfs_partition_avh_sector;+ }+ if (hfs_resize_debug) {+ printf ("hfs_MountHFSPlusVolume: partition_avh_sector=%qu, fs_avh_sector=%qu\n",+ hfsmp->hfs_partition_avh_sector, hfsmp->hfs_fs_avh_sector);+ }++ bzero(&cndesc, sizeof(cndesc));+ cndesc.cd_parentcnid = kHFSRootParentID;+ cndesc.cd_flags |= CD_ISMETA;+ bzero(&cnattr, sizeof(cnattr));+ cnattr.ca_linkcount = 1;+ cnattr.ca_mode = S_IFREG;++ /*+ * Set up Extents B-tree vnode+ */+ cndesc.cd_nameptr = hfs_extname;+ cndesc.cd_namelen = strlen((char *)hfs_extname);+ cndesc.cd_cnid = cnattr.ca_fileid = kHFSExtentsFileID;++ cfork.cf_size = SWAP_BE64 (vhp->extentsFile.logicalSize);+ cfork.cf_new_size= 0;+ cfork.cf_clump = SWAP_BE32 (vhp->extentsFile.clumpSize);+ cfork.cf_blocks = SWAP_BE32 (vhp->extentsFile.totalBlocks);+ cfork.cf_vblocks = 0;+ cnattr.ca_blocks = cfork.cf_blocks;+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ cfork.cf_extents[i].startBlock =+ SWAP_BE32 (vhp->extentsFile.extents[i].startBlock);+ cfork.cf_extents[i].blockCount =+ SWAP_BE32 (vhp->extentsFile.extents[i].blockCount);+ }+ retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork,+ &hfsmp->hfs_extents_vp, &newvnode_flags);+ if (retval)+ {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mounthfsplus: hfs_getnewvnode returned (%d) getting extentoverflow BT\n", retval);+ }+ goto ErrorExit;+ }++ hfsmp->hfs_extents_cp = VTOC(hfsmp->hfs_extents_vp);++ retval = MacToVFSError(BTOpenPath(VTOF(hfsmp->hfs_extents_vp),+ (KeyCompareProcPtr) CompareExtentKeysPlus));++ hfs_unlock(hfsmp->hfs_extents_cp);++ if (retval)+ {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mounthfsplus: BTOpenPath returned (%d) getting extentoverflow BT\n", retval);+ }+ goto ErrorExit;+ }+ /*+ * Set up Catalog B-tree vnode+ */+ cndesc.cd_nameptr = hfs_catname;+ cndesc.cd_namelen = strlen((char *)hfs_catname);+ cndesc.cd_cnid = cnattr.ca_fileid = kHFSCatalogFileID;++ cfork.cf_size = SWAP_BE64 (vhp->catalogFile.logicalSize);+ cfork.cf_clump = SWAP_BE32 (vhp->catalogFile.clumpSize);+ cfork.cf_blocks = SWAP_BE32 (vhp->catalogFile.totalBlocks);+ cfork.cf_vblocks = 0;+ cnattr.ca_blocks = cfork.cf_blocks;+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ cfork.cf_extents[i].startBlock =+ SWAP_BE32 (vhp->catalogFile.extents[i].startBlock);+ cfork.cf_extents[i].blockCount =+ SWAP_BE32 (vhp->catalogFile.extents[i].blockCount);+ }+ retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork,+ &hfsmp->hfs_catalog_vp, &newvnode_flags);+ if (retval) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mounthfsplus: hfs_getnewvnode returned (%d) getting catalog BT\n", retval);+ }+ goto ErrorExit;+ }+ hfsmp->hfs_catalog_cp = VTOC(hfsmp->hfs_catalog_vp);++ retval = MacToVFSError(BTOpenPath(VTOF(hfsmp->hfs_catalog_vp),+ (KeyCompareProcPtr) CompareExtendedCatalogKeys));++ if (retval) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mounthfsplus: BTOpenPath returned (%d) getting catalog BT\n", retval);+ }+ hfs_unlock(hfsmp->hfs_catalog_cp);+ goto ErrorExit;+ }+ if ((hfsmp->hfs_flags & HFS_X) &&+ BTGetInformation(VTOF(hfsmp->hfs_catalog_vp), 0, &btinfo) == 0) {+ if (btinfo.keyCompareType == kHFSBinaryCompare) {+ hfsmp->hfs_flags |= HFS_CASE_SENSITIVE;+ /* Install a case-sensitive key compare */+ (void) BTOpenPath(VTOF(hfsmp->hfs_catalog_vp),+ (KeyCompareProcPtr)cat_binarykeycompare);+ }+ }++ hfs_unlock(hfsmp->hfs_catalog_cp);++ /*+ * Set up Allocation file vnode+ */+ cndesc.cd_nameptr = hfs_vbmname;+ cndesc.cd_namelen = strlen((char *)hfs_vbmname);+ cndesc.cd_cnid = cnattr.ca_fileid = kHFSAllocationFileID;++ cfork.cf_size = SWAP_BE64 (vhp->allocationFile.logicalSize);+ cfork.cf_clump = SWAP_BE32 (vhp->allocationFile.clumpSize);+ cfork.cf_blocks = SWAP_BE32 (vhp->allocationFile.totalBlocks);+ cfork.cf_vblocks = 0;+ cnattr.ca_blocks = cfork.cf_blocks;+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ cfork.cf_extents[i].startBlock =+ SWAP_BE32 (vhp->allocationFile.extents[i].startBlock);+ cfork.cf_extents[i].blockCount =+ SWAP_BE32 (vhp->allocationFile.extents[i].blockCount);+ }+ retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork,+ &hfsmp->hfs_allocation_vp, &newvnode_flags);+ if (retval) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mounthfsplus: hfs_getnewvnode returned (%d) getting bitmap\n", retval);+ }+ goto ErrorExit;+ }+ hfsmp->hfs_allocation_cp = VTOC(hfsmp->hfs_allocation_vp);+ hfs_unlock(hfsmp->hfs_allocation_cp);++ /*+ * Set up Attribute B-tree vnode+ */+ if (vhp->attributesFile.totalBlocks != 0) {+ cndesc.cd_nameptr = hfs_attrname;+ cndesc.cd_namelen = strlen((char *)hfs_attrname);+ cndesc.cd_cnid = cnattr.ca_fileid = kHFSAttributesFileID;++ cfork.cf_size = SWAP_BE64 (vhp->attributesFile.logicalSize);+ cfork.cf_clump = SWAP_BE32 (vhp->attributesFile.clumpSize);+ cfork.cf_blocks = SWAP_BE32 (vhp->attributesFile.totalBlocks);+ cfork.cf_vblocks = 0;+ cnattr.ca_blocks = cfork.cf_blocks;+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ cfork.cf_extents[i].startBlock =+ SWAP_BE32 (vhp->attributesFile.extents[i].startBlock);+ cfork.cf_extents[i].blockCount =+ SWAP_BE32 (vhp->attributesFile.extents[i].blockCount);+ }+ retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork,+ &hfsmp->hfs_attribute_vp, &newvnode_flags);+ if (retval) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mounthfsplus: hfs_getnewvnode returned (%d) getting EA BT\n", retval);+ }+ goto ErrorExit;+ }+ hfsmp->hfs_attribute_cp = VTOC(hfsmp->hfs_attribute_vp);+ retval = MacToVFSError(BTOpenPath(VTOF(hfsmp->hfs_attribute_vp),+ (KeyCompareProcPtr) hfs_attrkeycompare));+ hfs_unlock(hfsmp->hfs_attribute_cp);+ if (retval) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mounthfsplus: BTOpenPath returned (%d) getting EA BT\n", retval);+ }+ goto ErrorExit;+ }++ /* Initialize vnode for virtual attribute data file that spans the+ * entire file system space for performing I/O to attribute btree+ * We hold iocount on the attrdata vnode for the entire duration+ * of mount (similar to btree vnodes)+ */+ retval = init_attrdata_vnode(hfsmp);+ if (retval) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mounthfsplus: init_attrdata_vnode returned (%d) for virtual EA file\n", retval);+ }+ goto ErrorExit;+ }+ }++ /*+ * Set up Startup file vnode+ */+ if (vhp->startupFile.totalBlocks != 0) {+ cndesc.cd_nameptr = hfs_startupname;+ cndesc.cd_namelen = strlen((char *)hfs_startupname);+ cndesc.cd_cnid = cnattr.ca_fileid = kHFSStartupFileID;++ cfork.cf_size = SWAP_BE64 (vhp->startupFile.logicalSize);+ cfork.cf_clump = SWAP_BE32 (vhp->startupFile.clumpSize);+ cfork.cf_blocks = SWAP_BE32 (vhp->startupFile.totalBlocks);+ cfork.cf_vblocks = 0;+ cnattr.ca_blocks = cfork.cf_blocks;+ for (i = 0; i < kHFSPlusExtentDensity; i++) {+ cfork.cf_extents[i].startBlock =+ SWAP_BE32 (vhp->startupFile.extents[i].startBlock);+ cfork.cf_extents[i].blockCount =+ SWAP_BE32 (vhp->startupFile.extents[i].blockCount);+ }+ retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork,+ &hfsmp->hfs_startup_vp, &newvnode_flags);+ if (retval) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mounthfsplus: hfs_getnewvnode returned (%d) getting startup file\n", retval);+ }+ goto ErrorExit;+ }+ hfsmp->hfs_startup_cp = VTOC(hfsmp->hfs_startup_vp);+ hfs_unlock(hfsmp->hfs_startup_cp);+ }++ /*+ * Pick up volume name and create date+ *+ * Acquiring the volume name should not manipulate the bitmap, only the catalog+ * btree and possibly the extents overflow b-tree.+ */+ retval = cat_idlookup(hfsmp, kHFSRootFolderID, 0, 0, &cndesc, &cnattr, NULL);+ if (retval) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mounthfsplus: cat_idlookup returned (%d) getting rootfolder \n", retval);+ }+ goto ErrorExit;+ }+ vcb->hfs_itime = cnattr.ca_itime;+ vcb->volumeNameEncodingHint = cndesc.cd_encoding;+ bcopy(cndesc.cd_nameptr, vcb->vcbVN, min(255, cndesc.cd_namelen));+ volname_length = strlen ((const char*)vcb->vcbVN);+ cat_releasedesc(&cndesc);++ /* Send the volume name down to CoreStorage if necessary */+ retval = utf8_normalizestr(vcb->vcbVN, volname_length, (u_int8_t*)converted_volname, &conv_volname_length, 256, UTF_PRECOMPOSED);+ if (retval == 0) {+ (void) VNOP_IOCTL (hfsmp->hfs_devvp, _DKIOCCSSETLVNAME, converted_volname, 0, vfs_context_current());+ }++ /* reset retval == 0. we don't care about errors in volname conversion */+ retval = 0;++ /*+ * pull in the volume UUID while we are still single-threaded.+ * This brings the volume UUID into the cached one dangling off of the HFSMP+ * Otherwise it would have to be computed on first access.+ */+ uuid_t throwaway;+ hfs_getvoluuid (hfsmp, throwaway);++ /*+ * We now always initiate a full bitmap scan even if the volume is read-only because this is+ * our only shot to do I/Os of dramaticallly different sizes than what the buffer cache ordinarily+ * expects. TRIMs will not be delivered to the underlying media if the volume is not+ * read-write though.+ */+ hfsmp->scan_var = 0;++ /*+ * We have to ensure if we can proceed to scan the bitmap allocation+ * file asynchronously. If the catalog file is fragmented such that it+ * has overflow extents and the volume needs journal transaction we+ * cannot scan the bitmap asynchronously. Doing so will cause the mount+ * thread to block at journal transaction on bitmap lock, while scan+ * thread which hold the bitmap lock exclusively performs disk I/O to+ * issue TRIMS to unallocated ranges and build summary table. The+ * amount of time the mount thread is blocked depends on the size of+ * the volume, type of disk, etc. This blocking can cause the watchdog+ * timer to timeout resulting in panic. Thus to ensure we don't timeout+ * watchdog in such cases we scan the bitmap synchronously.+ *+ * Please NOTE: Currently this timeout only seem to happen for non SSD+ * drives. Possibly reading a big fragmented allocation file to+ * construct the summary table takes enough time to timeout watchdog.+ * Thus we check if we need to scan the bitmap synchronously only if+ * the disk is not SSD.+ */+ async_bitmap_scan = true;+ if (!ISSET(hfsmp->hfs_flags, HFS_SSD) && hfsmp->hfs_catalog_cp) {+ bool catalog_has_overflow_extents;+ bool journal_transaction_needed;++ catalog_has_overflow_extents = false;+ if ((hfsmp->hfs_catalog_vp != NULL) &&+ (overflow_extents(VTOF(hfsmp->hfs_catalog_vp)))) {+ catalog_has_overflow_extents = true;+ }++ journal_transaction_needed = false;+ if (hfsmp->jnl || ((vcb->vcbAtrb & kHFSVolumeJournaledMask) &&+ (hfsmp->hfs_flags & HFS_READ_ONLY))) {+ journal_transaction_needed = true;+ }++ if (catalog_has_overflow_extents && journal_transaction_needed)+ async_bitmap_scan = false;+ }++ if (async_bitmap_scan) {+ thread_t allocator_scanner;++ /* Take the HFS mount mutex and wait on scan_var */+ hfs_lock_mount (hfsmp);+++ /*+ * Scan the bitmap asynchronously.+ */+ kernel_thread_start ((thread_continue_t)hfs_scan_blocks, hfsmp,+ &allocator_scanner);++ /*+ * Wait until it registers that it's got the appropriate locks+ * (or that it is finished).+ */+ while ((hfsmp->scan_var & (HFS_ALLOCATOR_SCAN_INFLIGHT|+ HFS_ALLOCATOR_SCAN_COMPLETED)) == 0) {+ msleep (&hfsmp->scan_var, &hfsmp->hfs_mutex, PINOD,+ "hfs_scan_blocks", 0);+ }++ hfs_unlock_mount(hfsmp);++ thread_deallocate (allocator_scanner);+ } else {++ /*+ * Initialize the summary table and then scan the bitmap+ * synchronously. Since we are scanning the bitmap+ * synchronously we don't need to hold the bitmap lock.+ */+ if (hfs_init_summary (hfsmp)) {+ printf ("hfs: could not initialize summary table for "+ "%s\n", hfsmp->vcbVN);+ }++ (void)ScanUnmapBlocks (hfsmp);++ /*+ * We need to set that the allocator scan is completed because+ * hot file clustering waits for this condition later.+ */+ hfsmp->scan_var |= HFS_ALLOCATOR_SCAN_COMPLETED;+ buf_invalidateblks (hfsmp->hfs_allocation_vp, 0, 0, 0);+ }++ /* mark the volume dirty (clear clean unmount bit) */+ vcb->vcbAtrb &= ~kHFSVolumeUnmountedMask;+ if (hfsmp->jnl && (hfsmp->hfs_flags & HFS_READ_ONLY) == 0) {+ hfs_flushvolumeheader(hfsmp, HFS_FVH_WAIT);+ }++ /* kHFSHasFolderCount is only supported/updated on HFSX volumes */+ if ((hfsmp->hfs_flags & HFS_X) != 0) {+ hfsmp->hfs_flags |= HFS_FOLDERCOUNT;+ }++ //+ // Check if we need to do late journal initialization. This only+ // happens if a previous version of MacOS X (or 9) touched the disk.+ // In that case hfs_late_journal_init() will go re-locate the journal+ // and journal_info_block files and validate that they're still kosher.+ //+ if ( (vcb->vcbAtrb & kHFSVolumeJournaledMask)+ && (SWAP_BE32(vhp->lastMountedVersion) != kHFSJMountVersion)+ && (hfsmp->jnl == NULL)) {++ retval = hfs_late_journal_init(hfsmp, vhp, args);+ if (retval != 0) {+ if (retval == EROFS) {+ // EROFS is a special error code that means the volume has an external+ // journal which we couldn't find. in that case we do not want to+ // rewrite the volume header - we'll just refuse to mount the volume.+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mounthfsplus: hfs_late_journal_init returned (%d), maybe an external jnl?\n", retval);+ }+ retval = EINVAL;+ goto ErrorExit;+ }++ hfsmp->jnl = NULL;++ // if the journal failed to open, then set the lastMountedVersion+ // to be "FSK!" which fsck_hfs will see and force the fsck instead+ // of just bailing out because the volume is journaled.+ if (!(hfsmp->hfs_flags & HFS_READ_ONLY)) {+ HFSPlusVolumeHeader *jvhp;+ daddr64_t mdb_offset;+ struct buf *bp = NULL;++ hfsmp->hfs_flags |= HFS_NEED_JNL_RESET;++ mdb_offset = (daddr64_t)((embeddedOffset / blockSize) + HFS_PRI_SECTOR(blockSize));++ bp = NULL;+ retval = (int)buf_meta_bread(hfsmp->hfs_devvp,+ HFS_PHYSBLK_ROUNDDOWN(mdb_offset, hfsmp->hfs_log_per_phys),+ hfsmp->hfs_physical_block_size, cred, &bp);+ if (retval == 0) {+ jvhp = (HFSPlusVolumeHeader *)(buf_dataptr(bp) + HFS_PRI_OFFSET(hfsmp->hfs_physical_block_size));++ if (SWAP_BE16(jvhp->signature) == kHFSPlusSigWord || SWAP_BE16(jvhp->signature) == kHFSXSigWord) {+ printf ("hfs(3): Journal replay fail. Writing lastMountVersion as FSK!\n");+ jvhp->lastMountedVersion = SWAP_BE32(kFSKMountVersion);+ buf_bwrite(bp);+ } else {+ buf_brelse(bp);+ }+ bp = NULL;+ } else if (bp) {+ buf_brelse(bp);+ // clear this so the error exit path won't try to use it+ bp = NULL;+ }+ }++ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mounthfsplus: hfs_late_journal_init returned (%d)\n", retval);+ }+ retval = EINVAL;+ goto ErrorExit;+ } else if (hfsmp->jnl) {+ vfs_setflags(hfsmp->hfs_mp, (u_int64_t)((unsigned int)MNT_JOURNALED));+ }+ } else if (hfsmp->jnl || ((vcb->vcbAtrb & kHFSVolumeJournaledMask) && (hfsmp->hfs_flags & HFS_READ_ONLY))) {+ struct cat_attr jinfo_attr, jnl_attr;++ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ vcb->vcbAtrb &= ~kHFSVolumeJournaledMask;+ }++ // if we're here we need to fill in the fileid's for the+ // journal and journal_info_block.+ hfsmp->hfs_jnlinfoblkid = GetFileInfo(vcb, kRootDirID, ".journal_info_block", &jinfo_attr, NULL);+ hfsmp->hfs_jnlfileid = GetFileInfo(vcb, kRootDirID, ".journal", &jnl_attr, NULL);+ if (hfsmp->hfs_jnlinfoblkid == 0 || hfsmp->hfs_jnlfileid == 0) {+ printf("hfs: danger! couldn't find the file-id's for the journal or journal_info_block\n");+ printf("hfs: jnlfileid %d, jnlinfoblkid %d\n", hfsmp->hfs_jnlfileid, hfsmp->hfs_jnlinfoblkid);+ }++ if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ vcb->vcbAtrb |= kHFSVolumeJournaledMask;+ }++ if (hfsmp->jnl == NULL) {+ vfs_clearflags(hfsmp->hfs_mp, (u_int64_t)((unsigned int)MNT_JOURNALED));+ }+ }++ if ( !(vcb->vcbAtrb & kHFSVolumeHardwareLockMask) ) // if the disk is not write protected+ {+ MarkVCBDirty( vcb ); // mark VCB dirty so it will be written+ }++ if (hfsmp->hfs_flags & HFS_CS_METADATA_PIN) {+ hfs_pin_fs_metadata(hfsmp);+ }+ /*+ * Distinguish 3 potential cases involving content protection:+ * 1. mount point bit set; vcbAtrb does not support it. Fail.+ * 2. mount point bit set; vcbattrb supports it. we're good.+ * 3. mount point bit not set; vcbatrb supports it, turn bit on, then good.+ */+ if (vfs_flags(hfsmp->hfs_mp) & MNT_CPROTECT) {+ /* Does the mount point support it ? */+ if ((vcb->vcbAtrb & kHFSContentProtectionMask) == 0) {+ /* Case 1 above */+ retval = EINVAL;+ goto ErrorExit;+ }+ }+ else {+ /* not requested in the mount point. Is it in FS? */+ if (vcb->vcbAtrb & kHFSContentProtectionMask) {+ /* Case 3 above */+ vfs_setflags (hfsmp->hfs_mp, MNT_CPROTECT);+ }+ }++ /* At this point, if the mount point flag is set, we can enable it. */+ if (vfs_flags(hfsmp->hfs_mp) & MNT_CPROTECT) {+ /* Cases 2+3 above */+#if CONFIG_PROTECT+ /* Get the EAs as needed. */+ int cperr = 0;+ struct cp_root_xattr *xattr = NULL;+ xattr = hfs_malloc_type(struct cp_root_xattr);++ /* go get the EA to get the version information */+ cperr = cp_getrootxattr (hfsmp, xattr);+ /*+ * If there was no EA there, then write one out.+ * Assuming EA is not present on the root means+ * this is an erase install or a very old FS+ */++ if (cperr == 0) {+ /* Have to run a valid CP version. */+ if (!cp_is_supported_version(xattr->major_version)) {+ cperr = EINVAL;+ }+ }+ else if (cperr == ENOATTR) {+ printf("No root EA set, creating new EA with new version: %d\n", CP_CURRENT_VERS);+ bzero(xattr, sizeof(struct cp_root_xattr));+ xattr->major_version = CP_CURRENT_VERS;+ xattr->minor_version = CP_MINOR_VERS;+ cperr = cp_setrootxattr (hfsmp, xattr);+ }++ if (cperr) {+ hfs_free_type(xattr, struct cp_root_xattr);+ retval = EPERM;+ goto ErrorExit;+ }++ /* If we got here, then the CP version is valid. Set it in the mount point */+ hfsmp->hfs_running_cp_major_vers = xattr->major_version;+ printf("Running with CP root xattr: %d.%d\n", xattr->major_version, xattr->minor_version);+ hfsmp->cproot_flags = xattr->flags;+ hfsmp->cp_crypto_generation = ISSET(xattr->flags, CP_ROOT_CRYPTOG1) ? 1 : 0;+#if HFS_CONFIG_KEY_ROLL+ hfsmp->hfs_auto_roll_min_key_os_version = xattr->auto_roll_min_version;+ hfsmp->hfs_auto_roll_max_key_os_version = xattr->auto_roll_max_version;+#endif++ hfs_free_type(xattr, struct cp_root_xattr);++ /*+ * Acquire the boot-arg for the AKS default key; if invalid, obtain from the device tree.+ * Ensure that the boot-arg's value is valid for FILES (not directories),+ * since only files are actually protected for now.+ */++ PE_parse_boot_argn("aks_default_class", &hfsmp->default_cp_class, sizeof(hfsmp->default_cp_class));++ if (cp_is_valid_class(0, hfsmp->default_cp_class) == 0) {+ PE_get_default("kern.default_cp_class", &hfsmp->default_cp_class, sizeof(hfsmp->default_cp_class));+ }++#if HFS_TMPDBG+#if !SECURE_KERNEL+ PE_parse_boot_argn("aks_verbose", &hfsmp->hfs_cp_verbose, sizeof(hfsmp->hfs_cp_verbose));+#endif+#endif++ if (cp_is_valid_class(0, hfsmp->default_cp_class) == 0) {+ hfsmp->default_cp_class = PROTECTION_CLASS_C;+ }++#else+ /* If CONFIG_PROTECT not built, ignore CP */+ vfs_clearflags(hfsmp->hfs_mp, MNT_CPROTECT);+#endif+ }++ /*+ * Establish a metadata allocation zone.+ */+ hfs_metadatazone_init(hfsmp, false);++ /*+ * Make any metadata zone adjustments.+ */+ if (hfsmp->hfs_flags & HFS_METADATA_ZONE) {+ /* Keep the roving allocator out of the metadata zone. */+ if (vcb->nextAllocation >= hfsmp->hfs_metazone_start &&+ vcb->nextAllocation <= hfsmp->hfs_metazone_end) {+ HFS_UPDATE_NEXT_ALLOCATION(hfsmp, hfsmp->hfs_metazone_end + 1);+ }+ } else {+ if (vcb->nextAllocation <= 1) {+ vcb->nextAllocation = hfsmp->hfs_min_alloc_start;+ }+ }+ vcb->sparseAllocation = hfsmp->hfs_min_alloc_start;++ /* Setup private/hidden directories for hardlinks. */+ hfs_privatedir_init(hfsmp, FILE_HARDLINKS);+ hfs_privatedir_init(hfsmp, DIR_HARDLINKS);++ if ((hfsmp->hfs_flags & HFS_READ_ONLY) == 0)+ hfs_remove_orphans(hfsmp);++ /* See if we need to erase unused Catalog nodes due to <rdar://problem/6947811>. */+ if ((hfsmp->hfs_flags & HFS_READ_ONLY) == 0)+ {+ retval = hfs_erase_unused_nodes(hfsmp);+ if (retval) {+ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mounthfsplus: hfs_erase_unused_nodes returned (%d) for %s \n", retval, hfsmp->vcbVN);+ }++ goto ErrorExit;+ }+ }++ /*+ * Allow hot file clustering if conditions allow.+ */+ if ((hfsmp->hfs_flags & HFS_METADATA_ZONE) && !(hfsmp->hfs_flags & HFS_READ_ONLY) &&+ ((hfsmp->hfs_flags & HFS_SSD) == 0 || (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN))) {+ //+ // Wait until the bitmap scan completes before we initializes the+ // hotfile area so that we do not run into any issues with the+ // bitmap being read while hotfiles is initializing itself. On+ // some older/slower machines, without this interlock, the bitmap+ // would sometimes get corrupted at boot time.+ //+ hfs_lock_mount(hfsmp);+ while(!(hfsmp->scan_var & HFS_ALLOCATOR_SCAN_COMPLETED)) {+ (void) msleep (&hfsmp->scan_var, &hfsmp->hfs_mutex, PINOD, "hfs_hotfile_bitmap_interlock", 0);+ }+ hfs_unlock_mount(hfsmp);++ /*+ * Note: at this point we are not allowed to fail the+ * mount operation because the HotFile init code+ * in hfs_recording_init() will lookup vnodes with+ * VNOP_LOOKUP() which hangs vnodes off the mount+ * (and if we were to fail, VFS is not prepared to+ * clean that up at this point. Since HotFiles are+ * optional, this is not a big deal.+ */+ (void) hfs_recording_init(hfsmp);+ }++ /* Force ACLs on HFS+ file systems. */+ vfs_setextendedsecurity(HFSTOVFS(hfsmp));++ /* Enable extent-based extended attributes by default */+ hfsmp->hfs_flags |= HFS_XATTR_EXTENTS;++ return (0);++ErrorExit:+ /*+ * A fatal error occurred and the volume cannot be mounted, so+ * release any resources that we acquired...+ */+ hfsUnmount(hfsmp, NULL);++ if (HFS_MOUNT_DEBUG) {+ printf("hfs_mounthfsplus: encountered error (%d)\n", retval);+ }+ return (retval);+}++static int+_pin_metafile(struct hfsmount *hfsmp, vnode_t vp)+{+ int err;++ err = hfs_lock(VTOC(vp), HFS_SHARED_LOCK, HFS_LOCK_DEFAULT);+ if (err == 0) {+ err = hfs_pin_vnode(hfsmp, vp, HFS_PIN_IT, NULL);+ hfs_unlock(VTOC(vp));+ }++ return err;+}++void+hfs_pin_fs_metadata(struct hfsmount *hfsmp)+{+ ExtendedVCB *vcb;+ int err;++ vcb = HFSTOVCB(hfsmp);++ err = _pin_metafile(hfsmp, hfsmp->hfs_extents_vp);+ if (err != 0) {+ printf("hfs: failed to pin extents overflow file %d\n", err);+ }+ err = _pin_metafile(hfsmp, hfsmp->hfs_catalog_vp);+ if (err != 0) {+ printf("hfs: failed to pin catalog file %d\n", err);+ }+ err = _pin_metafile(hfsmp, hfsmp->hfs_allocation_vp);+ if (err != 0) {+ printf("hfs: failed to pin bitmap file %d\n", err);+ }+ err = _pin_metafile(hfsmp, hfsmp->hfs_attribute_vp);+ if (err != 0) {+ printf("hfs: failed to pin extended attr file %d\n", err);+ }++ hfs_pin_block_range(hfsmp, HFS_PIN_IT, 0, 1);+ hfs_pin_block_range(hfsmp, HFS_PIN_IT, vcb->totalBlocks-1, 1);++ if (vfs_flags(hfsmp->hfs_mp) & MNT_JOURNALED) {+ // and hey, if we've got a journal, let's pin that too!+ hfs_pin_block_range(hfsmp, HFS_PIN_IT, hfsmp->jnl_start, howmany(hfsmp->jnl_size, vcb->blockSize));+ }+}++/*+ * ReleaseMetaFileVNode+ *+ * vp L - -+ */+static void ReleaseMetaFileVNode(struct vnode *vp)+{+ struct filefork *fp;++ if (vp && (fp = VTOF(vp))) {+ if (fp->fcbBTCBPtr != NULL) {+ (void)hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ (void) BTClosePath(fp);+ hfs_unlock(VTOC(vp));+ }++ /* release the node even if BTClosePath fails */+ vnode_recycle(vp);+ vnode_put(vp);+ }+}+++/*************************************************************+*+* Unmounts a hfs volume.+* At this point vflush() has been called (to dump all non-metadata files)+*+*************************************************************/++int+hfsUnmount( register struct hfsmount *hfsmp, __unused struct proc *p)+{+ /* Get rid of our attribute data vnode (if any). This is done+ * after the vflush() during mount, so we don't need to worry+ * about any locks.+ */+ if (hfsmp->hfs_attrdata_vp) {+ ReleaseMetaFileVNode(hfsmp->hfs_attrdata_vp);+ hfsmp->hfs_attrdata_vp = NULLVP;+ }++ if (hfsmp->hfs_startup_vp) {+ ReleaseMetaFileVNode(hfsmp->hfs_startup_vp);+ hfsmp->hfs_startup_cp = NULL;+ hfsmp->hfs_startup_vp = NULL;+ }++ if (hfsmp->hfs_attribute_vp) {+ ReleaseMetaFileVNode(hfsmp->hfs_attribute_vp);+ hfsmp->hfs_attribute_cp = NULL;+ hfsmp->hfs_attribute_vp = NULL;+ }++ if (hfsmp->hfs_catalog_vp) {+ ReleaseMetaFileVNode(hfsmp->hfs_catalog_vp);+ hfsmp->hfs_catalog_cp = NULL;+ hfsmp->hfs_catalog_vp = NULL;+ }++ if (hfsmp->hfs_extents_vp) {+ ReleaseMetaFileVNode(hfsmp->hfs_extents_vp);+ hfsmp->hfs_extents_cp = NULL;+ hfsmp->hfs_extents_vp = NULL;+ }++ if (hfsmp->hfs_allocation_vp) {+ ReleaseMetaFileVNode(hfsmp->hfs_allocation_vp);+ hfsmp->hfs_allocation_cp = NULL;+ hfsmp->hfs_allocation_vp = NULL;+ }++ return (0);+}+++/*+ * Test if fork has overflow extents.+ *+ * Returns:+ * non-zero - overflow extents exist+ * zero - overflow extents do not exist+ */+bool overflow_extents(struct filefork *fp)+{+ u_int32_t blocks;++ //+ // If the vnode pointer is NULL then we're being called+ // from hfs_remove_orphans() with a faked-up filefork+ // and therefore it has to be an HFS+ volume. Otherwise+ // we check through the volume header to see what type+ // of volume we're on.+ //++ if (fp->ff_extents[7].blockCount == 0)+ return false;++ blocks = fp->ff_extents[0].blockCount ++ fp->ff_extents[1].blockCount ++ fp->ff_extents[2].blockCount ++ fp->ff_extents[3].blockCount ++ fp->ff_extents[4].blockCount ++ fp->ff_extents[5].blockCount ++ fp->ff_extents[6].blockCount ++ fp->ff_extents[7].blockCount;++ return fp->ff_blocks > blocks;+}++static __attribute__((pure))+boolean_t hfs_is_frozen(struct hfsmount *hfsmp)+{+ return (hfsmp->hfs_freeze_state == HFS_FROZEN+ || (hfsmp->hfs_freeze_state == HFS_FREEZING+ && current_thread() != hfsmp->hfs_freezing_thread));+}++/*+ * Lock the HFS global journal lock+ */+int+hfs_lock_global (struct hfsmount *hfsmp, enum hfs_locktype locktype)+{+ thread_t thread = current_thread();++ if (hfsmp->hfs_global_lockowner == thread) {+ panic ("hfs_lock_global: locking against myself!");+ }++ /*+ * This check isn't really necessary but this stops us taking+ * the mount lock in most cases. The essential check is below.+ */+ if (hfs_is_frozen(hfsmp)) {+ /*+ * Unfortunately, there is no easy way of getting a notification+ * for when a process is exiting and it's possible for the exiting+ * process to get blocked somewhere else. To catch this, we+ * periodically monitor the frozen process here and thaw if+ * we spot that it's exiting.+ */+frozen:+ hfs_lock_mount(hfsmp);++ struct timespec ts = { 0, 500 * NSEC_PER_MSEC };++ while (hfs_is_frozen(hfsmp)) {+ if (hfsmp->hfs_freeze_state == HFS_FROZEN+ && proc_exiting(hfsmp->hfs_freezing_proc)) {+ hfs_thaw_locked(hfsmp);+ break;+ }++ msleep(&hfsmp->hfs_freeze_state, &hfsmp->hfs_mutex,+ PWAIT, "hfs_lock_global (frozen)", &ts);+ }+ hfs_unlock_mount(hfsmp);+ }++ /* HFS_SHARED_LOCK */+ if (locktype == HFS_SHARED_LOCK) {+ lck_rw_lock_shared (&hfsmp->hfs_global_lock);+ hfsmp->hfs_global_lockowner = HFS_SHARED_OWNER;+ }+ /* HFS_EXCLUSIVE_LOCK */+ else {+ lck_rw_lock_exclusive (&hfsmp->hfs_global_lock);+ hfsmp->hfs_global_lockowner = thread;+ }++ /*+ * We have to check if we're frozen again because of the time+ * between when we checked and when we took the global lock.+ */+ if (hfs_is_frozen(hfsmp)) {+ hfs_unlock_global(hfsmp);+ goto frozen;+ }++ return 0;+}+++/*+ * Unlock the HFS global journal lock+ */+void+hfs_unlock_global (struct hfsmount *hfsmp)+{+ thread_t thread = current_thread();++ /* HFS_LOCK_EXCLUSIVE */+ if (hfsmp->hfs_global_lockowner == thread) {+ hfsmp->hfs_global_lockowner = NULL;+ lck_rw_unlock_exclusive (&hfsmp->hfs_global_lock);+ }+ /* HFS_LOCK_SHARED */+ else {+ lck_rw_unlock_shared (&hfsmp->hfs_global_lock);+ }+}++/*+ * Lock the HFS mount lock+ *+ * Note: this is a mutex, not a rw lock!+ */+inline+void hfs_lock_mount (struct hfsmount *hfsmp) {+ lck_mtx_lock (&(hfsmp->hfs_mutex));+}++/*+ * Unlock the HFS mount lock+ *+ * Note: this is a mutex, not a rw lock!+ */+inline+void hfs_unlock_mount (struct hfsmount *hfsmp) {+ lck_mtx_unlock (&(hfsmp->hfs_mutex));+}++/*+ * Lock HFS system file(s).+ *+ * This function accepts a @flags parameter which indicates which+ * system file locks are required. The value it returns should be+ * used in a subsequent call to hfs_systemfile_unlock. The caller+ * should treat this value as opaque; it may or may not have a+ * relation to the @flags field that is passed in. The *only*+ * guarantee that we make is that a value of zero means that no locks+ * were taken and that there is no need to call hfs_systemfile_unlock+ * (although it is harmless to do so). Recursion is supported but+ * care must still be taken to ensure correct lock ordering. Note+ * that requests for certain locks may cause other locks to also be+ * taken, including locks that are not possible to ask for via the+ * @flags parameter.+ */+int+hfs_systemfile_lock(struct hfsmount *hfsmp, int flags, enum hfs_locktype locktype)+{+ /*+ * Locking order is Catalog file, Attributes file, Startup file, Bitmap file, Extents file+ */+ if (flags & SFL_CATALOG) {+ if (hfsmp->hfs_catalog_cp+ && hfsmp->hfs_catalog_cp->c_lockowner != current_thread()) {+#ifdef HFS_CHECK_LOCK_ORDER+ if (hfsmp->hfs_attribute_cp && hfsmp->hfs_attribute_cp->c_lockowner == current_thread()) {+ panic("hfs_systemfile_lock: bad lock order (Attributes before Catalog)");+ }+ if (hfsmp->hfs_startup_cp && hfsmp->hfs_startup_cp->c_lockowner == current_thread()) {+ panic("hfs_systemfile_lock: bad lock order (Startup before Catalog)");+ }+ if (hfsmp-> hfs_extents_cp && hfsmp->hfs_extents_cp->c_lockowner == current_thread()) {+ panic("hfs_systemfile_lock: bad lock order (Extents before Catalog)");+ }+#endif /* HFS_CHECK_LOCK_ORDER */++ (void) hfs_lock(hfsmp->hfs_catalog_cp, locktype, HFS_LOCK_DEFAULT);+ /*+ * When the catalog file has overflow extents then+ * also acquire the extents b-tree lock if its not+ * already requested.+ */+ if (((flags & SFL_EXTENTS) == 0) &&+ (hfsmp->hfs_catalog_vp != NULL) &&+ (overflow_extents(VTOF(hfsmp->hfs_catalog_vp)))) {+ flags |= SFL_EXTENTS;+ }+ } else {+ flags &= ~SFL_CATALOG;+ }+ }++ if (flags & SFL_ATTRIBUTE) {+ if (hfsmp->hfs_attribute_cp+ && hfsmp->hfs_attribute_cp->c_lockowner != current_thread()) {+#ifdef HFS_CHECK_LOCK_ORDER+ if (hfsmp->hfs_startup_cp && hfsmp->hfs_startup_cp->c_lockowner == current_thread()) {+ panic("hfs_systemfile_lock: bad lock order (Startup before Attributes)");+ }+ if (hfsmp->hfs_extents_cp && hfsmp->hfs_extents_cp->c_lockowner == current_thread()) {+ panic("hfs_systemfile_lock: bad lock order (Extents before Attributes)");+ }+#endif /* HFS_CHECK_LOCK_ORDER */++ (void) hfs_lock(hfsmp->hfs_attribute_cp, locktype, HFS_LOCK_DEFAULT);+ /*+ * When the attribute file has overflow extents then+ * also acquire the extents b-tree lock if its not+ * already requested.+ */+ if (((flags & SFL_EXTENTS) == 0) &&+ (hfsmp->hfs_attribute_vp != NULL) &&+ (overflow_extents(VTOF(hfsmp->hfs_attribute_vp)))) {+ flags |= SFL_EXTENTS;+ }+ } else {+ flags &= ~SFL_ATTRIBUTE;+ }+ }++ if (flags & SFL_STARTUP) {+ if (hfsmp->hfs_startup_cp+ && hfsmp->hfs_startup_cp->c_lockowner != current_thread()) {+#ifdef HFS_CHECK_LOCK_ORDER+ if (hfsmp-> hfs_extents_cp && hfsmp->hfs_extents_cp->c_lockowner == current_thread()) {+ panic("hfs_systemfile_lock: bad lock order (Extents before Startup)");+ }+#endif /* HFS_CHECK_LOCK_ORDER */++ (void) hfs_lock(hfsmp->hfs_startup_cp, locktype, HFS_LOCK_DEFAULT);+ /*+ * When the startup file has overflow extents then+ * also acquire the extents b-tree lock if its not+ * already requested.+ */+ if (((flags & SFL_EXTENTS) == 0) &&+ (hfsmp->hfs_startup_vp != NULL) &&+ (overflow_extents(VTOF(hfsmp->hfs_startup_vp)))) {+ flags |= SFL_EXTENTS;+ }+ } else {+ flags &= ~SFL_STARTUP;+ }+ }++ /*+ * To prevent locks being taken in the wrong order, the extent lock+ * gets a bitmap lock as well.+ */+ if (flags & (SFL_BITMAP | SFL_EXTENTS)) {+ if (hfsmp->hfs_allocation_cp) {+ (void) hfs_lock(hfsmp->hfs_allocation_cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ /*+ * The bitmap lock is also grabbed when only extent lock+ * was requested. Set the bitmap lock bit in the lock+ * flags which callers will use during unlock.+ */+ flags |= SFL_BITMAP;+ } else {+ flags &= ~SFL_BITMAP;+ }+ }++ if (flags & SFL_EXTENTS) {+ /*+ * Since the extents btree lock is recursive we always+ * need exclusive access.+ */+ if (hfsmp->hfs_extents_cp) {+ (void) hfs_lock(hfsmp->hfs_extents_cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);++ if (vfs_isswapmount(hfsmp->hfs_mp)) {+ /*+ * because we may need this lock on the pageout path (if a swapfile allocation+ * spills into the extents overflow tree), we will grant the holder of this+ * lock the privilege of dipping into the reserve free pool in order to prevent+ * a deadlock from occurring if we need those pageouts to complete before we+ * will make any new pages available on the free list... the deadlock can occur+ * if this thread needs to allocate memory while this lock is held+ */+ if (set_vm_privilege(TRUE) == FALSE) {+ /*+ * indicate that we need to drop vm_privilege+ * when we unlock+ */+ flags |= SFL_VM_PRIV;+ }+ }+ } else {+ flags &= ~SFL_EXTENTS;+ }+ }++ return (flags);+}++/*+ * unlock HFS system file(s).+ */+void+hfs_systemfile_unlock(struct hfsmount *hfsmp, int flags)+{+ if (!flags)+ return;++ struct timeval tv;+ u_int32_t lastfsync;+ int numOfLockedBuffs;++ if (hfsmp->jnl == NULL) {+ microuptime(&tv);+ lastfsync = tv.tv_sec;+ }+ if (flags & SFL_STARTUP && hfsmp->hfs_startup_cp) {+ hfs_unlock(hfsmp->hfs_startup_cp);+ }+ if (flags & SFL_ATTRIBUTE && hfsmp->hfs_attribute_cp) {+ if (hfsmp->jnl == NULL) {+ BTGetLastSync((FCB*)VTOF(hfsmp->hfs_attribute_vp), &lastfsync);+ numOfLockedBuffs = count_lock_queue();+ if ((numOfLockedBuffs > kMaxLockedMetaBuffers) ||+ ((numOfLockedBuffs > 1) && ((tv.tv_sec - lastfsync) >+ kMaxSecsForFsync))) {+ hfs_btsync(hfsmp->hfs_attribute_vp, HFS_SYNCTRANS);+ }+ }+ hfs_unlock(hfsmp->hfs_attribute_cp);+ }+ if (flags & SFL_CATALOG && hfsmp->hfs_catalog_cp) {+ if (hfsmp->jnl == NULL) {+ BTGetLastSync((FCB*)VTOF(hfsmp->hfs_catalog_vp), &lastfsync);+ numOfLockedBuffs = count_lock_queue();+ if ((numOfLockedBuffs > kMaxLockedMetaBuffers) ||+ ((numOfLockedBuffs > 1) && ((tv.tv_sec - lastfsync) >+ kMaxSecsForFsync))) {+ hfs_btsync(hfsmp->hfs_catalog_vp, HFS_SYNCTRANS);+ }+ }+ hfs_unlock(hfsmp->hfs_catalog_cp);+ }+ if (flags & SFL_BITMAP && hfsmp->hfs_allocation_cp) {+ hfs_unlock(hfsmp->hfs_allocation_cp);+ }+ if (flags & SFL_EXTENTS && hfsmp->hfs_extents_cp) {+ if (hfsmp->jnl == NULL) {+ BTGetLastSync((FCB*)VTOF(hfsmp->hfs_extents_vp), &lastfsync);+ numOfLockedBuffs = count_lock_queue();+ if ((numOfLockedBuffs > kMaxLockedMetaBuffers) ||+ ((numOfLockedBuffs > 1) && ((tv.tv_sec - lastfsync) >+ kMaxSecsForFsync))) {+ hfs_btsync(hfsmp->hfs_extents_vp, HFS_SYNCTRANS);+ }+ }+ hfs_unlock(hfsmp->hfs_extents_cp);++ if (flags & SFL_VM_PRIV) {+ /*+ * revoke the vm_privilege we granted this thread+ * now that we have unlocked the overflow extents+ */+ set_vm_privilege(FALSE);+ }+ }+}+++/*+ * RequireFileLock+ *+ * Check to see if a vnode is locked in the current context+ * This is to be used for debugging purposes only!!+ */+#if DEBUG+void RequireFileLock(FileReference vp, int shareable)+{+ int locked;++ /* The extents btree and allocation bitmap are always exclusive. */+ if (VTOC(vp)->c_fileid == kHFSExtentsFileID ||+ VTOC(vp)->c_fileid == kHFSAllocationFileID) {+ shareable = 0;+ }++ locked = VTOC(vp)->c_lockowner == current_thread();++ if (!locked && !shareable) {+ switch (VTOC(vp)->c_fileid) {+ case kHFSExtentsFileID:+ panic("hfs: extents btree not locked! v: 0x%08X\n #\n", (u_int)vp);+ break;+ case kHFSCatalogFileID:+ panic("hfs: catalog btree not locked! v: 0x%08X\n #\n", (u_int)vp);+ break;+ case kHFSAllocationFileID:+ /* The allocation file can hide behind the jornal lock. */+ if (VTOHFS(vp)->jnl == NULL)+ panic("hfs: allocation file not locked! v: 0x%08X\n #\n", (u_int)vp);+ break;+ case kHFSStartupFileID:+ panic("hfs: startup file not locked! v: 0x%08X\n #\n", (u_int)vp);+ case kHFSAttributesFileID:+ panic("hfs: attributes btree not locked! v: 0x%08X\n #\n", (u_int)vp);+ break;+ }+ }+}+#endif // DEBUG+++/*+ * There are three ways to qualify for ownership rights on an object:+ *+ * 1. (a) Your UID matches the cnode's UID.+ * (b) The object in question is owned by "unknown"+ * 2. (a) Permissions on the filesystem are being ignored and+ * your UID matches the replacement UID.+ * (b) Permissions on the filesystem are being ignored and+ * the replacement UID is "unknown".+ * 3. You are root.+ *+ */+int+hfs_owner_rights(struct hfsmount *hfsmp, uid_t cnode_uid, kauth_cred_t cred,+ __unused struct proc *p, int invokesuperuserstatus)+{+ if ((kauth_cred_getuid(cred) == cnode_uid) || /* [1a] */+ (cnode_uid == UNKNOWNUID) || /* [1b] */+ ((((unsigned int)vfs_flags(HFSTOVFS(hfsmp))) & MNT_UNKNOWNPERMISSIONS) && /* [2] */+ ((kauth_cred_getuid(cred) == hfsmp->hfs_uid) || /* [2a] */+ (hfsmp->hfs_uid == UNKNOWNUID))) || /* [2b] */+ (invokesuperuserstatus && (suser(cred, 0) == 0))) { /* [3] */+ return (0);+ } else {+ return (EPERM);+ }+}+++u_int32_t BestBlockSizeFit(u_int32_t allocationBlockSize,+ u_int32_t blockSizeLimit,+ u_int32_t baseMultiple) {+ /*+ Compute the optimal (largest) block size (no larger than allocationBlockSize) that is less than the+ specified limit but still an even multiple of the baseMultiple.+ */+ int baseBlockCount, blockCount;+ u_int32_t trialBlockSize;++ if (allocationBlockSize % baseMultiple != 0) {+ /*+ Whoops: the allocation blocks aren't even multiples of the specified base:+ no amount of dividing them into even parts will be a multiple, either then!+ */+ return 512; /* Hope for the best */+ };++ /* Try the obvious winner first, to prevent 12K allocation blocks, for instance,+ from being handled as two 6K logical blocks instead of 3 4K logical blocks.+ Even though the former (the result of the loop below) is the larger allocation+ block size, the latter is more efficient: */+ if (allocationBlockSize % PAGE_SIZE == 0) return PAGE_SIZE;++ /* No clear winner exists: pick the largest even fraction <= MAXBSIZE: */+ baseBlockCount = allocationBlockSize / baseMultiple; /* Now guaranteed to be an even multiple */++ for (blockCount = baseBlockCount; blockCount > 0; --blockCount) {+ trialBlockSize = blockCount * baseMultiple;+ if (allocationBlockSize % trialBlockSize == 0) { /* An even multiple? */+ if ((trialBlockSize <= blockSizeLimit) &&+ (trialBlockSize % baseMultiple == 0)) {+ return trialBlockSize;+ };+ };+ };++ /* Note: we should never get here, since blockCount = 1 should always work,+ but this is nice and safe and makes the compiler happy, too ... */+ return 512;+}+++u_int32_t+GetFileInfo(ExtendedVCB *vcb, __unused u_int32_t dirid, const char *name,+ struct cat_attr *fattr, struct cat_fork *forkinfo)+{+ struct hfsmount * hfsmp;+ struct cat_desc jdesc;+ int lockflags;+ int error;++ if (vcb->vcbSigWord != kHFSPlusSigWord)+ return (0);++ hfsmp = VCBTOHFS(vcb);++ memset(&jdesc, 0, sizeof(struct cat_desc));+ jdesc.cd_parentcnid = kRootDirID;+ jdesc.cd_nameptr = (const u_int8_t *)name;+ jdesc.cd_namelen = strlen(name);++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);+ error = cat_lookup(hfsmp, &jdesc, 0, 0, NULL, fattr, forkinfo, NULL);+ hfs_systemfile_unlock(hfsmp, lockflags);++ if (error == 0) {+ return (fattr->ca_fileid);+ } else if (hfsmp->hfs_flags & HFS_READ_ONLY) {+ return (0);+ }++ return (0); /* XXX what callers expect on an error */+}+++/*+ * On HFS Plus Volumes, there can be orphaned files or directories+ * These are files or directories that were unlinked while busy.+ * If the volume was not cleanly unmounted then some of these may+ * have persisted and need to be removed.+ */+void+hfs_remove_orphans(struct hfsmount * hfsmp)+{+ struct BTreeIterator * iterator = NULL;+ struct FSBufferDescriptor btdata;+ struct HFSPlusCatalogFile filerec;+ struct HFSPlusCatalogKey * keyp;+ struct proc *p = current_proc();+ FCB *fcb;+ ExtendedVCB *vcb;+ char filename[32];+ char tempname[32];+ size_t namelen;+ cat_cookie_t cookie;+ int catlock = 0;+ int catreserve = 0;+ bool started_tr = false;+ int lockflags;+ int result;+ int orphaned_files = 0;+ int orphaned_dirs = 0;++ bzero(&cookie, sizeof(cookie));++ if (hfsmp->hfs_flags & HFS_CLEANED_ORPHANS)+ return;++ vcb = HFSTOVCB(hfsmp);+ fcb = VTOF(hfsmp->hfs_catalog_vp);++ btdata.bufferAddress = &filerec;+ btdata.itemSize = sizeof(filerec);+ btdata.itemCount = 1;++ iterator = hfs_malloc_type(struct BTreeIterator);++ /* Build a key to "temp" */+ keyp = (HFSPlusCatalogKey*)&iterator->key;+ keyp->parentID = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid;+ keyp->nodeName.length = 4; /* "temp" */+ keyp->keyLength = kHFSPlusCatalogKeyMinimumLength + keyp->nodeName.length * 2;+ keyp->nodeName.unicode[0] = 't';+ keyp->nodeName.unicode[1] = 'e';+ keyp->nodeName.unicode[2] = 'm';+ keyp->nodeName.unicode[3] = 'p';++ /*+ * Position the iterator just before the first real temp file/dir.+ */+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);+ (void) BTSearchRecord(fcb, iterator, NULL, NULL, iterator);+ hfs_systemfile_unlock(hfsmp, lockflags);++ /* Visit all the temp files/dirs in the HFS+ private directory. */+ for (;;) {+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);+ result = BTIterateRecord(fcb, kBTreeNextRecord, iterator, &btdata, NULL);+ hfs_systemfile_unlock(hfsmp, lockflags);+ if (result)+ break;+ if (keyp->parentID != hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid)+ break;++ (void) utf8_encodestr(keyp->nodeName.unicode, keyp->nodeName.length * 2,+ (u_int8_t *)filename, &namelen, sizeof(filename), 0, 0);++ (void) snprintf(tempname, sizeof(tempname), "%s%d",+ HFS_DELETE_PREFIX, filerec.fileID);++ /*+ * Delete all files (and directories) named "tempxxx",+ * where xxx is the file's cnid in decimal.+ *+ */+ if (bcmp(tempname, filename, namelen + 1) != 0)+ continue;++ struct filefork dfork;+ struct filefork rfork;+ struct cnode cnode;+ int mode = 0;++ bzero(&dfork, sizeof(dfork));+ bzero(&rfork, sizeof(rfork));+ bzero(&cnode, sizeof(cnode));++ if (hfs_start_transaction(hfsmp) != 0) {+ printf("hfs_remove_orphans: failed to start transaction\n");+ goto exit;+ }+ started_tr = true;++ /*+ * Reserve some space in the Catalog file.+ */+ if (cat_preflight(hfsmp, CAT_DELETE, &cookie, p) != 0) {+ printf("hfs_remove_orphans: cat_preflight failed\n");+ goto exit;+ }+ catreserve = 1;++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE | SFL_EXTENTS | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);+ catlock = 1;++ /* Build a fake cnode */+ cat_convertattr(hfsmp, (CatalogRecord *)&filerec, &cnode.c_attr,+ &dfork.ff_data, &rfork.ff_data);+ cnode.c_desc.cd_parentcnid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid;+ cnode.c_desc.cd_nameptr = (const u_int8_t *)filename;+ cnode.c_desc.cd_namelen = namelen;+ cnode.c_desc.cd_cnid = cnode.c_attr.ca_fileid;+ cnode.c_blocks = dfork.ff_blocks + rfork.ff_blocks;++ /* Position iterator at previous entry */+ if (BTIterateRecord(fcb, kBTreePrevRecord, iterator,+ NULL, NULL) != 0) {+ break;+ }++ /* Truncate the file to zero (both forks) */+ if (dfork.ff_blocks > 0) {+ u_int64_t fsize;++ dfork.ff_cp = &cnode;+ cnode.c_datafork = &dfork;+ cnode.c_rsrcfork = NULL;+ fsize = (u_int64_t)dfork.ff_blocks * (u_int64_t)HFSTOVCB(hfsmp)->blockSize;+ while (fsize > 0) {+ if (fsize > HFS_BIGFILE_SIZE) {+ fsize -= HFS_BIGFILE_SIZE;+ } else {+ fsize = 0;+ }++ if (TruncateFileC(vcb, (FCB*)&dfork, fsize, 1, 0,+ cnode.c_attr.ca_fileid, false) != 0) {+ printf("hfs: error truncating data fork!\n");+ break;+ }++ //+ // if we're iteratively truncating this file down,+ // then end the transaction and start a new one so+ // that no one transaction gets too big.+ //+ if (fsize > 0) {+ /* Drop system file locks before starting+ * another transaction to preserve lock order.+ */+ hfs_systemfile_unlock(hfsmp, lockflags);+ catlock = 0;+ hfs_end_transaction(hfsmp);++ if (hfs_start_transaction(hfsmp) != 0) {+ started_tr = false;+ goto exit;+ }+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE | SFL_EXTENTS | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);+ catlock = 1;+ }+ }+ }++ if (rfork.ff_blocks > 0) {+ rfork.ff_cp = &cnode;+ cnode.c_datafork = NULL;+ cnode.c_rsrcfork = &rfork;+ if (TruncateFileC(vcb, (FCB*)&rfork, 0, 1, 1, cnode.c_attr.ca_fileid, false) != 0) {+ printf("hfs: error truncating rsrc fork!\n");+ break;+ }+ }++ // Deal with extended attributes+ if (ISSET(cnode.c_attr.ca_recflags, kHFSHasAttributesMask)) {+ // hfs_removeallattr uses its own transactions+ hfs_systemfile_unlock(hfsmp, lockflags);+ catlock = false;+ hfs_end_transaction(hfsmp);++ hfs_removeallattr(hfsmp, cnode.c_attr.ca_fileid, &started_tr);++ if (!started_tr) {+ if (hfs_start_transaction(hfsmp) != 0) {+ printf("hfs_remove_orphans: failed to start transaction\n");+ goto exit;+ }+ started_tr = true;+ }++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE | SFL_EXTENTS | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);+ catlock = 1;+ }++ /* Remove the file or folder record from the Catalog */+ if (cat_delete(hfsmp, &cnode.c_desc, &cnode.c_attr) != 0) {+ printf("hfs_remove_orphans: error deleting cat rec for id %d!\n", cnode.c_desc.cd_cnid);+ hfs_systemfile_unlock(hfsmp, lockflags);+ catlock = 0;+ hfs_volupdate(hfsmp, VOL_UPDATE, 0);+ break;+ }++ mode = cnode.c_attr.ca_mode & S_IFMT;++ if (mode == S_IFDIR) {+ orphaned_dirs++;+ }+ else {+ orphaned_files++;+ }++ /* Update parent and volume counts */+ hfsmp->hfs_private_attr[FILE_HARDLINKS].ca_entries--;+ if (mode == S_IFDIR) {+ DEC_FOLDERCOUNT(hfsmp, hfsmp->hfs_private_attr[FILE_HARDLINKS]);+ }++ (void)cat_update(hfsmp, &hfsmp->hfs_private_desc[FILE_HARDLINKS],+ &hfsmp->hfs_private_attr[FILE_HARDLINKS], NULL, NULL);++ /* Drop locks and end the transaction */+ hfs_systemfile_unlock(hfsmp, lockflags);+ cat_postflight(hfsmp, &cookie, p);+ catlock = catreserve = 0;++ /*+ Now that Catalog is unlocked, update the volume info, making+ sure to differentiate between files and directories+ */+ if (mode == S_IFDIR) {+ hfs_volupdate(hfsmp, VOL_RMDIR, 0);+ }+ else{+ hfs_volupdate(hfsmp, VOL_RMFILE, 0);+ }++ hfs_end_transaction(hfsmp);+ started_tr = false;+ } /* end for */++exit:++ if (orphaned_files > 0 || orphaned_dirs > 0)+ printf("hfs: Removed %d orphaned / unlinked files and %d directories \n", orphaned_files, orphaned_dirs);+ if (catlock) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ }+ if (catreserve) {+ cat_postflight(hfsmp, &cookie, p);+ }+ if (started_tr) {+ hfs_end_transaction(hfsmp);+ }++ hfs_free_type(iterator, struct BTreeIterator);+ hfsmp->hfs_flags |= HFS_CLEANED_ORPHANS;+}+++/*+ * This will return the correct logical block size for a given vnode.+ * For most files, it is the allocation block size, for meta data like+ * BTrees, this is kept as part of the BTree private nodeSize+ */+u_int32_t+GetLogicalBlockSize(struct vnode *vp)+{+u_int32_t logBlockSize;++ hfs_assert(vp != NULL);++ /* start with default */+ logBlockSize = VTOHFS(vp)->hfs_logBlockSize;++ if (vnode_issystem(vp)) {+ if (VTOF(vp)->fcbBTCBPtr != NULL) {+ BTreeInfoRec bTreeInfo;++ /*+ * We do not lock the BTrees, because if we are getting block..then the tree+ * should be locked in the first place.+ * We just want the nodeSize wich will NEVER change..so even if the world+ * is changing..the nodeSize should remain the same. Which argues why lock+ * it in the first place??+ */++ (void) BTGetInformation (VTOF(vp), kBTreeInfoVersion, &bTreeInfo);++ logBlockSize = bTreeInfo.nodeSize;++ } else if (VTOC(vp)->c_fileid == kHFSAllocationFileID) {+ logBlockSize = VTOVCB(vp)->vcbVBMIOSize;+ }+ }++ hfs_assert(logBlockSize > 0);++ return logBlockSize;+}++#if HFS_SPARSE_DEV+static bool hfs_get_backing_free_blks(hfsmount_t *hfsmp, uint64_t *pfree_blks)+{+ struct vfsstatfs *vfsp; /* 272 bytes */+ uint64_t vfreeblks;+ struct timeval now;++ hfs_lock_mount(hfsmp);++ vnode_t backing_vp = hfsmp->hfs_backingvp;+ if (!backing_vp) {+ hfs_unlock_mount(hfsmp);+ return false;+ }++ // usecount is not enough; we need iocount+ if (vnode_get(backing_vp)) {+ hfs_unlock_mount(hfsmp);+ *pfree_blks = 0;+ return true;+ }++ uint32_t loanedblks = hfsmp->loanedBlocks + hfsmp->lockedBlocks;+ uint32_t bandblks = hfsmp->hfs_sparsebandblks;+ uint64_t maxblks = hfsmp->hfs_backingfs_maxblocks;++ hfs_unlock_mount(hfsmp);++ mount_t backingfs_mp = vnode_mount(backing_vp);++ microtime(&now);+ if ((now.tv_sec - hfsmp->hfs_last_backingstatfs) >= 1) {+ vfs_update_vfsstat(backingfs_mp, vfs_context_kernel(), VFS_KERNEL_EVENT);+ hfsmp->hfs_last_backingstatfs = now.tv_sec;+ }++ if (!(vfsp = vfs_statfs(backingfs_mp))) {+ vnode_put(backing_vp);+ return false;+ }++ vfreeblks = vfsp->f_bavail;+ /* Normalize block count if needed. */+ if (vfsp->f_bsize != hfsmp->blockSize)+ vfreeblks = vfreeblks * vfsp->f_bsize / hfsmp->blockSize;+ if (vfreeblks > bandblks)+ vfreeblks -= bandblks;+ else+ vfreeblks = 0;++ /*+ * Take into account any delayed allocations. It is not+ * certain what the original reason for the "2 *" is. Most+ * likely it is to allow for additional requirements in the+ * host file system and metadata required by disk images. The+ * number of loaned blocks is likely to be small and we will+ * stop using them as we get close to the limit.+ */+ loanedblks = 2 * loanedblks;+ if (vfreeblks > loanedblks)+ vfreeblks -= loanedblks;+ else+ vfreeblks = 0;++ if (maxblks)+ vfreeblks = MIN(vfreeblks, maxblks);++ vnode_put(backing_vp);++ *pfree_blks = vfreeblks;++ return true;+}+#endif++u_int32_t+hfs_free_cnids(struct hfsmount * hfsmp)+{+ return HFS_MAX_FILES - hfsmp->hfs_filecount - hfsmp->hfs_dircount;+}++u_int32_t+hfs_freeblks(struct hfsmount * hfsmp, int wantreserve)+{+ u_int32_t freeblks;+ u_int32_t rsrvblks;+ u_int32_t loanblks;++ /*+ * We don't bother taking the mount lock+ * to look at these values since the values+ * themselves are each updated atomically+ * on aligned addresses.+ */+ freeblks = hfsmp->freeBlocks;+ rsrvblks = hfsmp->reserveBlocks;+ loanblks = hfsmp->loanedBlocks + hfsmp->lockedBlocks;+ if (wantreserve) {+ if (freeblks > rsrvblks)+ freeblks -= rsrvblks;+ else+ freeblks = 0;+ }+ if (freeblks > loanblks)+ freeblks -= loanblks;+ else+ freeblks = 0;++#if HFS_SPARSE_DEV+ /*+ * When the underlying device is sparse, check the+ * available space on the backing store volume.+ */+ uint64_t vfreeblks;+ if (hfs_get_backing_free_blks(hfsmp, &vfreeblks))+ freeblks = MIN(freeblks, vfreeblks);+#endif /* HFS_SPARSE_DEV */++ return (freeblks);+}++/*+ * Map HFS Common errors (negative) to BSD error codes (positive).+ * Positive errors (ie BSD errors) are passed through unchanged.+ */+short MacToVFSError(OSErr err)+{+ if (err >= 0)+ return err;++ /* BSD/VFS internal errnos */+ switch (err) {+ case HFS_ERESERVEDNAME: /* -8 */+ return err;+ }++ switch (err) {+ case dskFulErr: /* -34 */+ case btNoSpaceAvail: /* -32733 */+ return ENOSPC;+ case fxOvFlErr: /* -32750 */+ return EOVERFLOW;++ case btBadNode: /* -32731 */+ return EIO;++ case memFullErr: /* -108 */+ return ENOMEM; /* +12 */++ case cmExists: /* -32718 */+ case btExists: /* -32734 */+ return EEXIST; /* +17 */++ case cmNotFound: /* -32719 */+ case btNotFound: /* -32735 */+ return ENOENT; /* 28 */++ case cmNotEmpty: /* -32717 */+ return ENOTEMPTY; /* 66 */++ case cmFThdDirErr: /* -32714 */+ return EISDIR; /* 21 */++ case fxRangeErr: /* -32751 */+ return ERANGE;++ case bdNamErr: /* -37 */+ return ENAMETOOLONG; /* 63 */++ case paramErr: /* -50 */+ case fileBoundsErr: /* -1309 */+ return EINVAL; /* +22 */++ case fsBTBadNodeSize:+ return ENXIO;++ default:+ return EIO; /* +5 */+ }+}+++/*+ * Find the current thread's directory hint for a given index.+ *+ * Requires an exclusive lock on directory cnode.+ *+ * Use detach if the cnode lock must be dropped while the hint is still active.+ */+directoryhint_t *+hfs_getdirhint(struct cnode *dcp, int index, int detach)+{+ struct timeval tv;+ directoryhint_t *hint;+ boolean_t need_remove, need_init;+ const u_int8_t * name;++ microuptime(&tv);++ /*+ * Look for an existing hint first. If not found, create a new one (when+ * the list is not full) or recycle the oldest hint. Since new hints are+ * always added to the head of the list, the last hint is always the+ * oldest.+ */+ TAILQ_FOREACH(hint, &dcp->c_hintlist, dh_link) {+ if (hint->dh_index == index)+ break;+ }+ if (hint != NULL) { /* found an existing hint */+ need_init = false;+ need_remove = true;+ } else { /* cannot find an existing hint */+ need_init = true;+ if (dcp->c_dirhintcnt < HFS_MAXDIRHINTS) { /* we don't need recycling */+ /* Create a default directory hint */+ hint = hfs_zalloc(HFS_DIRHINT_ZONE);+ ++dcp->c_dirhintcnt;+ need_remove = false;+ } else { /* recycle the last (i.e., the oldest) hint */+ hint = TAILQ_LAST(&dcp->c_hintlist, hfs_hinthead);+ if ((hint->dh_desc.cd_flags & CD_HASBUF) &&+ (name = hint->dh_desc.cd_nameptr)) {+ hint->dh_desc.cd_nameptr = NULL;+ hint->dh_desc.cd_namelen = 0;+ hint->dh_desc.cd_flags &= ~CD_HASBUF;+ vfs_removename((const char *)name);+ }+ need_remove = true;+ }+ }++ if (need_remove)+ TAILQ_REMOVE(&dcp->c_hintlist, hint, dh_link);++ if (detach)+ --dcp->c_dirhintcnt;+ else+ TAILQ_INSERT_HEAD(&dcp->c_hintlist, hint, dh_link);++ if (need_init) {+ hint->dh_index = index;+ hint->dh_desc.cd_flags = 0;+ hint->dh_desc.cd_encoding = 0;+ hint->dh_desc.cd_namelen = 0;+ hint->dh_desc.cd_nameptr = NULL;+ hint->dh_desc.cd_parentcnid = dcp->c_fileid;+ hint->dh_desc.cd_hint = dcp->c_childhint;+ hint->dh_desc.cd_cnid = 0;+ }+ hint->dh_time = tv.tv_sec;+ return (hint);+}++/*+ * Release a single directory hint.+ *+ * Requires an exclusive lock on directory cnode.+ */+void+hfs_reldirhint(struct cnode *dcp, directoryhint_t * relhint)+{+ const u_int8_t * name;+ directoryhint_t *hint;++ /* Check if item is on list (could be detached) */+ TAILQ_FOREACH(hint, &dcp->c_hintlist, dh_link) {+ if (hint == relhint) {+ TAILQ_REMOVE(&dcp->c_hintlist, relhint, dh_link);+ --dcp->c_dirhintcnt;+ break;+ }+ }+ name = relhint->dh_desc.cd_nameptr;+ if ((relhint->dh_desc.cd_flags & CD_HASBUF) && (name != NULL)) {+ relhint->dh_desc.cd_nameptr = NULL;+ relhint->dh_desc.cd_namelen = 0;+ relhint->dh_desc.cd_flags &= ~CD_HASBUF;+ vfs_removename((const char *)name);+ }+ hfs_zfree(relhint, HFS_DIRHINT_ZONE);+}++/*+ * Release directory hints for given directory+ *+ * Requires an exclusive lock on directory cnode.+ */+void+hfs_reldirhints(struct cnode *dcp, int stale_hints_only)+{+ struct timeval tv;+ directoryhint_t *hint, *prev;+ const u_int8_t * name;++ if (stale_hints_only)+ microuptime(&tv);++ /* searching from the oldest to the newest, so we can stop early when releasing stale hints only */+ for (hint = TAILQ_LAST(&dcp->c_hintlist, hfs_hinthead); hint != NULL; hint = prev) {+ if (stale_hints_only && (tv.tv_sec - hint->dh_time) < HFS_DIRHINT_TTL)+ break; /* stop here if this entry is too new */+ name = hint->dh_desc.cd_nameptr;+ if ((hint->dh_desc.cd_flags & CD_HASBUF) && (name != NULL)) {+ hint->dh_desc.cd_nameptr = NULL;+ hint->dh_desc.cd_namelen = 0;+ hint->dh_desc.cd_flags &= ~CD_HASBUF;+ vfs_removename((const char *)name);+ }+ prev = TAILQ_PREV(hint, hfs_hinthead, dh_link); /* must save this pointer before calling FREE_ZONE on this node */+ TAILQ_REMOVE(&dcp->c_hintlist, hint, dh_link);+ hfs_zfree(hint, HFS_DIRHINT_ZONE);+ --dcp->c_dirhintcnt;+ }+}++/*+ * Insert a detached directory hint back into the list of dirhints.+ *+ * Requires an exclusive lock on directory cnode.+ */+void+hfs_insertdirhint(struct cnode *dcp, directoryhint_t * hint)+{+ directoryhint_t *test;++ TAILQ_FOREACH(test, &dcp->c_hintlist, dh_link) {+ if (test == hint)+ panic("hfs_insertdirhint: hint %p already on list!", hint);+ }++ TAILQ_INSERT_HEAD(&dcp->c_hintlist, hint, dh_link);+ ++dcp->c_dirhintcnt;+}++/*+ * Perform a case-insensitive compare of two UTF-8 filenames.+ *+ * Returns 0 if the strings match.+ */+int+hfs_namecmp(const u_int8_t *str1, size_t len1, const u_int8_t *str2, size_t len2)+{+ u_int16_t *ustr1, *ustr2;+ size_t ulen1, ulen2;+ size_t maxbytes;+ int cmp = -1;++ if (len1 != len2)+ return (cmp);++ maxbytes = kHFSPlusMaxFileNameChars << 1;+ ustr1 = hfs_malloc_data(maxbytes << 1);+ ustr2 = ustr1 + (maxbytes >> 1);++ if (utf8_decodestr(str1, len1, ustr1, &ulen1, maxbytes, ':', 0) != 0)+ goto out;+ if (utf8_decodestr(str2, len2, ustr2, &ulen2, maxbytes, ':', 0) != 0)+ goto out;++ cmp = FastUnicodeCompare(ustr1, ulen1>>1, ustr2, ulen2>>1);+out:+ hfs_free_data(ustr1, maxbytes << 1);+ return (cmp);+}++typedef struct jopen_cb_info {+ mount_t mp;+ off_t jsize;+ char *desired_uuid;+ struct vnode *jvp;+ size_t blksize;+ int need_clean;+ int need_init;+} jopen_cb_info;++static int+journal_open_cb(const char *bsd_dev_name, const char *uuid_str, void *arg)+{+ jopen_cb_info *ji = (jopen_cb_info *)arg;+ char bsd_name[256];+ int error;++ strlcpy(&bsd_name[0], "/dev/", sizeof(bsd_name));+ strlcpy(&bsd_name[5], bsd_dev_name, sizeof(bsd_name)-5);++ if ((error = vnode_lookup(bsd_name, VNODE_LOOKUP_NOFOLLOW, &ji->jvp,+ vfs_context_kernel()))) {+ printf("hfs: journal open cb: error %d looking up device %s (dev uuid %s)\n", error, bsd_name, uuid_str);+ return 1; // keep iterating+ }++ struct vnop_open_args oargs = {+ .a_vp = ji->jvp,+ .a_mode = FREAD | FWRITE,+ .a_context = vfs_context_kernel(),+ };++ if (spec_open(&oargs)) {+ vnode_put(ji->jvp);+ ji->jvp = NULL;+ return 1;+ }++ // if the journal is dirty and we didn't specify a desired+ // journal device uuid, then do not use the journal. but+ // if the journal is just invalid (e.g. it hasn't been+ // initialized) then just set the need_init flag.+ if (ji->need_clean && ji->desired_uuid && ji->desired_uuid[0] == '\0') {+ error = journal_is_clean(ji->jvp, 0, ji->jsize,+ (void *)1, ji->blksize);+ if (error == EBUSY) {+ struct vnop_close_args cargs = {+ .a_vp = ji->jvp,+ .a_fflag = FREAD | FWRITE,+ .a_context = vfs_context_kernel()+ };+ spec_close(&cargs);+ vnode_put(ji->jvp);+ ji->jvp = NULL;+ return 1; // keep iterating+ } else if (error == EINVAL) {+ ji->need_init = 1;+ }+ }++ if (ji->desired_uuid && ji->desired_uuid[0] == '\0') {+ strlcpy(ji->desired_uuid, uuid_str, 128);+ }+ vnode_setmountedon(ji->jvp);+ return 0; // stop iterating+}++static vnode_t+open_journal_dev(mount_t mp,+ const char *vol_device,+ int need_clean,+ char *uuid_str,+ char *machine_serial_num,+ off_t jsize,+ size_t blksize,+ int *need_init)+{+ int retry_counter=0;+ jopen_cb_info ji;++ ji.mp = mp;+ ji.jsize = jsize;+ ji.desired_uuid = uuid_str;+ ji.jvp = NULL;+ ji.blksize = blksize;+ ji.need_clean = need_clean;+ ji.need_init = 0;++// if (uuid_str[0] == '\0') {+// printf("hfs: open journal dev: %s: locating any available non-dirty external journal partition\n", vol_device);+// } else {+// printf("hfs: open journal dev: %s: trying to find the external journal partition w/uuid %s\n", vol_device, uuid_str);+// }+ while (ji.jvp == NULL && retry_counter++ < 4) {+ if (retry_counter > 1) {+ if (uuid_str[0]) {+ printf("hfs: open_journal_dev: uuid %s not found. waiting 10sec.\n", uuid_str);+ } else {+ printf("hfs: open_journal_dev: no available external journal partition found. waiting 10sec.\n");+ }+ delay_for_interval(10* 1000000, NSEC_PER_USEC); // wait for ten seconds and then try again+ }++ hfs_iterate_media_with_content(EXTJNL_CONTENT_TYPE_UUID,+ journal_open_cb, &ji);+ }++ if (ji.jvp == NULL) {+ printf("hfs: volume: %s: did not find jnl device uuid: %s from machine serial number: %s\n",+ vol_device, uuid_str, machine_serial_num);+ }++ *need_init = ji.need_init;++ return ji.jvp;+}++void hfs_close_jvp(hfsmount_t *hfsmp)+{+ if (!hfsmp || !hfsmp->jvp || hfsmp->jvp == hfsmp->hfs_devvp)+ return;++ vnode_clearmountedon(hfsmp->jvp);+ struct vnop_close_args cargs = {+ .a_vp = hfsmp->jvp,+ .a_fflag = FREAD | FWRITE,+ .a_context = vfs_context_kernel()+ };+ spec_close(&cargs);+ vnode_put(hfsmp->jvp);+ hfsmp->jvp = NULL;+}++int+hfs_early_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,+ void *_args, off_t embeddedOffset, daddr64_t mdb_offset,+ HFSMasterDirectoryBlock *mdbp, kauth_cred_t cred)+{+ JournalInfoBlock *jibp;+ struct buf *jinfo_bp, *bp;+ int sectors_per_fsblock, arg_flags=0, arg_tbufsz=0;+ int retval, write_jibp = 0;+ uint32_t blksize = hfsmp->hfs_logical_block_size;+ struct vnode *devvp;+ struct hfs_mount_args *args = _args;+ u_int32_t jib_flags;+ u_int64_t jib_offset;+ u_int64_t jib_size;+ const char *dev_name;++ devvp = hfsmp->hfs_devvp;+ dev_name = vnode_getname_printable(devvp);++ if (args != NULL && (args->flags & HFSFSMNT_EXTENDED_ARGS)) {+ arg_flags = args->journal_flags;+ arg_tbufsz = args->journal_tbuffer_size;+ }++ sectors_per_fsblock = SWAP_BE32(vhp->blockSize) / blksize;++ jinfo_bp = NULL;+ retval = (int)buf_meta_bread(devvp,+ (daddr64_t)((embeddedOffset/blksize) ++ ((u_int64_t)SWAP_BE32(vhp->journalInfoBlock)*sectors_per_fsblock)),+ hfsmp->hfs_physical_block_size, cred, &jinfo_bp);+ if (retval) {+ if (jinfo_bp) {+ buf_brelse(jinfo_bp);+ }+ goto cleanup_dev_name;+ }++ jibp = (JournalInfoBlock *)buf_dataptr(jinfo_bp);+ jib_flags = SWAP_BE32(jibp->flags);+ jib_size = SWAP_BE64(jibp->size);++ if (jib_flags & kJIJournalInFSMask) {+ hfsmp->jvp = hfsmp->hfs_devvp;+ jib_offset = SWAP_BE64(jibp->offset);+ } else {+ int need_init=0;++ // if the volume was unmounted cleanly then we'll pick any+ // available external journal partition+ //+ if (SWAP_BE32(vhp->attributes) & kHFSVolumeUnmountedMask) {+ *((char *)&jibp->ext_jnl_uuid[0]) = '\0';+ }++ hfsmp->jvp = open_journal_dev(hfsmp->hfs_mp,+ dev_name,+ !(jib_flags & kJIJournalNeedInitMask),+ (char *)&jibp->ext_jnl_uuid[0],+ (char *)&jibp->machine_serial_num[0],+ jib_size,+ hfsmp->hfs_logical_block_size,+ &need_init);+ if (hfsmp->jvp == NULL) {+ buf_brelse(jinfo_bp);+ retval = EROFS;+ goto cleanup_dev_name;+ } else {+ if (hfs_get_platform_serial_number(&jibp->machine_serial_num[0], sizeof(jibp->machine_serial_num)) != KERN_SUCCESS) {+ strlcpy(&jibp->machine_serial_num[0], "unknown-machine-uuid", sizeof(jibp->machine_serial_num));+ }+ }++ jib_offset = 0;+ write_jibp = 1;+ if (need_init) {+ jib_flags |= kJIJournalNeedInitMask;+ }+ }++ // save this off for the hack-y check in hfs_remove()+ hfsmp->jnl_start = jib_offset / SWAP_BE32(vhp->blockSize);+ hfsmp->jnl_size = jib_size;++ if ((hfsmp->hfs_flags & HFS_READ_ONLY) && (vfs_flags(hfsmp->hfs_mp) & MNT_ROOTFS) == 0) {+ // if the file system is read-only, check if the journal is empty.+ // if it is, then we can allow the mount. otherwise we have to+ // return failure.+ retval = journal_is_clean(hfsmp->jvp,+ jib_offset + embeddedOffset,+ jib_size,+ devvp,+ hfsmp->hfs_logical_block_size);++ hfsmp->jnl = NULL;++ buf_brelse(jinfo_bp);++ if (retval) {+ const char *name = vnode_getname_printable(devvp);+ printf("hfs: early journal init: volume on %s is read-only and journal is dirty. Can not mount volume.\n",+ name);+ vnode_putname_printable(name);+ }++ goto cleanup_dev_name;+ }++ if (jib_flags & kJIJournalNeedInitMask) {+ printf("hfs: Initializing the journal (joffset 0x%llx sz 0x%llx)...\n",+ jib_offset + embeddedOffset, jib_size);+ hfsmp->jnl = journal_create(hfsmp->jvp,+ jib_offset + embeddedOffset,+ jib_size,+ devvp,+ blksize,+ arg_flags,+ arg_tbufsz,+ hfs_sync_metadata, hfsmp->hfs_mp,+ hfsmp->hfs_mp);+ if (hfsmp->jnl)+ journal_trim_set_callback(hfsmp->jnl, hfs_trim_callback, hfsmp);++ // no need to start a transaction here... if this were to fail+ // we'd just re-init it on the next mount.+ jib_flags &= ~kJIJournalNeedInitMask;+ jibp->flags = SWAP_BE32(jib_flags);+ buf_bwrite(jinfo_bp);+ jinfo_bp = NULL;+ jibp = NULL;+ } else {+ //printf("hfs: Opening the journal (joffset 0x%llx sz 0x%llx vhp_blksize %d)...\n",+ // jib_offset + embeddedOffset,+ // jib_size, SWAP_BE32(vhp->blockSize));++ hfsmp->jnl = journal_open(hfsmp->jvp,+ jib_offset + embeddedOffset,+ jib_size,+ devvp,+ blksize,+ arg_flags,+ arg_tbufsz,+ hfs_sync_metadata, hfsmp->hfs_mp,+ hfsmp->hfs_mp);+ if (hfsmp->jnl)+ journal_trim_set_callback(hfsmp->jnl, hfs_trim_callback, hfsmp);++ if (write_jibp) {+ buf_bwrite(jinfo_bp);+ } else {+ buf_brelse(jinfo_bp);+ }+ jinfo_bp = NULL;+ jibp = NULL;++ if (hfsmp->jnl && mdbp) {+ // reload the mdb because it could have changed+ // if the journal had to be replayed.+ if (mdb_offset == 0) {+ mdb_offset = (daddr64_t)((embeddedOffset / blksize) + HFS_PRI_SECTOR(blksize));+ }+ bp = NULL;+ retval = (int)buf_meta_bread(devvp,+ HFS_PHYSBLK_ROUNDDOWN(mdb_offset, hfsmp->hfs_log_per_phys),+ hfsmp->hfs_physical_block_size, cred, &bp);+ if (retval) {+ if (bp) {+ buf_brelse(bp);+ }+ printf("hfs: failed to reload the mdb after opening the journal (retval %d)!\n",+ retval);+ goto cleanup_dev_name;+ }+ bcopy((char *)buf_dataptr(bp) + HFS_PRI_OFFSET(hfsmp->hfs_physical_block_size), mdbp, 512);+ buf_brelse(bp);+ bp = NULL;+ }+ }++ // if we expected the journal to be there and we couldn't+ // create it or open it then we have to bail out.+ if (hfsmp->jnl == NULL) {+ printf("hfs: early jnl init: failed to open/create the journal (retval %d).\n", retval);+ retval = EINVAL;+ goto cleanup_dev_name;+ }++ retval = 0;++cleanup_dev_name:+ vnode_putname_printable(dev_name);+ return retval;+}+++//+// This function will go and re-locate the .journal_info_block and+// the .journal files in case they moved (which can happen if you+// run Norton SpeedDisk). If we fail to find either file we just+// disable journaling for this volume and return. We turn off the+// journaling bit in the vcb and assume it will get written to disk+// later (if it doesn't on the next mount we'd do the same thing+// again which is harmless). If we disable journaling we don't+// return an error so that the volume is still mountable.+//+// If the info we find for the .journal_info_block and .journal files+// isn't what we had stored, we re-set our cached info and proceed+// with opening the journal normally.+//+static int+hfs_late_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, void *_args)+{+ JournalInfoBlock *jibp;+ struct buf *jinfo_bp;+ int sectors_per_fsblock, arg_flags=0, arg_tbufsz=0;+ int retval, write_jibp = 0, recreate_journal = 0;+ struct vnode *devvp;+ struct cat_attr jib_attr, jattr;+ struct cat_fork jib_fork, jfork;+ ExtendedVCB *vcb;+ u_int32_t fid;+ struct hfs_mount_args *args = _args;+ u_int32_t jib_flags;+ u_int64_t jib_offset;+ u_int64_t jib_size;++ devvp = hfsmp->hfs_devvp;+ vcb = HFSTOVCB(hfsmp);++ if (args != NULL && (args->flags & HFSFSMNT_EXTENDED_ARGS)) {+ if (args->journal_disable) {+ return 0;+ }++ arg_flags = args->journal_flags;+ arg_tbufsz = args->journal_tbuffer_size;+ }++ fid = GetFileInfo(vcb, kRootDirID, ".journal_info_block", &jib_attr, &jib_fork);+ if (fid == 0 || jib_fork.cf_extents[0].startBlock == 0 || jib_fork.cf_size == 0) {+ printf("hfs: can't find the .journal_info_block! disabling journaling (start: %d).\n",+ fid ? jib_fork.cf_extents[0].startBlock : 0);+ vcb->vcbAtrb &= ~kHFSVolumeJournaledMask;+ return 0;+ }+ hfsmp->hfs_jnlinfoblkid = fid;++ // make sure the journal_info_block begins where we think it should.+ if (SWAP_BE32(vhp->journalInfoBlock) != jib_fork.cf_extents[0].startBlock) {+ printf("hfs: The journal_info_block moved (was: %d; is: %d). Fixing up\n",+ SWAP_BE32(vhp->journalInfoBlock), jib_fork.cf_extents[0].startBlock);++ vcb->vcbJinfoBlock = jib_fork.cf_extents[0].startBlock;+ vhp->journalInfoBlock = SWAP_BE32(jib_fork.cf_extents[0].startBlock);+ recreate_journal = 1;+ }+++ sectors_per_fsblock = SWAP_BE32(vhp->blockSize) / hfsmp->hfs_logical_block_size;+ jinfo_bp = NULL;+ retval = (int)buf_meta_bread(devvp,+ (vcb->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size ++ ((u_int64_t)SWAP_BE32(vhp->journalInfoBlock)*sectors_per_fsblock)),+ hfsmp->hfs_physical_block_size, NOCRED, &jinfo_bp);+ if (retval) {+ if (jinfo_bp) {+ buf_brelse(jinfo_bp);+ }+ printf("hfs: can't read journal info block. disabling journaling.\n");+ vcb->vcbAtrb &= ~kHFSVolumeJournaledMask;+ return 0;+ }++ jibp = (JournalInfoBlock *)buf_dataptr(jinfo_bp);+ jib_flags = SWAP_BE32(jibp->flags);+ jib_offset = SWAP_BE64(jibp->offset);+ jib_size = SWAP_BE64(jibp->size);++ fid = GetFileInfo(vcb, kRootDirID, ".journal", &jattr, &jfork);+ if (fid == 0 || jfork.cf_extents[0].startBlock == 0 || jfork.cf_size == 0) {+ printf("hfs: can't find the journal file! disabling journaling (start: %d)\n",+ fid ? jfork.cf_extents[0].startBlock : 0);+ buf_brelse(jinfo_bp);+ vcb->vcbAtrb &= ~kHFSVolumeJournaledMask;+ return 0;+ }+ hfsmp->hfs_jnlfileid = fid;++ // make sure the journal file begins where we think it should.+ if ((jib_flags & kJIJournalInFSMask) && (jib_offset / (u_int64_t)vcb->blockSize) != jfork.cf_extents[0].startBlock) {+ printf("hfs: The journal file moved (was: %lld; is: %d). Fixing up\n",+ (jib_offset / (u_int64_t)vcb->blockSize), jfork.cf_extents[0].startBlock);++ jib_offset = (u_int64_t)jfork.cf_extents[0].startBlock * (u_int64_t)vcb->blockSize;+ write_jibp = 1;+ recreate_journal = 1;+ }++ // check the size of the journal file.+ if (jib_size != (u_int64_t)jfork.cf_extents[0].blockCount*vcb->blockSize) {+ printf("hfs: The journal file changed size! (was %lld; is %lld). Fixing up.\n",+ jib_size, (u_int64_t)jfork.cf_extents[0].blockCount*vcb->blockSize);++ jib_size = (u_int64_t)jfork.cf_extents[0].blockCount * vcb->blockSize;+ write_jibp = 1;+ recreate_journal = 1;+ }++ if (jib_flags & kJIJournalInFSMask) {+ hfsmp->jvp = hfsmp->hfs_devvp;+ jib_offset += (off_t)vcb->hfsPlusIOPosOffset;+ } else {+ const char *dev_name;+ int need_init = 0;++ dev_name = vnode_getname_printable(devvp);++ // since the journal is empty, just use any available external journal+ *((char *)&jibp->ext_jnl_uuid[0]) = '\0';++ // this fills in the uuid of the device we actually get+ hfsmp->jvp = open_journal_dev(hfsmp->hfs_mp,+ dev_name,+ !(jib_flags & kJIJournalNeedInitMask),+ (char *)&jibp->ext_jnl_uuid[0],+ (char *)&jibp->machine_serial_num[0],+ jib_size,+ hfsmp->hfs_logical_block_size,+ &need_init);+ if (hfsmp->jvp == NULL) {+ buf_brelse(jinfo_bp);+ vnode_putname_printable(dev_name);+ return EROFS;+ } else {+ if (hfs_get_platform_serial_number(&jibp->machine_serial_num[0], sizeof(jibp->machine_serial_num)) != KERN_SUCCESS) {+ strlcpy(&jibp->machine_serial_num[0], "unknown-machine-serial-num", sizeof(jibp->machine_serial_num));+ }+ }+ jib_offset = 0;+ recreate_journal = 1;+ write_jibp = 1;+ if (need_init) {+ jib_flags |= kJIJournalNeedInitMask;+ }+ vnode_putname_printable(dev_name);+ }++ // save this off for the hack-y check in hfs_remove()+ hfsmp->jnl_start = jib_offset / SWAP_BE32(vhp->blockSize);+ hfsmp->jnl_size = jib_size;++ if ((hfsmp->hfs_flags & HFS_READ_ONLY) && (vfs_flags(hfsmp->hfs_mp) & MNT_ROOTFS) == 0) {+ // if the file system is read-only, check if the journal is empty.+ // if it is, then we can allow the mount. otherwise we have to+ // return failure.+ retval = journal_is_clean(hfsmp->jvp,+ jib_offset,+ jib_size,+ devvp,+ hfsmp->hfs_logical_block_size);++ hfsmp->jnl = NULL;++ buf_brelse(jinfo_bp);++ if (retval) {+ const char *name = vnode_getname_printable(devvp);+ printf("hfs: late journal init: volume on %s is read-only and journal is dirty. Can not mount volume.\n",+ name);+ vnode_putname_printable(name);+ }++ return retval;+ }++ if ((jib_flags & kJIJournalNeedInitMask) || recreate_journal) {+ printf("hfs: Initializing the journal (joffset 0x%llx sz 0x%llx)...\n",+ jib_offset, jib_size);+ hfsmp->jnl = journal_create(hfsmp->jvp,+ jib_offset,+ jib_size,+ devvp,+ hfsmp->hfs_logical_block_size,+ arg_flags,+ arg_tbufsz,+ hfs_sync_metadata, hfsmp->hfs_mp,+ hfsmp->hfs_mp);+ if (hfsmp->jnl)+ journal_trim_set_callback(hfsmp->jnl, hfs_trim_callback, hfsmp);++ // no need to start a transaction here... if this were to fail+ // we'd just re-init it on the next mount.+ jib_flags &= ~kJIJournalNeedInitMask;+ write_jibp = 1;++ } else {+ //+ // if we weren't the last person to mount this volume+ // then we need to throw away the journal because it+ // is likely that someone else mucked with the disk.+ // if the journal is empty this is no big deal. if the+ // disk is dirty this prevents us from replaying the+ // journal over top of changes that someone else made.+ //+ arg_flags |= JOURNAL_RESET;++ //printf("hfs: Opening the journal (joffset 0x%llx sz 0x%llx vhp_blksize %d)...\n",+ // jib_offset,+ // jib_size, SWAP_BE32(vhp->blockSize));++ hfsmp->jnl = journal_open(hfsmp->jvp,+ jib_offset,+ jib_size,+ devvp,+ hfsmp->hfs_logical_block_size,+ arg_flags,+ arg_tbufsz,+ hfs_sync_metadata, hfsmp->hfs_mp,+ hfsmp->hfs_mp);+ if (hfsmp->jnl)+ journal_trim_set_callback(hfsmp->jnl, hfs_trim_callback, hfsmp);+ }+++ if (write_jibp) {+ jibp->flags = SWAP_BE32(jib_flags);+ jibp->offset = SWAP_BE64(jib_offset);+ jibp->size = SWAP_BE64(jib_size);++ buf_bwrite(jinfo_bp);+ } else {+ buf_brelse(jinfo_bp);+ }+ jinfo_bp = NULL;+ jibp = NULL;++ // if we expected the journal to be there and we couldn't+ // create it or open it then we have to bail out.+ if (hfsmp->jnl == NULL) {+ printf("hfs: late jnl init: failed to open/create the journal (retval %d).\n", retval);+ return EINVAL;+ }++ return 0;+}++/*+ * Calculate the allocation zone for metadata.+ *+ * This zone includes the following:+ * Allocation Bitmap file+ * Overflow Extents file+ * Journal file+ * Quota files+ * Clustered Hot files+ * Catalog file+ *+ * METADATA ALLOCATION ZONE+ * ____________________________________________________________________________+ * | | | | | | |+ * | BM | JF | OEF | CATALOG |---> | HOT FILES |+ * |____|____|_____|_______________|______________________________|___________|+ *+ * <------------------------------- N * 128 MB ------------------------------->+ *+ */+#define GIGABYTE (u_int64_t)(1024*1024*1024)++#define HOTBAND_MINIMUM_SIZE (10*1024*1024)+#define HOTBAND_MAXIMUM_SIZE (512*1024*1024)++/* Initialize the metadata zone.+ *+ * If the size of the volume is less than the minimum size for+ * metadata zone, metadata zone is disabled.+ *+ * If disable is true, disable metadata zone unconditionally.+ */+void+hfs_metadatazone_init(struct hfsmount *hfsmp, int disable)+{+ ExtendedVCB *vcb;+ u_int64_t fs_size;+ u_int64_t zonesize;+ u_int64_t temp;+ u_int64_t filesize;+ u_int32_t blk;+ int items, really_do_it=1;++ vcb = HFSTOVCB(hfsmp);+ fs_size = (u_int64_t)vcb->blockSize * (u_int64_t)vcb->allocLimit;++ /*+ * For volumes less than 10 GB, don't bother.+ */+ if (fs_size < ((u_int64_t)10 * GIGABYTE)) {+ really_do_it = 0;+ }++ /*+ * Skip non-journaled volumes as well.+ */+ if (hfsmp->jnl == NULL) {+ really_do_it = 0;+ }++ /* If caller wants to disable metadata zone, do it */+ if (disable == true) {+ really_do_it = 0;+ }++ /*+ * Start with space for the boot blocks and Volume Header.+ * 1536 = byte offset from start of volume to end of volume header:+ * 1024 bytes is the offset from the start of the volume to the+ * start of the volume header (defined by the volume format)+ * + 512 bytes (the size of the volume header).+ */+ zonesize = roundup(1536, hfsmp->blockSize);++ /*+ * Add the on-disk size of allocation bitmap.+ */+ zonesize += hfsmp->hfs_allocation_cp->c_datafork->ff_blocks * hfsmp->blockSize;++ /*+ * Add space for the Journal Info Block and Journal (if they're in+ * this file system).+ */+ if (hfsmp->jnl && hfsmp->jvp == hfsmp->hfs_devvp) {+ zonesize += hfsmp->blockSize + hfsmp->jnl_size;+ }++ /*+ * Add the existing size of the Extents Overflow B-tree.+ * (It rarely grows, so don't bother reserving additional room for it.)+ */+ zonesize += hfs_blk_to_bytes(hfsmp->hfs_extents_cp->c_datafork->ff_blocks, hfsmp->blockSize);++ /*+ * If there is an Attributes B-tree, leave room for 11 clumps worth.+ * newfs_hfs allocates one clump, and leaves a gap of 10 clumps.+ * When installing a full OS install onto a 20GB volume, we use+ * 7 to 8 clumps worth of space (depending on packages), so that leaves+ * us with another 3 or 4 clumps worth before we need another extent.+ */+ if (hfsmp->hfs_attribute_cp) {+ zonesize += 11 * hfsmp->hfs_attribute_cp->c_datafork->ff_clumpsize;+ }++ /*+ * Leave room for 11 clumps of the Catalog B-tree.+ * Again, newfs_hfs allocates one clump plus a gap of 10 clumps.+ * When installing a full OS install onto a 20GB volume, we use+ * 7 to 8 clumps worth of space (depending on packages), so that leaves+ * us with another 3 or 4 clumps worth before we need another extent.+ */+ zonesize += 11 * hfsmp->hfs_catalog_cp->c_datafork->ff_clumpsize;++ /*+ * Add space for hot file region.+ *+ * ...for now, use 5 MB per 1 GB (0.5 %)+ */+ filesize = (fs_size / 1024) * 5;+ if (filesize > HOTBAND_MAXIMUM_SIZE)+ filesize = HOTBAND_MAXIMUM_SIZE;+ else if (filesize < HOTBAND_MINIMUM_SIZE)+ filesize = HOTBAND_MINIMUM_SIZE;+ /*+ * Calculate user quota file requirements.+ */+ if (hfsmp->hfs_flags & HFS_QUOTAS) {+ items = QF_USERS_PER_GB * (fs_size / GIGABYTE);+ if (items < QF_MIN_USERS)+ items = QF_MIN_USERS;+ else if (items > QF_MAX_USERS)+ items = QF_MAX_USERS;+ if (!powerof2(items)) {+ int x = items;+ items = 4;+ while (x>>1 != 1) {+ x = x >> 1;+ items = items << 1;+ }+ }+ filesize += (items + 1) * sizeof(struct dqblk);+ /*+ * Calculate group quota file requirements.+ *+ */+ items = QF_GROUPS_PER_GB * (fs_size / GIGABYTE);+ if (items < QF_MIN_GROUPS)+ items = QF_MIN_GROUPS;+ else if (items > QF_MAX_GROUPS)+ items = QF_MAX_GROUPS;+ if (!powerof2(items)) {+ int x = items;+ items = 4;+ while (x>>1 != 1) {+ x = x >> 1;+ items = items << 1;+ }+ }+ filesize += (items + 1) * sizeof(struct dqblk);+ }+ zonesize += filesize;++ /*+ * Round up entire zone to a bitmap block's worth.+ * The extra space goes to the catalog file and hot file area.+ */+ temp = zonesize;+ zonesize = roundup(zonesize, (u_int64_t)vcb->vcbVBMIOSize * 8 * vcb->blockSize);+ hfsmp->hfs_min_alloc_start = zonesize / vcb->blockSize;+ /*+ * If doing the round up for hfs_min_alloc_start would push us past+ * allocLimit, then just reset it back to 0. Though using a value+ * bigger than allocLimit would not cause damage in the block allocator+ * code, this value could get stored in the volume header and make it out+ * to disk, making the volume header technically corrupt.+ */+ if (hfsmp->hfs_min_alloc_start >= hfsmp->allocLimit) {+ hfsmp->hfs_min_alloc_start = 0;+ }++ if (really_do_it == 0) {+ /* If metadata zone needs to be disabled because the+ * volume was truncated, clear the bit and zero out+ * the values that are no longer needed.+ */+ if (hfsmp->hfs_flags & HFS_METADATA_ZONE) {+ /* Disable metadata zone */+ hfsmp->hfs_flags &= ~HFS_METADATA_ZONE;++ /* Zero out mount point values that are not required */+ hfsmp->hfs_catalog_maxblks = 0;+ hfsmp->hfs_hotfile_maxblks = 0;+ hfsmp->hfs_hotfile_start = 0;+ hfsmp->hfs_hotfile_end = 0;+ hfsmp->hfs_hotfile_freeblks = 0;+ hfsmp->hfs_metazone_start = 0;+ hfsmp->hfs_metazone_end = 0;+ }++ return;+ }++ temp = zonesize - temp; /* temp has extra space */+ filesize += temp / 3;+ hfsmp->hfs_catalog_maxblks += (temp - (temp / 3)) / vcb->blockSize;++ if (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) {+ hfsmp->hfs_hotfile_maxblks = (uint32_t) (hfsmp->hfs_cs_hotfile_size / HFSTOVCB(hfsmp)->blockSize);+ } else {+ hfsmp->hfs_hotfile_maxblks = filesize / vcb->blockSize;+ }++ /* Convert to allocation blocks. */+ blk = zonesize / vcb->blockSize;++ /* The default metadata zone location is at the start of volume. */+ hfsmp->hfs_metazone_start = 1;+ hfsmp->hfs_metazone_end = blk - 1;++ /* The default hotfile area is at the end of the zone. */+ if (vfs_flags(HFSTOVFS(hfsmp)) & MNT_ROOTFS) {+ hfsmp->hfs_hotfile_start = blk - (filesize / vcb->blockSize);+ hfsmp->hfs_hotfile_end = hfsmp->hfs_metazone_end;+ hfsmp->hfs_hotfile_freeblks = hfs_hotfile_freeblocks(hfsmp);+ }+ else {+ hfsmp->hfs_hotfile_start = 0;+ hfsmp->hfs_hotfile_end = 0;+ hfsmp->hfs_hotfile_freeblks = 0;+ }+#if DEBUG+ printf("hfs:%s: metadata zone is %d to %d\n", hfsmp->vcbVN, hfsmp->hfs_metazone_start, hfsmp->hfs_metazone_end);+ printf("hfs:%s: hot file band is %d to %d\n", hfsmp->vcbVN, hfsmp->hfs_hotfile_start, hfsmp->hfs_hotfile_end);+ printf("hfs:%s: hot file band free blocks = %d\n", hfsmp->vcbVN, hfsmp->hfs_hotfile_freeblks);+#endif++ hfsmp->hfs_flags |= HFS_METADATA_ZONE;+}+++static u_int32_t+hfs_hotfile_freeblocks(struct hfsmount *hfsmp)+{+ ExtendedVCB *vcb = HFSTOVCB(hfsmp);+ int lockflags;+ int freeblocks;++ if (hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) {+ //+ // This is only used at initialization time and on an ssd+ // we'll get the real info from the hotfile btree user+ // info+ //+ return 0;+ }++ lockflags = hfs_systemfile_lock(hfsmp, SFL_BITMAP, HFS_EXCLUSIVE_LOCK);+ freeblocks = MetaZoneFreeBlocks(vcb);+ hfs_systemfile_unlock(hfsmp, lockflags);++ /* Minus Extents overflow file reserve. */+ if ((uint32_t)hfsmp->hfs_overflow_maxblks >= VTOF(hfsmp->hfs_extents_vp)->ff_blocks) {+ freeblocks -= hfsmp->hfs_overflow_maxblks - VTOF(hfsmp->hfs_extents_vp)->ff_blocks;+ }++ /* Minus catalog file reserve. */+ if ((uint32_t)hfsmp->hfs_catalog_maxblks >= VTOF(hfsmp->hfs_catalog_vp)->ff_blocks) {+ freeblocks -= hfsmp->hfs_catalog_maxblks - VTOF(hfsmp->hfs_catalog_vp)->ff_blocks;+ }++ if (freeblocks < 0)+ freeblocks = 0;++ // printf("hfs: hotfile_freeblocks: MIN(%d, %d) = %d\n", freeblocks, hfsmp->hfs_hotfile_maxblks, MIN(freeblocks, hfsmp->hfs_hotfile_maxblks));+ return MIN(freeblocks, hfsmp->hfs_hotfile_maxblks);+}++/*+ * Determine if a file is a "virtual" metadata file.+ * This includes journal and quota files.+ */+int+hfs_virtualmetafile(struct cnode *cp)+{+ const char * filename;+++ if (cp->c_parentcnid != kHFSRootFolderID)+ return (0);++ filename = (const char *)cp->c_desc.cd_nameptr;+ if (filename == NULL)+ return (0);++ if ((strncmp(filename, ".journal", sizeof(".journal")) == 0) ||+ (strncmp(filename, ".journal_info_block", sizeof(".journal_info_block")) == 0) ||+ (strncmp(filename, ".quota.user", sizeof(".quota.user")) == 0) ||+ (strncmp(filename, ".quota.group", sizeof(".quota.group")) == 0) ||+ (strncmp(filename, ".hotfiles.btree", sizeof(".hotfiles.btree")) == 0))+ return (1);++ return (0);+}++void hfs_syncer_lock(struct hfsmount *hfsmp)+{+ hfs_lock_mount(hfsmp);+}++void hfs_syncer_unlock(struct hfsmount *hfsmp)+{+ hfs_unlock_mount(hfsmp);+}++void hfs_syncer_wait(struct hfsmount *hfsmp, struct timespec *ts)+{+ msleep(&hfsmp->hfs_syncer_thread, &hfsmp->hfs_mutex, PWAIT,+ "hfs_syncer_wait", ts);+}++void hfs_syncer_wakeup(struct hfsmount *hfsmp)+{+ wakeup(&hfsmp->hfs_syncer_thread);+}++uint64_t hfs_usecs_to_deadline(uint64_t usecs)+{+ uint64_t deadline;+ clock_interval_to_deadline(usecs, NSEC_PER_USEC, &deadline);+ return deadline;+}++//+// Fire off a timed callback to sync the disk if the+// volume is on ejectable media.+//+void hfs_sync_ejectable(struct hfsmount *hfsmp)+{+ // If we don't have a syncer or we get called by the syncer, just return+ if (!ISSET(hfsmp->hfs_flags, HFS_RUN_SYNCER)+ || current_thread() == hfsmp->hfs_syncer_thread) {+ return;+ }++ hfs_syncer_lock(hfsmp);++ if (!timerisset(&hfsmp->hfs_sync_req_oldest))+ microuptime(&hfsmp->hfs_sync_req_oldest);++ /* If hfs_unmount is running, it will clear the HFS_RUN_SYNCER+ flag. Also, we don't want to queue again if there is a sync+ outstanding. */+ if (!ISSET(hfsmp->hfs_flags, HFS_RUN_SYNCER)+ || hfsmp->hfs_syncer_thread) {+ hfs_syncer_unlock(hfsmp);+ return;+ }++ hfsmp->hfs_syncer_thread = (void *)1;++ hfs_syncer_unlock(hfsmp);++ kernel_thread_start(hfs_syncer, hfsmp, &hfsmp->hfs_syncer_thread);+ thread_deallocate(hfsmp->hfs_syncer_thread);+}++int+hfs_start_transaction(struct hfsmount *hfsmp)+{+ int ret = 0, unlock_on_err = 0;+ thread_t thread = current_thread();++#ifdef HFS_CHECK_LOCK_ORDER+ /*+ * You cannot start a transaction while holding a system+ * file lock. (unless the transaction is nested.)+ */+ if (hfsmp->jnl && journal_owner(hfsmp->jnl) != thread) {+ if (hfsmp->hfs_catalog_cp && hfsmp->hfs_catalog_cp->c_lockowner == thread) {+ panic("hfs_start_transaction: bad lock order (cat before jnl)\n");+ }+ if (hfsmp->hfs_attribute_cp && hfsmp->hfs_attribute_cp->c_lockowner == thread) {+ panic("hfs_start_transaction: bad lock order (attr before jnl)\n");+ }+ if (hfsmp->hfs_extents_cp && hfsmp->hfs_extents_cp->c_lockowner == thread) {+ panic("hfs_start_transaction: bad lock order (ext before jnl)\n");+ }+ }+#endif /* HFS_CHECK_LOCK_ORDER */++again:++ if (hfsmp->jnl) {+ if (journal_owner(hfsmp->jnl) != thread) {+ /*+ * The global lock should be held shared if journal is+ * active to prevent disabling. If we're not the owner+ * of the journal lock, verify that we're not already+ * holding the global lock exclusive before moving on.+ */+ if (hfsmp->hfs_global_lockowner == thread) {+ ret = EBUSY;+ goto out;+ }++ hfs_lock_global (hfsmp, HFS_SHARED_LOCK);++ // Things could have changed+ if (!hfsmp->jnl) {+ hfs_unlock_global(hfsmp);+ goto again;+ }++ OSAddAtomic(1, (SInt32 *)&hfsmp->hfs_active_threads);+ unlock_on_err = 1;+ }+ } else {+ // No journal+ if (hfsmp->hfs_global_lockowner != thread) {+ hfs_lock_global(hfsmp, HFS_EXCLUSIVE_LOCK);++ // Things could have changed+ if (hfsmp->jnl) {+ hfs_unlock_global(hfsmp);+ goto again;+ }++ OSAddAtomic(1, (SInt32 *)&hfsmp->hfs_active_threads);+ unlock_on_err = 1;+ }+ }++ /* If a downgrade to read-only mount is in progress, no other+ * thread than the downgrade thread is allowed to modify+ * the file system.+ */+ if ((hfsmp->hfs_flags & HFS_RDONLY_DOWNGRADE) &&+ hfsmp->hfs_downgrading_thread != thread) {+ ret = EROFS;+ goto out;+ }++ if (hfsmp->jnl) {+ ret = journal_start_transaction(hfsmp->jnl);+ } else {+ ret = 0;+ }++ if (ret == 0)+ ++hfsmp->hfs_transaction_nesting;++out:+ if (ret != 0 && unlock_on_err) {+ hfs_unlock_global (hfsmp);+ OSAddAtomic(-1, (SInt32 *)&hfsmp->hfs_active_threads);+ }++ return ret;+}++int+hfs_end_transaction(struct hfsmount *hfsmp)+{+ int ret;++ hfs_assert(!hfsmp->jnl || journal_owner(hfsmp->jnl) == current_thread());+ hfs_assert(hfsmp->hfs_transaction_nesting > 0);++ if (hfsmp->jnl && hfsmp->hfs_transaction_nesting == 1)+ hfs_flushvolumeheader(hfsmp, HFS_FVH_FLUSH_IF_DIRTY);++ bool need_unlock = !--hfsmp->hfs_transaction_nesting;++ if (hfsmp->jnl) {+ ret = journal_end_transaction(hfsmp->jnl);+ } else {+ ret = 0;+ }++ if (need_unlock) {+ OSAddAtomic(-1, (SInt32 *)&hfsmp->hfs_active_threads);+ hfs_unlock_global (hfsmp);+ hfs_sync_ejectable(hfsmp);+ }++ return ret;+}+++void+hfs_journal_lock(struct hfsmount *hfsmp)+{+ /* Only peek at hfsmp->jnl while holding the global lock */+ hfs_lock_global (hfsmp, HFS_SHARED_LOCK);+ if (hfsmp->jnl) {+ journal_lock(hfsmp->jnl);+ }+ hfs_unlock_global (hfsmp);+}++void+hfs_journal_unlock(struct hfsmount *hfsmp)+{+ /* Only peek at hfsmp->jnl while holding the global lock */+ hfs_lock_global (hfsmp, HFS_SHARED_LOCK);+ if (hfsmp->jnl) {+ journal_unlock(hfsmp->jnl);+ }+ hfs_unlock_global (hfsmp);+}++/*+ * Flush the contents of the journal to the disk.+ *+ * - HFS_FLUSH_JOURNAL+ * Wait to write in-memory journal to the disk consistently.+ * This means that the journal still contains uncommitted+ * transactions and the file system metadata blocks in+ * the journal transactions might be written asynchronously+ * to the disk. But there is no guarantee that they are+ * written to the disk before returning to the caller.+ * Note that this option is sufficient for file system+ * data integrity as it guarantees consistent journal+ * content on the disk.+ *+ * - HFS_FLUSH_JOURNAL_META+ * Wait to write in-memory journal to the disk+ * consistently, and also wait to write all asynchronous+ * metadata blocks to its corresponding locations+ * consistently on the disk. This is overkill in normal+ * scenarios but is useful whenever the metadata blocks+ * are required to be consistent on-disk instead of+ * just the journalbeing consistent; like before live+ * verification and live volume resizing. The update of the+ * metadata doesn't include a barrier of track cache flush.+ *+ * - HFS_FLUSH_FULL+ * HFS_FLUSH_JOURNAL + force a track cache flush to media+ *+ * - HFS_FLUSH_CACHE+ * Force a track cache flush to media.+ *+ * - HFS_FLUSH_BARRIER+ * Barrier-only flush to ensure write order+ *+ */+errno_t hfs_flush(struct hfsmount *hfsmp, hfs_flush_mode_t mode)+{+ errno_t error = 0;+ int options = 0;+ dk_synchronize_t sync_req = { .options = DK_SYNCHRONIZE_OPTION_BARRIER };++ switch (mode) {+ case HFS_FLUSH_JOURNAL_META:+ // wait for journal, metadata blocks and previous async flush to finish+ SET(options, JOURNAL_WAIT_FOR_IO);++ // no break++ case HFS_FLUSH_JOURNAL:+ case HFS_FLUSH_JOURNAL_BARRIER:+ case HFS_FLUSH_FULL:++ if (mode == HFS_FLUSH_JOURNAL_BARRIER &&+ !(hfsmp->hfs_flags & HFS_FEATURE_BARRIER))+ mode = HFS_FLUSH_FULL;++ if (mode == HFS_FLUSH_FULL)+ SET(options, JOURNAL_FLUSH_FULL);++ /* Only peek at hfsmp->jnl while holding the global lock */+ hfs_lock_global (hfsmp, HFS_SHARED_LOCK);++ if (hfsmp->jnl)+ error = journal_flush(hfsmp->jnl, options);++ hfs_unlock_global (hfsmp);++ /*+ * This may result in a double barrier as+ * journal_flush may have issued a barrier itself+ */+ if (mode == HFS_FLUSH_JOURNAL_BARRIER)+ error = VNOP_IOCTL(hfsmp->hfs_devvp,+ DKIOCSYNCHRONIZE, (caddr_t)&sync_req,+ FWRITE, NULL);++ break;++ case HFS_FLUSH_CACHE:+ // Do a full sync+ sync_req.options = 0;++ // no break++ case HFS_FLUSH_BARRIER:+ // If barrier only flush doesn't support, fall back to use full flush.+ if (!(hfsmp->hfs_flags & HFS_FEATURE_BARRIER))+ sync_req.options = 0;++ error = VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZE, (caddr_t)&sync_req,+ FWRITE, NULL);+ break;++ default:+ error = EINVAL;+ }++ return error;+}++/*+ * hfs_erase_unused_nodes+ *+ * Check wheter a volume may suffer from unused Catalog B-tree nodes that+ * are not zeroed (due to <rdar://problem/6947811>). If so, just write+ * zeroes to the unused nodes.+ *+ * How do we detect when a volume needs this repair? We can't always be+ * certain. If a volume was created after a certain date, then it may have+ * been created with the faulty newfs_hfs. Since newfs_hfs only created one+ * clump, we can assume that if a Catalog B-tree is larger than its clump size,+ * that means that the entire first clump must have been written to, which means+ * there shouldn't be unused and unwritten nodes in that first clump, and this+ * repair is not needed.+ *+ * We have defined a bit in the Volume Header's attributes to indicate when the+ * unused nodes have been repaired. A newer newfs_hfs will set this bit.+ * As will fsck_hfs when it repairs the unused nodes.+ */+int hfs_erase_unused_nodes(struct hfsmount *hfsmp)+{+ int result;+ struct filefork *catalog;+ int lockflags;++ if (hfsmp->vcbAtrb & kHFSUnusedNodeFixMask)+ {+ /* This volume has already been checked and repaired. */+ return 0;+ }++ if ((hfsmp->localCreateDate < kHFSUnusedNodesFixDate))+ {+ /* This volume is too old to have had the problem. */+ hfsmp->vcbAtrb |= kHFSUnusedNodeFixMask;+ return 0;+ }++ catalog = hfsmp->hfs_catalog_cp->c_datafork;+ if (catalog->ff_size > catalog->ff_clumpsize)+ {+ /* The entire first clump must have been in use at some point. */+ hfsmp->vcbAtrb |= kHFSUnusedNodeFixMask;+ return 0;+ }++ /*+ * If we get here, we need to zero out those unused nodes.+ *+ * We start a transaction and lock the catalog since we're going to be+ * making on-disk changes. But note that BTZeroUnusedNodes doens't actually+ * do its writing via the journal, because that would be too much I/O+ * to fit in a transaction, and it's a pain to break it up into multiple+ * transactions. (It behaves more like growing a B-tree would.)+ */+ printf("hfs_erase_unused_nodes: updating volume %s.\n", hfsmp->vcbVN);+ result = hfs_start_transaction(hfsmp);+ if (result)+ goto done;+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);+ result = BTZeroUnusedNodes(catalog);+ vnode_waitforwrites(hfsmp->hfs_catalog_vp, 0, 0, 0, "hfs_erase_unused_nodes");+ hfs_systemfile_unlock(hfsmp, lockflags);+ hfs_end_transaction(hfsmp);+ if (result == 0)+ hfsmp->vcbAtrb |= kHFSUnusedNodeFixMask;+ printf("hfs_erase_unused_nodes: done updating volume %s.\n", hfsmp->vcbVN);++done:+ return result;+}+++int+check_for_dataless_file(struct vnode *vp, uint64_t op_type)+{+ int error;++ if (vp == NULL || (VTOC(vp)->c_bsdflags & UF_COMPRESSED) == 0 || VTOCMP(vp) == NULL || decmpfs_cnode_cmp_type(VTOCMP(vp)) != DATALESS_CMPFS_TYPE) {+ // there's nothing to do, it's not dataless+ return 0;+ }++ /* Swap files are special; ignore them */+ if (vnode_isswap(vp)) {+ return 0;+ }++ // printf("hfs: dataless: encountered a file with the dataless bit set! (vp %p)\n", vp);+ error = resolve_nspace_item(vp, op_type | NAMESPACE_HANDLER_NSPACE_EVENT);+ if (error == EDEADLK && op_type == NAMESPACE_HANDLER_WRITE_OP) {+ error = 0;+ } else if (error) {+ if (error == EAGAIN) {+ printf("hfs: dataless: timed out waiting for namespace handler...\n");+ // XXXdbg - return the fabled ENOTPRESENT (i.e. EJUKEBOX)?+ return 0;+ } else if (error == EINTR) {+ // printf("hfs: dataless: got a signal while waiting for namespace handler...\n");+ return EINTR;+ }+ } else if (VTOC(vp)->c_bsdflags & UF_COMPRESSED) {+ //+ // if we're here, the dataless bit is still set on the file+ // which means it didn't get handled. we return an error+ // but it's presently ignored by all callers of this function.+ //+ // XXXdbg - EDATANOTPRESENT is what we really need...+ //+ return EBADF;+ }++ return error;+}+++//+// NOTE: this function takes care of starting a transaction and+// acquiring the systemfile lock so that it can call+// cat_update().+//+// NOTE: do NOT hold and cnode locks while calling this function+// to avoid deadlocks (because we take a lock on the root+// cnode)+//+int+hfs_generate_document_id(struct hfsmount *hfsmp, uint32_t *docid)+{+ struct vnode *rvp;+ struct cnode *cp;+ int error;++ error = hfs_vfs_root(HFSTOVFS(hfsmp), &rvp, vfs_context_kernel());+ if (error) {+ return error;+ }++ cp = VTOC(rvp);+ if ((error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT)) != 0) {+ return error;+ }+ struct FndrExtendedDirInfo *extinfo = (struct FndrExtendedDirInfo *)((void *)((char *)&cp->c_attr.ca_finderinfo + 16));++ int lockflags;+ if ((error = hfs_start_transaction(hfsmp)) != 0) {+ return error;+ }+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);++ if (extinfo->document_id == 0) {+ // initialize this to start at 3 (one greater than the root-dir id)+ extinfo->document_id = 3;+ }++ *docid = extinfo->document_id++;++ // mark the root cnode dirty+ cp->c_flag |= C_MODIFIED;+ hfs_update(cp->c_vp, 0);++ hfs_systemfile_unlock (hfsmp, lockflags);+ (void) hfs_end_transaction(hfsmp);++ (void) hfs_unlock(cp);++ vnode_put(rvp);+ rvp = NULL;++ return 0;+}+++/*+ * Return information about number of file system allocation blocks+ * taken by metadata on a volume.+ *+ * This function populates struct hfsinfo_metadata with allocation blocks+ * used by extents overflow btree, catalog btree, bitmap, attribute btree,+ * journal file, and sum of all of the above.+ */+int+hfs_getinfo_metadata_blocks(struct hfsmount *hfsmp, struct hfsinfo_metadata *hinfo)+{+ int lockflags = 0;+ int ret_lockflags = 0;++ /* Zero out the output buffer */+ bzero(hinfo, sizeof(struct hfsinfo_metadata));++ /*+ * Getting number of allocation blocks for all btrees+ * should be a quick operation, so we grab locks for+ * all of them at the same time+ */+ lockflags = SFL_CATALOG | SFL_EXTENTS | SFL_BITMAP | SFL_ATTRIBUTE;+ ret_lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);+ /*+ * Make sure that we were able to acquire all locks requested+ * to protect us against conditions like unmount in progress.+ */+ if ((lockflags & ret_lockflags) != lockflags) {+ /* Release any locks that were acquired */+ hfs_systemfile_unlock(hfsmp, ret_lockflags);+ return EPERM;+ }++ /* Get information about all the btrees */+ hinfo->extents = hfsmp->hfs_extents_cp->c_datafork->ff_blocks;+ hinfo->catalog = hfsmp->hfs_catalog_cp->c_datafork->ff_blocks;+ hinfo->allocation = hfsmp->hfs_allocation_cp->c_datafork->ff_blocks;+ hinfo->attribute = hfsmp->hfs_attribute_cp->c_datafork->ff_blocks;++ /* Done with btrees, give up the locks */+ hfs_systemfile_unlock(hfsmp, ret_lockflags);++ /* Get information about journal file */+ hinfo->journal = howmany(hfsmp->jnl_size, hfsmp->blockSize);++ /* Calculate total number of metadata blocks */+ hinfo->total = hinfo->extents + hinfo->catalog ++ hinfo->allocation + hinfo->attribute ++ hinfo->journal;++ return 0;+}++static int+hfs_freezewrite_callback(struct vnode *vp, __unused void *cargs)+{+ vnode_waitforwrites(vp, 0, 0, 0, "hfs freeze 8");++ return 0;+}++int hfs_freeze(struct hfsmount *hfsmp)+{+ // First make sure some other process isn't freezing+ hfs_lock_mount(hfsmp);+ while (hfsmp->hfs_freeze_state != HFS_THAWED) {+ if (msleep(&hfsmp->hfs_freeze_state, &hfsmp->hfs_mutex,+ PWAIT | PCATCH, "hfs freeze 1", NULL) == EINTR) {+ hfs_unlock_mount(hfsmp);+ return EINTR;+ }+ }++ // Stop new syncers from starting+ hfsmp->hfs_freeze_state = HFS_WANT_TO_FREEZE;++ // Now wait for all syncers to finish+ while (hfsmp->hfs_syncers) {+ if (msleep(&hfsmp->hfs_freeze_state, &hfsmp->hfs_mutex,+ PWAIT | PCATCH, "hfs freeze 2", NULL) == EINTR) {+ hfs_thaw_locked(hfsmp);+ hfs_unlock_mount(hfsmp);+ return EINTR;+ }+ }+ hfs_unlock_mount(hfsmp);++ // flush things before we get started to try and prevent+ // dirty data from being paged out while we're frozen.+ // note: we can't do this once we're in the freezing state because+ // other threads will need to take the global lock+ vnode_iterate(hfsmp->hfs_mp, 0, hfs_freezewrite_callback, NULL);++ // Block everything in hfs_lock_global now+ hfs_lock_mount(hfsmp);+ hfsmp->hfs_freeze_state = HFS_FREEZING;+ hfsmp->hfs_freezing_thread = current_thread();+ hfs_unlock_mount(hfsmp);++ /* Take the exclusive lock to flush out anything else that+ might have the global lock at the moment and also so we+ can flush the journal. */+ hfs_lock_global(hfsmp, HFS_EXCLUSIVE_LOCK);+ journal_flush(hfsmp->jnl, JOURNAL_WAIT_FOR_IO);+ hfs_unlock_global(hfsmp);++ // don't need to iterate on all vnodes, we just need to+ // wait for writes to the system files and the device vnode+ //+ // Now that journal flush waits for all metadata blocks to+ // be written out, waiting for btree writes is probably no+ // longer required.+ if (HFSTOVCB(hfsmp)->extentsRefNum)+ vnode_waitforwrites(HFSTOVCB(hfsmp)->extentsRefNum, 0, 0, 0, "hfs freeze 3");+ if (HFSTOVCB(hfsmp)->catalogRefNum)+ vnode_waitforwrites(HFSTOVCB(hfsmp)->catalogRefNum, 0, 0, 0, "hfs freeze 4");+ if (HFSTOVCB(hfsmp)->allocationsRefNum)+ vnode_waitforwrites(HFSTOVCB(hfsmp)->allocationsRefNum, 0, 0, 0, "hfs freeze 5");+ if (hfsmp->hfs_attribute_vp)+ vnode_waitforwrites(hfsmp->hfs_attribute_vp, 0, 0, 0, "hfs freeze 6");+ vnode_waitforwrites(hfsmp->hfs_devvp, 0, 0, 0, "hfs freeze 7");++ // We're done, mark frozen+ hfs_lock_mount(hfsmp);+ hfsmp->hfs_freeze_state = HFS_FROZEN;+ hfsmp->hfs_freezing_proc = current_proc();+ hfs_unlock_mount(hfsmp);++ return 0;+}++int hfs_thaw(struct hfsmount *hfsmp, const struct proc *process)+{+ hfs_lock_mount(hfsmp);++ if (hfsmp->hfs_freeze_state != HFS_FROZEN) {+ hfs_unlock_mount(hfsmp);+ return EINVAL;+ }+ if (process && hfsmp->hfs_freezing_proc != process) {+ hfs_unlock_mount(hfsmp);+ return EPERM;+ }++ hfs_thaw_locked(hfsmp);++ hfs_unlock_mount(hfsmp);++ return 0;+}++static void hfs_thaw_locked(struct hfsmount *hfsmp)+{+ hfsmp->hfs_freezing_proc = NULL;+ hfsmp->hfs_freeze_state = HFS_THAWED;++ wakeup(&hfsmp->hfs_freeze_state);+}++uintptr_t obfuscate_addr(void *addr)+{+ vm_offset_t new_addr;+ vm_kernel_addrperm_external((vm_offset_t)addr, &new_addr);+ return new_addr;+}++uint64_t hfs_allocated __attribute__((aligned(8)));++HFS_SYSCTL(QUAD, _vfs_generic_hfs, OID_AUTO, allocated,+ CTLFLAG_RD | CTLFLAG_LOCKED, &hfs_allocated, "Memory allocated")++// -- Zone allocator-related structures and routines --++hfs_zone_entry_t hfs_zone_entries[HFS_NUM_ZONES] = {+ { HFS_CNODE_ZONE, sizeof(struct cnode), "HFS node" },+ { HFS_FILEFORK_ZONE, sizeof(struct filefork), "HFS fork" },+ { HFS_DIRHINT_ZONE, sizeof(struct directoryhint), "HFS dirhint" }+};++hfs_zone_t hfs_zones[HFS_NUM_ZONES];++void hfs_init_zones(void) {+ for (int i = 0; i < HFS_NUM_ZONES; i++) {+ hfs_zones[i].hz_zone = zone_create(hfs_zone_entries[i].hze_name,+ hfs_zone_entries[i].hze_elem_size, ZC_NOENCRYPT);+ }+}++void *hfs_zalloc(hfs_zone_kind_t zone)+{+ OSAddAtomic64(hfs_zones[zone].hz_elem_size, &hfs_allocated);++ return zalloc(hfs_zones[zone].hz_zone);+}++void hfs_zfree(void *ptr, hfs_zone_kind_t zone)+{+ OSAddAtomic64(-(int64_t)hfs_zones[zone].hz_elem_size, &hfs_allocated);++ zfree(hfs_zones[zone].hz_zone, ptr);+}++struct hfs_sysctl_chain *sysctl_list;++void hfs_sysctl_register(void)+{+ struct hfs_sysctl_chain *e = sysctl_list;+ while (e) {+ sysctl_register_oid(e->oid);+ e = e->next;+ }+}++void hfs_sysctl_unregister(void)+{+ struct hfs_sysctl_chain *e = sysctl_list;+ while (e) {+ sysctl_unregister_oid(e->oid);+ e = e->next;+ }+}++void hfs_assert_fail(const char *file, unsigned line, const char *expr)+{+ Assert(file, line, expr);+ __builtin_unreachable();+}diff --git a/xnu/files/bsd/hfs/hfs_vnops.c b/xnu/files/bsd/hfs/hfs_vnops.cnew file mode 100644index 0000000..d210179--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_vnops.c@@ -0,0 +1,7525 @@+/*+ * Copyright (c) 2000-2017 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@+ */++#include <libkern/OSAtomic.h>+#include <stdbool.h>+#include <sys/systm.h>+#include <sys/param.h>+#include <sys/kernel.h>+#include <sys/dirent.h>+#include <sys/stat.h>+#include <sys/buf.h>+#include <sys/mount.h>+#include <sys/vnode_if.h>+#include <sys/malloc.h>+#include <sys/ubc.h>+#include <sys/paths.h>+#include <sys/quota.h>+#include <sys/time.h>+#include <sys/disk.h>+#include <sys/kauth.h>+#include <sys/fsctl.h>+#include <sys/xattr.h>+#include <sys/decmpfs.h>+#include <sys/mman.h>+#include <sys/doc_tombstone.h>+#include <sys/namei.h>+#include <string.h>+#include <sys/fsevents.h>++#include <miscfs/specfs/specdev.h>+#include <miscfs/fifofs/fifo.h>+#include <vfs/vfs_support.h>++#include <sys/kdebug.h>+#include <sys/sysctl.h>+#include <stdbool.h>++#include "hfs.h"+#include "hfs_catalog.h"+#include "hfs_cnode.h"+#include "hfs_dbg.h"+#include "hfs_mount.h"+#include "hfs_quota.h"+#include "hfs_endian.h"+#include "hfs_kdebug.h"+#include "hfs_cprotect.h"++#if HFS_CONFIG_KEY_ROLL+#include "hfs_key_roll.h"+#endif++#include "BTreesInternal.h"+#include "FileMgrInternal.h"++/* Global vfs data structures for hfs */++/*+ * Always F_FULLFSYNC? 1=yes,0=no (default due to "various" reasons is+ * 'no'). At some point this might need to move into VFS and we might+ * need to provide an API to get at it, but for now, this is only used+ * by HFS+.+ */+int always_do_fullfsync = 0;+SYSCTL_DECL(_vfs_generic);+HFS_SYSCTL(INT, _vfs_generic, OID_AUTO, always_do_fullfsync, CTLFLAG_RW | CTLFLAG_LOCKED, &always_do_fullfsync, 0, "always F_FULLFSYNC when fsync is called")++int hfs_makenode(struct vnode *dvp, struct vnode **vpp,+ struct componentname *cnp, struct vnode_attr *vap,+ vfs_context_t ctx);+int hfs_metasync(struct hfsmount *hfsmp, daddr64_t node, __unused struct proc *p);+int hfs_metasync_all(struct hfsmount *hfsmp);++int hfs_removedir(struct vnode *, struct vnode *, struct componentname *,+ int, int);+int hfs_removefile(struct vnode *, struct vnode *, struct componentname *,+ int, int, int, struct vnode *, int);++/* Used here and in cnode teardown -- for symlinks */+int hfs_removefile_callback(struct buf *bp, void *hfsmp);++enum {+ HFS_MOVE_DATA_INCLUDE_RSRC = 1,+};+typedef uint32_t hfs_move_data_options_t;++static int hfs_move_data(cnode_t *from_cp, cnode_t *to_cp,+ hfs_move_data_options_t options);+static int hfs_move_fork(filefork_t *srcfork, cnode_t *src,+ filefork_t *dstfork, cnode_t *dst);+++static int hfs_exchangedata_getxattr (struct vnode *vp, uint32_t name_selector, void **buffer, size_t *xattr_size);+static int hfs_exchangedata_setxattr (struct hfsmount *hfsmp, uint32_t fileid,+ uint32_t name_selector, void *buffer, size_t xattr_size);++enum XATTR_NAME_ENTRIES {+ quarantine = 0,+ MAX_NUM_XATTR_NAMES //must be last+};+++/* These are special EAs that follow the content in exchangedata(2). */+const char *XATTR_NAMES [MAX_NUM_XATTR_NAMES] = { "com.apple.quarantine" };++#define MAX_EXCHANGE_EA_SIZE 4096++#if HFS_COMPRESSION+static int hfs_move_compressed(cnode_t *from_vp, cnode_t *to_vp);+#endif++decmpfs_cnode* hfs_lazy_init_decmpfs_cnode (struct cnode *cp);++#if FIFO+static int hfsfifo_read(struct vnop_read_args *);+static int hfsfifo_write(struct vnop_write_args *);+static int hfsfifo_close(struct vnop_close_args *);++extern int (**fifo_vnodeop_p)(void *);+#endif /* FIFO */++int hfs_vnop_close(struct vnop_close_args*);+int hfs_vnop_exchange(struct vnop_exchange_args*);+int hfs_vnop_fsync(struct vnop_fsync_args*);+int hfs_vnop_mkdir(struct vnop_mkdir_args*);+int hfs_vnop_mknod(struct vnop_mknod_args*);+int hfs_vnop_getattr(struct vnop_getattr_args*);+int hfs_vnop_open(struct vnop_open_args*);+int hfs_vnop_readdir(struct vnop_readdir_args*);+int hfs_vnop_rename(struct vnop_rename_args*);+int hfs_vnop_renamex(struct vnop_renamex_args*);+int hfs_vnop_rmdir(struct vnop_rmdir_args*);+int hfs_vnop_symlink(struct vnop_symlink_args*);+int hfs_vnop_setattr(struct vnop_setattr_args*);+int hfs_vnop_readlink(struct vnop_readlink_args *);+int hfs_vnop_pathconf(struct vnop_pathconf_args *);+int hfs_vnop_mmap(struct vnop_mmap_args *ap);+int hfsspec_read(struct vnop_read_args *);+int hfsspec_write(struct vnop_write_args *);+int hfsspec_close(struct vnop_close_args *);++/* Options for hfs_removedir and hfs_removefile */+#define HFSRM_SKIP_RESERVE 0x01++++/*****************************************************************************+*+* Common Operations on vnodes+*+*****************************************************************************/++/*+ * Is the given cnode either the .journal or .journal_info_block file on+ * a volume with an active journal? Many VNOPs use this to deny access+ * to those files.+ *+ * Note: the .journal file on a volume with an external journal still+ * returns true here, even though it does not actually hold the contents+ * of the volume's journal.+ */+bool+hfs_is_journal_file(struct hfsmount *hfsmp, struct cnode *cp)+{+ if (hfsmp->jnl != NULL &&+ (cp->c_fileid == hfsmp->hfs_jnlinfoblkid ||+ cp->c_fileid == hfsmp->hfs_jnlfileid)) {+ return true;+ } else {+ return false;+ }+}++/*+ * Create a regular file.+ */+int+hfs_vnop_create(struct vnop_create_args *ap)+{+ /*+ * We leave handling of certain race conditions here to the caller+ * which will have a better understanding of the semantics it+ * requires. For example, if it turns out that the file exists,+ * it would be wrong of us to return a reference to the existing+ * file because the caller might not want that and it would be+ * misleading to suggest the file had been created when it hadn't+ * been. Note that our NFS server code does not set the+ * VA_EXCLUSIVE flag so you cannot assume that callers don't want+ * EEXIST errors if it's not set. The common case, where users+ * are calling open with the O_CREAT mode, is handled in VFS; when+ * we return EEXIST, it will loop and do the look-up again.+ */+ return hfs_makenode(ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap, ap->a_context);+}++/*+ * Make device special file.+ */+int+hfs_vnop_mknod(struct vnop_mknod_args *ap)+{+ struct vnode_attr *vap = ap->a_vap;+ struct vnode *dvp = ap->a_dvp;+ struct vnode **vpp = ap->a_vpp;+ struct cnode *cp;+ int error;++ if (VTOVCB(dvp)->vcbSigWord != kHFSPlusSigWord) {+ return (ENOTSUP);+ }++ /* Create the vnode */+ error = hfs_makenode(dvp, vpp, ap->a_cnp, vap, ap->a_context);+ if (error)+ return (error);++ cp = VTOC(*vpp);+ cp->c_touch_acctime = TRUE;+ cp->c_touch_chgtime = TRUE;+ cp->c_touch_modtime = TRUE;++ if ((vap->va_rdev != VNOVAL) &&+ (vap->va_type == VBLK || vap->va_type == VCHR))+ cp->c_rdev = vap->va_rdev;++ return (0);+}++#if HFS_COMPRESSION+/*+ * hfs_ref_data_vp(): returns the data fork vnode for a given cnode.+ * In the (hopefully rare) case where the data fork vnode is not+ * present, it will use hfs_vget() to create a new vnode for the+ * data fork.+ *+ * NOTE: If successful and a vnode is returned, the caller is responsible+ * for releasing the returned vnode with vnode_rele().+ */+static int+hfs_ref_data_vp(struct cnode *cp, struct vnode **data_vp, int skiplock)+{+ int vref = 0;++ if (!data_vp || !cp) /* sanity check incoming parameters */+ return EINVAL;++ /* maybe we should take the hfs cnode lock here, and if so, use the skiplock parameter to tell us not to */++ if (!skiplock) hfs_lock(cp, HFS_SHARED_LOCK, HFS_LOCK_DEFAULT);+ struct vnode *c_vp = cp->c_vp;+ if (c_vp) {+ /* we already have a data vnode */+ *data_vp = c_vp;+ vref = vnode_ref(*data_vp);+ if (!skiplock) hfs_unlock(cp);+ if (vref == 0) {+ return 0;+ }+ return EINVAL;+ }+ /* no data fork vnode in the cnode, so ask hfs for one. */++ if (!cp->c_rsrc_vp) {+ /* if we don't have either a c_vp or c_rsrc_vp, we can't really do anything useful */+ *data_vp = NULL;+ if (!skiplock) hfs_unlock(cp);+ return EINVAL;+ }++ if (0 == hfs_vget(VTOHFS(cp->c_rsrc_vp), cp->c_cnid, data_vp, 1, 0) &&+ 0 != data_vp) {+ vref = vnode_ref(*data_vp);+ vnode_put(*data_vp);+ if (!skiplock) hfs_unlock(cp);+ if (vref == 0) {+ return 0;+ }+ return EINVAL;+ }+ /* there was an error getting the vnode */+ *data_vp = NULL;+ if (!skiplock) hfs_unlock(cp);+ return EINVAL;+}++/*+ * hfs_lazy_init_decmpfs_cnode(): returns the decmpfs_cnode for a cnode,+ * allocating it if necessary; returns NULL if there was an allocation error.+ * function is non-static so that it can be used from the FCNTL handler.+ */+decmpfs_cnode *+hfs_lazy_init_decmpfs_cnode(struct cnode *cp)+{+ if (!cp->c_decmp) {+ decmpfs_cnode *dp = decmpfs_cnode_alloc();+ decmpfs_cnode_init(dp);+ if (!OSCompareAndSwapPtr(NULL, dp, (void * volatile *)&cp->c_decmp)) {+ /* another thread got here first, so free the decmpfs_cnode we allocated */+ decmpfs_cnode_destroy(dp);+ decmpfs_cnode_free(dp);+ }+ }++ return cp->c_decmp;+}++/*+ * hfs_file_is_compressed(): returns 1 if the file is compressed, and 0 (zero) if not.+ * if the file's compressed flag is set, makes sure that the decmpfs_cnode field+ * is allocated by calling hfs_lazy_init_decmpfs_cnode(), then makes sure it is populated,+ * or else fills it in via the decmpfs_file_is_compressed() function.+ */+int+hfs_file_is_compressed(struct cnode *cp, int skiplock)+{+ int ret = 0;++ /* fast check to see if file is compressed. If flag is clear, just answer no */+ if (!(cp->c_bsdflags & UF_COMPRESSED)) {+ return 0;+ }++ decmpfs_cnode *dp = hfs_lazy_init_decmpfs_cnode(cp);+ if (!dp) {+ /* error allocating a decmpfs cnode, treat the file as uncompressed */+ return 0;+ }++ /* flag was set, see if the decmpfs_cnode state is valid (zero == invalid) */+ uint32_t decmpfs_state = decmpfs_cnode_get_vnode_state(dp);+ switch(decmpfs_state) {+ case FILE_IS_COMPRESSED:+ case FILE_IS_CONVERTING: /* treat decompressing files as if they are compressed */+ return 1;+ case FILE_IS_NOT_COMPRESSED:+ return 0;+ /* otherwise the state is not cached yet */+ }++ /* decmpfs hasn't seen this file yet, so call decmpfs_file_is_compressed() to init the decmpfs_cnode struct */+ struct vnode *data_vp = NULL;+ if (0 == hfs_ref_data_vp(cp, &data_vp, skiplock)) {+ if (data_vp) {+ ret = decmpfs_file_is_compressed(data_vp, VTOCMP(data_vp)); // fill in decmpfs_cnode+ vnode_rele(data_vp);+ }+ }+ return ret;+}++/* hfs_uncompressed_size_of_compressed_file() - get the uncompressed size of the file.+ * if the caller has passed a valid vnode (has a ref count > 0), then hfsmp and fid are not required.+ * if the caller doesn't have a vnode, pass NULL in vp, and pass valid hfsmp and fid.+ * files size is returned in size (required)+ * if the indicated file is a directory (or something that doesn't have a data fork), then this call+ * will return an error and the caller should fall back to treating the item as an uncompressed file+ */+int+hfs_uncompressed_size_of_compressed_file(struct hfsmount *hfsmp, struct vnode *vp, cnid_t fid, off_t *size, int skiplock)+{+ int ret = 0;+ int putaway = 0; /* flag to remember if we used hfs_vget() */++ if (!size) {+ return EINVAL; /* no place to put the file size */+ }++ if (NULL == vp) {+ if (!hfsmp || !fid) { /* make sure we have the required parameters */+ return EINVAL;+ }+ if (0 != hfs_vget(hfsmp, fid, &vp, skiplock, 0)) { /* vnode is null, use hfs_vget() to get it */+ vp = NULL;+ } else {+ putaway = 1; /* note that hfs_vget() was used to aquire the vnode */+ }+ }+ /* this double check for compression (hfs_file_is_compressed)+ * ensures the cached size is present in case decmpfs hasn't+ * encountered this node yet.+ */+ if (vp) {+ if (hfs_file_is_compressed(VTOC(vp), skiplock) ) {+ *size = decmpfs_cnode_get_vnode_cached_size(VTOCMP(vp)); /* file info will be cached now, so get size */+ } else if (VTOCMP(vp)) {+ uint32_t cmp_type = decmpfs_cnode_cmp_type(VTOCMP(vp));++ if (cmp_type == DATALESS_CMPFS_TYPE) {+ *size = decmpfs_cnode_get_vnode_cached_size(VTOCMP(vp)); /* file info will be cached now, so get size */+ ret = 0;+ } else if (cmp_type >= CMP_MAX && VTOC(vp)->c_datafork) {+ // if we don't recognize this type, just use the real data fork size+ *size = VTOC(vp)->c_datafork->ff_size;+ ret = 0;+ } else+ ret = EINVAL;+ } else+ ret = EINVAL;+ }++ if (putaway) { /* did we use hfs_vget() to get this vnode? */+ vnode_put(vp); /* if so, release it and set it to null */+ vp = NULL;+ }+ return ret;+}++int+hfs_hides_rsrc(vfs_context_t ctx, struct cnode *cp, int skiplock)+{+ if (ctx == decmpfs_ctx)+ return 0;+ if (!hfs_file_is_compressed(cp, skiplock))+ return 0;+ return decmpfs_hides_rsrc(ctx, cp->c_decmp);+}++int+hfs_hides_xattr(vfs_context_t ctx, struct cnode *cp, const char *name, int skiplock)+{+ if (ctx == decmpfs_ctx)+ return 0;+ if (!hfs_file_is_compressed(cp, skiplock))+ return 0;+ return decmpfs_hides_xattr(ctx, cp->c_decmp, name);+}+#endif /* HFS_COMPRESSION */++/*+ * Open a file/directory.+ */+int+hfs_vnop_open(struct vnop_open_args *ap)+{+ struct vnode *vp = ap->a_vp;+ struct filefork *fp;+ struct timeval tv;+ int error;+ static int past_bootup = 0;+ struct cnode *cp = VTOC(vp);+ struct hfsmount *hfsmp = VTOHFS(vp);++#if CONFIG_PROTECT+ error = cp_handle_open(vp, ap->a_mode);+ if (error)+ return error;+#endif++#if HFS_COMPRESSION+ if (ap->a_mode & FWRITE) {+ /* open for write */+ if ( hfs_file_is_compressed(cp, 1) ) { /* 1 == don't take the cnode lock */+ /* opening a compressed file for write, so convert it to decompressed */+ struct vnode *data_vp = NULL;+ error = hfs_ref_data_vp(cp, &data_vp, 1); /* 1 == don't take the cnode lock */+ if (0 == error) {+ if (data_vp) {+ error = decmpfs_decompress_file(data_vp, VTOCMP(data_vp), -1, 1, 0);+ vnode_rele(data_vp);+ } else {+ error = EINVAL;+ }+ }+ if (error != 0)+ return error;+ }+ } else {+ /* open for read */+ if (hfs_file_is_compressed(cp, 1) ) { /* 1 == don't take the cnode lock */+ if (VNODE_IS_RSRC(vp)) {+ /* opening the resource fork of a compressed file, so nothing to do */+ } else {+ /* opening a compressed file for read, make sure it validates */+ error = decmpfs_validate_compressed_file(vp, VTOCMP(vp));+ if (error != 0)+ return error;+ }+ }+ }+#endif++ /*+ * Files marked append-only must be opened for appending.+ */+ if ((cp->c_bsdflags & APPEND) && !vnode_isdir(vp) &&+ (ap->a_mode & (FWRITE | O_APPEND)) == FWRITE)+ return (EPERM);++ if (vnode_issystem(vp))+ return (EBUSY); /* file is in use by the kernel */++ /* Don't allow journal to be opened externally. */+ if (hfs_is_journal_file(hfsmp, cp))+ return (EPERM);++ bool have_lock = false;++#if CONFIG_PROTECT+ if (ISSET(ap->a_mode, FENCRYPTED) && cp->c_cpentry && vnode_isreg(vp)) {+ bool have_trunc_lock = false;++#if HFS_CONFIG_KEY_ROLL+ again:+#endif++ if ((error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ if (have_trunc_lock)+ hfs_unlock_truncate(cp, 0);+ return error;+ }++ have_lock = true;++ if (cp->c_cpentry->cp_raw_open_count + 1+ < cp->c_cpentry->cp_raw_open_count) {+ // Overflow; too many raw opens on this file+ hfs_unlock(cp);+ if (have_trunc_lock)+ hfs_unlock_truncate(cp, 0);+ return ENFILE;+ }++#if HFS_CONFIG_KEY_ROLL+ if (cp_should_auto_roll(hfsmp, cp->c_cpentry)) {+ if (!have_trunc_lock) {+ hfs_unlock(cp);+ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, 0);+ have_trunc_lock = true;+ goto again;+ }++ error = hfs_key_roll_start(cp);+ if (error) {+ hfs_unlock(cp);+ hfs_unlock_truncate(cp, 0);+ return error;+ }+ }+#endif++ if (have_trunc_lock)+ hfs_unlock_truncate(cp, 0);++ ++cp->c_cpentry->cp_raw_open_count;+ }+#endif++ if (ISSET(hfsmp->hfs_flags, HFS_READ_ONLY)+ || !vnode_isreg(vp)+#if NAMEDSTREAMS+ || vnode_isnamedstream(vp)+#endif+ || !hfsmp->jnl || vnode_isinuse(vp, 0)) {++#if CONFIG_PROTECT+ if (have_lock)+ hfs_unlock(cp);+#endif++ return (0);+ }++ if (!have_lock && (error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT)))+ return (error);++#if QUOTA+ /* If we're going to write to the file, initialize quotas. */+ if ((ap->a_mode & FWRITE) && (hfsmp->hfs_flags & HFS_QUOTAS))+ (void)hfs_getinoquota(cp);+#endif /* QUOTA */++ /*+ * On the first (non-busy) open of a fragmented+ * file attempt to de-frag it, if it's less than hfs_defrag_max bytes.+ * That field is initially set to 20MB.+ */+ fp = VTOF(vp);+ if (fp->ff_blocks &&+ fp->ff_extents[7].blockCount != 0 &&+ fp->ff_size <= hfsmp->hfs_defrag_max) {++ int no_mods = 0;+ struct timeval now;+ /*+ * Wait until system bootup is done (3 min).+ * And don't relocate a file that's been modified+ * within the past minute -- this can lead to+ * system thrashing.+ */++ if (hfsmp->hfs_defrag_nowait) {+ /* If this is toggled, then issue the defrag if appropriate */+ past_bootup = 1;+ no_mods = 1;+ }++ if (!past_bootup) {+ microuptime(&tv);+ if (tv.tv_sec > (60*3)) {+ past_bootup = 1;+ }+ }++ microtime(&now);+ if ((now.tv_sec - cp->c_mtime) > 60) {+ no_mods = 1;+ }++ if (past_bootup && no_mods) {+ (void) hfs_relocate(vp, hfsmp->nextAllocation + 4096,+ vfs_context_ucred(ap->a_context),+ vfs_context_proc(ap->a_context));+ }+ }++ hfs_unlock(cp);++ return (0);+}+++/*+ * Close a file/directory.+ */+int+hfs_vnop_close(struct vnop_close_args *ap)+{+ register struct vnode *vp = ap->a_vp;+ register struct cnode *cp;+ struct proc *p = vfs_context_proc(ap->a_context);+ struct hfsmount *hfsmp;+ int busy;+ int tooktrunclock = 0;+ int knownrefs = 0;++ if ( hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0)+ return (0);+ cp = VTOC(vp);+ hfsmp = VTOHFS(vp);++#if CONFIG_PROTECT+ if (cp->c_cpentry && ISSET(ap->a_fflag, FENCRYPTED) && vnode_isreg(vp)) {+ hfs_assert(cp->c_cpentry->cp_raw_open_count > 0);+ --cp->c_cpentry->cp_raw_open_count;+ }+#endif++ /*+ * If the rsrc fork is a named stream, it can cause the data fork to+ * stay around, preventing de-allocation of these blocks.+ * Do checks for truncation on close. Purge extra extents if they exist.+ * Make sure the vp is not a directory, and that it has a resource fork,+ * and that resource fork is also a named stream.+ */++ if ((vnode_vtype(vp) == VREG) && (cp->c_rsrc_vp)+ && (vnode_isnamedstream(cp->c_rsrc_vp))) {+ uint32_t blks;++ blks = howmany(VTOF(vp)->ff_size, VTOVCB(vp)->blockSize);+ /*+ * If there are extra blocks and there are only 2 refs on+ * this vp (ourselves + rsrc fork holding ref on us), go ahead+ * and try to truncate.+ */+ if ((blks < VTOF(vp)->ff_blocks) && (!vnode_isinuse(vp, 2))) {+ // release cnode lock; must acquire truncate lock BEFORE cnode lock+ hfs_unlock(cp);++ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ tooktrunclock = 1;++ if (hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ // bail out if we can't re-acquire cnode lock+ return 0;+ }+ // now re-test to make sure it's still valid+ if (cp->c_rsrc_vp) {+ knownrefs = 1 + vnode_isnamedstream(cp->c_rsrc_vp);+ if (!vnode_isinuse(vp, knownrefs)){+ // now we can truncate the file, if necessary+ blks = howmany(VTOF(vp)->ff_size, VTOVCB(vp)->blockSize);+ if (blks < VTOF(vp)->ff_blocks){+ (void) hfs_truncate(vp, VTOF(vp)->ff_size, IO_NDELAY,+ 0, ap->a_context);+ }+ }+ }+ }+ }+++ // if we froze the fs and we're exiting, then "thaw" the fs+ if (hfsmp->hfs_freeze_state == HFS_FROZEN+ && hfsmp->hfs_freezing_proc == p && proc_exiting(p)) {+ hfs_thaw(hfsmp, p);+ }++ busy = vnode_isinuse(vp, 1);++ if (busy) {+ hfs_touchtimes(VTOHFS(vp), cp);+ }+ if (vnode_isdir(vp)) {+ hfs_reldirhints(cp, busy);+ } else if (vnode_issystem(vp) && !busy) {+ vnode_recycle(vp);+ }++ if (tooktrunclock){+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ }+ hfs_unlock(cp);++ if (ap->a_fflag & FWASWRITTEN) {+ hfs_sync_ejectable(hfsmp);+ }++ return (0);+}++static bool hfs_should_generate_document_id(hfsmount_t *hfsmp, cnode_t *cp)+{+ return (!ISSET(hfsmp->hfs_flags, HFS_READ_ONLY)+ && ISSET(cp->c_bsdflags, UF_TRACKED)+ && cp->c_desc.cd_cnid != kHFSRootFolderID+ && (S_ISDIR(cp->c_mode) || S_ISREG(cp->c_mode) || S_ISLNK(cp->c_mode)));+}++/*+ * Get basic attributes.+ */+int+hfs_vnop_getattr(struct vnop_getattr_args *ap)+{+#define VNODE_ATTR_TIMES \+ (VNODE_ATTR_va_access_time|VNODE_ATTR_va_change_time|VNODE_ATTR_va_modify_time)+#define VNODE_ATTR_AUTH \+ (VNODE_ATTR_va_mode | VNODE_ATTR_va_uid | VNODE_ATTR_va_gid | \+ VNODE_ATTR_va_flags | VNODE_ATTR_va_acl)++ struct vnode *vp = ap->a_vp;+ struct vnode_attr *vap = ap->a_vap;+ struct vnode *rvp = NULLVP;+ struct hfsmount *hfsmp;+ struct cnode *cp;+ uint64_t data_size;+ enum vtype v_type;+ int error = 0;+ cp = VTOC(vp);++#if HFS_COMPRESSION+ /* we need to inspect the decmpfs state of the file before we take the hfs cnode lock */+ int compressed = 0;+ int hide_size = 0;+ off_t uncompressed_size = -1;+ if (VATTR_IS_ACTIVE(vap, va_data_size) || VATTR_IS_ACTIVE(vap, va_total_alloc) || VATTR_IS_ACTIVE(vap, va_data_alloc) || VATTR_IS_ACTIVE(vap, va_total_size)) {+ /* we only care about whether the file is compressed if asked for the uncompressed size */+ if (VNODE_IS_RSRC(vp)) {+ /* if it's a resource fork, decmpfs may want us to hide the size */+ hide_size = hfs_hides_rsrc(ap->a_context, cp, 0);+ } else {+ /* if it's a data fork, we need to know if it was compressed so we can report the uncompressed size */+ compressed = hfs_file_is_compressed(cp, 0);+ }+ if ((VATTR_IS_ACTIVE(vap, va_data_size) || VATTR_IS_ACTIVE(vap, va_total_size))) {+ // if it's compressed+ if (compressed || (!VNODE_IS_RSRC(vp) && cp->c_decmp && decmpfs_cnode_cmp_type(cp->c_decmp) >= CMP_MAX)) {+ if (0 != hfs_uncompressed_size_of_compressed_file(NULL, vp, 0, &uncompressed_size, 0)) {+ /* failed to get the uncompressed size, we'll check for this later */+ uncompressed_size = -1;+ } else {+ // fake that it's compressed+ compressed = 1;+ }+ }+ }+ }+#endif++ /*+ * Shortcut for vnode_authorize path. Each of the attributes+ * in this set is updated atomically so we don't need to take+ * the cnode lock to access them.+ */+ if ((vap->va_active & ~VNODE_ATTR_AUTH) == 0) {+ /* Make sure file still exists. */+ if (cp->c_flag & C_NOEXISTS)+ return (ENOENT);++ vap->va_uid = cp->c_uid;+ vap->va_gid = cp->c_gid;+ vap->va_mode = cp->c_mode;+ vap->va_flags = cp->c_bsdflags;+ vap->va_supported |= VNODE_ATTR_AUTH & ~VNODE_ATTR_va_acl;++ if ((cp->c_attr.ca_recflags & kHFSHasSecurityMask) == 0) {+ vap->va_acl = (kauth_acl_t) KAUTH_FILESEC_NONE;+ VATTR_SET_SUPPORTED(vap, va_acl);+ }++ return (0);+ }++ hfsmp = VTOHFS(vp);+ v_type = vnode_vtype(vp);++ if (VATTR_IS_ACTIVE(vap, va_document_id)) {+ uint32_t document_id;++ if (cp->c_desc.cd_cnid == kHFSRootFolderID)+ document_id = kHFSRootFolderID;+ else {+ /*+ * This is safe without a lock because we're just reading+ * a 32 bit aligned integer which should be atomic on all+ * platforms we support.+ */+ document_id = hfs_get_document_id(cp);++ if (!document_id && hfs_should_generate_document_id(hfsmp, cp)) {+ uint32_t new_document_id;++ error = hfs_generate_document_id(hfsmp, &new_document_id);+ if (error)+ return error;++ error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ if (error)+ return error;++ bool want_docid_fsevent = false;++ // Need to check again now that we have the lock+ document_id = hfs_get_document_id(cp);+ if (!document_id && hfs_should_generate_document_id(hfsmp, cp)) {+ cp->c_attr.ca_finderextendeddirinfo.document_id = document_id = new_document_id;+ want_docid_fsevent = true;+ SET(cp->c_flag, C_MODIFIED);+ }++ hfs_unlock(cp);++ if (want_docid_fsevent) {+ add_fsevent(FSE_DOCID_CHANGED, ap->a_context,+ FSE_ARG_DEV, hfsmp->hfs_raw_dev,+ FSE_ARG_INO, (ino64_t)0, // src inode #+ FSE_ARG_INO, (ino64_t)cp->c_fileid, // dst inode #+ FSE_ARG_INT32, document_id,+ FSE_ARG_DONE);++ if (need_fsevent(FSE_STAT_CHANGED, vp)) {+ add_fsevent(FSE_STAT_CHANGED, ap->a_context,+ FSE_ARG_VNODE, vp, FSE_ARG_DONE);+ }+ }+ }+ }++ vap->va_document_id = document_id;+ VATTR_SET_SUPPORTED(vap, va_document_id);+ }++ /*+ * If time attributes are requested and we have cnode times+ * that require updating, then acquire an exclusive lock on+ * the cnode before updating the times. Otherwise we can+ * just acquire a shared lock.+ */+ if ((vap->va_active & VNODE_ATTR_TIMES) &&+ (cp->c_touch_acctime || cp->c_touch_chgtime || cp->c_touch_modtime)) {+ if ((error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT)))+ return (error);+ hfs_touchtimes(hfsmp, cp);++ // downgrade to a shared lock since that's all we need from here on out+ cp->c_lockowner = HFS_SHARED_OWNER;+ lck_rw_lock_exclusive_to_shared(&cp->c_rwlock);++ } else if ((error = hfs_lock(cp, HFS_SHARED_LOCK, HFS_LOCK_DEFAULT))) {+ return (error);+ }++ if (v_type == VDIR) {+ data_size = (cp->c_entries + 2) * AVERAGE_HFSDIRENTRY_SIZE;++ if (VATTR_IS_ACTIVE(vap, va_nlink)) {+ int nlink;++ /*+ * For directories, the va_nlink is esentially a count+ * of the ".." references to a directory plus the "."+ * reference and the directory itself. So for HFS+ this+ * becomes the sub-directory count plus two.+ *+ * In the absence of a sub-directory count we use the+ * directory's item count. This will be too high in+ * most cases since it also includes files.+ */+ if ((hfsmp->hfs_flags & HFS_FOLDERCOUNT) &&+ (cp->c_attr.ca_recflags & kHFSHasFolderCountMask))+ nlink = cp->c_attr.ca_dircount; /* implied ".." entries */+ else+ nlink = cp->c_entries;++ /* Account for ourself and our "." entry */+ nlink += 2;+ /* Hide our private directories. */+ if (cp->c_cnid == kHFSRootFolderID) {+ if (hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid != 0) {+ --nlink;+ }+ if (hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid != 0) {+ --nlink;+ }+ }+ VATTR_RETURN(vap, va_nlink, (u_int64_t)nlink);+ }+ if (VATTR_IS_ACTIVE(vap, va_nchildren)) {+ int entries;++ entries = cp->c_entries;+ /* Hide our private files and directories. */+ if (cp->c_cnid == kHFSRootFolderID) {+ if (hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid != 0)+ --entries;+ if (hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid != 0)+ --entries;+ if (hfsmp->jnl || ((hfsmp->vcbAtrb & kHFSVolumeJournaledMask) && (hfsmp->hfs_flags & HFS_READ_ONLY)))+ entries -= 2; /* hide the journal files */+ }+ VATTR_RETURN(vap, va_nchildren, entries);+ }+ /*+ * The va_dirlinkcount is the count of real directory hard links.+ * (i.e. its not the sum of the implied "." and ".." references)+ */+ if (VATTR_IS_ACTIVE(vap, va_dirlinkcount)) {+ VATTR_RETURN(vap, va_dirlinkcount, (uint32_t)cp->c_linkcount);+ }+ } else /* !VDIR */ {+ data_size = VCTOF(vp, cp)->ff_size;++ VATTR_RETURN(vap, va_nlink, (u_int64_t)cp->c_linkcount);+ if (VATTR_IS_ACTIVE(vap, va_data_alloc)) {+ u_int64_t blocks;++#if HFS_COMPRESSION+ if (hide_size) {+ VATTR_RETURN(vap, va_data_alloc, 0);+ } else if (compressed) {+ /* for compressed files, we report all allocated blocks as belonging to the data fork */+ blocks = cp->c_blocks;+ VATTR_RETURN(vap, va_data_alloc, blocks * (u_int64_t)hfsmp->blockSize);+ }+ else+#endif+ {+ blocks = VCTOF(vp, cp)->ff_blocks;+ VATTR_RETURN(vap, va_data_alloc, blocks * (u_int64_t)hfsmp->blockSize);+ }+ }+ }++ /* conditional because 64-bit arithmetic can be expensive */+ if (VATTR_IS_ACTIVE(vap, va_total_size)) {+ if (v_type == VDIR) {+ VATTR_RETURN(vap, va_total_size, (cp->c_entries + 2) * AVERAGE_HFSDIRENTRY_SIZE);+ } else {+ u_int64_t total_size = ~0ULL;+ struct cnode *rcp;+#if HFS_COMPRESSION+ if (hide_size) {+ /* we're hiding the size of this file, so just return 0 */+ total_size = 0;+ } else if (compressed) {+ if (uncompressed_size == -1) {+ /*+ * We failed to get the uncompressed size above,+ * so we'll fall back to the standard path below+ * since total_size is still -1+ */+ } else {+ /* use the uncompressed size we fetched above */+ total_size = uncompressed_size;+ }+ }+#endif+ if (total_size == ~0ULL) {+ if (cp->c_datafork) {+ total_size = cp->c_datafork->ff_size;+ }++ if (cp->c_blocks - VTOF(vp)->ff_blocks) {+ /* We deal with rsrc fork vnode iocount at the end of the function */+ error = hfs_vgetrsrc(hfsmp, vp, &rvp);+ if (error) {+ /*+ * Note that we call hfs_vgetrsrc with error_on_unlinked+ * set to FALSE. This is because we may be invoked via+ * fstat() on an open-unlinked file descriptor and we must+ * continue to support access to the rsrc fork until it disappears.+ * The code at the end of this function will be+ * responsible for releasing the iocount generated by+ * hfs_vgetrsrc. This is because we can't drop the iocount+ * without unlocking the cnode first.+ */+ goto out;+ }++ rcp = VTOC(rvp);+ if (rcp && rcp->c_rsrcfork) {+ total_size += rcp->c_rsrcfork->ff_size;+ }+ }+ }++ VATTR_RETURN(vap, va_total_size, total_size);+ }+ }+ if (VATTR_IS_ACTIVE(vap, va_total_alloc)) {+ if (v_type == VDIR) {+ VATTR_RETURN(vap, va_total_alloc, 0);+ } else {+ VATTR_RETURN(vap, va_total_alloc, (u_int64_t)cp->c_blocks * (u_int64_t)hfsmp->blockSize);+ }+ }++ /*+ * If the VFS wants extended security data, and we know that we+ * don't have any (because it never told us it was setting any)+ * then we can return the supported bit and no data. If we do+ * have extended security, we can just leave the bit alone and+ * the VFS will use the fallback path to fetch it.+ */+ if (VATTR_IS_ACTIVE(vap, va_acl)) {+ if ((cp->c_attr.ca_recflags & kHFSHasSecurityMask) == 0) {+ vap->va_acl = (kauth_acl_t) KAUTH_FILESEC_NONE;+ VATTR_SET_SUPPORTED(vap, va_acl);+ }+ }++ vap->va_access_time.tv_sec = cp->c_atime;+ vap->va_access_time.tv_nsec = 0;+ vap->va_create_time.tv_sec = cp->c_itime;+ vap->va_create_time.tv_nsec = 0;+ vap->va_modify_time.tv_sec = cp->c_mtime;+ vap->va_modify_time.tv_nsec = 0;+ vap->va_change_time.tv_sec = cp->c_ctime;+ vap->va_change_time.tv_nsec = 0;+ vap->va_backup_time.tv_sec = cp->c_btime;+ vap->va_backup_time.tv_nsec = 0;++ /* See if we need to emit the date added field to the user */+ if (VATTR_IS_ACTIVE(vap, va_addedtime)) {+ u_int32_t dateadded = hfs_get_dateadded (cp);+ if (dateadded) {+ vap->va_addedtime.tv_sec = dateadded;+ vap->va_addedtime.tv_nsec = 0;+ VATTR_SET_SUPPORTED (vap, va_addedtime);+ }+ }++ /* XXX is this really a good 'optimal I/O size'? */+ vap->va_iosize = hfsmp->hfs_logBlockSize;+ vap->va_uid = cp->c_uid;+ vap->va_gid = cp->c_gid;+ vap->va_mode = cp->c_mode;+ vap->va_flags = cp->c_bsdflags;++ /*+ * Exporting file IDs from HFS Plus:+ *+ * For "normal" files the c_fileid is the same value as the+ * c_cnid. But for hard link files, they are different - the+ * c_cnid belongs to the active directory entry (ie the link)+ * and the c_fileid is for the actual inode (ie the data file).+ *+ * The stat call (getattr) uses va_fileid and the Carbon APIs,+ * which are hardlink-ignorant, will ask for va_linkid.+ */+ vap->va_fileid = (u_int64_t)cp->c_fileid;+ /*+ * We need to use the origin cache for both hardlinked files+ * and directories. Hardlinked directories have multiple cnids+ * and parents (one per link). Hardlinked files also have their+ * own parents and link IDs separate from the indirect inode number.+ * If we don't use the cache, we could end up vending the wrong ID+ * because the cnode will only reflect the link that was looked up most recently.+ */+ if (cp->c_flag & C_HARDLINK) {+ vap->va_linkid = (u_int64_t)hfs_currentcnid(cp);+ vap->va_parentid = (u_int64_t)hfs_currentparent(cp, /* have_lock: */ true);+ } else {+ vap->va_linkid = (u_int64_t)cp->c_cnid;+ vap->va_parentid = (u_int64_t)cp->c_parentcnid;+ }++ vap->va_fsid = hfsmp->hfs_raw_dev;+ if (VATTR_IS_ACTIVE(vap, va_devid)) {+ VATTR_RETURN(vap, va_devid, hfsmp->hfs_raw_dev);+ }+ vap->va_filerev = 0;+ vap->va_encoding = cp->c_encoding;+ vap->va_rdev = (v_type == VBLK || v_type == VCHR) ? cp->c_rdev : 0;+#if HFS_COMPRESSION+ if (VATTR_IS_ACTIVE(vap, va_data_size)) {+ if (hide_size)+ vap->va_data_size = 0;+ else if (compressed) {+ if (uncompressed_size == -1) {+ /* failed to get the uncompressed size above, so just return data_size */+ vap->va_data_size = data_size;+ } else {+ /* use the uncompressed size we fetched above */+ vap->va_data_size = uncompressed_size;+ }+ } else+ vap->va_data_size = data_size;+ VATTR_SET_SUPPORTED(vap, va_data_size);+ }+#else+ vap->va_data_size = data_size;+ vap->va_supported |= VNODE_ATTR_va_data_size;+#endif++#if CONFIG_PROTECT+ if (VATTR_IS_ACTIVE(vap, va_dataprotect_class)) {+ vap->va_dataprotect_class = cp->c_cpentry ? CP_CLASS(cp->c_cpentry->cp_pclass) : 0;+ VATTR_SET_SUPPORTED(vap, va_dataprotect_class);+ }+#endif+ if (VATTR_IS_ACTIVE(vap, va_write_gencount)) {+ if (ubc_is_mapped_writable(vp)) {+ /*+ * Return 0 to the caller to indicate the file may be+ * changing. There is no need for us to increment the+ * generation counter here because it gets done as part of+ * page-out and also when the file is unmapped (to account+ * for changes we might not have seen).+ */+ vap->va_write_gencount = 0;+ } else {+ vap->va_write_gencount = hfs_get_gencount(cp);+ }++ VATTR_SET_SUPPORTED(vap, va_write_gencount);+ }++ /* Mark them all at once instead of individual VATTR_SET_SUPPORTED calls. */+ vap->va_supported |= VNODE_ATTR_va_access_time |+ VNODE_ATTR_va_create_time | VNODE_ATTR_va_modify_time |+ VNODE_ATTR_va_change_time| VNODE_ATTR_va_backup_time |+ VNODE_ATTR_va_iosize | VNODE_ATTR_va_uid |+ VNODE_ATTR_va_gid | VNODE_ATTR_va_mode |+ VNODE_ATTR_va_flags |VNODE_ATTR_va_fileid |+ VNODE_ATTR_va_linkid | VNODE_ATTR_va_parentid |+ VNODE_ATTR_va_fsid | VNODE_ATTR_va_filerev |+ VNODE_ATTR_va_encoding | VNODE_ATTR_va_rdev;++ /* If this is the root, let VFS to find out the mount name, which+ * may be different from the real name. Otherwise, we need to take care+ * for hardlinked files, which need to be looked up, if necessary+ */+ if (VATTR_IS_ACTIVE(vap, va_name) && (cp->c_cnid != kHFSRootFolderID)) {+ struct cat_desc linkdesc;+ int lockflags;+ int uselinkdesc = 0;+ cnid_t nextlinkid = 0;+ cnid_t prevlinkid = 0;++ /* Get the name for ATTR_CMN_NAME. We need to take special care for hardlinks+ * here because the info. for the link ID requested by getattrlist may be+ * different than what's currently in the cnode. This is because the cnode+ * will be filled in with the information for the most recent link ID that went+ * through namei/lookup(). If there are competing lookups for hardlinks that point+ * to the same inode, one (or more) getattrlists could be vended incorrect name information.+ * Also, we need to beware of open-unlinked files which could have a namelen of 0.+ */++ if ((cp->c_flag & C_HARDLINK) &&+ ((cp->c_desc.cd_namelen == 0) || (vap->va_linkid != cp->c_cnid))) {+ /*+ * If we have no name and our link ID is the raw inode number, then we may+ * have an open-unlinked file. Go to the next link in this case.+ */+ if ((cp->c_desc.cd_namelen == 0) && (vap->va_linkid == cp->c_fileid)) {+ if ((error = hfs_lookup_siblinglinks(hfsmp, vap->va_linkid, &prevlinkid, &nextlinkid))){+ goto out;+ }+ }+ else {+ /* just use link obtained from vap above */+ nextlinkid = vap->va_linkid;+ }++ /* We need to probe the catalog for the descriptor corresponding to the link ID+ * stored in nextlinkid. Note that we don't know if we have the exclusive lock+ * for the cnode here, so we can't just update the descriptor. Instead,+ * we should just store the descriptor's value locally and then use it to pass+ * out the name value as needed below.+ */+ if (nextlinkid){+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);+ error = cat_findname(hfsmp, nextlinkid, &linkdesc);+ hfs_systemfile_unlock(hfsmp, lockflags);+ if (error == 0) {+ uselinkdesc = 1;+ }+ }+ }++ /* By this point, we've either patched up the name above and the c_desc+ * points to the correct data, or it already did, in which case we just proceed+ * by copying the name into the vap. Note that we will never set va_name to+ * supported if nextlinkid is never initialized. This could happen in the degenerate+ * case above involving the raw inode number, where it has no nextlinkid. In this case+ * we will simply not mark the name bit as supported.+ */+ if (uselinkdesc) {+ strlcpy(vap->va_name, (const char*) linkdesc.cd_nameptr, MAXPATHLEN);+ VATTR_SET_SUPPORTED(vap, va_name);+ cat_releasedesc(&linkdesc);+ }+ else if (cp->c_desc.cd_namelen) {+ strlcpy(vap->va_name, (const char*) cp->c_desc.cd_nameptr, MAXPATHLEN);+ VATTR_SET_SUPPORTED(vap, va_name);+ }+ }++out:+ hfs_unlock(cp);+ /*+ * We need to vnode_put the rsrc fork vnode only *after* we've released+ * the cnode lock, since vnode_put can trigger an inactive call, which+ * will go back into HFS and try to acquire a cnode lock.+ */+ if (rvp) {+ vnode_put (rvp);+ }++ return (error);+}++int+hfs_set_bsd_flags(struct hfsmount *hfsmp, struct cnode *cp,+ u_int32_t new_bsd_flags, u_int32_t document_id,+ vfs_context_t ctx, int *compression_changedp)+{+ u_int16_t *fdFlags;++ if ((new_bsd_flags & UF_TRACKED) && !(cp->c_bsdflags & UF_TRACKED)) {+ struct FndrExtendedDirInfo *fip = (struct FndrExtendedDirInfo *)((char *)&cp->c_attr.ca_finderinfo + 16);++ //+ // we're marking this item UF_TRACKED. if the document_id is+ // not set, get a new one and put it on the file.+ //+ if (fip->document_id == 0) {+ if (document_id != 0) {+ // printf("SETATTR: assigning doc-id %d to %s (ino %d)\n", document_id, vp->v_name, cp->c_desc.cd_cnid);+ fip->document_id = (uint32_t)document_id;+ add_fsevent(FSE_DOCID_CHANGED, ctx,+ FSE_ARG_DEV, hfsmp->hfs_raw_dev,+ FSE_ARG_INO, (ino64_t)0, // src inode #+ FSE_ARG_INO, (ino64_t)cp->c_fileid, // dst inode #+ FSE_ARG_INT32, document_id,+ FSE_ARG_DONE);+ } else {+ // printf("hfs: could not acquire a new document_id for %s (ino %d)\n", vp->v_name, cp->c_desc.cd_cnid);+ }+ }++ } else if (!(new_bsd_flags & UF_TRACKED) && (cp->c_bsdflags & UF_TRACKED)) {+ //+ // UF_TRACKED is being cleared so clear the document_id+ //+ struct FndrExtendedDirInfo *fip = (struct FndrExtendedDirInfo *)((char *)&cp->c_attr.ca_finderinfo + 16);+ if (fip->document_id) {+ // printf("SETATTR: clearing doc-id %d from %s (ino %d)\n", fip->document_id, vp->v_name, cp->c_desc.cd_cnid);+ add_fsevent(FSE_DOCID_CHANGED, ctx,+ FSE_ARG_DEV, hfsmp->hfs_raw_dev,+ FSE_ARG_INO, (ino64_t)cp->c_fileid, // src inode #+ FSE_ARG_INO, (ino64_t)0, // dst inode #+ FSE_ARG_INT32, fip->document_id, // document id+ FSE_ARG_DONE);+ fip->document_id = 0;+ cp->c_bsdflags &= ~UF_TRACKED;+ }+ }++#if HFS_COMPRESSION+ if ((cp->c_bsdflags ^ new_bsd_flags) & UF_COMPRESSED) {+ /*+ * the UF_COMPRESSED was toggled, so reset our cached compressed state+ * but we don't want to actually do the update until we've released the cnode lock down below+ * NOTE: turning the flag off doesn't actually decompress the file, so that we can+ * turn off the flag and look at the "raw" file for debugging purposes+ */+ *compression_changedp = 1;+ }+#endif++ cp->c_bsdflags = new_bsd_flags;+ cp->c_flag |= C_MODIFIED;+ cp->c_touch_chgtime = TRUE;++ /*+ * Mirror the UF_HIDDEN flag to the invisible bit of the Finder Info.+ *+ * The fdFlags for files and frFlags for folders are both 8 bytes+ * into the userInfo (the first 16 bytes of the Finder Info). They+ * are both 16-bit fields.+ */+ fdFlags = (u_int16_t *) &cp->c_finderinfo[8];+ if (new_bsd_flags & UF_HIDDEN)+ *fdFlags |= OSSwapHostToBigConstInt16(kFinderInvisibleMask);+ else+ *fdFlags &= ~OSSwapHostToBigConstInt16(kFinderInvisibleMask);++ return 0;+}++int+hfs_vnop_setattr(struct vnop_setattr_args *ap)+{+ struct vnode_attr *vap = ap->a_vap;+ struct vnode *vp = ap->a_vp;+ struct cnode *cp = NULL;+ struct hfsmount *hfsmp;+ kauth_cred_t cred = vfs_context_ucred(ap->a_context);+ struct proc *p = vfs_context_proc(ap->a_context);+ int error = 0;+ uid_t nuid;+ gid_t ngid;+ time_t orig_ctime;++ orig_ctime = VTOC(vp)->c_ctime;++#if HFS_COMPRESSION+ int decmpfs_reset_state = 0;+ /*+ we call decmpfs_update_attributes even if the file is not compressed+ because we want to update the incoming flags if the xattrs are invalid+ */+ error = decmpfs_update_attributes(vp, vap);+ if (error)+ return error;+#endif+ //+ // if this is not a size-changing setattr and it is not just+ // an atime update, then check for a snapshot.+ //+ if (!VATTR_IS_ACTIVE(vap, va_data_size) && !(vap->va_active == VNODE_ATTR_va_access_time)) {+ nspace_snapshot_event(vp, orig_ctime, NAMESPACE_HANDLER_METADATA_MOD, NSPACE_REARM_NO_ARG);+ }++#if CONFIG_PROTECT+ /*+ * All metadata changes should be allowed except a size-changing setattr, which+ * has effects on file content and requires calling into cp_handle_vnop+ * to have content protection check.+ */+ if (VATTR_IS_ACTIVE(vap, va_data_size)) {+ if ((error = cp_handle_vnop(vp, CP_WRITE_ACCESS, 0)) != 0) {+ return (error);+ }+ }+#endif /* CONFIG_PROTECT */++ hfsmp = VTOHFS(vp);++ /* Don't allow modification of the journal. */+ if (hfs_is_journal_file(hfsmp, VTOC(vp))) {+ return (EPERM);+ }++ //+ // Check if we'll need a document_id and if so, get it before we lock the+ // the cnode to avoid any possible deadlock with the root vnode which has+ // to get locked to get the document id+ //+ u_int32_t document_id=0;+ if (VATTR_IS_ACTIVE(vap, va_flags) && (vap->va_flags & UF_TRACKED) && !(VTOC(vp)->c_bsdflags & UF_TRACKED)) {+ struct FndrExtendedDirInfo *fip = (struct FndrExtendedDirInfo *)((char *)&(VTOC(vp)->c_attr.ca_finderinfo) + 16);+ //+ // If the document_id is not set, get a new one. It will be set+ // on the file down below once we hold the cnode lock.+ //+ if (fip->document_id == 0) {+ if (hfs_generate_document_id(hfsmp, &document_id) != 0) {+ document_id = 0;+ }+ }+ }+++ /*+ * File size change request.+ * We are guaranteed that this is not a directory, and that+ * the filesystem object is writeable.+ *+ * NOTE: HFS COMPRESSION depends on the data_size being set *before* the bsd flags are updated+ */+ VATTR_SET_SUPPORTED(vap, va_data_size);+ if (VATTR_IS_ACTIVE(vap, va_data_size)) {+ if (!vnode_isreg(vp)) {+ if (vnode_isdir(vp)) {+ return EISDIR;+ }+ //otherwise return EINVAL+ return EINVAL;+ }++#if HFS_COMPRESSION+ /* keep the compressed state locked until we're done truncating the file */+ decmpfs_cnode *dp = VTOCMP(vp);+ if (!dp) {+ /*+ * call hfs_lazy_init_decmpfs_cnode() to make sure that the decmpfs_cnode+ * is filled in; we need a decmpfs_cnode to lock out decmpfs state changes+ * on this file while it's truncating+ */+ dp = hfs_lazy_init_decmpfs_cnode(VTOC(vp));+ if (!dp) {+ /* failed to allocate a decmpfs_cnode */+ return ENOMEM; /* what should this be? */+ }+ }++ nspace_snapshot_event(vp, orig_ctime, vap->va_data_size == 0 ? NAMESPACE_HANDLER_TRUNCATE_OP|NAMESPACE_HANDLER_DELETE_OP : NAMESPACE_HANDLER_TRUNCATE_OP, NULL);++ decmpfs_lock_compressed_data(dp, 1);+ if (hfs_file_is_compressed(VTOC(vp), 1)) {+ error = decmpfs_decompress_file(vp, dp, -1/*vap->va_data_size*/, 0, 1);+ if (error != 0) {+ decmpfs_unlock_compressed_data(dp, 1);+ return error;+ }+ }+#endif++ // Take truncate lock+ hfs_lock_truncate(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);++ // hfs_truncate will deal with the cnode lock+ error = hfs_truncate(vp, vap->va_data_size, vap->va_vaflags & 0xffff,+ 0, ap->a_context);++ hfs_unlock_truncate(VTOC(vp), HFS_LOCK_DEFAULT);+#if HFS_COMPRESSION+ decmpfs_unlock_compressed_data(dp, 1);+#endif+ if (error)+ return error;+ }+ if (cp == NULL) {+ if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT)))+ return (error);+ cp = VTOC(vp);+ }++ /*+ * If it is just an access time update request by itself+ * we know the request is from kernel level code, and we+ * can delay it without being as worried about consistency.+ * This change speeds up mmaps, in the rare case that they+ * get caught behind a sync.+ */++ if (vap->va_active == VNODE_ATTR_va_access_time) {+ cp->c_touch_acctime=TRUE;+ goto out;+ }++++ /*+ * Owner/group change request.+ * We are guaranteed that the new owner/group is valid and legal.+ */+ VATTR_SET_SUPPORTED(vap, va_uid);+ VATTR_SET_SUPPORTED(vap, va_gid);+ nuid = VATTR_IS_ACTIVE(vap, va_uid) ? vap->va_uid : (uid_t)VNOVAL;+ ngid = VATTR_IS_ACTIVE(vap, va_gid) ? vap->va_gid : (gid_t)VNOVAL;+ if (((nuid != (uid_t)VNOVAL) || (ngid != (gid_t)VNOVAL)) &&+ ((error = hfs_chown(vp, nuid, ngid, cred, p)) != 0))+ goto out;++ /*+ * Mode change request.+ * We are guaranteed that the mode value is valid and that in+ * conjunction with the owner and group, this change is legal.+ */+ VATTR_SET_SUPPORTED(vap, va_mode);+ if (VATTR_IS_ACTIVE(vap, va_mode) &&+ ((error = hfs_chmod(vp, (int)vap->va_mode, cred, p)) != 0))+ goto out;++ /*+ * File flags change.+ * We are guaranteed that only flags allowed to change given the+ * current securelevel are being changed.+ */+ VATTR_SET_SUPPORTED(vap, va_flags);+ if (VATTR_IS_ACTIVE(vap, va_flags)) {+ if ((error = hfs_set_bsd_flags(hfsmp, cp, vap->va_flags, document_id,+ ap->a_context,+ &decmpfs_reset_state)) != 0) {+ goto out;+ }+ }++ /*+ * Timestamp updates.+ */+ VATTR_SET_SUPPORTED(vap, va_create_time);+ VATTR_SET_SUPPORTED(vap, va_access_time);+ VATTR_SET_SUPPORTED(vap, va_modify_time);+ VATTR_SET_SUPPORTED(vap, va_backup_time);+ VATTR_SET_SUPPORTED(vap, va_change_time);+ if (VATTR_IS_ACTIVE(vap, va_create_time) ||+ VATTR_IS_ACTIVE(vap, va_access_time) ||+ VATTR_IS_ACTIVE(vap, va_modify_time) ||+ VATTR_IS_ACTIVE(vap, va_backup_time)) {+ if (VATTR_IS_ACTIVE(vap, va_create_time))+ cp->c_itime = vap->va_create_time.tv_sec;+ if (VATTR_IS_ACTIVE(vap, va_access_time)) {+ cp->c_atime = vap->va_access_time.tv_sec;+ cp->c_touch_acctime = FALSE;+ }+ if (VATTR_IS_ACTIVE(vap, va_modify_time)) {+ cp->c_mtime = vap->va_modify_time.tv_sec;+ cp->c_touch_modtime = FALSE;+ cp->c_touch_chgtime = TRUE;++ hfs_clear_might_be_dirty_flag(cp);++ /*+ * The utimes system call can reset the modification+ * time but it doesn't know about HFS create times.+ * So we need to ensure that the creation time is+ * always at least as old as the modification time.+ */+ if ((VTOVCB(vp)->vcbSigWord == kHFSPlusSigWord) &&+ (cp->c_cnid != kHFSRootFolderID) &&+ !VATTR_IS_ACTIVE(vap, va_create_time) &&+ (cp->c_mtime < cp->c_itime)) {+ cp->c_itime = cp->c_mtime;+ }+ }+ if (VATTR_IS_ACTIVE(vap, va_backup_time))+ cp->c_btime = vap->va_backup_time.tv_sec;+ cp->c_flag |= C_MINOR_MOD;+ }++ // Set the date added time+ VATTR_SET_SUPPORTED(vap, va_addedtime);+ if (VATTR_IS_ACTIVE(vap, va_addedtime)) {+ hfs_write_dateadded(&cp->c_attr, vap->va_addedtime.tv_sec);+ cp->c_flag &= ~C_NEEDS_DATEADDED;+ cp->c_touch_chgtime = true;+ }++ /*+ * Set name encoding.+ */+ VATTR_SET_SUPPORTED(vap, va_encoding);+ if (VATTR_IS_ACTIVE(vap, va_encoding)) {+ cp->c_encoding = vap->va_encoding;+ cp->c_flag |= C_MODIFIED;+ hfs_setencodingbits(hfsmp, cp->c_encoding);+ }++ if ((error = hfs_update(vp, 0)) != 0)+ goto out;++out:+ if (cp) {+ /* Purge origin cache for cnode, since caller now has correct link ID for it+ * We purge it here since it was acquired for us during lookup, and we no longer need it.+ */+ if ((cp->c_flag & C_HARDLINK) && (vnode_vtype(vp) != VDIR)){+ hfs_relorigin(cp, 0);+ }++ hfs_unlock(cp);+#if HFS_COMPRESSION+ if (decmpfs_reset_state) {+ /*+ * we've changed the UF_COMPRESSED flag, so reset the decmpfs state for this cnode+ * but don't do it while holding the hfs cnode lock+ */+ decmpfs_cnode *dp = VTOCMP(vp);+ if (!dp) {+ /*+ * call hfs_lazy_init_decmpfs_cnode() to make sure that the decmpfs_cnode+ * is filled in; we need a decmpfs_cnode to prevent decmpfs state changes+ * on this file if it's locked+ */+ dp = hfs_lazy_init_decmpfs_cnode(VTOC(vp));+ if (!dp) {+ /* failed to allocate a decmpfs_cnode */+ return ENOMEM; /* what should this be? */+ }+ }+ decmpfs_cnode_set_vnode_state(dp, FILE_TYPE_UNKNOWN, 0);+ }+#endif+ }++#if CONFIG_PROTECT+ VATTR_SET_SUPPORTED(vap, va_dataprotect_class);+ if (!error && VATTR_IS_ACTIVE(vap, va_dataprotect_class))+ error = cp_vnode_setclass(vp, vap->va_dataprotect_class);+#endif++ return (error);+}+++/*+ * Change the mode on a file.+ * cnode must be locked before calling.+ */+int+hfs_chmod(struct vnode *vp, int mode, __unused kauth_cred_t cred, __unused struct proc *p)+{+ register struct cnode *cp = VTOC(vp);++ if (VTOVCB(vp)->vcbSigWord != kHFSPlusSigWord)+ return (0);++ // Don't allow modification of the journal or journal_info_block+ if (hfs_is_journal_file(VTOHFS(vp), cp)) {+ return EPERM;+ }++#if OVERRIDE_UNKNOWN_PERMISSIONS+ if (((unsigned int)vfs_flags(VTOVFS(vp))) & MNT_UNKNOWNPERMISSIONS) {+ return (0);+ };+#endif++ mode_t new_mode = (cp->c_mode & ~ALLPERMS) | (mode & ALLPERMS);+ if (new_mode != cp->c_mode) {+ cp->c_mode = new_mode;+ cp->c_flag |= C_MINOR_MOD;+ }+ cp->c_touch_chgtime = TRUE;+ return (0);+}+++int+hfs_write_access(struct vnode *vp, kauth_cred_t cred, struct proc *p, Boolean considerFlags)+{+ struct cnode *cp = VTOC(vp);+ int retval = 0;+ int is_member;++ /*+ * Disallow write attempts on read-only file systems;+ * unless the file is a socket, fifo, or a block or+ * character device resident on the file system.+ */+ switch (vnode_vtype(vp)) {+ case VDIR:+ case VLNK:+ case VREG:+ if (VTOHFS(vp)->hfs_flags & HFS_READ_ONLY)+ return (EROFS);+ break;+ default:+ break;+ }++ /* If immutable bit set, nobody gets to write it. */+ if (considerFlags && (cp->c_bsdflags & IMMUTABLE))+ return (EPERM);++ /* Otherwise, user id 0 always gets access. */+ if (!suser(cred, NULL))+ return (0);++ /* Otherwise, check the owner. */+ if ((retval = hfs_owner_rights(VTOHFS(vp), cp->c_uid, cred, p, false)) == 0)+ return ((cp->c_mode & S_IWUSR) == S_IWUSR ? 0 : EACCES);++ /* Otherwise, check the groups. */+ if (kauth_cred_ismember_gid(cred, cp->c_gid, &is_member) == 0 && is_member) {+ return ((cp->c_mode & S_IWGRP) == S_IWGRP ? 0 : EACCES);+ }++ /* Otherwise, check everyone else. */+ return ((cp->c_mode & S_IWOTH) == S_IWOTH ? 0 : EACCES);+}+++/*+ * Perform chown operation on cnode cp;+ * code must be locked prior to call.+ */+int+#if !QUOTA+hfs_chown(struct vnode *vp, uid_t uid, gid_t gid, __unused kauth_cred_t cred,+ __unused struct proc *p)+#else+hfs_chown(struct vnode *vp, uid_t uid, gid_t gid, kauth_cred_t cred,+ __unused struct proc *p)+#endif+{+ register struct cnode *cp = VTOC(vp);+ uid_t ouid;+ gid_t ogid;+#if QUOTA+ int error = 0;+ register int i;+ int64_t change;+#endif /* QUOTA */++ if (VTOVCB(vp)->vcbSigWord != kHFSPlusSigWord)+ return (ENOTSUP);++ if (((unsigned int)vfs_flags(VTOVFS(vp))) & MNT_UNKNOWNPERMISSIONS)+ return (0);++ if (uid == (uid_t)VNOVAL)+ uid = cp->c_uid;+ if (gid == (gid_t)VNOVAL)+ gid = cp->c_gid;++#if 0 /* we are guaranteed that this is already the case */+ /*+ * If we don't own the file, are trying to change the owner+ * of the file, or are not a member of the target group,+ * the caller must be superuser or the call fails.+ */+ if ((kauth_cred_getuid(cred) != cp->c_uid || uid != cp->c_uid ||+ (gid != cp->c_gid &&+ (kauth_cred_ismember_gid(cred, gid, &is_member) || !is_member))) &&+ (error = suser(cred, 0)))+ return (error);+#endif++ ogid = cp->c_gid;+ ouid = cp->c_uid;++ if (ouid == uid && ogid == gid) {+ // No change, just set change time+ cp->c_touch_chgtime = TRUE;+ return 0;+ }++#if QUOTA+ if ((error = hfs_getinoquota(cp)))+ return (error);+ if (ouid == uid) {+ dqrele(cp->c_dquot[USRQUOTA]);+ cp->c_dquot[USRQUOTA] = NODQUOT;+ }+ if (ogid == gid) {+ dqrele(cp->c_dquot[GRPQUOTA]);+ cp->c_dquot[GRPQUOTA] = NODQUOT;+ }++ /*+ * Eventually need to account for (fake) a block per directory+ * if (vnode_isdir(vp))+ * change = VTOHFS(vp)->blockSize;+ * else+ */++ change = (int64_t)(cp->c_blocks) * (int64_t)VTOVCB(vp)->blockSize;+ (void) hfs_chkdq(cp, -change, cred, CHOWN);+ (void) hfs_chkiq(cp, -1, cred, CHOWN);+ for (i = 0; i < MAXQUOTAS; i++) {+ dqrele(cp->c_dquot[i]);+ cp->c_dquot[i] = NODQUOT;+ }+#endif /* QUOTA */+ cp->c_gid = gid;+ cp->c_uid = uid;+#if QUOTA+ if ((error = hfs_getinoquota(cp)) == 0) {+ if (ouid == uid) {+ dqrele(cp->c_dquot[USRQUOTA]);+ cp->c_dquot[USRQUOTA] = NODQUOT;+ }+ if (ogid == gid) {+ dqrele(cp->c_dquot[GRPQUOTA]);+ cp->c_dquot[GRPQUOTA] = NODQUOT;+ }+ if ((error = hfs_chkdq(cp, change, cred, CHOWN)) == 0) {+ if ((error = hfs_chkiq(cp, 1, cred, CHOWN)) == 0)+ goto good;+ else+ (void) hfs_chkdq(cp, -change, cred, CHOWN|FORCE);+ }+ for (i = 0; i < MAXQUOTAS; i++) {+ dqrele(cp->c_dquot[i]);+ cp->c_dquot[i] = NODQUOT;+ }+ }+ cp->c_gid = ogid;+ cp->c_uid = ouid;+ if (hfs_getinoquota(cp) == 0) {+ if (ouid == uid) {+ dqrele(cp->c_dquot[USRQUOTA]);+ cp->c_dquot[USRQUOTA] = NODQUOT;+ }+ if (ogid == gid) {+ dqrele(cp->c_dquot[GRPQUOTA]);+ cp->c_dquot[GRPQUOTA] = NODQUOT;+ }+ (void) hfs_chkdq(cp, change, cred, FORCE|CHOWN);+ (void) hfs_chkiq(cp, 1, cred, FORCE|CHOWN);+ (void) hfs_getinoquota(cp);+ }+ return (error);+good:+ if (hfs_getinoquota(cp))+ panic("hfs_chown: lost quota");+#endif /* QUOTA */++ /*+ * Without quotas, we could probably make this a minor+ * modification.+ */+ cp->c_flag |= C_MODIFIED;++ /*+ According to the SUSv3 Standard, chown() shall mark+ for update the st_ctime field of the file.+ (No exceptions mentioned)+ */+ cp->c_touch_chgtime = TRUE;+ return (0);+}++#if HFS_COMPRESSION+/*+ * Flush the resource fork if it exists. vp is the data fork and has+ * an iocount.+ */+static int hfs_flush_rsrc(vnode_t vp, vfs_context_t ctx)+{+ cnode_t *cp = VTOC(vp);++ hfs_lock(cp, HFS_SHARED_LOCK, 0);++ vnode_t rvp = cp->c_rsrc_vp;++ if (!rvp) {+ hfs_unlock(cp);+ return 0;+ }++ int vid = vnode_vid(rvp);++ hfs_unlock(cp);++ int error = vnode_getwithvid(rvp, vid);++ if (error)+ return error == ENOENT ? 0 : error;++ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, 0);+ hfs_lock_always(cp, HFS_EXCLUSIVE_LOCK);+ hfs_filedone(rvp, ctx, HFS_FILE_DONE_NO_SYNC);+ hfs_unlock(cp);+ hfs_unlock_truncate(cp, 0);++ error = ubc_msync(rvp, 0, ubc_getsize(rvp), NULL,+ UBC_PUSHALL | UBC_SYNC);++ vnode_put(rvp);++ return error;+}+#endif // HFS_COMPRESSION+++/* Helper Functions for exchangedata(2) */++/*+ * hfs_exchangedata_getxattr+ * arguments:+ * vp: vnode to extract the EA for+ * name_selector: the index into the array of EA name entries.+ * buffer: address for output buffer to store the output EA+ * NOTE: This function will allocate the buffer, it is the caller's responsibility to free it.+ * xattr_size: output argument; will return the size of the EA, to correspond with the buffer.+ *+ * Return: 0 on success.+ * errno on error. If we return any error, the buffer is guaranteed to be NULL.+ *+ * Assumes CNODE lock held on cnode for 'vp'+ */+static+int hfs_exchangedata_getxattr (struct vnode *vp, uint32_t name_selector, void **buffer, size_t *xattr_size) {+ void *xattr_rawdata = NULL;+ void *extracted_xattr = NULL;+ uio_t uio;+ size_t memsize = MAX_EXCHANGE_EA_SIZE;+ size_t attrsize;+ int error = 0;+ struct hfsmount *hfsmp = NULL;++ /* Sanity check inputs */+ if (name_selector > MAX_NUM_XATTR_NAMES) {+ return EINVAL;+ }++ if (buffer == NULL || xattr_size == NULL) {+ return EINVAL;+ }++ hfsmp = VTOHFS(vp);++ //allocate 4k memory to hold the EA. We don't use this for "large" EAs, and the default+ //EA B-tree size should produce inline attributes of size < 4K+ xattr_rawdata = hfs_malloc_data(MAX_EXCHANGE_EA_SIZE);+ if (!xattr_rawdata) {+ return ENOMEM;+ }++ //now create the UIO+ uio = uio_create (1, 0, UIO_SYSSPACE, UIO_READ);+ if (!uio) {+ hfs_free_data(xattr_rawdata, memsize);+ return ENOMEM;+ }+ uio_addiov(uio, CAST_USER_ADDR_T(xattr_rawdata), memsize);+ attrsize = memsize;++ struct vnop_getxattr_args vga = {+ .a_uio = uio,+ .a_name = XATTR_NAMES[name_selector],+ .a_size = &attrsize+ };++ // this takes care of grabbing the systemfile locks for us.+ error = hfs_getxattr_internal (VTOC(vp), &vga, hfsmp, 0);++ if (error) {+ /*+ * We could have gotten a variety of errors back from the XATTR tree:+ * is it too big? (bigger than 4k?) == ERANGE+ * was the EA not found? == ENOATTR+ */+ uio_free(uio);+ hfs_free_data(xattr_rawdata, memsize);+ return error;+ }++ //free the UIO+ uio_free(uio);++ //upon success, a_size/attrsize now contains the actua/exported EA size+ extracted_xattr = hfs_malloc_data(attrsize);+ memcpy (extracted_xattr, xattr_rawdata, attrsize);+ hfs_free_data(xattr_rawdata, memsize);++ *xattr_size = attrsize;+ *buffer = extracted_xattr;++ return error;+}+++/*+ * hfs_exchangedata_setxattr+ *+ * Note: This function takes fileIDs in as inputs, because exchangedata does+ * swizzly things with the two cnodes (See big block comment in hfs_vnop_exchange)+ * so we operate with FileIDs more or less directly on the XATTR b-tree.+ *+ * arguments:+ * hfsmp: the mount we're working on+ * fileid: the fileID of the EA to store into the tree.+ * name_selector: selector into the EA name array.+ * buffer: pointer to the memory of the EA to write.+ * xattr_size: size of the EA to write.+ *+ * Returns 0 on success+ * errno on failure+ *+ * Assumes that a transaction has already begun when this is called+ */++static+int hfs_exchangedata_setxattr (struct hfsmount *hfsmp, uint32_t fileid,+ uint32_t name_selector, void *buffer, size_t xattr_size) {++ int error = 0;+++ /* Sanity check arguments */+ if (name_selector > MAX_NUM_XATTR_NAMES - 1) {+ return EINVAL;+ }++ if (buffer == NULL || xattr_size == 0 || fileid < kHFSFirstUserCatalogNodeID ) {+ return EINVAL;+ }++ // is the size too big?+ if (xattr_size > hfsmp->hfs_max_inline_attrsize) {+ return EINVAL;+ }++ /* setup the arguments to setxattr*/+ struct vnop_setxattr_args vsa = {+ .a_desc = NULL,+ .a_vp = NULL,+ .a_name = XATTR_NAMES[name_selector],+ .a_uio = NULL, // we use the data_ptr argument to setxattr_internal instead+ .a_options = 0,+ .a_context = NULL // no context needed, only done from within exchangedata+ };++ /*+ * Since we must be in a transaction to guard the exchangedata operation, this will start+ * a nested transaction within the exchangedata one.+ */+ error = hfs_setxattr_internal (NULL, (caddr_t) buffer, xattr_size, &vsa, hfsmp, fileid);++ return error;++}++/*+ * hfs_vnop_exchange:+ *+ * Inputs:+ * 'from' vnode/cnode+ * 'to' vnode/cnode+ * options flag bits+ * vfs_context+ *+ * Discussion:+ * hfs_vnop_exchange is used to service the exchangedata(2) system call.+ * Per the requirements of that system call, this function "swaps" some+ * of the information that lives in one catalog record for some that+ * lives in another. Note that not everything is swapped; in particular,+ * the extent information stored in each cnode is kept local to that+ * cnode. This allows existing file descriptor references to continue+ * to operate on the same content, regardless of the location in the+ * namespace that the file may have moved to. See inline comments+ * in the function for more information.+ */+int+hfs_vnop_exchange(struct vnop_exchange_args *ap)+{+ struct vnode *from_vp = ap->a_fvp;+ struct vnode *to_vp = ap->a_tvp;+ struct cnode *from_cp;+ struct cnode *to_cp;+ struct hfsmount *hfsmp;+ struct cat_desc tempdesc;+ struct cat_attr tempattr;+ const unsigned char *from_nameptr;+ const unsigned char *to_nameptr;+ char from_iname[32];+ char to_iname[32];+ uint32_t to_flag_special;+ uint32_t from_flag_special;++ uint16_t to_recflags_special;+ uint16_t from_recflags_special;++ cnid_t from_parid;+ cnid_t to_parid;+ int lockflags;+ int error = 0, started_tr = 0, got_cookie = 0;+ cat_cookie_t cookie;+ time_t orig_from_ctime, orig_to_ctime;+ bool have_cnode_locks = false, have_from_trunc_lock = false, have_to_trunc_lock = false;++ /* For the quarantine EA */+ void *from_xattr = NULL;+ void *to_xattr = NULL;+ size_t from_attrsize = 0;+ size_t to_attrsize = 0;+++ /*+ * VFS does the following checks:+ * 1. Validate that both are files.+ * 2. Validate that both are on the same mount.+ * 3. Validate that they're not the same vnode.+ */++ from_cp = VTOC(from_vp);+ to_cp = VTOC(to_vp);+ hfsmp = VTOHFS(from_vp);++ orig_from_ctime = from_cp->c_ctime;+ orig_to_ctime = to_cp->c_ctime;++#if CONFIG_PROTECT+ /*+ * Do not allow exchangedata/F_MOVEDATAEXTENTS on data-protected filesystems+ * because the EAs will not be swapped. As a result, the persistent keys would not+ * match and the files will be garbage.+ */+ if (cp_fs_protected (vnode_mount(from_vp))) {+ return EINVAL;+ }+#endif++#if HFS_COMPRESSION+ if (!ISSET(ap->a_options, FSOPT_EXCHANGE_DATA_ONLY)) {+ if ( hfs_file_is_compressed(from_cp, 0) ) {+ if ( 0 != ( error = decmpfs_decompress_file(from_vp, VTOCMP(from_vp), -1, 0, 1) ) ) {+ return error;+ }+ }++ if ( hfs_file_is_compressed(to_cp, 0) ) {+ if ( 0 != ( error = decmpfs_decompress_file(to_vp, VTOCMP(to_vp), -1, 0, 1) ) ) {+ return error;+ }+ }+ }+#endif // HFS_COMPRESSION++ // Resource forks cannot be exchanged.+ if (VNODE_IS_RSRC(from_vp) || VNODE_IS_RSRC(to_vp))+ return EINVAL;++ /*+ * Normally, we want to notify the user handlers about the event,+ * except if it's a handler driving the event.+ */+ if ((ap->a_options & FSOPT_EXCHANGE_DATA_ONLY) == 0) {+ nspace_snapshot_event(from_vp, orig_from_ctime, NAMESPACE_HANDLER_WRITE_OP, NULL);+ nspace_snapshot_event(to_vp, orig_to_ctime, NAMESPACE_HANDLER_WRITE_OP, NULL);+ } else {+ /*+ * This is currently used by mtmd so we should tidy up the+ * file now because the data won't be used again in the+ * destination file.+ */+ hfs_lock_truncate(from_cp, HFS_EXCLUSIVE_LOCK, 0);+ hfs_lock_always(from_cp, HFS_EXCLUSIVE_LOCK);+ hfs_filedone(from_vp, ap->a_context, HFS_FILE_DONE_NO_SYNC);+ hfs_unlock(from_cp);+ hfs_unlock_truncate(from_cp, 0);++ // Flush all the data from the source file+ error = ubc_msync(from_vp, 0, ubc_getsize(from_vp), NULL,+ UBC_PUSHALL | UBC_SYNC);+ if (error)+ goto exit;++#if HFS_COMPRESSION+ /*+ * If this is a compressed file, we need to do the same for+ * the resource fork.+ */+ if (ISSET(from_cp->c_bsdflags, UF_COMPRESSED)) {+ error = hfs_flush_rsrc(from_vp, ap->a_context);+ if (error)+ goto exit;+ }+#endif++ /*+ * We're doing a data-swap so we need to take the truncate+ * lock exclusively. We need an exclusive lock because we+ * will be completely truncating the source file and we must+ * make sure nobody else sneaks in and trys to issue I/O+ * whilst we don't have the cnode lock.+ *+ * After taking the truncate lock we do a quick check to+ * verify there are no other references (including mmap+ * references), but we must remember that this does not stop+ * anybody coming in later and taking a reference. We will+ * have the truncate lock exclusively so that will prevent+ * them from issuing any I/O.+ */++ if (to_cp < from_cp) {+ hfs_lock_truncate(to_cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ have_to_trunc_lock = true;+ }++ hfs_lock_truncate(from_cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ have_from_trunc_lock = true;++ /*+ * Do an early check to verify the source is not in use by+ * anyone. We should be called from an FD opened as F_EVTONLY+ * so that doesn't count as a reference.+ */+ if (vnode_isinuse(from_vp, 0)) {+ error = EBUSY;+ goto exit;+ }++ if (to_cp >= from_cp) {+ hfs_lock_truncate(to_cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ have_to_trunc_lock = true;+ }+ }++ if ((error = hfs_lockpair(from_cp, to_cp, HFS_EXCLUSIVE_LOCK)))+ goto exit;+ have_cnode_locks = true;++ // Don't allow modification of the journal or journal_info_block+ if (hfs_is_journal_file(hfsmp, from_cp) ||+ hfs_is_journal_file(hfsmp, to_cp)) {+ error = EPERM;+ goto exit;+ }++ /*+ * If doing a data move, then call the underlying function.+ */+ if (ISSET(ap->a_options, FSOPT_EXCHANGE_DATA_ONLY)) {+#if HFS_COMPRESSION+ if (ISSET(from_cp->c_bsdflags, UF_COMPRESSED)) {+ error = hfs_move_compressed(from_cp, to_cp);+ goto exit;+ }+#endif++ error = hfs_move_data(from_cp, to_cp, 0);+ goto exit;+ }++ /*+ * If we're doing a normal exchangedata, then get the source/dst quarantine+ * EAs as needed. We do it here before we start the transaction.+ */++ //get the EA for the 'from' vnode if it exists.+ error = hfs_exchangedata_getxattr (from_vp, quarantine, &from_xattr, &from_attrsize);+ if (error) {+ if (error == ENOATTR) {+ //it's OK for the quarantine EA to not exist+ error = 0;+ }+ else {+ goto exit;+ }+ }+++ //get the EA from the 'to' vnode if it exists+ error = hfs_exchangedata_getxattr (to_vp, quarantine, &to_xattr, &to_attrsize);+ if (error) {+ if (error == ENOATTR) {+ //it's OK for the quarantine EA to not exist+ error = 0;+ }+ else {+ goto exit;+ }+ }+++ /* Start a transaction; we have to do all of this atomically */+ if ((error = hfs_start_transaction(hfsmp)) != 0) {+ goto exit;+ }+ started_tr = 1;++ /*+ * Reserve some space in the Catalog file.+ */+ if ((error = cat_preflight(hfsmp, CAT_EXCHANGE, &cookie, vfs_context_proc(ap->a_context)))) {+ goto exit;+ }+ got_cookie = 1;++ /* The backend code always tries to delete the virtual+ * extent id for exchanging files so we need to lock+ * the extents b-tree.+ */+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_EXTENTS | SFL_ATTRIBUTE, HFS_EXCLUSIVE_LOCK);++ /* Account for the location of the catalog objects. */+ if (from_cp->c_flag & C_HARDLINK) {+ MAKE_INODE_NAME(from_iname, sizeof(from_iname),+ from_cp->c_attr.ca_linkref);+ from_nameptr = (unsigned char *)from_iname;+ from_parid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid;+ from_cp->c_hint = 0;+ } else {+ from_nameptr = from_cp->c_desc.cd_nameptr;+ from_parid = from_cp->c_parentcnid;+ }+ if (to_cp->c_flag & C_HARDLINK) {+ MAKE_INODE_NAME(to_iname, sizeof(to_iname),+ to_cp->c_attr.ca_linkref);+ to_nameptr = (unsigned char *)to_iname;+ to_parid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid;+ to_cp->c_hint = 0;+ } else {+ to_nameptr = to_cp->c_desc.cd_nameptr;+ to_parid = to_cp->c_parentcnid;+ }++ /*+ * ExchangeFileIDs swaps the on-disk, or in-BTree extent information+ * attached to two different file IDs. It also swaps the extent+ * information that may live in the extents-overflow B-Tree.+ *+ * We do this in a transaction as this may require a lot of B-Tree nodes+ * to do completely, particularly if one of the files in question+ * has a lot of extents.+ *+ * For example, assume "file1" has fileID 50, and "file2" has fileID 52.+ * For the on-disk records, which are assumed to be synced, we will+ * first swap the resident inline-8 extents as part of the catalog records.+ * Then we will swap any extents overflow records for each file.+ *+ * When ExchangeFileIDs returns successfully, "file1" will have fileID 52,+ * and "file2" will have fileID 50. However, note that this is only+ * approximately half of the work that exchangedata(2) will need to+ * accomplish. In other words, we swap "too much" of the information+ * because if we only called ExchangeFileIDs, both the fileID and extent+ * information would be the invariants of this operation. We don't+ * actually want that; we want to conclude with "file1" having+ * file ID 50, and "file2" having fileID 52.+ *+ * The remainder of hfs_vnop_exchange will swap the file ID and other cnode+ * data back to the proper ownership, while still allowing the cnode to remain+ * pointing at the same set of extents that it did originally.+ */+ error = ExchangeFileIDs(hfsmp, from_nameptr, to_nameptr, from_parid,+ to_parid, from_cp->c_hint, to_cp->c_hint);+ hfs_systemfile_unlock(hfsmp, lockflags);++ if (error != E_NONE) {+ error = MacToVFSError(error);+ goto exit;+ }++ /*+ * Now, we have to swap the quarantine EA.+ *+ * Ordinarily, we would not have to swap/exchange any extended attributes,+ * since they are keyed by the file ID, and this function is supposed+ * to manipulate the main data stream/fork only.+ *+ * However, we want the quarantine EA to follow the file content.+ */++ int from_xattr_status = 0;+ if (from_xattr) {+ /*+ * Caution!+ * We've crossed a point of no return here, because if we+ * have successfully swapped the file content above, we need to continue here+ * to swap the rest of the cnode content, which is not subject to failure.+ * Failing the whole function because the xattr swap will result in perceived+ * data loss to the caller, so we swallow the error case here.+ */+ from_xattr_status = hfs_removexattr_by_id (hfsmp, from_cp->c_fileid, XATTR_NAMES[quarantine]);+ if (from_xattr_status == 0) {+ int xattr_lockflags;+ int remaining_eas;+ /*+ * Check to see if we need to remove the xattr bit from the catalog record flags while+ * 'from_cp' still tracks with its original file ID. Once the cnodes' contents are swapped+ * and they are ready to be re-hashed, we will OR in the bit if we know that we moved the+ * EA to the counterpart.+ */+ xattr_lockflags = hfs_systemfile_lock (hfsmp, SFL_ATTRIBUTE, HFS_SHARED_LOCK);+ remaining_eas = file_attribute_exist (hfsmp, from_cp->c_fileid);+ if (remaining_eas == 0) {+ from_cp->c_attr.ca_recflags &= ~kHFSHasAttributesMask;+ //the cnode will be pushed out to disk LATER on.+ }+ hfs_systemfile_unlock (hfsmp, xattr_lockflags);++ }+ }++ //and the same for to_xattr+ if (to_xattr) {+ int xattr_status = hfs_removexattr_by_id (hfsmp, to_cp->c_fileid, XATTR_NAMES[quarantine]);++ if (xattr_status == 0) {+ int xattr_lockflags;+ int remaining_eas;+ /*+ * Check to see if we need to remove the xattr bit from the catalog record flags while+ * 'to_cp' still tracks with its original file ID. Once the cnodes' contents are swapped+ * and they are ready to be re-hashed, we will OR in the bit if we know that we moved the+ * EA to the counterpart.+ */+ xattr_lockflags = hfs_systemfile_lock (hfsmp, SFL_ATTRIBUTE, HFS_SHARED_LOCK);+ remaining_eas = file_attribute_exist (hfsmp, from_cp->c_fileid);+ if (remaining_eas == 0) {+ to_cp->c_attr.ca_recflags &= ~kHFSHasAttributesMask;+ //the cnode will be pushed out to disk LATER on.+ }+ hfs_systemfile_unlock (hfsmp, xattr_lockflags);++ /* Now move the EA to the counterparty fileID. We piggyback on the larger transaction here */+ hfs_exchangedata_setxattr (hfsmp, from_cp->c_fileid, quarantine, to_xattr, to_attrsize);+ }+ }++ if (from_xattr && from_xattr_status == 0) {+ /*+ * if the from EA got removed properly, then attach it to the 'to' file. We do it at this point+ * to ensure that it got removed properly above before re-setting it again.+ */+ hfs_exchangedata_setxattr (hfsmp, to_cp->c_fileid, quarantine, from_xattr, from_attrsize);+ }+++ /* Purge the vnodes from the name cache */+ if (from_vp)+ cache_purge(from_vp);+ if (to_vp)+ cache_purge(to_vp);++ /* Bump both source and destination write counts before any swaps. */+ {+ hfs_incr_gencount (from_cp);+ hfs_incr_gencount (to_cp);+ }++ /* Save a copy of "from" attributes before swapping. */+ bcopy(&from_cp->c_desc, &tempdesc, sizeof(struct cat_desc));+ bcopy(&from_cp->c_attr, &tempattr, sizeof(struct cat_attr));++ /* Save whether or not each cnode is a hardlink or has EAs */+ from_flag_special = from_cp->c_flag & (C_HARDLINK | C_HASXATTRS);+ from_recflags_special = (from_cp->c_attr.ca_recflags & kHFSHasAttributesMask);++ to_flag_special = to_cp->c_flag & (C_HARDLINK | C_HASXATTRS);+ to_recflags_special = (to_cp->c_attr.ca_recflags & kHFSHasAttributesMask);++ /* Drop the special bits from each cnode */+ from_cp->c_flag &= ~(C_HARDLINK | C_HASXATTRS);+ to_cp->c_flag &= ~(C_HARDLINK | C_HASXATTRS);+ from_cp->c_attr.ca_recflags &= ~(kHFSHasAttributesMask);+ to_cp->c_attr.ca_recflags &= ~(kHFSHasAttributesMask);++ /*+ * Now complete the in-memory portion of the copy.+ *+ * ExchangeFileIDs swaps the on-disk records involved. We complete the+ * operation by swapping the in-memory contents of the two files here.+ * We swap the cnode descriptors, which contain name, BSD attributes,+ * timestamps, etc, about the file.+ *+ * NOTE: We do *NOT* swap the fileforks of the two cnodes. We have+ * already swapped the on-disk extent information. As long as we swap the+ * IDs, the in-line resident 8 extents that live in the filefork data+ * structure will point to the right data for the new file ID if we leave+ * them alone.+ *+ * As a result, any file descriptor that points to a particular+ * vnode (even though it should change names), will continue+ * to point to the same content.+ */++ /* Copy the "to" -> "from" cnode */+ bcopy(&to_cp->c_desc, &from_cp->c_desc, sizeof(struct cat_desc));++ from_cp->c_hint = 0;+ /*+ * If 'to' was a hardlink, then we copied over its link ID/CNID/(namespace ID)+ * when we bcopy'd the descriptor above. However, the cnode attributes+ * are not bcopied. As a result, make sure to swap the file IDs of each item.+ *+ * Further, other hardlink attributes must be moved along in this swap:+ * the linkcount, the linkref, and the firstlink all need to move+ * along with the file IDs. See note below regarding the flags and+ * what moves vs. what does not.+ *+ * For Reference:+ * linkcount == total # of hardlinks.+ * linkref == the indirect inode pointer.+ * firstlink == the first hardlink in the chain (written to the raw inode).+ * These three are tied to the fileID and must move along with the rest of the data.+ */+ from_cp->c_fileid = to_cp->c_attr.ca_fileid;++ from_cp->c_itime = to_cp->c_itime;+ from_cp->c_btime = to_cp->c_btime;+ from_cp->c_atime = to_cp->c_atime;+ from_cp->c_ctime = to_cp->c_ctime;+ from_cp->c_gid = to_cp->c_gid;+ from_cp->c_uid = to_cp->c_uid;+ from_cp->c_bsdflags = to_cp->c_bsdflags;+ from_cp->c_mode = to_cp->c_mode;+ from_cp->c_linkcount = to_cp->c_linkcount;+ from_cp->c_attr.ca_linkref = to_cp->c_attr.ca_linkref;+ from_cp->c_attr.ca_firstlink = to_cp->c_attr.ca_firstlink;++ /*+ * The cnode flags need to stay with the cnode and not get transferred+ * over along with everything else because they describe the content; they are+ * not attributes that reflect changes specific to the file ID. In general,+ * fields that are tied to the file ID are the ones that will move.+ *+ * This reflects the fact that the file may have borrowed blocks, dirty metadata,+ * or other extents, which may not yet have been written to the catalog. If+ * they were, they would have been transferred above in the ExchangeFileIDs call above...+ *+ * The flags that are special are:+ * C_HARDLINK, C_HASXATTRS+ *+ * and the c_attr recflag:+ * kHFSHasAttributesMask+ *+ * These flags move with the item and file ID in the namespace since their+ * state is tied to that of the file ID.+ *+ * So to transfer the flags, we have to take the following steps+ * 1) Store in a localvar whether or not the special bits are set.+ * 2) Drop the special bits from the current flags+ * 3) swap the special flag bits to their destination+ */+ from_cp->c_flag |= to_flag_special | C_MODIFIED;+ from_cp->c_attr.ca_recflags = to_cp->c_attr.ca_recflags;+ from_cp->c_attr.ca_recflags |= to_recflags_special;+ if (from_xattr) {+ /*+ * NOTE:+ * This is counter-intuitive and part of the complexity of exchangedata.+ * if 'from_cp' originally had a quarantine EA, then ensure that the cnode+ * pointed to by 'from_cp' CONTINUES to keep the "has EAs" bit. This is because+ * the cnode is about to be re-hashed with a new ID, but the file CONTENT+ * (i.e. the file fork) stayed put. And we want the quarantine EA to follow+ * the content. The check above is correct.+ */+ from_cp->c_attr.ca_recflags |= kHFSHasAttributesMask;+ }++ bcopy(to_cp->c_finderinfo, from_cp->c_finderinfo, 32);+++ /* Copy the "from" -> "to" cnode */+ bcopy(&tempdesc, &to_cp->c_desc, sizeof(struct cat_desc));+ to_cp->c_hint = 0;+ /*+ * Pull the file ID from the tempattr we copied above. We can't assume+ * it is the same as the CNID.+ */+ to_cp->c_fileid = tempattr.ca_fileid;+ to_cp->c_itime = tempattr.ca_itime;+ to_cp->c_btime = tempattr.ca_btime;+ to_cp->c_atime = tempattr.ca_atime;+ to_cp->c_ctime = tempattr.ca_ctime;+ to_cp->c_gid = tempattr.ca_gid;+ to_cp->c_uid = tempattr.ca_uid;+ to_cp->c_bsdflags = tempattr.ca_flags;+ to_cp->c_mode = tempattr.ca_mode;+ to_cp->c_linkcount = tempattr.ca_linkcount;+ to_cp->c_attr.ca_linkref = tempattr.ca_linkref;+ to_cp->c_attr.ca_firstlink = tempattr.ca_firstlink;++ /*+ * Only OR in the "from" flags into our cnode flags below.+ * Leave the rest of the flags alone.+ */+ to_cp->c_flag |= from_flag_special | C_MODIFIED;+ to_cp->c_attr.ca_recflags = tempattr.ca_recflags;+ to_cp->c_attr.ca_recflags |= from_recflags_special;++ if (to_xattr) {+ /*+ * NOTE:+ * This is counter-intuitive and part of the complexity of exchangedata.+ * if 'to_cp' originally had a quarantine EA, then ensure that the cnode+ * pointed to by 'to_cp' CONTINUES to keep the "has EAs" bit. This is because+ * the cnode is about to be re-hashed with a new ID, but the file CONTENT+ * (i.e. the file fork) stayed put. And we want the quarantine EA to follow+ * the content. The check above is correct.+ */+ to_cp->c_attr.ca_recflags |= kHFSHasAttributesMask;+ }++ bcopy(tempattr.ca_finderinfo, to_cp->c_finderinfo, 32);+++ /* Rehash the cnodes using their new file IDs */+ hfs_chash_rehash(hfsmp, from_cp, to_cp);++ /*+ * When a file moves out of "Cleanup At Startup"+ * we can drop its NODUMP status.+ */+ if ((from_cp->c_bsdflags & UF_NODUMP) &&+ (from_cp->c_parentcnid != to_cp->c_parentcnid)) {+ from_cp->c_bsdflags &= ~UF_NODUMP;+ from_cp->c_touch_chgtime = TRUE;+ }+ if ((to_cp->c_bsdflags & UF_NODUMP) &&+ (to_cp->c_parentcnid != from_cp->c_parentcnid)) {+ to_cp->c_bsdflags &= ~UF_NODUMP;+ to_cp->c_touch_chgtime = TRUE;+ }++exit:+ if (got_cookie) {+ cat_postflight(hfsmp, &cookie, vfs_context_proc(ap->a_context));+ }+ if (started_tr) {+ hfs_end_transaction(hfsmp);+ }++ if (have_cnode_locks)+ hfs_unlockpair(from_cp, to_cp);++ if (have_from_trunc_lock)+ hfs_unlock_truncate(from_cp, 0);++ if (have_to_trunc_lock)+ hfs_unlock_truncate(to_cp, 0);++ /* Free the memory used by the EAs */+ if (from_xattr) {+ hfs_free_data(from_xattr, from_attrsize);+ from_xattr = NULL;+ }++ if (to_xattr) {+ hfs_free_data(to_xattr, to_attrsize);+ to_xattr = NULL;+ }++ return (error);+}++#if HFS_COMPRESSION+/*+ * This function is used specifically for the case when a namespace+ * handler is trying to steal data before it's deleted. Note that we+ * don't bother deleting the xattr from the source because it will get+ * deleted a short time later anyway.+ *+ * cnodes must be locked+ */+static int hfs_move_compressed(cnode_t *from_cp, cnode_t *to_cp)+{+ int ret;+ void *data = NULL;++ CLR(from_cp->c_bsdflags, UF_COMPRESSED);+ SET(from_cp->c_flag, C_MODIFIED);++ ret = hfs_move_data(from_cp, to_cp, HFS_MOVE_DATA_INCLUDE_RSRC);+ if (ret)+ goto exit;++ /*+ * Transfer the xattr that decmpfs uses. Ideally, this code+ * should be with the other decmpfs code but it's file system+ * agnostic and this path is currently, and likely to remain, HFS++ * specific. It's easier and more performant if we implement it+ * here.+ */++ size_t size;+ size = MAX_DECMPFS_XATTR_SIZE;+ data = hfs_malloc_data(size);++ ret = hfs_xattr_read(from_cp->c_vp, DECMPFS_XATTR_NAME, data, &size);+ if (ret)+ goto exit;++ ret = hfs_xattr_write(to_cp->c_vp, DECMPFS_XATTR_NAME, data, size);+ if (ret)+ goto exit;++ SET(to_cp->c_bsdflags, UF_COMPRESSED);+ SET(to_cp->c_flag, C_MODIFIED);++exit:+ hfs_free_data(data, MAX_DECMPFS_XATTR_SIZE);++ return ret;+}+#endif // HFS_COMPRESSION++int+hfs_vnop_mmap(struct vnop_mmap_args *ap)+{+ struct vnode *vp = ap->a_vp;+ cnode_t *cp = VTOC(vp);+ int error;++ if (VNODE_IS_RSRC(vp)) {+ /* allow pageins of the resource fork */+ } else {+ int compressed = hfs_file_is_compressed(cp, 1); /* 1 == don't take the cnode lock */+ time_t orig_ctime = cp->c_ctime;++ if (!compressed && (cp->c_bsdflags & UF_COMPRESSED)) {+ error = check_for_dataless_file(vp, NAMESPACE_HANDLER_READ_OP);+ if (error != 0) {+ return error;+ }+ }++ if (ap->a_fflags & PROT_WRITE) {+ nspace_snapshot_event(vp, orig_ctime, NAMESPACE_HANDLER_WRITE_OP, NULL);+ }+ }++#if CONFIG_PROTECT+ error = cp_handle_vnop(vp, (ap->a_fflags & PROT_WRITE+ ? CP_WRITE_ACCESS : 0) | CP_READ_ACCESS, 0);+ if (error)+ return error;+#endif++ //+ // NOTE: we return ENOTSUP because we want the cluster layer+ // to actually do all the real work.+ //+ return (ENOTSUP);+}++static errno_t hfs_vnop_mnomap(struct vnop_mnomap_args *ap)+{+ vnode_t vp = ap->a_vp;++ /*+ * Whilst the file was mapped, there may not have been any+ * page-outs so we need to increment the generation counter now.+ * Unfortunately this may lead to a change in the generation+ * counter when no actual change has been made, but there is+ * little we can do about that with our current architecture.+ */+ if (ubc_is_mapped_writable(vp)) {+ cnode_t *cp = VTOC(vp);+ hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ hfs_incr_gencount(cp);++ /*+ * We don't want to set the modification time here since a+ * change to that is not acceptable if no changes were made.+ * Instead we set a flag so that if we get any page-outs we+ * know to update the modification time. It's possible that+ * they weren't actually because of changes made whilst the+ * file was mapped but that's not easy to fix now.+ */+ SET(cp->c_flag, C_MIGHT_BE_DIRTY_FROM_MAPPING);++ hfs_unlock(cp);+ }++ return 0;+}++/*+ * Mark the resource fork as needing a ubc_setsize when we drop the+ * cnode lock later.+ */+static void hfs_rsrc_setsize(cnode_t *cp)+{+ /*+ * We need to take an iocount if we don't have one. vnode_get+ * will return ENOENT if the vnode is terminating which is what we+ * want as it's not safe to call ubc_setsize in that case.+ */+ if (cp->c_rsrc_vp && !vnode_get(cp->c_rsrc_vp)) {+ // Shouldn't happen, but better safe...+ if (ISSET(cp->c_flag, C_NEED_RVNODE_PUT))+ vnode_put(cp->c_rsrc_vp);+ SET(cp->c_flag, C_NEED_RVNODE_PUT | C_NEED_RSRC_SETSIZE);+ }+}++/*+ * hfs_move_data+ *+ * This is a non-symmetric variant of exchangedata. In this function,+ * the contents of the data fork (and optionally the resource fork)+ * are moved from from_cp to to_cp.+ *+ * The cnodes must be locked.+ *+ * The cnode pointed to by 'to_cp' *must* be empty prior to invoking+ * this function. We impose this restriction because we may not be+ * able to fully delete the entire file's contents in a single+ * transaction, particularly if it has a lot of extents. In the+ * normal file deletion codepath, the file is screened for two+ * conditions: 1) bigger than 400MB, and 2) more than 8 extents. If+ * so, the file is relocated to the hidden directory and the deletion+ * is broken up into multiple truncates. We can't do that here+ * because both files need to exist in the namespace. The main reason+ * this is imposed is that we may have to touch a whole lot of bitmap+ * blocks if there are many extents.+ *+ * Any data written to 'from_cp' after this call completes is not+ * guaranteed to be moved.+ *+ * Arguments:+ * cnode_t *from_cp : source file+ * cnode_t *to_cp : destination file; must be empty+ *+ * Returns:+ *+ * EBUSY - File has been deleted or is in use+ * EFBIG - Destination file was not empty+ * EIO - An I/O error+ * 0 - success+ * other - Other errors that can be returned from called functions+ */+int hfs_move_data(cnode_t *from_cp, cnode_t *to_cp,+ hfs_move_data_options_t options)+{+ hfsmount_t *hfsmp = VTOHFS(from_cp->c_vp);+ int error = 0;+ int lockflags = 0;+ bool return_EIO_on_error = false;+ const bool include_rsrc = ISSET(options, HFS_MOVE_DATA_INCLUDE_RSRC);++ /* Verify that neither source/dest file is open-unlinked */+ if (ISSET(from_cp->c_flag, C_DELETED | C_NOEXISTS)+ || ISSET(to_cp->c_flag, C_DELETED | C_NOEXISTS)) {+ return EBUSY;+ }++ /*+ * Verify the source file is not in use by anyone besides us.+ *+ * This function is typically invoked by a namespace handler+ * process responding to a temporarily stalled system call.+ * The FD that it is working off of is opened O_EVTONLY, so+ * it really has no active usecounts (the kusecount from O_EVTONLY+ * is subtracted from the total usecounts).+ *+ * As a result, we shouldn't have any active usecounts against+ * this vnode when we go to check it below.+ */+ if (vnode_isinuse(from_cp->c_vp, 0))+ return EBUSY;++ if (include_rsrc && from_cp->c_rsrc_vp) {+ if (vnode_isinuse(from_cp->c_rsrc_vp, 0))+ return EBUSY;++ /*+ * In the code below, if the destination file doesn't have a+ * c_rsrcfork then we don't create it which means we we cannot+ * transfer the ff_invalidranges and cf_vblocks fields. These+ * shouldn't be set because we flush the resource fork before+ * calling this function but there is a tiny window when we+ * did not have any locks...+ */+ if (!to_cp->c_rsrcfork+ && (!TAILQ_EMPTY(&from_cp->c_rsrcfork->ff_invalidranges)+ || from_cp->c_rsrcfork->ff_unallocblocks)) {+ /*+ * The file isn't really busy now but something did slip+ * in and tinker with the file while we didn't have any+ * locks, so this is the most meaningful return code for+ * the caller.+ */+ return EBUSY;+ }+ }++ // Check the destination file is empty+ if (to_cp->c_datafork->ff_blocks+ || to_cp->c_datafork->ff_size+ || (include_rsrc+ && (to_cp->c_blocks+ || (to_cp->c_rsrcfork && to_cp->c_rsrcfork->ff_size)))) {+ return EFBIG;+ }++ if ((error = hfs_start_transaction (hfsmp)))+ return error;++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_EXTENTS | SFL_ATTRIBUTE,+ HFS_EXCLUSIVE_LOCK);++ // filefork_t is 128 bytes which should be OK+ filefork_t rfork_buf, *from_rfork = NULL;++ if (include_rsrc) {+ from_rfork = from_cp->c_rsrcfork;++ /*+ * Creating resource fork vnodes is expensive, so just get get+ * the fork data if we need it.+ */+ if (!from_rfork && hfs_has_rsrc(from_cp)) {+ from_rfork = &rfork_buf;++ from_rfork->ff_cp = from_cp;+ TAILQ_INIT(&from_rfork->ff_invalidranges);++ error = cat_idlookup(hfsmp, from_cp->c_fileid, 0, 1, NULL, NULL,+ &from_rfork->ff_data);++ if (error)+ goto exit;+ }+ }++ /*+ * From here on, any failures mean that we might be leaving things+ * in a weird or inconsistent state. Ideally, we should back out+ * all the changes, but to do that properly we need to fix+ * MoveData. We'll save fixing that for another time. For now,+ * just return EIO in all cases to the caller so that they know.+ */+ return_EIO_on_error = true;++ bool data_overflow_extents = overflow_extents(from_cp->c_datafork);++ // Move the data fork+ if ((error = hfs_move_fork (from_cp->c_datafork, from_cp,+ to_cp->c_datafork, to_cp))) {+ goto exit;+ }++ SET(from_cp->c_flag, C_NEED_DATA_SETSIZE);+ SET(to_cp->c_flag, C_NEED_DATA_SETSIZE);++ // We move the resource fork later++ /*+ * Note that because all we're doing is moving the extents around,+ * we can probably do this in a single transaction: Each extent+ * record (group of 8) is 64 bytes. A extent overflow B-Tree node+ * is typically 4k. This means each node can hold roughly ~60+ * extent records == (480 extents).+ *+ * If a file was massively fragmented and had 20k extents, this+ * means we'd roughly touch 20k/480 == 41 to 42 nodes, plus the+ * index nodes, for half of the operation. (inserting or+ * deleting). So if we're manipulating 80-100 nodes, this is+ * basically 320k of data to write to the journal in a bad case.+ */+ if (data_overflow_extents) {+ if ((error = MoveData(hfsmp, from_cp->c_cnid, to_cp->c_cnid, 0)))+ goto exit;+ }++ if (from_rfork && overflow_extents(from_rfork)) {+ if ((error = MoveData(hfsmp, from_cp->c_cnid, to_cp->c_cnid, 1)))+ goto exit;+ }++ // Touch times+ from_cp->c_touch_acctime = TRUE;+ from_cp->c_touch_chgtime = TRUE;+ from_cp->c_touch_modtime = TRUE;+ hfs_touchtimes(hfsmp, from_cp);++ to_cp->c_touch_acctime = TRUE;+ to_cp->c_touch_chgtime = TRUE;+ to_cp->c_touch_modtime = TRUE;+ hfs_touchtimes(hfsmp, to_cp);++ struct cat_fork dfork_buf;+ const struct cat_fork *dfork, *rfork;++ dfork = hfs_prepare_fork_for_update(to_cp->c_datafork, NULL,+ &dfork_buf, hfsmp->blockSize);+ rfork = hfs_prepare_fork_for_update(from_rfork, NULL,+ &rfork_buf.ff_data, hfsmp->blockSize);++ // Update the catalog nodes, to_cp first+ if ((error = cat_update(hfsmp, &to_cp->c_desc, &to_cp->c_attr,+ dfork, rfork))) {+ goto exit;+ }++ CLR(to_cp->c_flag, C_MODIFIED | C_MINOR_MOD);++ // Update in-memory resource fork data here+ if (from_rfork) {+ // Update c_blocks+ uint32_t moving = from_rfork->ff_blocks + from_rfork->ff_unallocblocks;++ from_cp->c_blocks -= moving;+ to_cp->c_blocks += moving;++ // Update to_cp's resource data if it has it+ filefork_t *to_rfork = to_cp->c_rsrcfork;+ if (to_rfork) {+ TAILQ_SWAP(&to_rfork->ff_invalidranges,+ &from_rfork->ff_invalidranges, rl_entry, rl_link);+ to_rfork->ff_data = from_rfork->ff_data;++ // Deal with ubc_setsize+ hfs_rsrc_setsize(to_cp);+ }++ // Wipe out the resource fork in from_cp+ rl_init(&from_rfork->ff_invalidranges);+ bzero(&from_rfork->ff_data, sizeof(from_rfork->ff_data));++ // Deal with ubc_setsize+ hfs_rsrc_setsize(from_cp);+ }++ // Currently unnecessary, but might be useful in future...+ dfork = hfs_prepare_fork_for_update(from_cp->c_datafork, NULL, &dfork_buf,+ hfsmp->blockSize);+ rfork = hfs_prepare_fork_for_update(from_rfork, NULL, &rfork_buf.ff_data,+ hfsmp->blockSize);++ // Update from_cp+ if ((error = cat_update(hfsmp, &from_cp->c_desc, &from_cp->c_attr,+ dfork, rfork))) {+ goto exit;+ }++ CLR(from_cp->c_flag, C_MODIFIED | C_MINOR_MOD);++exit:+ if (lockflags) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ hfs_end_transaction(hfsmp);+ }++ if (error && error != EIO && return_EIO_on_error) {+ printf("hfs_move_data: encountered error %d\n", error);+ error = EIO;+ }++ return error;+}++/*+ * Move all of the catalog and runtime data in srcfork to dstfork.+ *+ * This allows us to maintain the invalid ranges across the move data+ * operation so we don't need to force all of the pending IO right+ * now. In addition, we move all non overflow-extent extents into the+ * destination here.+ *+ * The destination fork must be empty and should have been checked+ * prior to calling this.+ */+static int hfs_move_fork(filefork_t *srcfork, cnode_t *src_cp,+ filefork_t *dstfork, cnode_t *dst_cp)+{+ // Move the invalid ranges+ TAILQ_SWAP(&dstfork->ff_invalidranges, &srcfork->ff_invalidranges,+ rl_entry, rl_link);+ rl_remove_all(&srcfork->ff_invalidranges);++ // Move the fork data (copy whole structure)+ dstfork->ff_data = srcfork->ff_data;+ bzero(&srcfork->ff_data, sizeof(srcfork->ff_data));++ // Update c_blocks+ src_cp->c_blocks -= dstfork->ff_blocks + dstfork->ff_unallocblocks;+ dst_cp->c_blocks += dstfork->ff_blocks + dstfork->ff_unallocblocks;++ return 0;+}++/*+ * cnode must be locked+ */+int+hfs_fsync(struct vnode *vp, int waitfor, hfs_fsync_mode_t fsyncmode, struct proc *p)+{+ struct cnode *cp = VTOC(vp);+ struct filefork *fp = NULL;+ int retval = 0;+ struct hfsmount *hfsmp = VTOHFS(vp);+ struct timeval tv;+ int waitdata; /* attributes necessary for data retrieval */+ int wait; /* all other attributes (e.g. atime, etc.) */+ int took_trunc_lock = 0;+ int fsync_default = 1;++ /*+ * Applications which only care about data integrity rather than full+ * file integrity may opt out of (delay) expensive metadata update+ * operations as a performance optimization.+ */+ wait = (waitfor == MNT_WAIT);+ waitdata = (waitfor == MNT_DWAIT) | wait;++ if (always_do_fullfsync)+ fsyncmode = HFS_FSYNC_FULL;+ if (fsyncmode != HFS_FSYNC)+ fsync_default = 0;++ /* HFS directories don't have any data blocks. */+ if (vnode_isdir(vp))+ goto metasync;+ fp = VTOF(vp);++ /*+ * For system files flush the B-tree header and+ * for regular files write out any clusters+ */+ if (vnode_issystem(vp)) {+ if (VTOF(vp)->fcbBTCBPtr != NULL) {+ // XXXdbg+ if (hfsmp->jnl == NULL) {+ BTFlushPath(VTOF(vp));+ }+ }+ } else {+ hfs_unlock(cp);+ hfs_lock_truncate(cp, HFS_SHARED_LOCK, HFS_LOCK_DEFAULT);+ took_trunc_lock = 1;++ if (fp->ff_unallocblocks != 0) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);++ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ }++ /* Don't hold cnode lock when calling into cluster layer. */+ (void) cluster_push(vp, waitdata ? IO_SYNC : 0);++ hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ }+ /*+ * When MNT_WAIT is requested and the zero fill timeout+ * has expired then we must explicitly zero out any areas+ * that are currently marked invalid (holes).+ *+ * Files with NODUMP can bypass zero filling here.+ */+ if (fp && (((cp->c_flag & C_ALWAYS_ZEROFILL) && !TAILQ_EMPTY(&fp->ff_invalidranges)) ||+ ((wait || (cp->c_flag & C_ZFWANTSYNC)) &&+ ((cp->c_bsdflags & UF_NODUMP) == 0) &&+ (vnode_issystem(vp) ==0) &&+ cp->c_zftimeout != 0))) {++ microuptime(&tv);+ if ((cp->c_flag & C_ALWAYS_ZEROFILL) == 0 && fsync_default && tv.tv_sec < (long)cp->c_zftimeout) {+ /* Remember that a force sync was requested. */+ cp->c_flag |= C_ZFWANTSYNC;+ goto datasync;+ }+ if (!TAILQ_EMPTY(&fp->ff_invalidranges)) {+ if (!took_trunc_lock || (cp->c_truncatelockowner == HFS_SHARED_OWNER)) {+ hfs_unlock(cp);+ if (took_trunc_lock) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ }+ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ took_trunc_lock = 1;+ }+ hfs_flush_invalid_ranges(vp);+ hfs_unlock(cp);+ (void) cluster_push(vp, waitdata ? IO_SYNC : 0);+ hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);+ }+ }+datasync:+ if (took_trunc_lock) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ took_trunc_lock = 0;+ }++ if (!hfsmp->jnl)+ buf_flushdirtyblks(vp, waitdata, 0, "hfs_fsync");+ else if (fsync_default && vnode_islnk(vp)+ && vnode_hasdirtyblks(vp) && vnode_isrecycled(vp)) {+ /*+ * If it's a symlink that's dirty and is about to be recycled,+ * we need to flush the journal.+ */+ fsync_default = 0;+ }++metasync:+ if (vnode_isreg(vp) && vnode_issystem(vp)) {+ if (VTOF(vp)->fcbBTCBPtr != NULL) {+ microuptime(&tv);+ BTSetLastSync(VTOF(vp), tv.tv_sec);+ }+ cp->c_touch_acctime = FALSE;+ cp->c_touch_chgtime = FALSE;+ cp->c_touch_modtime = FALSE;+ } else if (!vnode_isswap(vp)) {+ retval = hfs_update(vp, HFS_UPDATE_FORCE);++ /*+ * When MNT_WAIT is requested push out the catalog record for+ * this file. If they asked for a full fsync, we can skip this+ * because the journal_flush or hfs_metasync_all will push out+ * all of the metadata changes.+ */+ if ((retval == 0) && wait && fsync_default && cp->c_hint &&+ !ISSET(cp->c_flag, C_DELETED | C_NOEXISTS)) {+ hfs_metasync(VTOHFS(vp), (daddr64_t)cp->c_hint, p);+ }++ /*+ * If this was a full fsync, make sure all metadata+ * changes get to stable storage.+ */+ if (!fsync_default) {+ if (hfsmp->jnl) {+ if (fsyncmode == HFS_FSYNC_FULL)+ hfs_flush(hfsmp, HFS_FLUSH_FULL);+ else+ hfs_flush(hfsmp, HFS_FLUSH_JOURNAL_BARRIER);+ } else {+ retval = hfs_metasync_all(hfsmp);+ /* XXX need to pass context! */+ hfs_flush(hfsmp, HFS_FLUSH_CACHE);+ }+ }+ }++ if (!hfs_is_dirty(cp) && !ISSET(cp->c_flag, C_DELETED))+ vnode_cleardirty(vp);++ return (retval);+}+++/* Sync an hfs catalog b-tree node */+int+hfs_metasync(struct hfsmount *hfsmp, daddr64_t node, __unused struct proc *p)+{+ vnode_t vp;+ buf_t bp;+ int lockflags;++ vp = HFSTOVCB(hfsmp)->catalogRefNum;++ // XXXdbg - don't need to do this on a journaled volume+ if (hfsmp->jnl) {+ return 0;+ }++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);+ /*+ * Look for a matching node that has been delayed+ * but is not part of a set (B_LOCKED).+ *+ * BLK_ONLYVALID causes buf_getblk to return a+ * buf_t for the daddr64_t specified only if it's+ * currently resident in the cache... the size+ * parameter to buf_getblk is ignored when this flag+ * is set+ */+ bp = buf_getblk(vp, node, 0, 0, 0, BLK_META | BLK_ONLYVALID);++ if (bp) {+ if ((buf_flags(bp) & (B_LOCKED | B_DELWRI)) == B_DELWRI)+ (void) VNOP_BWRITE(bp);+ else+ buf_brelse(bp);+ }++ hfs_systemfile_unlock(hfsmp, lockflags);++ return (0);+}+++/*+ * Sync all hfs B-trees. Use this instead of journal_flush for a volume+ * without a journal. Note that the volume bitmap does not get written;+ * we rely on fsck_hfs to fix that up (which it can do without any loss+ * of data).+ */+int+hfs_metasync_all(struct hfsmount *hfsmp)+{+ int lockflags;++ /* Lock all of the B-trees so we get a mutually consistent state */+ lockflags = hfs_systemfile_lock(hfsmp,+ SFL_CATALOG|SFL_EXTENTS|SFL_ATTRIBUTE, HFS_EXCLUSIVE_LOCK);++ /* Sync each of the B-trees */+ if (hfsmp->hfs_catalog_vp)+ hfs_btsync(hfsmp->hfs_catalog_vp, 0);+ if (hfsmp->hfs_extents_vp)+ hfs_btsync(hfsmp->hfs_extents_vp, 0);+ if (hfsmp->hfs_attribute_vp)+ hfs_btsync(hfsmp->hfs_attribute_vp, 0);++ /* Wait for all of the writes to complete */+ if (hfsmp->hfs_catalog_vp)+ vnode_waitforwrites(hfsmp->hfs_catalog_vp, 0, 0, 0, "hfs_metasync_all");+ if (hfsmp->hfs_extents_vp)+ vnode_waitforwrites(hfsmp->hfs_extents_vp, 0, 0, 0, "hfs_metasync_all");+ if (hfsmp->hfs_attribute_vp)+ vnode_waitforwrites(hfsmp->hfs_attribute_vp, 0, 0, 0, "hfs_metasync_all");++ hfs_systemfile_unlock(hfsmp, lockflags);++ return 0;+}+++/*ARGSUSED 1*/+static int+hfs_btsync_callback(struct buf *bp, __unused void *dummy)+{+ buf_clearflags(bp, B_LOCKED);+ (void) buf_bawrite(bp);++ return(BUF_CLAIMED);+}+++int+hfs_btsync(struct vnode *vp, int sync_transaction)+{+ struct cnode *cp = VTOC(vp);+ struct timeval tv;+ int flags = 0;++ if (sync_transaction)+ flags |= BUF_SKIP_NONLOCKED;+ /*+ * Flush all dirty buffers associated with b-tree.+ */+ buf_iterate(vp, hfs_btsync_callback, flags, 0);++ microuptime(&tv);+ if (vnode_issystem(vp) && (VTOF(vp)->fcbBTCBPtr != NULL))+ (void) BTSetLastSync(VTOF(vp), tv.tv_sec);+ cp->c_touch_acctime = FALSE;+ cp->c_touch_chgtime = FALSE;+ cp->c_touch_modtime = FALSE;++ return 0;+}++/*+ * Remove a directory.+ */+int+hfs_vnop_rmdir(struct vnop_rmdir_args *ap)+{+ struct vnode *dvp = ap->a_dvp;+ struct vnode *vp = ap->a_vp;+ struct cnode *dcp = VTOC(dvp);+ struct cnode *cp = VTOC(vp);+ int error;+ time_t orig_ctime;++ orig_ctime = VTOC(vp)->c_ctime;++ if (!S_ISDIR(cp->c_mode)) {+ return (ENOTDIR);+ }+ if (dvp == vp) {+ return (EINVAL);+ }++ nspace_snapshot_event(vp, orig_ctime, NAMESPACE_HANDLER_DELETE_OP, NULL);+ cp = VTOC(vp);++ if ((error = hfs_lockpair(dcp, cp, HFS_EXCLUSIVE_LOCK))) {+ return (error);+ }++ /* Check for a race with rmdir on the parent directory */+ if (dcp->c_flag & (C_DELETED | C_NOEXISTS)) {+ hfs_unlockpair (dcp, cp);+ return ENOENT;+ }++ //+ // if the item is tracked but doesn't have a document_id, assign one and generate an fsevent for it+ //+ if ((cp->c_bsdflags & UF_TRACKED) && ((struct FndrExtendedDirInfo *)((char *)&cp->c_attr.ca_finderinfo + 16))->document_id == 0) {+ uint32_t newid;++ hfs_unlockpair(dcp, cp);++ if (hfs_generate_document_id(VTOHFS(vp), &newid) == 0) {+ hfs_lockpair(dcp, cp, HFS_EXCLUSIVE_LOCK);+ ((struct FndrExtendedDirInfo *)((char *)&cp->c_attr.ca_finderinfo + 16))->document_id = newid;+ add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(),+ FSE_ARG_DEV, VTOHFS(vp)->hfs_raw_dev,+ FSE_ARG_INO, (ino64_t)0, // src inode #+ FSE_ARG_INO, (ino64_t)cp->c_fileid, // dst inode #+ FSE_ARG_INT32, newid,+ FSE_ARG_DONE);+ } else {+ // XXXdbg - couldn't get a new docid... what to do? can't really fail the rm...+ hfs_lockpair(dcp, cp, HFS_EXCLUSIVE_LOCK);+ }+ }++ error = hfs_removedir(dvp, vp, ap->a_cnp, 0, 0);++ hfs_unlockpair(dcp, cp);++ return (error);+}++/*+ * Remove a directory+ *+ * Both dvp and vp cnodes are locked+ */+int+hfs_removedir(struct vnode *dvp, struct vnode *vp, struct componentname *cnp,+ int skip_reserve, int only_unlink)+{+ struct cnode *cp;+ struct cnode *dcp;+ struct hfsmount * hfsmp;+ struct cat_desc desc;+ int lockflags;+ int error = 0, started_tr = 0;++ cp = VTOC(vp);+ dcp = VTOC(dvp);+ hfsmp = VTOHFS(vp);++ if (dcp == cp) {+ return (EINVAL); /* cannot remove "." */+ }+ if (cp->c_flag & (C_NOEXISTS | C_DELETED)) {+ return (0);+ }+ if (cp->c_entries != 0) {+ return (ENOTEMPTY);+ }++ /*+ * If the directory is open or in use (e.g. opendir() or current working+ * directory for some process); wait for inactive/reclaim to actually+ * remove cnode from the catalog. Both inactive and reclaim codepaths are capable+ * of removing open-unlinked directories from the catalog, as well as getting rid+ * of EAs still on the element. So change only_unlink to true, so that it will get+ * cleaned up below.+ *+ * Otherwise, we can get into a weird old mess where the directory has C_DELETED,+ * but it really means C_NOEXISTS because the item was actually removed from the+ * catalog. Then when we try to remove the entry from the catalog later on, it won't+ * really be there anymore.+ */+ if (vnode_isinuse(vp, 0)) {+ only_unlink = 1;+ }++ /* Deal with directory hardlinks */+ if (cp->c_flag & C_HARDLINK) {+ /*+ * Note that if we have a directory which was a hardlink at any point,+ * its actual directory data is stored in the directory inode in the hidden+ * directory rather than the leaf element(s) present in the namespace.+ *+ * If there are still other hardlinks to this directory,+ * then we'll just eliminate this particular link and the vnode will still exist.+ * If this is the last link to an empty directory, then we'll open-unlink the+ * directory and it will be only tagged with C_DELETED (as opposed to C_NOEXISTS).+ *+ * We could also return EBUSY here.+ */++ return hfs_unlink(hfsmp, dvp, vp, cnp, skip_reserve);+ }++ /*+ * In a few cases, we may want to allow the directory to persist in an+ * open-unlinked state. If the directory is being open-unlinked (still has usecount+ * references), or if it has EAs, or if it was being deleted as part of a rename,+ * then we go ahead and move it to the hidden directory.+ *+ * If the directory is being open-unlinked, then we want to keep the catalog entry+ * alive so that future EA calls and fchmod/fstat etc. do not cause issues later.+ *+ * If the directory had EAs, then we want to use the open-unlink trick so that the+ * EA removal is not done in one giant transaction. Otherwise, it could cause a panic+ * due to overflowing the journal.+ *+ * Finally, if it was deleted as part of a rename, we move it to the hidden directory+ * in order to maintain rename atomicity.+ *+ * Note that the allow_dirs argument to hfs_removefile specifies that it is+ * supposed to handle directories for this case.+ */++ if (((hfsmp->hfs_attribute_vp != NULL) &&+ ((cp->c_attr.ca_recflags & kHFSHasAttributesMask) != 0)) ||+ (only_unlink != 0)) {++ int ret = hfs_removefile(dvp, vp, cnp, 0, 0, 1, NULL, only_unlink);+ /*+ * Even though hfs_vnop_rename calls vnode_recycle for us on tvp we call+ * it here just in case we were invoked by rmdir() on a directory that had+ * EAs. To ensure that we start reclaiming the space as soon as possible,+ * we call vnode_recycle on the directory.+ */+ vnode_recycle(vp);++ return ret;++ }++ dcp->c_flag |= C_DIR_MODIFICATION;++#if QUOTA+ if (hfsmp->hfs_flags & HFS_QUOTAS)+ (void)hfs_getinoquota(cp);+#endif+ if ((error = hfs_start_transaction(hfsmp)) != 0) {+ goto out;+ }+ started_tr = 1;++ /*+ * Verify the directory is empty (and valid).+ * (Rmdir ".." won't be valid since+ * ".." will contain a reference to+ * the current directory and thus be+ * non-empty.)+ */+ if ((dcp->c_bsdflags & APPEND) || (cp->c_bsdflags & (IMMUTABLE | APPEND))) {+ error = EPERM;+ goto out;+ }++ /* Remove the entry from the namei cache: */+ cache_purge(vp);++ /*+ * Protect against a race with rename by using the component+ * name passed in and parent id from dvp (instead of using+ * the cp->c_desc which may have changed).+ */+ desc.cd_nameptr = (const u_int8_t *)cnp->cn_nameptr;+ desc.cd_namelen = cnp->cn_namelen;+ desc.cd_parentcnid = dcp->c_fileid;+ desc.cd_cnid = cp->c_cnid;+ desc.cd_flags = CD_ISDIR;+ desc.cd_encoding = cp->c_encoding;+ desc.cd_hint = 0;++ if (!hfs_valid_cnode(hfsmp, dvp, cnp, cp->c_fileid, NULL, &error)) {+ error = 0;+ goto out;+ }++ /* Remove entry from catalog */+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);++ if (!skip_reserve) {+ /*+ * Reserve some space in the Catalog file.+ */+ if ((error = cat_preflight(hfsmp, CAT_DELETE, NULL, 0))) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ goto out;+ }+ }++ error = cat_delete(hfsmp, &desc, &cp->c_attr);++ if (!error) {+ //+ // if skip_reserve == 1 then we're being called from hfs_vnop_rename() and thus+ // we don't need to touch the document_id as it's handled by the rename code.+ // otherwise it's a normal remove and we need to save the document id in the+ // per thread struct and clear it from the cnode.+ //+ struct doc_tombstone *ut;+ ut = doc_tombstone_get();+ if (!skip_reserve && (cp->c_bsdflags & UF_TRACKED)+ && doc_tombstone_should_save(ut, vp, cnp)) {++ uint32_t doc_id = hfs_get_document_id(cp);++ // this event is more of a "pending-delete"+ if (ut->t_lastop_document_id) {+ add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(),+ FSE_ARG_DEV, hfsmp->hfs_raw_dev,+ FSE_ARG_INO, (ino64_t)cp->c_fileid, // src inode #+ FSE_ARG_INO, (ino64_t)0, // dst inode #+ FSE_ARG_INT32, doc_id,+ FSE_ARG_DONE);+ }++ doc_tombstone_save(dvp, vp, cnp, doc_id, cp->c_fileid);++ struct FndrExtendedFileInfo *fip = (struct FndrExtendedFileInfo *)((char *)&cp->c_attr.ca_finderinfo + 16);++ // clear this so it's never returned again+ fip->document_id = 0;+ cp->c_bsdflags &= ~UF_TRACKED;+ }++ /* The parent lost a child */+ if (dcp->c_entries > 0)+ dcp->c_entries--;+ DEC_FOLDERCOUNT(hfsmp, dcp->c_attr);+ dcp->c_dirchangecnt++;+ hfs_incr_gencount(dcp);++ dcp->c_touch_chgtime = TRUE;+ dcp->c_touch_modtime = TRUE;+ dcp->c_flag |= C_MODIFIED;++ hfs_update(dcp->c_vp, 0);+ }++ hfs_systemfile_unlock(hfsmp, lockflags);++ if (error)+ goto out;++#if QUOTA+ if (hfsmp->hfs_flags & HFS_QUOTAS)+ (void)hfs_chkiq(cp, -1, NOCRED, 0);+#endif /* QUOTA */++ hfs_volupdate(hfsmp, VOL_RMDIR, (dcp->c_cnid == kHFSRootFolderID));++ /* Mark C_NOEXISTS since the catalog entry is now gone */+ cp->c_flag |= C_NOEXISTS;++out:+ dcp->c_flag &= ~C_DIR_MODIFICATION;+ wakeup((caddr_t)&dcp->c_flag);++ if (started_tr) {+ hfs_end_transaction(hfsmp);+ }++ return (error);+}+++/*+ * Remove a file or link.+ */+int+hfs_vnop_remove(struct vnop_remove_args *ap)+{+ struct vnode *dvp = ap->a_dvp;+ struct vnode *vp = ap->a_vp;+ struct cnode *dcp = VTOC(dvp);+ struct cnode *cp;+ struct vnode *rvp = NULL;+ int error=0, recycle_rsrc=0;+ int recycle_vnode = 0;+ uint32_t rsrc_vid = 0;+ time_t orig_ctime;++ if (dvp == vp) {+ return (EINVAL);+ }++ orig_ctime = VTOC(vp)->c_ctime;+ if (!vnode_isnamedstream(vp) && ((ap->a_flags & VNODE_REMOVE_SKIP_NAMESPACE_EVENT) == 0)) {+ error = nspace_snapshot_event(vp, orig_ctime, NAMESPACE_HANDLER_DELETE_OP, NULL);+ if (error) {+ // XXXdbg - decide on a policy for handling namespace handler failures!+ // for now we just let them proceed.+ }+ }+ error = 0;++ cp = VTOC(vp);++relock:++ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);++ if ((error = hfs_lockpair(dcp, cp, HFS_EXCLUSIVE_LOCK))) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ if (rvp) {+ vnode_put (rvp);+ }+ return (error);+ }+ //+ // if the item is tracked but doesn't have a document_id, assign one and generate an fsevent for it+ //+ if ((cp->c_bsdflags & UF_TRACKED) && ((struct FndrExtendedDirInfo *)((char *)&cp->c_attr.ca_finderinfo + 16))->document_id == 0) {+ uint32_t newid;++ hfs_unlockpair(dcp, cp);++ if (hfs_generate_document_id(VTOHFS(vp), &newid) == 0) {+ hfs_lockpair(dcp, cp, HFS_EXCLUSIVE_LOCK);+ ((struct FndrExtendedDirInfo *)((char *)&cp->c_attr.ca_finderinfo + 16))->document_id = newid;+ add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(),+ FSE_ARG_DEV, VTOHFS(vp)->hfs_raw_dev,+ FSE_ARG_INO, (ino64_t)0, // src inode #+ FSE_ARG_INO, (ino64_t)cp->c_fileid, // dst inode #+ FSE_ARG_INT32, newid,+ FSE_ARG_DONE);+ } else {+ // XXXdbg - couldn't get a new docid... what to do? can't really fail the rm...+ hfs_lockpair(dcp, cp, HFS_EXCLUSIVE_LOCK);+ }+ }++ /*+ * Lazily respond to determining if there is a valid resource fork+ * vnode attached to 'cp' if it is a regular file or symlink.+ * If the vnode does not exist, then we may proceed without having to+ * create it.+ *+ * If, however, it does exist, then we need to acquire an iocount on the+ * vnode after acquiring its vid. This ensures that if we have to do I/O+ * against it, it can't get recycled from underneath us in the middle+ * of this call.+ *+ * Note: this function may be invoked for directory hardlinks, so just skip these+ * steps if 'vp' is a directory.+ */++ enum vtype vtype = vnode_vtype(vp);+ if ((vtype == VLNK) || (vtype == VREG)) {+ if ((cp->c_rsrc_vp) && (rvp == NULL)) {+ /* We need to acquire the rsrc vnode */+ rvp = cp->c_rsrc_vp;+ rsrc_vid = vnode_vid (rvp);++ /* Unlock everything to acquire iocount on the rsrc vnode */+ hfs_unlock_truncate (cp, HFS_LOCK_DEFAULT);+ hfs_unlockpair (dcp, cp);+ /* Use the vid to maintain identity on rvp */+ if (vnode_getwithvid(rvp, rsrc_vid)) {+ /*+ * If this fails, then it was recycled or+ * reclaimed in the interim. Reset fields and+ * start over.+ */+ rvp = NULL;+ rsrc_vid = 0;+ }+ goto relock;+ }+ }++ /*+ * Check to see if we raced rmdir for the parent directory+ * hfs_removefile already checks for a race on vp/cp+ */+ if (dcp->c_flag & (C_DELETED | C_NOEXISTS)) {+ error = ENOENT;+ goto rm_done;+ }++ error = hfs_removefile(dvp, vp, ap->a_cnp, ap->a_flags, 0, 0, NULL, 0);++ /*+ * If the remove succeeded in deleting the file, then we may need to mark+ * the resource fork for recycle so that it is reclaimed as quickly+ * as possible. If it were not recycled quickly, then this resource fork+ * vnode could keep a v_parent reference on the data fork, which prevents it+ * from going through reclaim (by giving it extra usecounts), except in the force-+ * unmount case.+ *+ * However, a caveat: we need to continue to supply resource fork+ * access to open-unlinked files even if the resource fork is not open. This is+ * a requirement for the compressed files work. Luckily, hfs_vgetrsrc will handle+ * this already if the data fork has been re-parented to the hidden directory.+ *+ * As a result, all we really need to do here is mark the resource fork vnode+ * for recycle. If it goes out of core, it can be brought in again if needed.+ * If the cnode was instead marked C_NOEXISTS, then there wouldn't be any+ * more work.+ */+ if (error == 0) {+ hfs_hotfile_deleted(vp);++ if (rvp) {+ recycle_rsrc = 1;+ }+ /*+ * If the target was actually removed from the catalog schedule it for+ * full reclamation/inactivation. We hold an iocount on it so it should just+ * get marked with MARKTERM+ */+ if (cp->c_flag & C_NOEXISTS) {+ recycle_vnode = 1;+ }+ }+++ /*+ * Drop the truncate lock before unlocking the cnode+ * (which can potentially perform a vnode_put and+ * recycle the vnode which in turn might require the+ * truncate lock)+ */+rm_done:+ hfs_unlockpair(dcp, cp);+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);++ if (recycle_rsrc) {+ /* inactive or reclaim on rvp will clean up the blocks from the rsrc fork */+ vnode_recycle(rvp);+ }+ if (recycle_vnode) {+ vnode_recycle (vp);+ }++ if (rvp) {+ /* drop iocount on rsrc fork, was obtained at beginning of fxn */+ vnode_put(rvp);+ }++ return (error);+}+++int+hfs_removefile_callback(struct buf *bp, void *hfsmp) {++ if ( !(buf_flags(bp) & B_META))+ panic("hfs: symlink bp @ %p is not marked meta-data!\n", bp);+ /*+ * it's part of the current transaction, kill it.+ */+ journal_kill_block(((struct hfsmount *)hfsmp)->jnl, bp);++ return (BUF_CLAIMED);+}++/*+ * hfs_removefile+ *+ * Similar to hfs_vnop_remove except there are additional options.+ * This function may be used to remove directories if they have+ * lots of EA's -- note the 'allow_dirs' argument.+ *+ * This function is able to delete blocks & fork data for the resource+ * fork even if it does not exist in core (and have a backing vnode).+ * It should infer the correct behavior based on the number of blocks+ * in the cnode and whether or not the resource fork pointer exists or+ * not. As a result, one only need pass in the 'vp' corresponding to the+ * data fork of this file (or main vnode in the case of a directory).+ * Passing in a resource fork will result in an error.+ *+ * Because we do not create any vnodes in this function, we are not at+ * risk of deadlocking against ourselves by double-locking.+ *+ * Requires cnode and truncate locks to be held.+ */+int+hfs_removefile(struct vnode *dvp, struct vnode *vp, struct componentname *cnp,+ int flags, int skip_reserve, int allow_dirs,+ __unused struct vnode *rvp, int only_unlink)+{+ struct cnode *cp;+ struct cnode *dcp;+ struct vnode *rsrc_vp = NULL;+ struct hfsmount *hfsmp;+ struct cat_desc desc;+ struct timeval tv;+ int dataforkbusy = 0;+ int rsrcforkbusy = 0;+ int lockflags;+ int error = 0;+ int started_tr = 0;+ int isbigfile = 0, defer_remove=0, isdir=0;+ int update_vh = 0;++ cp = VTOC(vp);+ dcp = VTOC(dvp);+ hfsmp = VTOHFS(vp);++ /* Check if we lost a race post lookup. */+ if (cp->c_flag & (C_NOEXISTS | C_DELETED)) {+ return (0);+ }++ if (!hfs_valid_cnode(hfsmp, dvp, cnp, cp->c_fileid, NULL, &error)) {+ return 0;+ }++ /* Make sure a remove is permitted */+ if (VNODE_IS_RSRC(vp)) {+ return (EPERM);+ }+ else {+ /*+ * We know it's a data fork.+ * Probe the cnode to see if we have a valid resource fork+ * in hand or not.+ */+ rsrc_vp = cp->c_rsrc_vp;+ }++ /* Don't allow deleting the journal or journal_info_block. */+ if (hfs_is_journal_file(hfsmp, cp)) {+ return (EPERM);+ }++ /*+ * Hard links require special handling.+ */+ if (cp->c_flag & C_HARDLINK) {+ if ((flags & VNODE_REMOVE_NODELETEBUSY) && vnode_isinuse(vp, 0)) {+ return (EBUSY);+ } else {+ /* A directory hard link with a link count of one is+ * treated as a regular directory. Therefore it should+ * only be removed using rmdir().+ */+ if ((vnode_isdir(vp) == 1) && (cp->c_linkcount == 1) &&+ (allow_dirs == 0)) {+ return (EPERM);+ }+ return hfs_unlink(hfsmp, dvp, vp, cnp, skip_reserve);+ }+ }++ /* Directories should call hfs_rmdir! (unless they have a lot of attributes) */+ if (vnode_isdir(vp)) {+ if (allow_dirs == 0)+ return (EPERM); /* POSIX */+ isdir = 1;+ }+ /* Sanity check the parent ids. */+ if ((cp->c_parentcnid != hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid) &&+ (cp->c_parentcnid != dcp->c_fileid)) {+ return (EINVAL);+ }++ dcp->c_flag |= C_DIR_MODIFICATION;++ // this guy is going away so mark him as such+ cp->c_flag |= C_DELETED;+++ /* Remove our entry from the namei cache. */+ cache_purge(vp);++ /*+ * If the caller was operating on a file (as opposed to a+ * directory with EAs), then we need to figure out+ * whether or not it has a valid resource fork vnode.+ *+ * If there was a valid resource fork vnode, then we need+ * to use hfs_truncate to eliminate its data. If there is+ * no vnode, then we hold the cnode lock which would+ * prevent it from being created. As a result,+ * we can use the data deletion functions which do not+ * require that a cnode/vnode pair exist.+ */++ /* Check if this file is being used. */+ if (isdir == 0) {+ dataforkbusy = vnode_isinuse(vp, 0);+ /*+ * At this point, we know that 'vp' points to the+ * a data fork because we checked it up front. And if+ * there is no rsrc fork, rsrc_vp will be NULL.+ */+ if (rsrc_vp && (cp->c_blocks - VTOF(vp)->ff_blocks)) {+ rsrcforkbusy = vnode_isinuse(rsrc_vp, 0);+ }+ }++ /* Check if we have to break the deletion into multiple pieces. */+ if (isdir == 0)+ isbigfile = cp->c_datafork->ff_size >= HFS_BIGFILE_SIZE;++ /* Check if the file has xattrs. If it does we'll have to delete them in+ individual transactions in case there are too many */+ if ((hfsmp->hfs_attribute_vp != NULL) &&+ (cp->c_attr.ca_recflags & kHFSHasAttributesMask) != 0) {+ defer_remove = 1;+ }++ /* If we are explicitly told to only unlink item and move to hidden dir, then do it */+ if (only_unlink) {+ defer_remove = 1;+ }++ /*+ * Carbon semantics prohibit deleting busy files.+ * (enforced when VNODE_REMOVE_NODELETEBUSY is requested)+ */+ if (dataforkbusy || rsrcforkbusy) {+ if ((flags & VNODE_REMOVE_NODELETEBUSY) ||+ (hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid == 0)) {+ error = EBUSY;+ goto out;+ }+ }++#if QUOTA+ if (hfsmp->hfs_flags & HFS_QUOTAS)+ (void)hfs_getinoquota(cp);+#endif /* QUOTA */++ /*+ * Do a ubc_setsize to indicate we need to wipe contents if:+ * 1) item is a regular file.+ * 2) Neither fork is busy AND we are not told to unlink this.+ *+ * We need to check for the defer_remove since it can be set without+ * having a busy data or rsrc fork+ */+ if (isdir == 0 && (!dataforkbusy || !rsrcforkbusy) && (defer_remove == 0)) {+ /*+ * A ubc_setsize can cause a pagein so defer it+ * until after the cnode lock is dropped. The+ * cnode lock cannot be dropped/reacquired here+ * since we might already hold the journal lock.+ */+ if (!dataforkbusy && cp->c_datafork->ff_blocks && !isbigfile) {+ cp->c_flag |= C_NEED_DATA_SETSIZE;+ }+ if (!rsrcforkbusy && rsrc_vp) {+ cp->c_flag |= C_NEED_RSRC_SETSIZE;+ }+ }++ if ((error = hfs_start_transaction(hfsmp)) != 0) {+ goto out;+ }+ started_tr = 1;++ // XXXdbg - if we're journaled, kill any dirty symlink buffers+ if (hfsmp->jnl && vnode_islnk(vp) && (defer_remove == 0)) {+ buf_iterate(vp, hfs_removefile_callback, BUF_SKIP_NONLOCKED, (void *)hfsmp);+ }++ /*+ * Prepare to truncate any non-busy forks. Busy forks will+ * get truncated when their vnode goes inactive.+ * Note that we will only enter this region if we+ * can avoid creating an open-unlinked file. If+ * either region is busy, we will have to create an open+ * unlinked file.+ *+ * Since we are deleting the file, we need to stagger the runtime+ * modifications to do things in such a way that a crash won't+ * result in us getting overlapped extents or any other+ * bad inconsistencies. As such, we call prepare_release_storage+ * which updates the UBC, updates quota information, and releases+ * any loaned blocks that belong to this file. No actual+ * truncation or bitmap manipulation is done until *AFTER*+ * the catalog record is removed.+ */+ if (isdir == 0 && (!dataforkbusy && !rsrcforkbusy) && (only_unlink == 0)) {++ if (!dataforkbusy && !isbigfile && cp->c_datafork->ff_blocks != 0) {++ error = hfs_prepare_release_storage (hfsmp, vp);+ if (error) {+ goto out;+ }+ update_vh = 1;+ }++ /*+ * If the resource fork vnode does not exist, we can skip this step.+ */+ if (!rsrcforkbusy && rsrc_vp) {+ error = hfs_prepare_release_storage (hfsmp, rsrc_vp);+ if (error) {+ goto out;+ }+ update_vh = 1;+ }+ }++ /*+ * Protect against a race with rename by using the component+ * name passed in and parent id from dvp (instead of using+ * the cp->c_desc which may have changed). Also, be aware that+ * because we allow directories to be passed in, we need to special case+ * this temporary descriptor in case we were handed a directory.+ */+ if (isdir) {+ desc.cd_flags = CD_ISDIR;+ }+ else {+ desc.cd_flags = 0;+ }+ desc.cd_encoding = cp->c_desc.cd_encoding;+ desc.cd_nameptr = (const u_int8_t *)cnp->cn_nameptr;+ desc.cd_namelen = cnp->cn_namelen;+ desc.cd_parentcnid = dcp->c_fileid;+ desc.cd_hint = cp->c_desc.cd_hint;+ desc.cd_cnid = cp->c_cnid;+ microtime(&tv);++ /*+ * There are two cases to consider:+ * 1. File/Dir is busy/big/defer_remove ==> move/rename the file/dir+ * 2. File is not in use ==> remove the file+ *+ * We can get a directory in case 1 because it may have had lots of attributes,+ * which need to get removed here.+ */+ if (dataforkbusy || rsrcforkbusy || isbigfile || defer_remove) {+ char delname[32];+ struct cat_desc to_desc;+ struct cat_desc todir_desc;++ /*+ * Orphan this file or directory (move to hidden directory).+ * Again, we need to take care that we treat directories as directories,+ * and files as files. Because directories with attributes can be passed in+ * check to make sure that we have a directory or a file before filling in the+ * temporary descriptor's flags. We keep orphaned directories AND files in+ * the FILE_HARDLINKS private directory since we're generalizing over all+ * orphaned filesystem objects.+ */+ bzero(&todir_desc, sizeof(todir_desc));+ todir_desc.cd_parentcnid = 2;++ MAKE_DELETED_NAME(delname, sizeof(delname), cp->c_fileid);+ bzero(&to_desc, sizeof(to_desc));+ to_desc.cd_nameptr = (const u_int8_t *)delname;+ to_desc.cd_namelen = strlen(delname);+ to_desc.cd_parentcnid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid;+ if (isdir) {+ to_desc.cd_flags = CD_ISDIR;+ }+ else {+ to_desc.cd_flags = 0;+ }+ to_desc.cd_cnid = cp->c_cnid;++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);+ if (!skip_reserve) {+ if ((error = cat_preflight(hfsmp, CAT_RENAME, NULL, 0))) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ goto out;+ }+ }++ error = cat_rename(hfsmp, &desc, &todir_desc,+ &to_desc, (struct cat_desc *)NULL);++ if (error == 0) {+ hfsmp->hfs_private_attr[FILE_HARDLINKS].ca_entries++;+ if (isdir == 1) {+ INC_FOLDERCOUNT(hfsmp, hfsmp->hfs_private_attr[FILE_HARDLINKS]);+ }+ (void) cat_update(hfsmp, &hfsmp->hfs_private_desc[FILE_HARDLINKS],+ &hfsmp->hfs_private_attr[FILE_HARDLINKS], NULL, NULL);++ /* Update the parent directory */+ if (dcp->c_entries > 0)+ dcp->c_entries--;+ if (isdir == 1) {+ DEC_FOLDERCOUNT(hfsmp, dcp->c_attr);+ }+ dcp->c_dirchangecnt++;+ hfs_incr_gencount(dcp);++ dcp->c_ctime = tv.tv_sec;+ dcp->c_mtime = tv.tv_sec;+ (void) cat_update(hfsmp, &dcp->c_desc, &dcp->c_attr, NULL, NULL);++ /* Update the file or directory's state */+ cp->c_flag |= C_DELETED;+ cp->c_ctime = tv.tv_sec;+ --cp->c_linkcount;+ (void) cat_update(hfsmp, &to_desc, &cp->c_attr, NULL, NULL);+ }+ hfs_systemfile_unlock(hfsmp, lockflags);+ if (error)+ goto out;++ }+ else {+ /*+ * Nobody is using this item; we can safely remove everything.+ */+ struct filefork *temp_rsrc_fork = NULL;+#if QUOTA+ off_t savedbytes;+ int blksize = hfsmp->blockSize;+#endif+ u_int32_t fileid = cp->c_fileid;++ /*+ * Figure out if we need to read the resource fork data into+ * core before wiping out the catalog record.+ *+ * 1) Must not be a directory+ * 2) cnode's c_rsrcfork ptr must be NULL.+ * 3) rsrc fork must have actual blocks+ */+ if ((isdir == 0) && (cp->c_rsrcfork == NULL) &&+ (cp->c_blocks - VTOF(vp)->ff_blocks)) {+ /*+ * The resource fork vnode & filefork did not exist.+ * Create a temporary one for use in this function only.+ */+ temp_rsrc_fork = hfs_zalloc(HFS_FILEFORK_ZONE);+ bzero(temp_rsrc_fork, sizeof(struct filefork));+ temp_rsrc_fork->ff_cp = cp;+ rl_init(&temp_rsrc_fork->ff_invalidranges);+ }++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);++ /* Look up the resource fork first, if necessary */+ if (temp_rsrc_fork) {+ error = cat_lookup (hfsmp, &desc, 1, 0, (struct cat_desc*) NULL,+ (struct cat_attr*) NULL, &temp_rsrc_fork->ff_data, NULL);+ if (error) {+ hfs_zfree(temp_rsrc_fork, HFS_FILEFORK_ZONE);+ hfs_systemfile_unlock (hfsmp, lockflags);+ goto out;+ }+ }++ if (!skip_reserve) {+ if ((error = cat_preflight(hfsmp, CAT_DELETE, NULL, 0))) {+ if (temp_rsrc_fork) {+ hfs_zfree(temp_rsrc_fork, HFS_FILEFORK_ZONE);+ }+ hfs_systemfile_unlock(hfsmp, lockflags);+ goto out;+ }+ }++ error = cat_delete(hfsmp, &desc, &cp->c_attr);++ if (error && error != ENXIO && error != ENOENT) {+ printf("hfs_removefile: deleting file %s (id=%d) vol=%s err=%d\n",+ cp->c_desc.cd_nameptr, cp->c_attr.ca_fileid, hfsmp->vcbVN, error);+ }++ if (error == 0) {+ /* Update the parent directory */+ if (dcp->c_entries > 0)+ dcp->c_entries--;+ dcp->c_dirchangecnt++;+ hfs_incr_gencount(dcp);++ dcp->c_ctime = tv.tv_sec;+ dcp->c_mtime = tv.tv_sec;+ (void) cat_update(hfsmp, &dcp->c_desc, &dcp->c_attr, NULL, NULL);+ }+ hfs_systemfile_unlock(hfsmp, lockflags);++ if (error) {+ if (temp_rsrc_fork) {+ hfs_zfree(temp_rsrc_fork, HFS_FILEFORK_ZONE);+ }+ goto out;+ }++ /*+ * Now that we've wiped out the catalog record, the file effectively doesn't+ * exist anymore. So update the quota records to reflect the loss of the+ * data fork and the resource fork.+ */+#if QUOTA+ if (cp->c_datafork->ff_blocks > 0) {+ savedbytes = ((off_t)cp->c_datafork->ff_blocks * (off_t)blksize);+ (void) hfs_chkdq(cp, (int64_t)-(savedbytes), NOCRED, 0);+ }++ /*+ * We may have just deleted the catalog record for a resource fork even+ * though it did not exist in core as a vnode. However, just because there+ * was a resource fork pointer in the cnode does not mean that it had any blocks.+ */+ if (temp_rsrc_fork || cp->c_rsrcfork) {+ if (cp->c_rsrcfork) {+ if (cp->c_rsrcfork->ff_blocks > 0) {+ savedbytes = ((off_t)cp->c_rsrcfork->ff_blocks * (off_t)blksize);+ (void) hfs_chkdq(cp, (int64_t)-(savedbytes), NOCRED, 0);+ }+ }+ else {+ /* we must have used a temporary fork */+ savedbytes = ((off_t)temp_rsrc_fork->ff_blocks * (off_t)blksize);+ (void) hfs_chkdq(cp, (int64_t)-(savedbytes), NOCRED, 0);+ }+ }++ if (hfsmp->hfs_flags & HFS_QUOTAS) {+ (void)hfs_chkiq(cp, -1, NOCRED, 0);+ }+#endif++ if (vnode_islnk(vp) && cp->c_datafork->ff_symlinkptr) {+ hfs_free_data(cp->c_datafork->ff_symlinkptr, cp->c_datafork->ff_size);+ cp->c_datafork->ff_symlinkptr = NULL;+ }++ /*+ * If we didn't get any errors deleting the catalog entry, then go ahead+ * and release the backing store now. The filefork pointers are still valid.+ */+ if (temp_rsrc_fork) {+ error = hfs_release_storage (hfsmp, cp->c_datafork, temp_rsrc_fork, fileid);+ }+ else {+ /* if cp->c_rsrcfork == NULL, hfs_release_storage will skip over it. */+ error = hfs_release_storage (hfsmp, cp->c_datafork, cp->c_rsrcfork, fileid);+ }+ if (error) {+ /*+ * If we encountered an error updating the extents and bitmap,+ * mark the volume inconsistent. At this point, the catalog record has+ * already been deleted, so we can't recover it at this point. We need+ * to proceed and update the volume header and mark the cnode C_NOEXISTS.+ * The subsequent fsck should be able to recover the free space for us.+ */+ hfs_mark_inconsistent(hfsmp, HFS_OP_INCOMPLETE);+ }+ else {+ /* reset update_vh to 0, since hfs_release_storage should have done it for us */+ update_vh = 0;+ }++ /* Get rid of the temporary rsrc fork */+ if (temp_rsrc_fork) {+ hfs_zfree(temp_rsrc_fork, HFS_FILEFORK_ZONE);+ }++ cp->c_flag |= C_NOEXISTS;+ cp->c_flag &= ~C_DELETED;++ cp->c_touch_chgtime = TRUE;+ --cp->c_linkcount;++ /*+ * We must never get a directory if we're in this else block. We could+ * accidentally drop the number of files in the volume header if we did.+ */+ hfs_volupdate(hfsmp, VOL_RMFILE, (dcp->c_cnid == kHFSRootFolderID));++ }++ //+ // if skip_reserve == 1 then we're being called from hfs_vnop_rename() and thus+ // we don't need to touch the document_id as it's handled by the rename code.+ // otherwise it's a normal remove and we need to save the document id in the+ // per thread struct and clear it from the cnode.+ //+ if (!error && !skip_reserve && (cp->c_bsdflags & UF_TRACKED)+ && cp->c_linkcount <= 1) {+ struct doc_tombstone *ut;+ ut = doc_tombstone_get();+ if (doc_tombstone_should_save(ut, vp, cnp)) {+ add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(),+ FSE_ARG_DEV, hfsmp->hfs_raw_dev,+ FSE_ARG_INO, (ino64_t)cp->c_fileid, // src inode #+ FSE_ARG_INO, (ino64_t)0, // dst inode #+ FSE_ARG_INT32, hfs_get_document_id(cp), // document id+ FSE_ARG_DONE);++ doc_tombstone_save(dvp, vp, cnp, hfs_get_document_id(cp),+ cp->c_fileid);++ struct FndrExtendedFileInfo *fip = (struct FndrExtendedFileInfo *)((char *)&cp->c_attr.ca_finderinfo + 16);++ fip->document_id = 0;+ cp->c_bsdflags &= ~UF_TRACKED;+ }+ }++ /*+ * All done with this cnode's descriptor...+ *+ * Note: all future catalog calls for this cnode must be by+ * fileid only. This is OK for HFS (which doesn't have file+ * thread records) since HFS doesn't support the removal of+ * busy files.+ */+ cat_releasedesc(&cp->c_desc);++out:+ if (error) {+ cp->c_flag &= ~C_DELETED;+ }++ if (update_vh) {+ /*+ * If we bailed out earlier, we may need to update the volume header+ * to deal with the borrowed blocks accounting.+ */+ hfs_volupdate (hfsmp, VOL_UPDATE, 0);+ }++ if (started_tr) {+ hfs_end_transaction(hfsmp);+ }++ dcp->c_flag &= ~C_DIR_MODIFICATION;+ wakeup((caddr_t)&dcp->c_flag);++ return (error);+}+++void+replace_desc(struct cnode *cp, struct cat_desc *cdp)+{+ // fixes 4348457 and 4463138+ if (&cp->c_desc == cdp) {+ return;+ }++ /* First release allocated name buffer */+ if (cp->c_desc.cd_flags & CD_HASBUF && cp->c_desc.cd_nameptr != 0) {+ const u_int8_t *name = cp->c_desc.cd_nameptr;++ cp->c_desc.cd_nameptr = 0;+ cp->c_desc.cd_namelen = 0;+ cp->c_desc.cd_flags &= ~CD_HASBUF;+ vfs_removename((const char *)name);+ }+ bcopy(cdp, &cp->c_desc, sizeof(cp->c_desc));++ /* Cnode now owns the name buffer */+ cdp->cd_nameptr = 0;+ cdp->cd_namelen = 0;+ cdp->cd_flags &= ~CD_HASBUF;+}++/*+ * hfs_vnop_rename+ *+ * Just forwards the arguments from VNOP_RENAME into those of+ * VNOP_RENAMEX but zeros out the flags word.+ */+int hfs_vnop_rename (struct vnop_rename_args *args) {+ struct vnop_renamex_args vrx;++ vrx.a_desc = args->a_desc; // we aren't using it to switch into the vnop array, so fine as is.+ vrx.a_fdvp = args->a_fdvp;+ vrx.a_fvp = args->a_fvp;+ vrx.a_fcnp = args->a_fcnp;+ vrx.a_tdvp = args->a_tdvp;+ vrx.a_tvp = args->a_tvp;+ vrx.a_tcnp = args->a_tcnp;+ vrx.a_vap = NULL; // not used+ vrx.a_flags = 0; //zero out the flags.+ vrx.a_context = args->a_context;++ return hfs_vnop_renamex (&vrx);+}++++/*+ * Rename a cnode.+ *+ * The VFS layer guarantees that:+ * - source and destination will either both be directories, or+ * both not be directories.+ * - all the vnodes are from the same file system+ *+ * When the target is a directory, HFS must ensure that its empty.+ *+ * Note that this function requires up to 6 vnodes in order to work properly+ * if it is operating on files (and not on directories). This is because only+ * files can have resource forks, and we now require iocounts to be held on the+ * vnodes corresponding to the resource forks (if applicable) as well as+ * the files or directories undergoing rename. The problem with not holding+ * iocounts on the resource fork vnodes is that it can lead to a deadlock+ * situation: The rsrc fork of the source file may be recycled and reclaimed+ * in order to provide a vnode for the destination file's rsrc fork. Since+ * data and rsrc forks share the same cnode, we'd eventually try to lock the+ * source file's cnode in order to sync its rsrc fork to disk, but it's already+ * been locked. By taking the rsrc fork vnodes up front we ensure that they+ * cannot be recycled, and that the situation mentioned above cannot happen.+ */+int+hfs_vnop_renamex(struct vnop_renamex_args *ap)+{+ struct vnode *tvp = ap->a_tvp;+ struct vnode *tdvp = ap->a_tdvp;+ struct vnode *fvp = ap->a_fvp;+ struct vnode *fdvp = ap->a_fdvp;+ /*+ * Note that we only need locals for the target/destination's+ * resource fork vnode (and only if necessary). We don't care if the+ * source has a resource fork vnode or not.+ */+ struct vnode *tvp_rsrc = NULLVP;+ uint32_t tvp_rsrc_vid = 0;+ struct componentname *tcnp = ap->a_tcnp;+ struct componentname *fcnp = ap->a_fcnp;+ struct proc *p = vfs_context_proc(ap->a_context);+ struct cnode *fcp;+ struct cnode *fdcp;+ struct cnode *tdcp;+ struct cnode *tcp;+ struct cnode *error_cnode;+ struct cat_desc from_desc;+ struct cat_desc to_desc;+ struct cat_desc out_desc;+ struct hfsmount *hfsmp;+ cat_cookie_t cookie;+ int tvp_deleted = 0;+ int started_tr = 0, got_cookie = 0;+ int took_trunc_lock = 0;+ int lockflags;+ int error;+ time_t orig_from_ctime, orig_to_ctime;+ int emit_rename = 1;+ int emit_delete = 1;+ int is_tracked = 0;+ int unlocked;+ vnode_t old_doc_vp = NULL;+ int rename_exclusive = 0;++ orig_from_ctime = VTOC(fvp)->c_ctime;+ if (tvp && VTOC(tvp)) {+ orig_to_ctime = VTOC(tvp)->c_ctime;+ } else {+ orig_to_ctime = ~0;+ }++ hfsmp = VTOHFS(tdvp);++ /* Check the flags first, so we can avoid grabbing locks if necessary */+ if (ap->a_flags) {+ /* These are the only flags we support for now */+ if ((ap->a_flags & (VFS_RENAME_EXCL)) == 0) {+ return ENOTSUP;+ }++ /* The rename flags are mutually exclusive for HFS+ */+ switch (ap->a_flags & VFS_RENAME_FLAGS_MASK) {+ case VFS_RENAME_EXCL:+ rename_exclusive = true;+ break;+ default:+ return ENOTSUP;+ }+ }++ /*+ * Do special case checks here. If fvp == tvp then we need to check the+ * cnode with locks held.+ */+ if (fvp == tvp) {+ int is_hardlink = 0;+ /*+ * In this case, we do *NOT* ever emit a DELETE event.+ * We may not necessarily emit a RENAME event+ */+ emit_delete = 0;+ if ((error = hfs_lock(VTOC(fvp), HFS_SHARED_LOCK, HFS_LOCK_DEFAULT))) {+ return error;+ }+ /* Check to see if the item is a hardlink or not */+ is_hardlink = (VTOC(fvp)->c_flag & C_HARDLINK);+ hfs_unlock (VTOC(fvp));++ /*+ * If the item is not a hardlink, then case sensitivity must be off, otherwise+ * two names should not resolve to the same cnode unless they were case variants.+ */+ if (is_hardlink) {+ emit_rename = 0;+ /*+ * Hardlinks are a little trickier. We only want to emit a rename event+ * if the item is a hardlink, the parent directories are the same, case sensitivity+ * is off, and the case folded names are the same. See the fvp == tvp case below for more+ * info.+ */++ if ((fdvp == tdvp) && ((hfsmp->hfs_flags & HFS_CASE_SENSITIVE) == 0)) {+ if (hfs_namecmp((const u_int8_t *)fcnp->cn_nameptr, fcnp->cn_namelen,+ (const u_int8_t *)tcnp->cn_nameptr, tcnp->cn_namelen) == 0) {+ /* Then in this case only it is ok to emit a rename */+ emit_rename = 1;+ }+ }+ }+ }+ if (emit_rename) {+ /* c_bsdflags should only be assessed while holding the cnode lock.+ * This is not done consistently throughout the code and can result+ * in race. This will be fixed via rdar://12181064+ */+ if (VTOC(fvp)->c_bsdflags & UF_TRACKED) {+ is_tracked = 1;+ }+ nspace_snapshot_event(fvp, orig_from_ctime, NAMESPACE_HANDLER_RENAME_OP, NULL);+ }++ if (tvp && VTOC(tvp)) {+ if (emit_delete) {+ nspace_snapshot_event(tvp, orig_to_ctime, NAMESPACE_HANDLER_DELETE_OP, NULL);+ }+ }++retry:+ /* When tvp exists, take the truncate lock for hfs_removefile(). */+ if (tvp && (vnode_isreg(tvp) || vnode_islnk(tvp))) {+ hfs_lock_truncate(VTOC(tvp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ took_trunc_lock = 1;+ }++relock:+ error = hfs_lockfour(VTOC(fdvp), VTOC(fvp), VTOC(tdvp), tvp ? VTOC(tvp) : NULL,+ HFS_EXCLUSIVE_LOCK, &error_cnode);+ if (error) {+ if (took_trunc_lock) {+ hfs_unlock_truncate(VTOC(tvp), HFS_LOCK_DEFAULT);+ took_trunc_lock = 0;+ }++ /*+ * We hit an error path. If we were trying to re-acquire the locks+ * after coming through here once, we might have already obtained+ * an iocount on tvp's resource fork vnode. Drop that before dealing+ * with the failure. Note this is safe -- since we are in an+ * error handling path, we can't be holding the cnode locks.+ */+ if (tvp_rsrc) {+ vnode_put (tvp_rsrc);+ tvp_rsrc_vid = 0;+ tvp_rsrc = NULL;+ }++ /*+ * tvp might no longer exist. If the cause of the lock failure+ * was tvp, then we can try again with tvp/tcp set to NULL.+ * This is ok because the vfs syscall will vnode_put the vnodes+ * after we return from hfs_vnop_rename.+ */+ if ((error == ENOENT) && (tvp != NULL) && (error_cnode == VTOC(tvp))) {+ tcp = NULL;+ tvp = NULL;+ goto retry;+ }++ /* If we want to reintroduce notifications for failed renames, this+ is the place to do it. */++ return (error);+ }++ fdcp = VTOC(fdvp);+ fcp = VTOC(fvp);+ tdcp = VTOC(tdvp);+ tcp = tvp ? VTOC(tvp) : NULL;++ //+ // if the item is tracked but doesn't have a document_id, assign one and generate an fsevent for it+ //+ unlocked = 0;+ if ((fcp->c_bsdflags & UF_TRACKED) && ((struct FndrExtendedDirInfo *)((char *)&fcp->c_attr.ca_finderinfo + 16))->document_id == 0) {+ uint32_t newid;++ hfs_unlockfour(VTOC(fdvp), VTOC(fvp), VTOC(tdvp), tvp ? VTOC(tvp) : NULL);+ unlocked = 1;++ if (hfs_generate_document_id(hfsmp, &newid) == 0) {+ hfs_lock(fcp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ ((struct FndrExtendedDirInfo *)((char *)&fcp->c_attr.ca_finderinfo + 16))->document_id = newid;+ add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(),+ FSE_ARG_DEV, hfsmp->hfs_raw_dev,+ FSE_ARG_INO, (ino64_t)0, // src inode #+ FSE_ARG_INO, (ino64_t)fcp->c_fileid, // dst inode #+ FSE_ARG_INT32, newid,+ FSE_ARG_DONE);+ hfs_unlock(fcp);+ } else {+ // XXXdbg - couldn't get a new docid... what to do? can't really fail the rename...+ }++ //+ // check if we're going to need to fix tcp as well. if we aren't, go back relock+ // everything. otherwise continue on and fix up tcp as well before relocking.+ //+ if (tcp == NULL || !(tcp->c_bsdflags & UF_TRACKED) || ((struct FndrExtendedDirInfo *)((char *)&tcp->c_attr.ca_finderinfo + 16))->document_id != 0) {+ goto relock;+ }+ }++ //+ // same thing for tcp if it's set+ //+ if (tcp && (tcp->c_bsdflags & UF_TRACKED) && ((struct FndrExtendedDirInfo *)((char *)&tcp->c_attr.ca_finderinfo + 16))->document_id == 0) {+ uint32_t newid;++ if (!unlocked) {+ hfs_unlockfour(VTOC(fdvp), VTOC(fvp), VTOC(tdvp), tvp ? VTOC(tvp) : NULL);+ unlocked = 1;+ }++ if (hfs_generate_document_id(hfsmp, &newid) == 0) {+ hfs_lock(tcp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ ((struct FndrExtendedDirInfo *)((char *)&tcp->c_attr.ca_finderinfo + 16))->document_id = newid;+ add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(),+ FSE_ARG_DEV, hfsmp->hfs_raw_dev,+ FSE_ARG_INO, (ino64_t)0, // src inode #+ FSE_ARG_INO, (ino64_t)tcp->c_fileid, // dst inode #+ FSE_ARG_INT32, newid,+ FSE_ARG_DONE);+ hfs_unlock(tcp);+ } else {+ // XXXdbg - couldn't get a new docid... what to do? can't really fail the rename...+ }++ // go back up and relock everything. next time through the if statement won't be true+ // and we'll skip over this block of code.+ goto relock;+ }++++ /*+ * Acquire iocounts on the destination's resource fork vnode+ * if necessary. If dst/src are files and the dst has a resource+ * fork vnode, then we need to try and acquire an iocount on the rsrc vnode.+ * If it does not exist, then we don't care and can skip it.+ */+ if ((vnode_isreg(fvp)) || (vnode_islnk(fvp))) {+ if ((tvp) && (tcp->c_rsrc_vp) && (tvp_rsrc == NULL)) {+ tvp_rsrc = tcp->c_rsrc_vp;+ /*+ * We can look at the vid here because we're holding the+ * cnode lock on the underlying cnode for this rsrc vnode.+ */+ tvp_rsrc_vid = vnode_vid (tvp_rsrc);++ /* Unlock everything to acquire iocount on this rsrc vnode */+ if (took_trunc_lock) {+ hfs_unlock_truncate (VTOC(tvp), HFS_LOCK_DEFAULT);+ took_trunc_lock = 0;+ }+ hfs_unlockfour(fdcp, fcp, tdcp, tcp);++ if (vnode_getwithvid (tvp_rsrc, tvp_rsrc_vid)) {+ /* iocount acquisition failed. Reset fields and start over.. */+ tvp_rsrc_vid = 0;+ tvp_rsrc = NULL;+ }+ goto retry;+ }+ }++++ /* Ensure we didn't race src or dst parent directories with rmdir. */+ if (fdcp->c_flag & (C_NOEXISTS | C_DELETED)) {+ error = ENOENT;+ goto out;+ }++ if (tdcp->c_flag & (C_NOEXISTS | C_DELETED)) {+ error = ENOENT;+ goto out;+ }+++ /* Check for a race against unlink. The hfs_valid_cnode checks validate+ * the parent/child relationship with fdcp and tdcp, as well as the+ * component name of the target cnodes.+ */+ if ((fcp->c_flag & (C_NOEXISTS | C_DELETED)) || !hfs_valid_cnode(hfsmp, fdvp, fcnp, fcp->c_fileid, NULL, &error)) {+ error = ENOENT;+ goto out;+ }++ if (tcp && ((tcp->c_flag & (C_NOEXISTS | C_DELETED)) || !hfs_valid_cnode(hfsmp, tdvp, tcnp, tcp->c_fileid, NULL, &error))) {+ //+ // hmm, the destination vnode isn't valid any more.+ // in this case we can just drop him and pretend he+ // never existed in the first place.+ //+ if (took_trunc_lock) {+ hfs_unlock_truncate(VTOC(tvp), HFS_LOCK_DEFAULT);+ took_trunc_lock = 0;+ }+ error = 0;++ hfs_unlockfour(fdcp, fcp, tdcp, tcp);++ tcp = NULL;+ tvp = NULL;++ // retry the locking with tvp null'ed out+ goto retry;+ }++ fdcp->c_flag |= C_DIR_MODIFICATION;+ if (fdvp != tdvp) {+ tdcp->c_flag |= C_DIR_MODIFICATION;+ }++ /*+ * Disallow renaming of a directory hard link if the source and+ * destination parent directories are different, or a directory whose+ * descendant is a directory hard link and the one of the ancestors+ * of the destination directory is a directory hard link.+ */+ if (vnode_isdir(fvp) && (fdvp != tdvp)) {+ if (fcp->c_flag & C_HARDLINK) {+ error = EPERM;+ goto out;+ }+ if (fcp->c_attr.ca_recflags & kHFSHasChildLinkMask) {+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);+ if (cat_check_link_ancestry(hfsmp, tdcp->c_fileid, 0)) {+ error = EPERM;+ hfs_systemfile_unlock(hfsmp, lockflags);+ goto out;+ }+ hfs_systemfile_unlock(hfsmp, lockflags);+ }+ }++ /*+ * The following edge case is caught here:+ * (to cannot be a descendent of from)+ *+ * o fdvp+ * /+ * /+ * o fvp+ * \+ * \+ * o tdvp+ * /+ * /+ * o tvp+ */+ if (tdcp->c_parentcnid == fcp->c_fileid) {+ error = EINVAL;+ goto out;+ }++ /*+ * The following two edge cases are caught here:+ * (note tvp is not empty)+ *+ * o tdvp o tdvp+ * / /+ * / /+ * o tvp tvp o fdvp+ * \ \+ * \ \+ * o fdvp o fvp+ * /+ * /+ * o fvp+ */+ if (tvp && vnode_isdir(tvp) && (tcp->c_entries != 0) && fvp != tvp) {+ error = ENOTEMPTY;+ goto out;+ }++ /*+ * The following edge case is caught here:+ * (the from child and parent are the same)+ *+ * o tdvp+ * /+ * /+ * fdvp o fvp+ */+ if (fdvp == fvp) {+ error = EINVAL;+ goto out;+ }++ /*+ * Make sure "from" vnode and its parent are changeable.+ */+ if ((fcp->c_bsdflags & (IMMUTABLE | APPEND)) || (fdcp->c_bsdflags & APPEND)) {+ error = EPERM;+ goto out;+ }++ /*+ * If the destination parent directory is "sticky", then the+ * user must own the parent directory, or the destination of+ * the rename, otherwise the destination may not be changed+ * (except by root). This implements append-only directories.+ *+ * Note that checks for immutable and write access are done+ * by the call to hfs_removefile.+ */+ if (tvp && (tdcp->c_mode & S_ISTXT) &&+ (suser(vfs_context_ucred(ap->a_context), NULL)) &&+ (kauth_cred_getuid(vfs_context_ucred(ap->a_context)) != tdcp->c_uid) &&+ (hfs_owner_rights(hfsmp, tcp->c_uid, vfs_context_ucred(ap->a_context), p, false)) ) {+ error = EPERM;+ goto out;+ }++ /* Don't allow modification of the journal or journal_info_block */+ if (hfs_is_journal_file(hfsmp, fcp) ||+ (tcp && hfs_is_journal_file(hfsmp, tcp))) {+ error = EPERM;+ goto out;+ }++#if QUOTA+ if (tvp)+ (void)hfs_getinoquota(tcp);+#endif+ /* Preflighting done, take fvp out of the name space. */+ cache_purge(fvp);++#if CONFIG_SECLUDED_RENAME+ /*+ * Check for "secure" rename that imposes additional restrictions on the+ * source vnode. We wait until here to check in order to prevent a race+ * with other threads that manage to look up fvp, but their open or link+ * is blocked by our locks. At this point, with fvp out of the name cache,+ * and holding the lock on fdvp, no other thread can find fvp.+ *+ * TODO: Do we need to limit these checks to regular files only?+ */+ if (fcnp->cn_flags & CN_SECLUDE_RENAME) {+ if (vnode_isdir(fvp)) {+ error = EISDIR;+ goto out;+ }++ /*+ * Neither fork of source may be open or memory mapped.+ * We also don't want it in use by any other system call.+ * The file must not have hard links.+ *+ * We can't simply use vnode_isinuse() because that does not+ * count opens with O_EVTONLY. We don't want a malicious+ * process using O_EVTONLY to subvert a secluded rename.+ */+ if (fcp->c_linkcount != 1) {+ error = EMLINK;+ goto out;+ }++ if (fcp->c_rsrc_vp && (vnode_usecount(fcp->c_rsrc_vp) > 0 ||+ vnode_iocount(fcp->c_rsrc_vp) > 0)) {+ /* Resource fork is in use (including O_EVTONLY) */+ error = EBUSY;+ goto out;+ }+ if (fcp->c_vp && (vnode_usecount(fcp->c_vp) > (fcp->c_rsrc_vp ? 1 : 0) ||+ vnode_iocount(fcp->c_vp) > 1)) {+ /*+ * Data fork is in use, including O_EVTONLY, but not+ * including a reference from the resource fork.+ */+ error = EBUSY;+ goto out;+ }+ }+#endif++ bzero(&from_desc, sizeof(from_desc));+ from_desc.cd_nameptr = (const u_int8_t *)fcnp->cn_nameptr;+ from_desc.cd_namelen = fcnp->cn_namelen;+ from_desc.cd_parentcnid = fdcp->c_fileid;+ from_desc.cd_flags = fcp->c_desc.cd_flags & ~(CD_HASBUF | CD_DECOMPOSED);+ from_desc.cd_cnid = fcp->c_cnid;++ bzero(&to_desc, sizeof(to_desc));+ to_desc.cd_nameptr = (const u_int8_t *)tcnp->cn_nameptr;+ to_desc.cd_namelen = tcnp->cn_namelen;+ to_desc.cd_parentcnid = tdcp->c_fileid;+ to_desc.cd_flags = fcp->c_desc.cd_flags & ~(CD_HASBUF | CD_DECOMPOSED);+ to_desc.cd_cnid = fcp->c_cnid;++ if ((error = hfs_start_transaction(hfsmp)) != 0) {+ goto out;+ }+ started_tr = 1;++ /* hfs_vnop_link() and hfs_vnop_rename() set kHFSHasChildLinkMask+ * inside a journal transaction and without holding a cnode lock.+ * As setting of this bit depends on being in journal transaction for+ * concurrency, check this bit again after we start journal transaction for rename+ * to ensure that this directory does not have any descendant that+ * is a directory hard link.+ */+ if (vnode_isdir(fvp) && (fdvp != tdvp)) {+ if (fcp->c_attr.ca_recflags & kHFSHasChildLinkMask) {+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);+ if (cat_check_link_ancestry(hfsmp, tdcp->c_fileid, 0)) {+ error = EPERM;+ hfs_systemfile_unlock(hfsmp, lockflags);+ goto out;+ }+ hfs_systemfile_unlock(hfsmp, lockflags);+ }+ }++ // if it's a hardlink then re-lookup the name so+ // that we get the correct cnid in from_desc (see+ // the comment in hfs_removefile for more details)+ //+ if (fcp->c_flag & C_HARDLINK) {+ struct cat_desc tmpdesc;+ cnid_t real_cnid;++ tmpdesc.cd_nameptr = (const u_int8_t *)fcnp->cn_nameptr;+ tmpdesc.cd_namelen = fcnp->cn_namelen;+ tmpdesc.cd_parentcnid = fdcp->c_fileid;+ tmpdesc.cd_hint = fdcp->c_childhint;+ tmpdesc.cd_flags = fcp->c_desc.cd_flags & CD_ISDIR;+ tmpdesc.cd_encoding = 0;++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);++ if (cat_lookup(hfsmp, &tmpdesc, 0, 0, NULL, NULL, NULL, &real_cnid) != 0) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ goto out;+ }++ // use the real cnid instead of whatever happened to be there+ from_desc.cd_cnid = real_cnid;+ hfs_systemfile_unlock(hfsmp, lockflags);+ }++ /*+ * Reserve some space in the Catalog file.+ */+ if ((error = cat_preflight(hfsmp, CAT_RENAME + CAT_DELETE, &cookie, p))) {+ goto out;+ }+ got_cookie = 1;++ /*+ * If the destination exists then it may need to be removed.+ *+ * Due to HFS's locking system, we should always move the+ * existing 'tvp' element to the hidden directory in hfs_vnop_rename.+ * Because the VNOP_LOOKUP call enters and exits the filesystem independently+ * of the actual vnop that it was trying to do (stat, link, readlink),+ * we must release the cnode lock of that element during the interim to+ * do MAC checking, vnode authorization, and other calls. In that time,+ * the item can be deleted (or renamed over). However, only in the rename+ * case is it inappropriate to return ENOENT from any of those calls. Either+ * the call should return information about the old element (stale), or get+ * information about the newer element that we are about to write in its place.+ *+ * HFS lookup has been modified to detect a rename and re-drive its+ * lookup internally. For other calls that have already succeeded in+ * their lookup call and are waiting to acquire the cnode lock in order+ * to proceed, that cnode lock will not fail due to the cnode being marked+ * C_NOEXISTS, because it won't have been marked as such. It will only+ * have C_DELETED. Thus, they will simply act on the stale open-unlinked+ * element. All future callers will get the new element.+ *+ * To implement this behavior, we pass the "only_unlink" argument to+ * hfs_removefile and hfs_removedir. This will result in the vnode acting+ * as though it is open-unlinked. Additionally, when we are done moving the+ * element to the hidden directory, we vnode_recycle the target so that it is+ * reclaimed as soon as possible. Reclaim and inactive are both+ * capable of clearing out unused blocks for an open-unlinked file or dir.+ */+ if (tvp) {+ //+ // if the destination has a document id, we need to preserve it+ //+ if (fvp != tvp) {+ uint32_t document_id;+ struct FndrExtendedDirInfo *ffip = (struct FndrExtendedDirInfo *)((char *)&fcp->c_attr.ca_finderinfo + 16);+ struct FndrExtendedDirInfo *tfip = (struct FndrExtendedDirInfo *)((char *)&tcp->c_attr.ca_finderinfo + 16);++ if (ffip->document_id && tfip->document_id) {+ // Both documents are tracked. `tvp` is deleted and `fvp` is+ // renamed on top of it. Send FSE_DOCID_CHANGED for both inodes,+ // clear tombstone of `old_doc_vp` and save tombstone of `fvp`.+ add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(),+ FSE_ARG_DEV, hfsmp->hfs_raw_dev,+ FSE_ARG_INO, (ino64_t)tcp->c_fileid, // src inode #+ FSE_ARG_INO, (ino64_t)0ULL, // dst inode #+ FSE_ARG_INT32, (uint32_t)tfip->document_id,+ FSE_ARG_DONE);+ add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(),+ FSE_ARG_DEV, hfsmp->hfs_raw_dev,+ FSE_ARG_INO, (ino64_t)fcp->c_fileid, // src inode #+ FSE_ARG_INO, (ino64_t)tcp->c_fileid, // dst inode #+ FSE_ARG_INT32, (uint32_t)ffip->document_id,+ FSE_ARG_DONE);+ doc_tombstone_clear(doc_tombstone_get(), &old_doc_vp);+ doc_tombstone_save(tdvp, fvp, tcnp, hfs_get_document_id(fcp),+ fcp->c_fileid);+ } else {+ struct doc_tombstone *ut;+ ut = doc_tombstone_get();++ document_id = tfip->document_id;+ tfip->document_id = 0;++ if (document_id != 0) {+ // clear UF_TRACKED as well since tcp is now no longer tracked+ tcp->c_bsdflags &= ~UF_TRACKED;+ (void) cat_update(hfsmp, &tcp->c_desc, &tcp->c_attr, NULL, NULL);+ }++ if (ffip->document_id == 0 && document_id != 0) {+ // printf("RENAME: preserving doc-id %d onto %s (from ino %d, to ino %d)\n", document_id, tcp->c_desc.cd_nameptr, tcp->c_desc.cd_cnid, fcp->c_desc.cd_cnid);+ fcp->c_bsdflags |= UF_TRACKED;+ ffip->document_id = document_id;++ (void) cat_update(hfsmp, &fcp->c_desc, &fcp->c_attr, NULL, NULL);+ add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(),+ FSE_ARG_DEV, hfsmp->hfs_raw_dev,+ FSE_ARG_INO, (ino64_t)tcp->c_fileid, // src inode #+ FSE_ARG_INO, (ino64_t)fcp->c_fileid, // dst inode #+ FSE_ARG_INT32, (uint32_t)ffip->document_id,+ FSE_ARG_DONE);+ }+ else if ((fcp->c_bsdflags & UF_TRACKED) && doc_tombstone_should_save(ut, fvp, fcnp)) {++ if (ut->t_lastop_document_id) {+ doc_tombstone_clear(ut, NULL);+ }+ doc_tombstone_save(fdvp, fvp, fcnp,+ hfs_get_document_id(fcp), fcp->c_fileid);++ //printf("RENAME: (dest-exists): saving tombstone doc-id %lld @ %s (ino %d)\n",+ // ut->t_lastop_document_id, ut->t_lastop_filename, fcp->c_desc.cd_cnid);+ }+ }+ }++ /*+ * When fvp matches tvp they could be case variants+ * or matching hard links.+ * If the caller requested an exclusive rename (VFS_RENAME_EXCL),+ * we allow rename when the target already exists when the following+ * conditions are met:+ * 1. the volume is case insensitive+ * 2. source and target directories are the same+ * 3. source and target files are the same+ * 4. name only differs in case+ */+ if (fvp == tvp) {+ if (!rename_exclusive && !(fcp->c_flag & C_HARDLINK)) {+ /*+ * If they're not hardlinks, then fvp == tvp must mean we+ * are using case-insensitive HFS because case-sensitive would+ * not use the same vnode for both. In this case we just update+ * the catalog for: a -> A+ */+ goto skip_rm; /* simple case variant */++ }+ /* For all cases below, we must be using hardlinks */+ else if ((fdvp != tdvp) ||+ (hfsmp->hfs_flags & HFS_CASE_SENSITIVE)) {+ /*+ * If the parent directories are not the same, AND the two items+ * are hardlinks, posix says to do nothing:+ * dir1/fred <-> dir2/bob and the op was mv dir1/fred -> dir2/bob+ * We just return 0 in this case.+ *+ * If case sensitivity is on, and we are using hardlinks+ * then renaming is supposed to do nothing.+ * dir1/fred <-> dir2/FRED, and op == mv dir1/fred -> dir2/FRED+ */+ goto out; /* matching hardlinks, nothing to do */++ } else if (hfs_namecmp((const u_int8_t *)fcnp->cn_nameptr, fcnp->cn_namelen,+ (const u_int8_t *)tcnp->cn_nameptr, tcnp->cn_namelen) == 0) {+ /*+ * If we get here, then the following must be true:+ * a) We are running case-insensitive HFS+.+ * b) Both paths 'fvp' and 'tvp' are in the same parent directory.+ * c) the two names are case-variants of each other.+ *+ * In this case, we are really only dealing with a single catalog record+ * whose name is being updated.+ *+ * op is dir1/fred -> dir1/FRED+ *+ * We need to special case the name matching, because if+ * dir1/fred <-> dir1/bob were the two links, and the+ * op was dir1/fred -> dir1/bob+ * That would fail/do nothing.+ */++ goto skip_rm; /* case-variant hardlink in the same dir */+ } else if (rename_exclusive) {+ error = EEXIST;+ goto out;+ } else {+ goto out; /* matching hardlink, nothing to do */+ }+ }+++ if (vnode_isdir(tvp)) {+ /*+ * hfs_removedir will eventually call hfs_removefile on the directory+ * we're working on, because only hfs_removefile does the renaming of the+ * item to the hidden directory. The directory will stay around in the+ * hidden directory with C_DELETED until it gets an inactive or a reclaim.+ * That way, we can destroy all of the EAs as needed and allow new ones to be+ * written.+ */+ error = hfs_removedir(tdvp, tvp, tcnp, HFSRM_SKIP_RESERVE, 1);+ }+ else {+ error = hfs_removefile(tdvp, tvp, tcnp, 0, HFSRM_SKIP_RESERVE, 0, NULL, 1);++ /*+ * If the destination file had a resource fork vnode, then we need to get rid of+ * its blocks when there are no more references to it. Because the call to+ * hfs_removefile above always open-unlinks things, we need to force an inactive/reclaim+ * on the resource fork vnode, in order to prevent block leaks. Otherwise,+ * the resource fork vnode could prevent the data fork vnode from going out of scope+ * because it holds a v_parent reference on it. So we mark it for termination+ * with a call to vnode_recycle. hfs_vnop_reclaim has been modified so that it+ * can clean up the blocks of open-unlinked files and resource forks.+ *+ * We can safely call vnode_recycle on the resource fork because we took an iocount+ * reference on it at the beginning of the function.+ */++ if ((error == 0) && (tcp->c_flag & C_DELETED) && (tvp_rsrc)) {+ vnode_recycle(tvp_rsrc);+ }+ }++ if (error) {+ goto out;+ }++ tvp_deleted = 1;++ /* Mark 'tcp' as being deleted due to a rename */+ tcp->c_flag |= C_RENAMED;++ /*+ * Aggressively mark tvp/tcp for termination to ensure that we recover all blocks+ * as quickly as possible.+ */+ vnode_recycle(tvp);+ } else {+ struct doc_tombstone *ut;+ ut = doc_tombstone_get();++ //+ // There is nothing at the destination. If the file being renamed is+ // tracked, save a "tombstone" of the document_id. If the file is+ // not a tracked file, then see if it needs to inherit a tombstone.+ //+ // NOTE: we do not save a tombstone if the file being renamed begins+ // with "atmp" which is done to work-around AutoCad's bizarre+ // 5-step un-safe save behavior+ //+ if (fcp->c_bsdflags & UF_TRACKED) {+ if (doc_tombstone_should_save(ut, fvp, fcnp)) {+ doc_tombstone_save(fdvp, fvp, fcnp, hfs_get_document_id(fcp),+ fcp->c_fileid);++ //printf("RENAME: (no dest): saving tombstone doc-id %lld @ %s (ino %d)\n",+ // ut->t_lastop_document_id, ut->t_lastop_filename, fcp->c_desc.cd_cnid);+ } else {+ // intentionally do nothing+ }+ } else if ( ut->t_lastop_document_id != 0+ && tdvp == ut->t_lastop_parent+ && vnode_vid(tdvp) == ut->t_lastop_parent_vid+ && strcmp((char *)ut->t_lastop_filename, (char *)tcnp->cn_nameptr) == 0) {++ //printf("RENAME: %s (ino %d) inheriting doc-id %lld\n", tcnp->cn_nameptr, fcp->c_desc.cd_cnid, ut->t_lastop_document_id);+ struct FndrExtendedFileInfo *fip = (struct FndrExtendedFileInfo *)((char *)&fcp->c_attr.ca_finderinfo + 16);+ fcp->c_bsdflags |= UF_TRACKED;+ fip->document_id = ut->t_lastop_document_id;+ cat_update(hfsmp, &fcp->c_desc, &fcp->c_attr, NULL, NULL);++ doc_tombstone_clear(ut, &old_doc_vp);+ } else if (ut->t_lastop_document_id && doc_tombstone_should_save(ut, fvp, fcnp) && doc_tombstone_should_save(ut, tvp, tcnp)) {+ // no match, clear the tombstone+ //printf("RENAME: clearing the tombstone %lld @ %s\n", ut->t_lastop_document_id, ut->t_lastop_filename);+ doc_tombstone_clear(ut, NULL);+ }++ }+skip_rm:+ /*+ * All done with tvp and fvp.+ *+ * We also jump to this point if there was no destination observed during lookup and namei.+ * However, because only iocounts are held at the VFS layer, there is nothing preventing a+ * competing thread from racing us and creating a file or dir at the destination of this rename+ * operation. If this occurs, it may cause us to get a spurious EEXIST out of the cat_rename+ * call below. To preserve rename's atomicity, we need to signal VFS to re-drive the+ * namei/lookup and restart the rename operation. EEXIST is an allowable errno to be bubbled+ * out of the rename syscall, but not for this reason, since it is a synonym errno for ENOTEMPTY.+ * To signal VFS, we return ERECYCLE (which is also used for lookup restarts). This errno+ * will be swallowed and it will restart the operation.+ */++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);+ error = cat_rename(hfsmp, &from_desc, &tdcp->c_desc, &to_desc, &out_desc);+ hfs_systemfile_unlock(hfsmp, lockflags);++ if (error) {+ if (error == EEXIST) {+ error = ERECYCLE;+ }+ goto out;+ }++ /* Invalidate negative cache entries in the destination directory */+ if (tdcp->c_flag & C_NEG_ENTRIES) {+ cache_purge_negatives(tdvp);+ tdcp->c_flag &= ~C_NEG_ENTRIES;+ }++ /* Update cnode's catalog descriptor */+ replace_desc(fcp, &out_desc);+ fcp->c_parentcnid = tdcp->c_fileid;+ fcp->c_hint = 0;++ /*+ * Now indicate this cnode needs to have date-added written to the+ * finderinfo, but only if moving to a different directory, or if+ * it doesn't already have it.+ */+ if (fdvp != tdvp || !ISSET(fcp->c_attr.ca_recflags, kHFSHasDateAddedMask))+ fcp->c_flag |= C_NEEDS_DATEADDED;++ (void) hfs_update (fvp, 0);++ hfs_volupdate(hfsmp, vnode_isdir(fvp) ? VOL_RMDIR : VOL_RMFILE,+ (fdcp->c_cnid == kHFSRootFolderID));+ hfs_volupdate(hfsmp, vnode_isdir(fvp) ? VOL_MKDIR : VOL_MKFILE,+ (tdcp->c_cnid == kHFSRootFolderID));++ /* Update both parent directories. */+ if (fdvp != tdvp) {+ if (vnode_isdir(fvp)) {+ /* If the source directory has directory hard link+ * descendants, set the kHFSHasChildLinkBit in the+ * destination parent hierarchy+ */+ if ((fcp->c_attr.ca_recflags & kHFSHasChildLinkMask) &&+ !(tdcp->c_attr.ca_recflags & kHFSHasChildLinkMask)) {++ tdcp->c_attr.ca_recflags |= kHFSHasChildLinkMask;++ error = cat_set_childlinkbit(hfsmp, tdcp->c_parentcnid);+ if (error) {+ printf ("hfs_vnop_rename: error updating parent chain for %u\n", tdcp->c_cnid);+ error = 0;+ }+ }+ INC_FOLDERCOUNT(hfsmp, tdcp->c_attr);+ DEC_FOLDERCOUNT(hfsmp, fdcp->c_attr);+ }+ tdcp->c_entries++;+ tdcp->c_dirchangecnt++;+ tdcp->c_flag |= C_MODIFIED;+ hfs_incr_gencount(tdcp);++ if (fdcp->c_entries > 0)+ fdcp->c_entries--;+ fdcp->c_dirchangecnt++;+ fdcp->c_flag |= C_MODIFIED;+ fdcp->c_touch_chgtime = TRUE;+ fdcp->c_touch_modtime = TRUE;++ if (ISSET(fcp->c_flag, C_HARDLINK)) {+ hfs_relorigin(fcp, fdcp->c_fileid);+ if (fdcp->c_fileid != fdcp->c_cnid)+ hfs_relorigin(fcp, fdcp->c_cnid);+ }++ (void) hfs_update(fdvp, 0);+ }+ hfs_incr_gencount(fdcp);++ tdcp->c_childhint = out_desc.cd_hint; /* Cache directory's location */+ tdcp->c_touch_chgtime = TRUE;+ tdcp->c_touch_modtime = TRUE;++ (void) hfs_update(tdvp, 0);++ /* Update the vnode's name now that the rename has completed. */+ vnode_update_identity(fvp, tdvp, tcnp->cn_nameptr, tcnp->cn_namelen,+ tcnp->cn_hash, (VNODE_UPDATE_PARENT | VNODE_UPDATE_NAME));++ /*+ * At this point, we may have a resource fork vnode attached to the+ * 'from' vnode. If it exists, we will want to update its name, because+ * it contains the old name + _PATH_RSRCFORKSPEC. ("/..namedfork/rsrc").+ *+ * Note that the only thing we need to update here is the name attached to+ * the vnode, since a resource fork vnode does not have a separate resource+ * cnode -- it's still 'fcp'.+ */+ if (fcp->c_rsrc_vp) {+ char* rsrc_path = NULL;+ int len;++ /* Create a new temporary buffer that's going to hold the new name */+ rsrc_path = hfs_malloc_data(MAXPATHLEN);+ len = snprintf (rsrc_path, MAXPATHLEN, "%s%s", tcnp->cn_nameptr, _PATH_RSRCFORKSPEC);+ len = MIN(len, MAXPATHLEN);++ /*+ * vnode_update_identity will do the following for us:+ * 1) release reference on the existing rsrc vnode's name.+ * 2) copy/insert new name into the name cache+ * 3) attach the new name to the resource vnode+ * 4) update the vnode's vid+ */+ vnode_update_identity (fcp->c_rsrc_vp, fvp, rsrc_path, len, 0, (VNODE_UPDATE_NAME | VNODE_UPDATE_CACHE));++ /* Free the memory associated with the resource fork's name */+ hfs_free_data(rsrc_path, MAXPATHLEN);+ }+out:+ if (got_cookie) {+ cat_postflight(hfsmp, &cookie, p);+ }+ if (started_tr) {+ hfs_end_transaction(hfsmp);+ }++ fdcp->c_flag &= ~C_DIR_MODIFICATION;+ wakeup((caddr_t)&fdcp->c_flag);+ if (fdvp != tdvp) {+ tdcp->c_flag &= ~C_DIR_MODIFICATION;+ wakeup((caddr_t)&tdcp->c_flag);+ }++ const ino64_t file_id = fcp->c_fileid;++ hfs_unlockfour(fdcp, fcp, tdcp, tcp);++ if (took_trunc_lock) {+ hfs_unlock_truncate(VTOC(tvp), HFS_LOCK_DEFAULT);+ }++ /* Now vnode_put the resource forks vnodes if necessary */+ if (tvp_rsrc) {+ vnode_put(tvp_rsrc);+ tvp_rsrc = NULL;+ }++ /* After tvp is removed the only acceptable error is EIO */+ if (error && tvp_deleted)+ error = EIO;++ /* If we want to reintroduce notifications for renames, this is the+ place to do it. */++ if (old_doc_vp) {+ cnode_t *ocp = VTOC(old_doc_vp);+ hfs_lock_always(ocp, HFS_EXCLUSIVE_LOCK);+ struct FndrExtendedFileInfo *ofip = (struct FndrExtendedFileInfo *)((char *)&ocp->c_attr.ca_finderinfo + 16);++ const uint32_t doc_id = ofip->document_id;+ const ino64_t old_file_id = ocp->c_fileid;++ // printf("clearing doc-id from ino %d\n", ocp->c_desc.cd_cnid);+ ofip->document_id = 0;+ ocp->c_bsdflags &= ~UF_TRACKED;+ ocp->c_flag |= C_MODIFIED;++ hfs_unlock(ocp);+ vnode_put(old_doc_vp);++ add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(),+ FSE_ARG_DEV, hfsmp->hfs_raw_dev,+ FSE_ARG_INO, old_file_id, // src inode #+ FSE_ARG_INO, file_id, // dst inode #+ FSE_ARG_INT32, doc_id,+ FSE_ARG_DONE);+ }++ return (error);+}+++/*+ * Make a directory.+ */+int+hfs_vnop_mkdir(struct vnop_mkdir_args *ap)+{+ /***** HACK ALERT ********/+ ap->a_cnp->cn_flags |= MAKEENTRY;+ return hfs_makenode(ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap, ap->a_context);+}+++/*+ * Create a symbolic link.+ */+int+hfs_vnop_symlink(struct vnop_symlink_args *ap)+{+ struct vnode **vpp = ap->a_vpp;+ struct vnode *dvp = ap->a_dvp;+ struct vnode *vp = NULL;+ struct cnode *cp = NULL;+ struct hfsmount *hfsmp;+ struct filefork *fp;+ struct buf *bp = NULL;+ char *datap;+ int started_tr = 0, locked_cp = 0;+ u_int32_t len;+ int error;++ /* HFS standard disks don't support symbolic links */+ if (VTOVCB(dvp)->vcbSigWord != kHFSPlusSigWord)+ return (ENOTSUP);++ hfsmp = VTOHFS(dvp);++ len = strlen(ap->a_target);+ if (len > MAXPATHLEN)+ return (ENAMETOOLONG);++ /* Check for free space */+ if (((u_int64_t)hfs_freeblks(hfsmp, 0) * (u_int64_t)hfsmp->blockSize) < len) {+ return (ENOSPC);+ }++ /* Create the vnode */+ ap->a_vap->va_mode |= S_IFLNK;+ if ((error = hfs_makenode(dvp, vpp, ap->a_cnp, ap->a_vap, ap->a_context))) {+ goto out;+ }+ vp = *vpp;+ if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ goto out;+ }+ locked_cp = 1;+ cp = VTOC(vp);+ fp = VTOF(vp);++ if (cp->c_flag & (C_NOEXISTS | C_DELETED)) {+ goto out;+ }++ if (!len)+ goto out;++#if QUOTA+ (void)hfs_getinoquota(cp);+#endif /* QUOTA */++ if ((error = hfs_start_transaction(hfsmp)) != 0) {+ goto out;+ }+ started_tr = 1;++ /*+ * Allocate space for the link.+ *+ * Since we're already inside a transaction,+ *+ * Don't need truncate lock since a symlink is treated as a system file.+ */+ error = hfs_truncate(vp, len, IO_NOZEROFILL, 0, ap->a_context);++ /* On errors, remove the symlink file */+ if (error) {+ /*+ * End the transaction so we don't re-take the cnode lock+ * below while inside a transaction (lock order violation).+ */+ hfs_end_transaction(hfsmp);++ /* hfs_removefile() requires holding the truncate lock */+ hfs_unlock(cp);+ hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_ALLOW_NOEXISTS);++ if (hfs_start_transaction(hfsmp) != 0) {+ started_tr = 0;+ } else {+ (void) hfs_removefile(dvp, vp, ap->a_cnp, 0, 0, 0, NULL, 0);+ }++ hfs_unlock(cp);+ locked_cp = 0;+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ goto out;+ }++ /* Write the link to disk */+ bp = buf_getblk(vp, (daddr64_t)0, roundup((int)fp->ff_size, hfsmp->hfs_physical_block_size),+ 0, 0, BLK_META);+ if (hfsmp->jnl) {+ journal_modify_block_start(hfsmp->jnl, bp);+ }+ datap = (char *)buf_dataptr(bp);+ bzero(datap, buf_size(bp));+ bcopy(ap->a_target, datap, len);++ if (hfsmp->jnl) {+ journal_modify_block_end(hfsmp->jnl, bp, NULL, NULL);+ } else {+ buf_bawrite(bp);+ }+out:+ if (started_tr)+ hfs_end_transaction(hfsmp);+ if (locked_cp != 0) {+ hfs_unlock(cp);+ }+ if (error) {+ if (vp) {+ vnode_put(vp);+ }+ *vpp = NULL;+ }+ return (error);+}+++/* structures to hold a "." or ".." directory entry */+struct hfs_stddotentry {+ u_int32_t d_fileno; /* unique file number */+ u_int16_t d_reclen; /* length of this structure */+ u_int8_t d_type; /* dirent file type */+ u_int8_t d_namlen; /* len of filename */+ char d_name[4]; /* "." or ".." */+};++struct hfs_extdotentry {+ u_int64_t d_fileno; /* unique file number */+ u_int64_t d_seekoff; /* seek offset (optional, used by servers) */+ u_int16_t d_reclen; /* length of this structure */+ u_int16_t d_namlen; /* len of filename */+ u_int8_t d_type; /* dirent file type */+ u_char d_name[3]; /* "." or ".." */+};++typedef union {+ struct hfs_stddotentry std;+ struct hfs_extdotentry ext;+} hfs_dotentry_t;++/*+ * hfs_vnop_readdir reads directory entries into the buffer pointed+ * to by uio, in a filesystem independent format. Up to uio_resid+ * bytes of data can be transferred. The data in the buffer is a+ * series of packed dirent structures where each one contains the+ * following entries:+ *+ * u_int32_t d_fileno; // file number of entry+ * u_int16_t d_reclen; // length of this record+ * u_int8_t d_type; // file type+ * u_int8_t d_namlen; // length of string in d_name+ * char d_name[MAXNAMELEN+1]; // null terminated file name+ *+ * The current position (uio_offset) refers to the next block of+ * entries. The offset can only be set to a value previously+ * returned by hfs_vnop_readdir or zero. This offset does not have+ * to match the number of bytes returned (in uio_resid).+ *+ * In fact, the offset used by HFS is essentially an index (26 bits)+ * with a tag (6 bits). The tag is for associating the next request+ * with the current request. This enables us to have multiple threads+ * reading the directory while the directory is also being modified.+ *+ * Each tag/index pair is tied to a unique directory hint. The hint+ * contains information (filename) needed to build the catalog b-tree+ * key for finding the next set of entries.+ *+ * If the directory is marked as deleted-but-in-use (cp->c_flag & C_DELETED),+ * do NOT synthesize entries for "." and "..".+ */+int+hfs_vnop_readdir(struct vnop_readdir_args *ap)+{+ struct vnode *vp = ap->a_vp;+ uio_t uio = ap->a_uio;+ struct cnode *cp = VTOC(vp);+ struct hfsmount *hfsmp = VTOHFS(vp);+ directoryhint_t *dirhint = NULL;+ directoryhint_t localhint;+ off_t offset;+ off_t startoffset;+ int error = 0;+ int eofflag = 0;+ user_addr_t user_start = 0;+ user_size_t user_len = 0;+ user_size_t user_original_resid = 0;+ int index;+ unsigned int tag;+ int items;+ int lockflags;+ int extended;+ int nfs_cookies;+ cnid_t cnid_hint = 0;+ int bump_valence = 0;++ items = 0;+ startoffset = offset = uio_offset(uio);+ extended = (ap->a_flags & VNODE_READDIR_EXTENDED);+ nfs_cookies = extended && (ap->a_flags & VNODE_READDIR_REQSEEKOFF);++ /* Sanity check the uio data. */+ if (uio_iovcnt(uio) > 1)+ return (EINVAL);++ if (VTOC(vp)->c_bsdflags & UF_COMPRESSED) {+ int compressed = hfs_file_is_compressed(VTOC(vp), 0); /* 0 == take the cnode lock */+ if (VTOCMP(vp) != NULL && !compressed) {+ error = check_for_dataless_file(vp, NAMESPACE_HANDLER_READ_OP);+ if (error) {+ return error;+ }+ }+ }++ //+ // We have to lock the user's buffer here so that we won't+ // fault on it after we've acquired a shared lock on the+ // catalog file. The issue is that you can get a 3-way+ // deadlock if someone else starts a transaction and then+ // tries to lock the catalog file but can't because we're+ // here and we can't service our page fault because VM is+ // blocked trying to start a transaction as a result of+ // trying to free up pages for our page fault. It's messy+ // but it does happen on dual-processors that are paging+ // heavily (see radar 3082639 for more info). By locking+ // the buffer up-front we prevent ourselves from faulting+ // while holding the shared catalog file lock.+ //+ // Fortunately this and hfs_search() are the only two places+ // currently (10/30/02) that can fault on user data with a+ // shared lock on the catalog file.+ //+ if (hfsmp->jnl && uio_isuserspace(uio)) {+ user_start = uio_curriovbase(uio);+ user_len = uio_curriovlen(uio);++ /* Bounds check the user buffer */+ if (user_len > (256 * 1024)) {+ /* only allow the user to wire down at most 256k */+ user_len = (256 * 1024);+ user_original_resid = uio_resid(uio);+ uio_setresid (uio, (user_ssize_t)(256 * 1024));+ }++ if ((error = vslock(user_start, user_len)) != 0) {+ if (user_original_resid > 0) {+ uio_setresid(uio, user_original_resid);+ user_original_resid = 0;+ }+ return error;+ }+ }++ /* Note that the dirhint calls require an exclusive lock. */+ if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ if (user_start) {+ if (user_original_resid > 0) {+ uio_setresid(uio, user_original_resid);+ user_original_resid = 0;+ }+ vsunlock(user_start, user_len, TRUE);+ }+ return error;+ }++ /* Pick up cnid hint (if any). */+ if (nfs_cookies) {+ cnid_hint = (cnid_t)(uio_offset(uio) >> 32);+ uio_setoffset(uio, uio_offset(uio) & 0x00000000ffffffffLL);+ if (cnid_hint == INT_MAX) { /* searching pass the last item */+ eofflag = 1;+ goto out;+ }+ }+ /*+ * Synthesize entries for "." and "..", unless the directory has+ * been deleted, but not closed yet (lazy delete in progress).+ */+ if (offset == 0 && !(cp->c_flag & C_DELETED)) {++ size_t uiosize;++ /*+ * We could use a union of the two types of dot entries (HFS / HFS+)+ * but it makes static analysis of this code difficult. The problem is that+ * the HFS standard dot entry is smaller than the HFS+ one, and we also ideally+ * want the uiomove to operate on a two-element adjacent array. If we used the+ * array of unions, we would have to do two separate uiomoves because the memory+ * for the hfs standard dot entries would not be adjacent to one another.+ * So just allocate the entries on the stack in separate cases.+ */++ if (extended) {+ hfs_dotentry_t dotentry[2];++ /* HFS Plus */+ struct hfs_extdotentry *entry = &dotentry[0].ext;++ entry->d_fileno = cp->c_cnid;+ entry->d_reclen = sizeof(struct hfs_extdotentry);+ entry->d_type = DT_DIR;+ entry->d_namlen = 1;+ entry->d_name[0] = '.';+ entry->d_name[1] = '\0';+ entry->d_name[2] = '\0';+ entry->d_seekoff = 1;++ ++entry;+ entry->d_fileno = cp->c_parentcnid;+ entry->d_reclen = sizeof(struct hfs_extdotentry);+ entry->d_type = DT_DIR;+ entry->d_namlen = 2;+ entry->d_name[0] = '.';+ entry->d_name[1] = '.';+ entry->d_name[2] = '\0';+ entry->d_seekoff = 2;+ uiosize = 2 * sizeof(struct hfs_extdotentry);++ if ((error = uiomove((caddr_t)dotentry, uiosize, uio))) {+ goto out;+ }++ } else {+ struct hfs_stddotentry hfs_std_dotentries[2];++ /* HFS Standard */+ struct hfs_stddotentry *entry = &hfs_std_dotentries[0];++ entry->d_fileno = cp->c_cnid;+ entry->d_reclen = sizeof(struct hfs_stddotentry);+ entry->d_type = DT_DIR;+ entry->d_namlen = 1;+ *(int *)&entry->d_name[0] = 0;+ entry->d_name[0] = '.';++ ++entry;+ entry->d_fileno = cp->c_parentcnid;+ entry->d_reclen = sizeof(struct hfs_stddotentry);+ entry->d_type = DT_DIR;+ entry->d_namlen = 2;+ *(int *)&entry->d_name[0] = 0;+ entry->d_name[0] = '.';+ entry->d_name[1] = '.';+ uiosize = 2 * sizeof(struct hfs_stddotentry);++ if ((error = uiomove((caddr_t)hfs_std_dotentries, uiosize, uio))) {+ goto out;+ }+ }++ offset += 2;+ }++ /*+ * Intentionally avoid checking the valence here. If we+ * have FS corruption that reports the valence is 0, even though it+ * has contents, we might artificially skip over iterating+ * this directory.+ */++ /* Convert offset into a catalog directory index. */+ index = (offset & HFS_INDEX_MASK) - 2;+ tag = offset & ~HFS_INDEX_MASK;++ /* Lock catalog during cat_findname and cat_getdirentries. */+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);++ /* When called from NFS, try and resolve a cnid hint. */+ if (nfs_cookies && cnid_hint != 0) {+ if (cat_findname(hfsmp, cnid_hint, &localhint.dh_desc) == 0) {+ if ( localhint.dh_desc.cd_parentcnid == cp->c_fileid) {+ localhint.dh_index = index - 1;+ localhint.dh_time = 0;+ bzero(&localhint.dh_link, sizeof(localhint.dh_link));+ dirhint = &localhint; /* don't forget to release the descriptor */+ } else {+ cat_releasedesc(&localhint.dh_desc);+ }+ }+ }++ /* Get a directory hint (cnode must be locked exclusive) */+ if (dirhint == NULL) {+ dirhint = hfs_getdirhint(cp, ((index - 1) & HFS_INDEX_MASK) | tag, 0);++ /* Hide tag from catalog layer. */+ dirhint->dh_index &= HFS_INDEX_MASK;+ if (dirhint->dh_index == HFS_INDEX_MASK) {+ dirhint->dh_index = -1;+ }+ }++ if (index == 0) {+ dirhint->dh_threadhint = cp->c_dirthreadhint;+ }+ else {+ /*+ * If we have a non-zero index, there is a possibility that during the last+ * call to hfs_vnop_readdir we hit EOF for this directory. If that is the case+ * then we don't want to return any new entries for the caller. Just return 0+ * items, mark the eofflag, and bail out. Because we won't have done any work, the+ * code at the end of the function will release the dirhint for us.+ *+ * Don't forget to unlock the catalog lock on the way out, too.+ */+ if (dirhint->dh_desc.cd_flags & CD_EOF) {+ error = 0;+ eofflag = 1;+ uio_setoffset(uio, startoffset);+ if (user_original_resid > 0) {+ uio_setresid(uio, user_original_resid);+ user_original_resid = 0;+ }+ hfs_systemfile_unlock (hfsmp, lockflags);++ goto seekoffcalc;+ }+ }++ /* Pack the buffer with dirent entries. */+ error = cat_getdirentries(hfsmp, cp->c_entries, dirhint, uio, ap->a_flags, &items, &eofflag);++ if (user_original_resid > 0) {+ user_original_resid = user_original_resid - ((user_ssize_t)256*1024 - uio_resid(uio));+ uio_setresid(uio, user_original_resid);+ user_original_resid = 0;+ }++ if (index == 0 && error == 0) {+ cp->c_dirthreadhint = dirhint->dh_threadhint;+ }++ hfs_systemfile_unlock(hfsmp, lockflags);++ if (error != 0) {+ goto out;+ }++ /* Get index to the next item */+ index += items;++ if (items >= (int)cp->c_entries) {+ eofflag = 1;+ }++ /*+ * Detect valence FS corruption.+ *+ * We are holding the cnode lock exclusive, so there should not be+ * anybody modifying the valence field of this cnode. If we enter+ * this block, that means we observed filesystem corruption, because+ * this directory reported a valence of 0, yet we found at least one+ * item. In this case, we need to minimally self-heal this+ * directory to prevent userland from tripping over a directory+ * that appears empty (getattr of valence reports 0), but actually+ * has contents.+ *+ * We'll force the cnode update at the end of the function after+ * completing all of the normal getdirentries steps.+ */+ if ((cp->c_entries == 0) && (items > 0)) {+ /* disk corruption */+ cp->c_entries++;+ /* Mark the cnode as dirty. */+ cp->c_flag |= C_MODIFIED;+ printf("hfs_vnop_readdir: repairing valence to non-zero! \n");+ bump_valence++;+ }+++ /* Convert catalog directory index back into an offset. */+ while (tag == 0)+ tag = (++cp->c_dirhinttag) << HFS_INDEX_BITS;+ uio_setoffset(uio, (index + 2) | tag);+ dirhint->dh_index |= tag;++seekoffcalc:+ cp->c_touch_acctime = TRUE;++ if (ap->a_numdirent) {+ if (startoffset == 0)+ items += 2;+ *ap->a_numdirent = items;+ }++out:+ if (user_start) {+ if (user_original_resid > 0) {+ uio_setresid(uio, user_original_resid);+ user_original_resid = 0;+ }+ vsunlock(user_start, user_len, TRUE);+ }+ /* If we didn't do anything then go ahead and dump the hint. */+ if ((dirhint != NULL) &&+ (dirhint != &localhint) &&+ (uio_offset(uio) == startoffset)) {+ hfs_reldirhint(cp, dirhint);+ eofflag = 1;+ }+ if (ap->a_eofflag) {+ *ap->a_eofflag = eofflag;+ }+ if (dirhint == &localhint) {+ cat_releasedesc(&localhint.dh_desc);+ }++ if (bump_valence) {+ /* force the update before dropping the cnode lock*/+ hfs_update(vp, 0);+ }++ hfs_unlock(cp);++ return (error);+}+++/*+ * Read contents of a symbolic link.+ */+int+hfs_vnop_readlink(struct vnop_readlink_args *ap)+{+ struct vnode *vp = ap->a_vp;+ struct cnode *cp;+ struct filefork *fp;+ int error;++ if (!vnode_islnk(vp))+ return (EINVAL);++ if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT)))+ return (error);+ cp = VTOC(vp);+ fp = VTOF(vp);++ /* Zero length sym links are not allowed */+ if (fp->ff_size > MAXPATHLEN) {+ error = EINVAL;+ goto exit;+ }++ /*+ * If this is an empty symlink, we are done. The call to uiomove() is+ * just for debug and diagnostics.+ */+ if (fp->ff_size == 0) {+ static uint8_t empty_str[] = {'\0'};++ error = uiomove((caddr_t)empty_str, 0, ap->a_uio);+ goto exit;+ }++ /* Cache the path so we don't waste buffer cache resources */+ if (fp->ff_symlinkptr == NULL) {+ struct buf *bp = NULL;++ fp->ff_symlinkptr = hfs_malloc_data(fp->ff_size);+ error = (int)buf_meta_bread(vp, (daddr64_t)0,+ roundup((int)fp->ff_size, VTOHFS(vp)->hfs_physical_block_size),+ vfs_context_ucred(ap->a_context), &bp);+ if (error) {+ if (bp)+ buf_brelse(bp);+ if (fp->ff_symlinkptr) {+ hfs_free_data(fp->ff_symlinkptr, fp->ff_size);+ fp->ff_symlinkptr = NULL;+ }+ goto exit;+ }+ bcopy((char *)buf_dataptr(bp), fp->ff_symlinkptr, (size_t)fp->ff_size);++ if (VTOHFS(vp)->jnl && (buf_flags(bp) & B_LOCKED) == 0) {+ buf_markinvalid(bp); /* data no longer needed */+ }+ buf_brelse(bp);+ }+ error = uiomove((caddr_t)fp->ff_symlinkptr, (int)fp->ff_size, ap->a_uio);++ /*+ * Keep track blocks read+ */+ if ((VTOHFS(vp)->hfc_stage == HFC_RECORDING) && (error == 0)) {++ /*+ * If this file hasn't been seen since the start of+ * the current sampling period then start over.+ */+ if (cp->c_atime < VTOHFS(vp)->hfc_timebase)+ VTOF(vp)->ff_bytesread = fp->ff_size;+ else+ VTOF(vp)->ff_bytesread += fp->ff_size;++ // if (VTOF(vp)->ff_bytesread > fp->ff_size)+ // cp->c_touch_acctime = TRUE;+ }++exit:+ hfs_unlock(cp);+ return (error);+}+++/*+ * Get configurable pathname variables.+ */+int+hfs_vnop_pathconf(struct vnop_pathconf_args *ap)+{+ switch (ap->a_name) {+ case _PC_LINK_MAX:+ *ap->a_retval = HFS_LINK_MAX;+ break;+ case _PC_NAME_MAX:+ *ap->a_retval = kHFSPlusMaxFileNameChars; /* 255 */+ break;+ case _PC_PATH_MAX:+ *ap->a_retval = PATH_MAX; /* 1024 */+ break;+ case _PC_PIPE_BUF:+ *ap->a_retval = PIPE_BUF;+ break;+ case _PC_CHOWN_RESTRICTED:+ *ap->a_retval = 200112; /* _POSIX_CHOWN_RESTRICTED */+ break;+ case _PC_NO_TRUNC:+ *ap->a_retval = 200112; /* _POSIX_NO_TRUNC */+ break;+ case _PC_NAME_CHARS_MAX:+ *ap->a_retval = kHFSPlusMaxFileNameChars; /* 255 */+ break;+ case _PC_CASE_SENSITIVE:+ if (VTOHFS(ap->a_vp)->hfs_flags & HFS_CASE_SENSITIVE)+ *ap->a_retval = 1;+ else+ *ap->a_retval = 0;+ break;+ case _PC_CASE_PRESERVING:+ *ap->a_retval = 1;+ break;+ case _PC_FILESIZEBITS:+ /* number of bits to store max file size */+ *ap->a_retval = 64;+ break;+ case _PC_XATTR_SIZE_BITS:+ /* Number of bits to store maximum extended attribute size */+ *ap->a_retval = HFS_XATTR_SIZE_BITS;+ break;+ default:+ return (EINVAL);+ }++ return (0);+}++/*+ * Prepares a fork for cat_update by making sure ff_size and ff_blocks+ * are no bigger than the valid data on disk thus reducing the chance+ * of exposing uninitialised data in the event of a non clean unmount.+ * fork_buf is where to put the temporary copy if required. (It can+ * be inside pfork.)+ */+const struct cat_fork *+hfs_prepare_fork_for_update(filefork_t *ff,+ const struct cat_fork *cf,+ struct cat_fork *cf_buf,+ uint32_t block_size)+{+ if (!ff)+ return NULL;++ if (!cf)+ cf = &ff->ff_data;+ if (!cf_buf)+ cf_buf = &ff->ff_data;++ off_t max_size = ff->ff_size;++ // Check first invalid range+ if (!TAILQ_EMPTY(&ff->ff_invalidranges))+ max_size = TAILQ_FIRST(&ff->ff_invalidranges)->rl_start;++ if (!ff->ff_unallocblocks && ff->ff_size <= max_size)+ return cf; // Nothing to do++ if (ff->ff_blocks < ff->ff_unallocblocks) {+ panic("hfs: ff_blocks %d is less than unalloc blocks %d\n",+ ff->ff_blocks, ff->ff_unallocblocks);+ }++ struct cat_fork *out = cf_buf;++ if (out != cf)+ bcopy(cf, out, sizeof(*cf));++ // Adjust cf_blocks for cf_vblocks+ out->cf_blocks -= out->cf_vblocks;++ /*+ * Here we trim the size with the updated cf_blocks. This is+ * probably unnecessary now because the invalid ranges should+ * catch this (but that wasn't always the case).+ */+ off_t alloc_bytes = hfs_blk_to_bytes(out->cf_blocks, block_size);+ if (out->cf_size > alloc_bytes)+ out->cf_size = alloc_bytes;++ // Trim cf_size to first invalid range+ if (out->cf_size > max_size)+ out->cf_size = max_size;++ return out;+}++/*+ * Update a cnode's on-disk metadata.+ *+ * The cnode must be locked exclusive. See declaration for possible+ * options.+ */+int+hfs_update(struct vnode *vp, int options)+{+ struct cnode *cp = VTOC(vp);+ struct proc *p;+ const struct cat_fork *dataforkp = NULL;+ const struct cat_fork *rsrcforkp = NULL;+ struct cat_fork datafork;+ struct cat_fork rsrcfork;+ struct hfsmount *hfsmp;+ int lockflags;+ int error;+ uint32_t tstate = 0;++ if (ISSET(cp->c_flag, C_NOEXISTS))+ return 0;++ p = current_proc();+ hfsmp = VTOHFS(vp);++ if (((vnode_issystem(vp) && (cp->c_cnid < kHFSFirstUserCatalogNodeID))) ||+ hfsmp->hfs_catalog_vp == NULL){+ return (0);+ }+ if ((hfsmp->hfs_flags & HFS_READ_ONLY) || (cp->c_mode == 0)) {+ CLR(cp->c_flag, C_MODIFIED | C_MINOR_MOD | C_NEEDS_DATEADDED);+ cp->c_touch_acctime = 0;+ cp->c_touch_chgtime = 0;+ cp->c_touch_modtime = 0;+ return (0);+ }+ if (kdebug_enable) {+ if (cp->c_touch_acctime || cp->c_atime != cp->c_attr.ca_atimeondisk)+ tstate |= DBG_HFS_UPDATE_ACCTIME;+ if (cp->c_touch_modtime)+ tstate |= DBG_HFS_UPDATE_MODTIME;+ if (cp->c_touch_chgtime)+ tstate |= DBG_HFS_UPDATE_CHGTIME;++ if (cp->c_flag & C_MODIFIED)+ tstate |= DBG_HFS_UPDATE_MODIFIED;+ if (ISSET(options, HFS_UPDATE_FORCE))+ tstate |= DBG_HFS_UPDATE_FORCE;+ if (cp->c_flag & C_NEEDS_DATEADDED)+ tstate |= DBG_HFS_UPDATE_DATEADDED;+ if (cp->c_flag & C_MINOR_MOD)+ tstate |= DBG_HFS_UPDATE_MINOR;+ }+ hfs_touchtimes(hfsmp, cp);++ if (!ISSET(cp->c_flag, C_MODIFIED | C_MINOR_MOD)+ && !hfs_should_save_atime(cp)) {+ // Nothing to update+ return 0;+ }++ KDBG(HFSDBG_UPDATE | DBG_FUNC_START, kdebug_vnode(vp), tstate);++ bool check_txn = false;++ if (!ISSET(options, HFS_UPDATE_FORCE) && !ISSET(cp->c_flag, C_MODIFIED)) {+ /*+ * This must be a minor modification. If the current+ * transaction already has an update for this node, then we+ * bundle in the modification.+ */+ if (hfsmp->jnl+ && journal_current_txn(hfsmp->jnl) == cp->c_update_txn) {+ check_txn = true;+ } else {+ tstate |= DBG_HFS_UPDATE_SKIPPED;+ error = 0;+ goto exit;+ }+ }++ if ((error = hfs_start_transaction(hfsmp)) != 0)+ goto exit;++ if (check_txn+ && journal_current_txn(hfsmp->jnl) != cp->c_update_txn) {+ hfs_end_transaction(hfsmp);+ tstate |= DBG_HFS_UPDATE_SKIPPED;+ error = 0;+ goto exit;+ }++ if (cp->c_datafork)+ dataforkp = &cp->c_datafork->ff_data;+ if (cp->c_rsrcfork)+ rsrcforkp = &cp->c_rsrcfork->ff_data;++ /*+ * Modify the values passed to cat_update based on whether or not+ * the file has invalid ranges or borrowed blocks.+ */+ dataforkp = hfs_prepare_fork_for_update(cp->c_datafork, NULL, &datafork, hfsmp->blockSize);+ rsrcforkp = hfs_prepare_fork_for_update(cp->c_rsrcfork, NULL, &rsrcfork, hfsmp->blockSize);++ if (__builtin_expect(kdebug_enable & KDEBUG_TRACE, 0)) {+ long dbg_parms[NUMPARMS];+ int err;+#ifdef VN_GETPATH_NEW+ size_t dbg_namelen;+#else // VN_GETPATH_NEW+ int dbg_namelen;+#endif // VN_GETPATH_NEW++ dbg_namelen = NUMPARMS * sizeof(long);+ err = vn_getpath_ext(vp, NULLVP, (char *)dbg_parms, &dbg_namelen, 0);++ if (!err && (dbg_namelen < (int)sizeof(dbg_parms)))+ memset((char *)dbg_parms + dbg_namelen, 0, sizeof(dbg_parms) - dbg_namelen);++ kdebug_lookup_gen_events(dbg_parms, dbg_namelen, (void *)vp, TRUE);+ }++ /*+ * Lock the Catalog b-tree file.+ */+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);++ error = cat_update(hfsmp, &cp->c_desc, &cp->c_attr, dataforkp, rsrcforkp);++ if (hfsmp->jnl)+ cp->c_update_txn = journal_current_txn(hfsmp->jnl);++ hfs_systemfile_unlock(hfsmp, lockflags);++ CLR(cp->c_flag, C_MODIFIED | C_MINOR_MOD);++ hfs_end_transaction(hfsmp);++exit:++ KDBG(HFSDBG_UPDATE | DBG_FUNC_END, kdebug_vnode(vp), tstate, error);++ return error;+}++/*+ * Allocate a new node+ */+int+hfs_makenode(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,+ struct vnode_attr *vap, vfs_context_t ctx)+{+ struct cnode *cp = NULL;+ struct cnode *dcp = NULL;+ struct vnode *tvp;+ struct hfsmount *hfsmp;+ struct cat_desc in_desc, out_desc;+ struct cat_attr attr;+ struct timeval tv;+ int lockflags;+ int error, started_tr = 0;+ enum vtype vnodetype;+ int mode;+ int newvnode_flags = 0;+ u_int32_t gnv_flags = 0;+ int protectable_target = 0;+ int nocache = 0;+ vnode_t old_doc_vp = NULL;++#if CONFIG_PROTECT+ struct cprotect *entry = NULL;+ int32_t cp_class = -1;++ /*+ * By default, it's OK for AKS to overrride our target class preferences.+ */+ uint32_t keywrap_flags = CP_KEYWRAP_DIFFCLASS;++ if (VATTR_IS_ACTIVE(vap, va_dataprotect_class)) {+ cp_class = (int32_t)vap->va_dataprotect_class;+ /*+ * Since the user specifically requested this target class be used,+ * we want to fail this creation operation if we cannot wrap to their+ * target class. The CP_KEYWRAP_DIFFCLASS bit says that it is OK to+ * use a different class than the one specified, so we turn that off+ * now.+ */+ keywrap_flags &= ~CP_KEYWRAP_DIFFCLASS;+ }+ int protected_mount = 0;+#endif+++ if ((error = hfs_lock(VTOC(dvp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT)))+ return (error);++ /* set the cnode pointer only after successfully acquiring lock */+ dcp = VTOC(dvp);++ /* Don't allow creation of new entries in open-unlinked directories */+ if ((error = hfs_checkdeleted(dcp))) {+ hfs_unlock(dcp);+ return error;+ }++ dcp->c_flag |= C_DIR_MODIFICATION;++ hfsmp = VTOHFS(dvp);++ *vpp = NULL;+ tvp = NULL;+ out_desc.cd_flags = 0;+ out_desc.cd_nameptr = NULL;++ vnodetype = vap->va_type;+ if (vnodetype == VNON)+ vnodetype = VREG;+ mode = MAKEIMODE(vnodetype, vap->va_mode);++ if (S_ISDIR (mode) || S_ISREG (mode)) {+ protectable_target = 1;+ }+++ /* Check if were out of usable disk space. */+ if ((hfs_freeblks(hfsmp, 1) == 0) && (vfs_context_suser(ctx) != 0)) {+ error = ENOSPC;+ goto exit;+ }++ microtime(&tv);++ /* Setup the default attributes */+ bzero(&attr, sizeof(attr));+ attr.ca_mode = mode;+ attr.ca_linkcount = 1;+ if (VATTR_IS_ACTIVE(vap, va_rdev)) {+ attr.ca_rdev = vap->va_rdev;+ }+ if (VATTR_IS_ACTIVE(vap, va_create_time)) {+ VATTR_SET_SUPPORTED(vap, va_create_time);+ attr.ca_itime = vap->va_create_time.tv_sec;+ } else {+ attr.ca_itime = tv.tv_sec;+ }++ attr.ca_atime = attr.ca_ctime = attr.ca_mtime = attr.ca_itime;+ attr.ca_atimeondisk = attr.ca_atime;+ if (VATTR_IS_ACTIVE(vap, va_flags)) {+ VATTR_SET_SUPPORTED(vap, va_flags);+ attr.ca_flags = vap->va_flags;+ }++ /*+ * HFS+ only: all files get ThreadExists+ * HFSX only: dirs get HasFolderCount+ */+ if (vnodetype == VDIR) {+ if (hfsmp->hfs_flags & HFS_FOLDERCOUNT)+ attr.ca_recflags = kHFSHasFolderCountMask;+ } else {+ attr.ca_recflags = kHFSThreadExistsMask;+ }++#if CONFIG_PROTECT+ if (cp_fs_protected(hfsmp->hfs_mp)) {+ protected_mount = 1;+ }+ /*+ * On a content-protected HFS+/HFSX filesystem, files and directories+ * cannot be created without atomically setting/creating the EA that+ * contains the protection class metadata and keys at the same time, in+ * the same transaction. As a result, pre-set the "EAs exist" flag+ * on the cat_attr for protectable catalog record creations. This will+ * cause the cnode creation routine in hfs_getnewvnode to mark the cnode+ * as having EAs.+ */+ if ((protected_mount) && (protectable_target)) {+ attr.ca_recflags |= kHFSHasAttributesMask;+ /* delay entering in the namecache */+ nocache = 1;+ }+#endif+++ /*+ * Add the date added to the item. See above, as+ * all of the dates are set to the itime.+ */+ hfs_write_dateadded (&attr, attr.ca_atime);++ /* Initialize the gen counter to 1 */+ hfs_write_gencount(&attr, (uint32_t)1);++ attr.ca_uid = vap->va_uid;+ attr.ca_gid = vap->va_gid;+ VATTR_SET_SUPPORTED(vap, va_mode);+ VATTR_SET_SUPPORTED(vap, va_uid);+ VATTR_SET_SUPPORTED(vap, va_gid);++#if QUOTA+ /* check to see if this node's creation would cause us to go over+ * quota. If so, abort this operation.+ */+ if (hfsmp->hfs_flags & HFS_QUOTAS) {+ if ((error = hfs_quotacheck(hfsmp, 1, attr.ca_uid, attr.ca_gid,+ vfs_context_ucred(ctx)))) {+ goto exit;+ }+ }+#endif+++ /* Tag symlinks with a type and creator. */+ if (vnodetype == VLNK) {+ struct FndrFileInfo *fip;++ fip = (struct FndrFileInfo *)&attr.ca_finderinfo;+ fip->fdType = SWAP_BE32(kSymLinkFileType);+ fip->fdCreator = SWAP_BE32(kSymLinkCreator);+ }++ /* Setup the descriptor */+ in_desc.cd_nameptr = (const u_int8_t *)cnp->cn_nameptr;+ in_desc.cd_namelen = cnp->cn_namelen;+ in_desc.cd_parentcnid = dcp->c_fileid;+ in_desc.cd_flags = S_ISDIR(mode) ? CD_ISDIR : 0;+ in_desc.cd_hint = dcp->c_childhint;+ in_desc.cd_encoding = 0;++#if CONFIG_PROTECT+ /*+ * To preserve file creation atomicity with regards to the content protection EA,+ * we must create the file in the catalog and then write out its EA in the same+ * transaction.+ *+ * We only denote the target class in this EA; key generation is not completed+ * until the file has been inserted into the catalog and will be done+ * in a separate transaction.+ */+ if ((protected_mount) && (protectable_target)) {+ error = cp_setup_newentry(hfsmp, dcp, cp_class, attr.ca_mode, &entry);+ if (error) {+ goto exit;+ }+ }+#endif++ if ((error = hfs_start_transaction(hfsmp)) != 0) {+ goto exit;+ }+ started_tr = 1;++ // have to also lock the attribute file because cat_create() needs+ // to check that any fileID it wants to use does not have orphaned+ // attributes in it.+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE, HFS_EXCLUSIVE_LOCK);+ cnid_t new_id;++ /* Reserve some space in the Catalog file. */+ if ((error = cat_preflight(hfsmp, CAT_CREATE, NULL, 0))) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ goto exit;+ }++ if ((error = cat_acquire_cnid(hfsmp, &new_id))) {+ hfs_systemfile_unlock (hfsmp, lockflags);+ goto exit;+ }++ error = cat_create(hfsmp, new_id, &in_desc, &attr, &out_desc);+ if (error == 0) {+ /* Update the parent directory */+ dcp->c_childhint = out_desc.cd_hint; /* Cache directory's location */+ dcp->c_entries++;++ if (vnodetype == VDIR) {+ INC_FOLDERCOUNT(hfsmp, dcp->c_attr);+ }+ dcp->c_dirchangecnt++;+ hfs_incr_gencount(dcp);++ dcp->c_touch_chgtime = dcp->c_touch_modtime = true;+ dcp->c_flag |= C_MODIFIED;++ hfs_update(dcp->c_vp, 0);++#if CONFIG_PROTECT+ /*+ * If we are creating a content protected file, now is when+ * we create the EA. We must create it in the same transaction+ * that creates the file. We can also guarantee that the file+ * MUST exist because we are still holding the catalog lock+ * at this point.+ */+ if ((attr.ca_fileid != 0) && (protected_mount) && (protectable_target)) {+ error = cp_setxattr (NULL, entry, hfsmp, attr.ca_fileid, XATTR_CREATE);++ if (error) {+ int delete_err;+ /*+ * If we fail the EA creation, then we need to delete the file.+ * Luckily, we are still holding all of the right locks.+ */+ delete_err = cat_delete (hfsmp, &out_desc, &attr);+ if (delete_err == 0) {+ /* Update the parent directory */+ if (dcp->c_entries > 0)+ dcp->c_entries--;+ dcp->c_dirchangecnt++;+ dcp->c_ctime = tv.tv_sec;+ dcp->c_mtime = tv.tv_sec;+ (void) cat_update(hfsmp, &dcp->c_desc, &dcp->c_attr, NULL, NULL);+ }++ /* Emit EINVAL if we fail to create EA*/+ error = EINVAL;+ }+ }+#endif+ }+ hfs_systemfile_unlock(hfsmp, lockflags);+ if (error)+ goto exit;++ uint32_t txn = hfsmp->jnl ? journal_current_txn(hfsmp->jnl) : 0;++ /* Invalidate negative cache entries in the directory */+ if (dcp->c_flag & C_NEG_ENTRIES) {+ cache_purge_negatives(dvp);+ dcp->c_flag &= ~C_NEG_ENTRIES;+ }++ hfs_volupdate(hfsmp, vnodetype == VDIR ? VOL_MKDIR : VOL_MKFILE,+ (dcp->c_cnid == kHFSRootFolderID));++ // XXXdbg+ // have to end the transaction here before we call hfs_getnewvnode()+ // because that can cause us to try and reclaim a vnode on a different+ // file system which could cause us to start a transaction which can+ // deadlock with someone on that other file system (since we could be+ // holding two transaction locks as well as various vnodes and we did+ // not obtain the locks on them in the proper order).+ //+ // NOTE: this means that if the quota check fails or we have to update+ // the change time on a block-special device that those changes+ // will happen as part of independent transactions.+ //+ if (started_tr) {+ hfs_end_transaction(hfsmp);+ started_tr = 0;+ }++#if CONFIG_PROTECT+ /*+ * At this point, we must have encountered success with writing the EA.+ * Destroy our temporary cprotect (which had no keys).+ */++ if ((attr.ca_fileid != 0) && (protected_mount) && (protectable_target)) {+ cp_entry_destroy (hfsmp, entry);+ entry = NULL;+ }+#endif+ gnv_flags |= GNV_CREATE;+ if (nocache) {+ gnv_flags |= GNV_NOCACHE;+ }++ /*+ * Create a vnode for the object just created.+ *+ * NOTE: Maintaining the cnode lock on the parent directory is important,+ * as it prevents race conditions where other threads want to look up entries+ * in the directory and/or add things as we are in the process of creating+ * the vnode below. However, this has the potential for causing a+ * double lock panic when dealing with shadow files on a HFS boot partition.+ * The panic could occur if we are not cleaning up after ourselves properly+ * when done with a shadow file or in the error cases. The error would occur if we+ * try to create a new vnode, and then end up reclaiming another shadow vnode to+ * create the new one. However, if everything is working properly, this should+ * be a non-issue as we would never enter that reclaim codepath.+ *+ * The cnode is locked on successful return.+ */+ error = hfs_getnewvnode(hfsmp, dvp, cnp, &out_desc, gnv_flags, &attr,+ NULL, &tvp, &newvnode_flags);+ if (error)+ goto exit;++ cp = VTOC(tvp);++ cp->c_update_txn = txn;++ struct doc_tombstone *ut;+ ut = doc_tombstone_get();+ if ( ut->t_lastop_document_id != 0+ && ut->t_lastop_parent == dvp+ && ut->t_lastop_parent_vid == vnode_vid(dvp)+ && strcmp((char *)ut->t_lastop_filename, (const char *)cp->c_desc.cd_nameptr) == 0) {+ struct FndrExtendedDirInfo *fip = (struct FndrExtendedDirInfo *)((char *)&cp->c_attr.ca_finderinfo + 16);++ //printf("CREATE: preserving doc-id %lld on %s\n", ut->t_lastop_document_id, ut->t_lastop_filename);+ fip->document_id = (uint32_t)(ut->t_lastop_document_id & 0xffffffff);++ cp->c_bsdflags |= UF_TRACKED;+ cp->c_flag |= C_MODIFIED;++ if ((error = hfs_start_transaction(hfsmp)) == 0) {+ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);++ (void) cat_update(hfsmp, &cp->c_desc, &cp->c_attr, NULL, NULL);++ hfs_systemfile_unlock (hfsmp, lockflags);+ (void) hfs_end_transaction(hfsmp);+ }++ doc_tombstone_clear(ut, &old_doc_vp);+ } else if (ut->t_lastop_document_id != 0) {+ int len = cnp->cn_namelen;+ if (len == 0) {+ len = strlen(cnp->cn_nameptr);+ }++ if (doc_tombstone_should_ignore_name(cnp->cn_nameptr, cnp->cn_namelen)) {+ // printf("CREATE: not clearing tombstone because %s is a temp name.\n", cnp->cn_nameptr);+ } else {+ // Clear the tombstone because the thread is not recreating the same path+ // printf("CREATE: clearing tombstone because %s is NOT a temp name.\n", cnp->cn_nameptr);+ doc_tombstone_clear(ut, NULL);+ }+ }++ if ((hfsmp->hfs_flags & HFS_CS_HOTFILE_PIN) && (vnode_isfastdevicecandidate(dvp) && !vnode_isautocandidate(dvp))) {++ //printf("hfs: flagging %s (fileid: %d) as VFASTDEVCANDIDATE (dvp name: %s)\n",+ // cnp->cn_nameptr ? cnp->cn_nameptr : "<NONAME>",+ // cp->c_fileid,+ // dvp->v_name ? dvp->v_name : "no-dir-name");++ //+ // On new files we set the FastDevCandidate flag so that+ // any new blocks allocated to it will be pinned.+ //+ cp->c_attr.ca_recflags |= kHFSFastDevCandidateMask;+ vnode_setfastdevicecandidate(tvp);++ //+ // properly inherit auto-cached flags+ //+ if (vnode_isautocandidate(dvp)) {+ cp->c_attr.ca_recflags |= kHFSAutoCandidateMask;+ vnode_setautocandidate(tvp);+ }+++ //+ // We also want to add it to the hotfile adoption list so+ // that it will eventually land in the hotfile btree+ //+ (void) hfs_addhotfile(tvp);+ }++ *vpp = tvp;++#if CONFIG_PROTECT+ /*+ * Now that we have a vnode-in-hand, generate keys for this namespace item.+ * If we fail to create the keys, then attempt to delete the item from the+ * namespace. If we can't delete the item, that's not desirable but also not fatal..+ * All of the places which deal with restoring/unwrapping keys must also be+ * prepared to encounter an entry that does not have keys.+ */+ if ((protectable_target) && (protected_mount)) {+ struct cprotect *keyed_entry = NULL;++ if (cp->c_cpentry == NULL) {+ panic ("hfs_makenode: no cpentry for cnode (%p)", cp);+ }++ error = cp_generate_keys (hfsmp, cp, CP_CLASS(cp->c_cpentry->cp_pclass), keywrap_flags, &keyed_entry);+ if (error == 0) {+ /*+ * Upon success, the keys were generated and written out.+ * Update the cp pointer in the cnode.+ */+ cp_replace_entry (hfsmp, cp, keyed_entry);+ if (nocache) {+ cache_enter (dvp, tvp, cnp);+ }+ }+ else {+ /* If key creation OR the setxattr failed, emit EPERM to userland */+ error = EPERM;++ /*+ * Beware! This slightly violates the lock ordering for the+ * cnode/vnode 'tvp'. Ordinarily, you must acquire the truncate lock+ * which guards file size changes before acquiring the normal cnode lock+ * and calling hfs_removefile on an item.+ *+ * However, in this case, we are still holding the directory lock so+ * 'tvp' is not lookup-able and it was a newly created vnode so it+ * cannot have any content yet. The only reason we are initiating+ * the removefile is because we could not generate content protection keys+ * for this namespace item. Note also that we pass a '1' in the allow_dirs+ * argument for hfs_removefile because we may be creating a directory here.+ *+ * All this to say that while it is technically a violation it is+ * impossible to race with another thread for this cnode so it is safe.+ */+ int err = hfs_removefile (dvp, tvp, cnp, 0, 0, 1, NULL, 0);+ if (err) {+ printf("hfs_makenode: removefile failed (%d) for CP entry %p\n", err, tvp);+ }++ /* Release the cnode lock and mark the vnode for termination */+ hfs_unlock (cp);+ err = vnode_recycle (tvp);+ if (err) {+ printf("hfs_makenode: vnode_recycle failed (%d) for CP entry %p\n", err, tvp);+ }++ /* Drop the iocount on the new vnode to force reclamation/recycling */+ vnode_put (tvp);+ cp = NULL;+ *vpp = NULL;+ }+ }+#endif++#if QUOTA+ /*+ * Once we create this vnode, we need to initialize its quota data+ * structures, if necessary. We know that it is OK to just go ahead and+ * initialize because we've already validated earlier (through the hfs_quotacheck+ * function) to see if creating this cnode/vnode would cause us to go over quota.+ */+ if (hfsmp->hfs_flags & HFS_QUOTAS) {+ if (cp) {+ /* cp could have been zeroed earlier */+ (void) hfs_getinoquota(cp);+ }+ }+#endif++exit:+ cat_releasedesc(&out_desc);++#if CONFIG_PROTECT+ /*+ * We may have jumped here in error-handling various situations above.+ * If we haven't already dumped the temporary CP used to initialize+ * the file atomically, then free it now. cp_entry_destroy should null+ * out the pointer if it was called already.+ */+ if (entry) {+ cp_entry_destroy (hfsmp, entry);+ entry = NULL;+ }+#endif++ /*+ * Make sure we release cnode lock on dcp.+ */+ if (dcp) {+ dcp->c_flag &= ~C_DIR_MODIFICATION;+ wakeup((caddr_t)&dcp->c_flag);++ hfs_unlock(dcp);+ }+ ino64_t file_id = 0;+ if (error == 0 && cp != NULL) {+ file_id = cp->c_fileid;+ hfs_unlock(cp);+ }+ if (started_tr) {+ hfs_end_transaction(hfsmp);+ started_tr = 0;+ }++ if (old_doc_vp) {+ cnode_t *ocp = VTOC(old_doc_vp);+ hfs_lock_always(ocp, HFS_EXCLUSIVE_LOCK);+ struct FndrExtendedFileInfo *ofip = (struct FndrExtendedFileInfo *)((char *)&ocp->c_attr.ca_finderinfo + 16);++ const uint32_t doc_id = ofip->document_id;+ const ino64_t old_file_id = ocp->c_fileid;++ // printf("clearing doc-id from ino %d\n", ocp->c_desc.cd_cnid);+ ofip->document_id = 0;+ ocp->c_bsdflags &= ~UF_TRACKED;+ ocp->c_flag |= C_MODIFIED;++ hfs_unlock(ocp);+ vnode_put(old_doc_vp);++ add_fsevent(FSE_DOCID_CHANGED, vfs_context_current(),+ FSE_ARG_DEV, hfsmp->hfs_raw_dev,+ FSE_ARG_INO, old_file_id, // src inode #+ FSE_ARG_INO, file_id, // dst inode #+ FSE_ARG_INT32, doc_id,+ FSE_ARG_DONE);+ }++ return (error);+}+++/*+ * hfs_vgetrsrc acquires a resource fork vnode corresponding to the+ * cnode that is found in 'vp'. The cnode should be locked upon entry+ * and will be returned locked, but it may be dropped temporarily.+ *+ * If the resource fork vnode does not exist, HFS will attempt to acquire an+ * empty (uninitialized) vnode from VFS so as to avoid deadlocks with+ * jetsam. If we let the normal getnewvnode code produce the vnode for us+ * we would be doing so while holding the cnode lock of our cnode.+ *+ * On success, *rvpp wlll hold the resource fork vnode with an+ * iocount. *Don't* forget the vnode_put.+ */+int+hfs_vgetrsrc(struct hfsmount *hfsmp, struct vnode *vp, struct vnode **rvpp)+{+ struct vnode *rvp = NULLVP;+ struct vnode *empty_rvp = NULLVP;+ struct vnode *dvp = NULLVP;+ struct cnode *cp = VTOC(vp);+ int error;+ int vid;++ if (vnode_vtype(vp) == VDIR) {+ return EINVAL;+ }++restart:+ /* Attempt to use existing vnode */+ if ((rvp = cp->c_rsrc_vp)) {+ vid = vnode_vid(rvp);++ // vnode_getwithvid can block so we need to drop the cnode lock+ hfs_unlock(cp);++ error = vnode_getwithvid(rvp, vid);++ hfs_lock_always(cp, HFS_EXCLUSIVE_LOCK);++ /*+ * When our lock was relinquished, the resource fork+ * could have been recycled. Check for this and try+ * again.+ */+ if (error == ENOENT)+ goto restart;++ if (error) {+ const char * name = (const char *)VTOC(vp)->c_desc.cd_nameptr;++ if (name)+ printf("hfs_vgetrsrc: couldn't get resource"+ " fork for %s, vol=%s, err=%d\n", name, hfsmp->vcbVN, error);+ return (error);+ }+ } else {+ struct cat_fork rsrcfork;+ struct componentname cn;+ struct cat_desc *descptr = NULL;+ struct cat_desc to_desc;+ char delname[32];+ int lockflags;+ int newvnode_flags = 0;++ /*+ * In this case, we don't currently see a resource fork vnode attached+ * to this cnode. In most cases, we were called from a read-only VNOP+ * like getattr, so it should be safe to drop the cnode lock and then+ * re-acquire it.+ *+ * Here, we drop the lock so that we can acquire an empty/husk+ * vnode so that we don't deadlock against jetsam.+ *+ * It does not currently appear possible to hold the truncate lock via+ * FS re-entrancy when we get to this point. (8/2014)+ */+ hfs_unlock (cp);++ error = vnode_create_empty (&empty_rvp);++ hfs_lock_always (cp, HFS_EXCLUSIVE_LOCK);++ if (error) {+ /* If acquiring the 'empty' vnode failed, then nothing to clean up */+ return error;+ }++ /*+ * We could have raced with another thread here while we dropped our cnode+ * lock. See if the cnode now has a resource fork vnode and restart if appropriate.+ *+ * Note: We just released the cnode lock, so there is a possibility that the+ * cnode that we just acquired has been deleted or even removed from disk+ * completely, though this is unlikely. If the file is open-unlinked, the+ * check below will resolve it for us. If it has been completely+ * removed (even from the catalog!), then when we examine the catalog+ * directly, below, while holding the catalog lock, we will not find the+ * item and we can fail out properly.+ */+ if (cp->c_rsrc_vp) {+ /* Drop the empty vnode before restarting */+ vnode_put (empty_rvp);+ empty_rvp = NULL;+ rvp = NULL;+ goto restart;+ }++ /*+ * hfs_vgetsrc may be invoked for a cnode that has already been marked+ * C_DELETED. This is because we need to continue to provide rsrc+ * fork access to open-unlinked files. In this case, build a fake descriptor+ * like in hfs_removefile. If we don't do this, buildkey will fail in+ * cat_lookup because this cnode has no name in its descriptor.+ */+ if ((cp->c_flag & C_DELETED ) && (cp->c_desc.cd_namelen == 0)) {+ bzero (&to_desc, sizeof(to_desc));+ bzero (delname, 32);+ MAKE_DELETED_NAME(delname, sizeof(delname), cp->c_fileid);+ to_desc.cd_nameptr = (const u_int8_t*) delname;+ to_desc.cd_namelen = strlen(delname);+ to_desc.cd_parentcnid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid;+ to_desc.cd_flags = 0;+ to_desc.cd_cnid = cp->c_cnid;++ descptr = &to_desc;+ }+ else {+ descptr = &cp->c_desc;+ }+++ lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);++ /*+ * We call cat_idlookup (instead of cat_lookup) below because we can't+ * trust the descriptor in the provided cnode for lookups at this point.+ * Between the time of the original lookup of this vnode and now, the+ * descriptor could have gotten swapped or replaced. If this occurred,+ * the parent/name combo originally desired may not necessarily be provided+ * if we use the descriptor. Even worse, if the vnode represents+ * a hardlink, we could have removed one of the links from the namespace+ * but left the descriptor alone, since hfs_unlink does not invalidate+ * the descriptor in the cnode if other links still point to the inode.+ *+ * Consider the following (slightly contrived) scenario:+ * /tmp/a <--> /tmp/b (hardlinks).+ * 1. Thread A: open rsrc fork on /tmp/b.+ * 1a. Thread A: does lookup, goes out to lunch right before calling getnamedstream.+ * 2. Thread B does 'mv /foo/b /tmp/b'+ * 2. Thread B succeeds.+ * 3. Thread A comes back and wants rsrc fork info for /tmp/b.+ *+ * Even though the hardlink backing /tmp/b is now eliminated, the descriptor+ * is not removed/updated during the unlink process. So, if you were to+ * do a lookup on /tmp/b, you'd acquire an entirely different record's resource+ * fork.+ *+ * As a result, we use the fileid, which should be invariant for the lifetime+ * of the cnode (possibly barring calls to exchangedata).+ *+ * Addendum: We can't do the above for HFS standard since we aren't guaranteed to+ * have thread records for files. They were only required for directories. So+ * we need to do the lookup with the catalog name. This is OK since hardlinks were+ * never allowed on HFS standard.+ */++ /* Get resource fork data */+ error = cat_idlookup (hfsmp, cp->c_fileid, 0, 1, NULL, NULL, &rsrcfork);++ hfs_systemfile_unlock(hfsmp, lockflags);+ if (error) {+ /* Drop our 'empty' vnode ! */+ vnode_put (empty_rvp);+ return (error);+ }+ /*+ * Supply hfs_getnewvnode with a component name.+ */+ cn.cn_pnbuf = NULL;+ if (descptr->cd_nameptr) {+ void *buf = hfs_malloc_data(MAXPATHLEN);++ cn = (struct componentname){+ .cn_nameiop = LOOKUP,+ .cn_flags = ISLASTCN,+ .cn_pnlen = MAXPATHLEN,+ .cn_pnbuf = buf,+ .cn_nameptr = buf,+ .cn_namelen = snprintf(buf, MAXPATHLEN,+ "%s%s", descptr->cd_nameptr,+ _PATH_RSRCFORKSPEC)+ };++ // Should never happen because cn.cn_nameptr won't ever be long...+ if (cn.cn_namelen >= MAXPATHLEN) {+ hfs_free_data(buf, MAXPATHLEN);+ /* Drop our 'empty' vnode ! */+ vnode_put (empty_rvp);+ return ENAMETOOLONG;++ }+ }+ dvp = vnode_getparent(vp);++ /*+ * We are about to call hfs_getnewvnode and pass in the vnode that we acquired+ * earlier when we were not holding any locks. The semantics of GNV_USE_VP require that+ * either hfs_getnewvnode consume the vnode and vend it back to us, properly initialized,+ * or it will consume/dispose of it properly if it errors out.+ */+ rvp = empty_rvp;++ error = hfs_getnewvnode(hfsmp, dvp, cn.cn_pnbuf ? &cn : NULL,+ descptr, (GNV_WANTRSRC | GNV_SKIPLOCK | GNV_USE_VP),+ &cp->c_attr, &rsrcfork, &rvp, &newvnode_flags);++ if (dvp)+ vnode_put(dvp);+ hfs_free_data(cn.cn_pnbuf, MAXPATHLEN);+ if (error)+ return (error);+ } /* End 'else' for rsrc fork not existing */++ *rvpp = rvp;+ return (0);+}++/*+ * Wrapper for special device reads+ */+int+hfsspec_read(struct vnop_read_args *ap)+{+ /*+ * Set access flag.+ */+ cnode_t *cp = VTOC(ap->a_vp);++ if (cp)+ cp->c_touch_acctime = TRUE;++ return spec_read(ap);+}++/*+ * Wrapper for special device writes+ */+int+hfsspec_write(struct vnop_write_args *ap)+{+ /*+ * Set update and change flags.+ */+ cnode_t *cp = VTOC(ap->a_vp);++ if (cp) {+ cp->c_touch_chgtime = TRUE;+ cp->c_touch_modtime = TRUE;+ }++ return spec_write(ap);+}++/*+ * Wrapper for special device close+ *+ * Update the times on the cnode then do device close.+ */+int+hfsspec_close(struct vnop_close_args *ap)+{+ struct vnode *vp = ap->a_vp;+ cnode_t *cp = VTOC(vp);++ if (cp && vnode_isinuse(ap->a_vp, 0)) {+ if (hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) == 0) {+ hfs_touchtimes(VTOHFS(vp), cp);+ hfs_unlock(cp);+ }+ }+ return spec_close(ap);+}++#if FIFO+/*+ * Wrapper for fifo reads+ */+static int+hfsfifo_read(struct vnop_read_args *ap)+{+ /*+ * Set access flag.+ */+ VTOC(ap->a_vp)->c_touch_acctime = TRUE;+ return fifo_read(ap);+}++/*+ * Wrapper for fifo writes+ */+static int+hfsfifo_write(struct vnop_write_args *ap)+{+ /*+ * Set update and change flags.+ */+ VTOC(ap->a_vp)->c_touch_chgtime = TRUE;+ VTOC(ap->a_vp)->c_touch_modtime = TRUE;+ return fifo_write(ap);+}++/*+ * Wrapper for fifo close+ *+ * Update the times on the cnode then do device close.+ */+static int+hfsfifo_close(struct vnop_close_args *ap)+{+ struct vnode *vp = ap->a_vp;+ struct cnode *cp;++ if (vnode_isinuse(ap->a_vp, 1)) {+ if (hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) == 0) {+ cp = VTOC(vp);+ hfs_touchtimes(VTOHFS(vp), cp);+ hfs_unlock(cp);+ }+ }+ return fifo_close(ap);+}+++#endif /* FIFO */++/*+ * Getter for the document_id+ * the document_id is stored in FndrExtendedFileInfo/FndrExtendedDirInfo+ */+static u_int32_t+hfs_get_document_id_internal(const uint8_t *finderinfo, mode_t mode)+{+ const uint8_t *finfo = NULL;+ u_int32_t doc_id = 0;++ /* overlay the FinderInfo to the correct pointer, and advance */+ finfo = finderinfo + 16;++ if (S_ISDIR(mode) || S_ISREG(mode)) {+ const struct FndrExtendedFileInfo *extinfo = (const struct FndrExtendedFileInfo *)finfo;+ doc_id = extinfo->document_id;+ }++ return doc_id;+}+++/* getter(s) for document id */+u_int32_t+hfs_get_document_id(struct cnode *cp)+{+ return (hfs_get_document_id_internal((u_int8_t*)cp->c_finderinfo,+ cp->c_attr.ca_mode));+}++/* If you have finderinfo and mode, you can use this */+u_int32_t+hfs_get_document_id_from_blob(const uint8_t *finderinfo, mode_t mode)+{+ return (hfs_get_document_id_internal(finderinfo, mode));+}++/*+ * Synchronize a file's in-core state with that on disk.+ */+int+hfs_vnop_fsync(struct vnop_fsync_args *ap)+{+ struct vnode* vp = ap->a_vp;+ int error;++ /* Note: We check hfs flags instead of vfs mount flag because during+ * read-write update, hfs marks itself read-write much earlier than+ * the vfs, and hence won't result in skipping of certain writes like+ * zero'ing out of unused nodes, creation of hotfiles btree, etc.+ */+ if (VTOHFS(vp)->hfs_flags & HFS_READ_ONLY) {+ return 0;+ }++ /*+ * No need to call cp_handle_vnop to resolve fsync(). Any dirty data+ * should have caused the keys to be unwrapped at the time the data was+ * put into the UBC, either at mmap/pagein/read-write. If we did manage+ * to let this by, then strategy will auto-resolve for us.+ *+ * We also need to allow ENOENT lock errors since unlink+ * system call can call VNOP_FSYNC during vclean.+ */+ error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ if (error)+ return (0);++ error = hfs_fsync(vp, ap->a_waitfor, 0, vfs_context_proc(ap->a_context));++ hfs_unlock(VTOC(vp));+ return (error);+}++int (**hfs_vnodeop_p)(void *);++#define VOPFUNC int (*)(void *)++/* VNOP table for HFS+ */+const struct vnodeopv_entry_desc hfs_vnodeop_entries[] = {+ { &vnop_default_desc, (VOPFUNC)vn_default_error },+ { &vnop_lookup_desc, (VOPFUNC)hfs_vnop_lookup }, /* lookup */+ { &vnop_create_desc, (VOPFUNC)hfs_vnop_create }, /* create */+ { &vnop_mknod_desc, (VOPFUNC)hfs_vnop_mknod }, /* mknod */+ { &vnop_open_desc, (VOPFUNC)hfs_vnop_open }, /* open */+ { &vnop_close_desc, (VOPFUNC)hfs_vnop_close }, /* close */+ { &vnop_getattr_desc, (VOPFUNC)hfs_vnop_getattr }, /* getattr */+ { &vnop_setattr_desc, (VOPFUNC)hfs_vnop_setattr }, /* setattr */+ { &vnop_read_desc, (VOPFUNC)hfs_vnop_read }, /* read */+ { &vnop_write_desc, (VOPFUNC)hfs_vnop_write }, /* write */+ { &vnop_ioctl_desc, (VOPFUNC)hfs_vnop_ioctl }, /* ioctl */+ { &vnop_select_desc, (VOPFUNC)hfs_vnop_select }, /* select */+ { &vnop_revoke_desc, (VOPFUNC)nop_revoke }, /* revoke */+ { &vnop_exchange_desc, (VOPFUNC)hfs_vnop_exchange }, /* exchange */+ { &vnop_mmap_desc, (VOPFUNC)hfs_vnop_mmap }, /* mmap */+ { &vnop_fsync_desc, (VOPFUNC)hfs_vnop_fsync }, /* fsync */+ { &vnop_remove_desc, (VOPFUNC)hfs_vnop_remove }, /* remove */+ { &vnop_link_desc, (VOPFUNC)hfs_vnop_link }, /* link */+ { &vnop_rename_desc, (VOPFUNC)hfs_vnop_rename }, /* rename */+ { &vnop_renamex_desc, (VOPFUNC)hfs_vnop_renamex }, /* renamex (with flags) */+ { &vnop_mkdir_desc, (VOPFUNC)hfs_vnop_mkdir }, /* mkdir */+ { &vnop_rmdir_desc, (VOPFUNC)hfs_vnop_rmdir }, /* rmdir */+ { &vnop_symlink_desc, (VOPFUNC)hfs_vnop_symlink }, /* symlink */+ { &vnop_readdir_desc, (VOPFUNC)hfs_vnop_readdir }, /* readdir */+ { &vnop_readdirattr_desc, (VOPFUNC)hfs_vnop_readdirattr }, /* readdirattr */+ { &vnop_readlink_desc, (VOPFUNC)hfs_vnop_readlink }, /* readlink */+ { &vnop_inactive_desc, (VOPFUNC)hfs_vnop_inactive }, /* inactive */+ { &vnop_reclaim_desc, (VOPFUNC)hfs_vnop_reclaim }, /* reclaim */+ { &vnop_strategy_desc, (VOPFUNC)hfs_vnop_strategy }, /* strategy */+ { &vnop_pathconf_desc, (VOPFUNC)hfs_vnop_pathconf }, /* pathconf */+ { &vnop_advlock_desc, (VOPFUNC)err_advlock }, /* advlock */+ { &vnop_allocate_desc, (VOPFUNC)hfs_vnop_allocate }, /* allocate */+#if CONFIG_SEARCHFS+ { &vnop_searchfs_desc, (VOPFUNC)hfs_vnop_search }, /* search fs */+#else+ { &vnop_searchfs_desc, (VOPFUNC)err_searchfs }, /* search fs */+#endif+ { &vnop_bwrite_desc, (VOPFUNC)hfs_vnop_bwrite }, /* bwrite */+ { &vnop_pagein_desc, (VOPFUNC)hfs_vnop_pagein }, /* pagein */+ { &vnop_pageout_desc,(VOPFUNC) hfs_vnop_pageout }, /* pageout */+ { &vnop_copyfile_desc, (VOPFUNC)err_copyfile }, /* copyfile */+ { &vnop_blktooff_desc, (VOPFUNC)hfs_vnop_blktooff }, /* blktooff */+ { &vnop_offtoblk_desc, (VOPFUNC)hfs_vnop_offtoblk }, /* offtoblk */+ { &vnop_blockmap_desc, (VOPFUNC)hfs_vnop_blockmap }, /* blockmap */+ { &vnop_getxattr_desc, (VOPFUNC)hfs_vnop_getxattr},+ { &vnop_setxattr_desc, (VOPFUNC)hfs_vnop_setxattr},+ { &vnop_removexattr_desc, (VOPFUNC)hfs_vnop_removexattr},+ { &vnop_listxattr_desc, (VOPFUNC)hfs_vnop_listxattr},+#if NAMEDSTREAMS+ { &vnop_getnamedstream_desc, (VOPFUNC)hfs_vnop_getnamedstream },+ { &vnop_makenamedstream_desc, (VOPFUNC)hfs_vnop_makenamedstream },+ { &vnop_removenamedstream_desc, (VOPFUNC)hfs_vnop_removenamedstream },+#endif+ { &vnop_getattrlistbulk_desc, (VOPFUNC)hfs_vnop_getattrlistbulk }, /* getattrlistbulk */+ { &vnop_mnomap_desc, (VOPFUNC)hfs_vnop_mnomap },+ { NULL, (VOPFUNC)NULL }+};++const struct vnodeopv_desc hfs_vnodeop_opv_desc =+{ &hfs_vnodeop_p, hfs_vnodeop_entries };+++/* Spec Op vnop table for HFS+ */+int (**hfs_specop_p)(void *);+const struct vnodeopv_entry_desc hfs_specop_entries[] = {+ { &vnop_default_desc, (VOPFUNC)vn_default_error },+ { &vnop_lookup_desc, (VOPFUNC)spec_lookup }, /* lookup */+ { &vnop_create_desc, (VOPFUNC)spec_create }, /* create */+ { &vnop_mknod_desc, (VOPFUNC)spec_mknod }, /* mknod */+ { &vnop_open_desc, (VOPFUNC)spec_open }, /* open */+ { &vnop_close_desc, (VOPFUNC)hfsspec_close }, /* close */+ { &vnop_getattr_desc, (VOPFUNC)hfs_vnop_getattr }, /* getattr */+ { &vnop_setattr_desc, (VOPFUNC)hfs_vnop_setattr }, /* setattr */+ { &vnop_read_desc, (VOPFUNC)hfsspec_read }, /* read */+ { &vnop_write_desc, (VOPFUNC)hfsspec_write }, /* write */+ { &vnop_ioctl_desc, (VOPFUNC)spec_ioctl }, /* ioctl */+ { &vnop_select_desc, (VOPFUNC)spec_select }, /* select */+ { &vnop_revoke_desc, (VOPFUNC)spec_revoke }, /* revoke */+ { &vnop_mmap_desc, (VOPFUNC)spec_mmap }, /* mmap */+ { &vnop_fsync_desc, (VOPFUNC)hfs_vnop_fsync }, /* fsync */+ { &vnop_remove_desc, (VOPFUNC)spec_remove }, /* remove */+ { &vnop_link_desc, (VOPFUNC)spec_link }, /* link */+ { &vnop_rename_desc, (VOPFUNC)spec_rename }, /* rename */+ { &vnop_mkdir_desc, (VOPFUNC)spec_mkdir }, /* mkdir */+ { &vnop_rmdir_desc, (VOPFUNC)spec_rmdir }, /* rmdir */+ { &vnop_symlink_desc, (VOPFUNC)spec_symlink }, /* symlink */+ { &vnop_readdir_desc, (VOPFUNC)spec_readdir }, /* readdir */+ { &vnop_readlink_desc, (VOPFUNC)spec_readlink }, /* readlink */+ { &vnop_inactive_desc, (VOPFUNC)hfs_vnop_inactive }, /* inactive */+ { &vnop_reclaim_desc, (VOPFUNC)hfs_vnop_reclaim }, /* reclaim */+ { &vnop_strategy_desc, (VOPFUNC)spec_strategy }, /* strategy */+ { &vnop_pathconf_desc, (VOPFUNC)spec_pathconf }, /* pathconf */+ { &vnop_advlock_desc, (VOPFUNC)err_advlock }, /* advlock */+ { &vnop_bwrite_desc, (VOPFUNC)hfs_vnop_bwrite },+ { &vnop_pagein_desc, (VOPFUNC)hfs_vnop_pagein }, /* Pagein */+ { &vnop_pageout_desc, (VOPFUNC)hfs_vnop_pageout }, /* Pageout */+ { &vnop_copyfile_desc, (VOPFUNC)err_copyfile }, /* copyfile */+ { &vnop_blktooff_desc, (VOPFUNC)hfs_vnop_blktooff }, /* blktooff */+ { &vnop_offtoblk_desc, (VOPFUNC)hfs_vnop_offtoblk }, /* offtoblk */+ { &vnop_getxattr_desc, (VOPFUNC)hfs_vnop_getxattr},+ { &vnop_setxattr_desc, (VOPFUNC)hfs_vnop_setxattr},+ { &vnop_removexattr_desc, (VOPFUNC)hfs_vnop_removexattr},+ { &vnop_listxattr_desc, (VOPFUNC)hfs_vnop_listxattr},+ { (struct vnodeop_desc*)NULL, (VOPFUNC)NULL }+};+const struct vnodeopv_desc hfs_specop_opv_desc =+ { &hfs_specop_p, hfs_specop_entries };++#if FIFO+/* HFS+ FIFO VNOP table */+int (**hfs_fifoop_p)(void *);+const struct vnodeopv_entry_desc hfs_fifoop_entries[] = {+ { &vnop_default_desc, (VOPFUNC)vn_default_error },+ { &vnop_lookup_desc, (VOPFUNC)fifo_lookup }, /* lookup */+ { &vnop_create_desc, (VOPFUNC)fifo_create }, /* create */+ { &vnop_mknod_desc, (VOPFUNC)fifo_mknod }, /* mknod */+ { &vnop_open_desc, (VOPFUNC)fifo_open }, /* open */+ { &vnop_close_desc, (VOPFUNC)hfsfifo_close }, /* close */+ { &vnop_getattr_desc, (VOPFUNC)hfs_vnop_getattr }, /* getattr */+ { &vnop_setattr_desc, (VOPFUNC)hfs_vnop_setattr }, /* setattr */+ { &vnop_read_desc, (VOPFUNC)hfsfifo_read }, /* read */+ { &vnop_write_desc, (VOPFUNC)hfsfifo_write }, /* write */+ { &vnop_ioctl_desc, (VOPFUNC)fifo_ioctl }, /* ioctl */+ { &vnop_select_desc, (VOPFUNC)fifo_select }, /* select */+ { &vnop_revoke_desc, (VOPFUNC)fifo_revoke }, /* revoke */+ { &vnop_mmap_desc, (VOPFUNC)fifo_mmap }, /* mmap */+ { &vnop_fsync_desc, (VOPFUNC)hfs_vnop_fsync }, /* fsync */+ { &vnop_remove_desc, (VOPFUNC)fifo_remove }, /* remove */+ { &vnop_link_desc, (VOPFUNC)fifo_link }, /* link */+ { &vnop_rename_desc, (VOPFUNC)fifo_rename }, /* rename */+ { &vnop_mkdir_desc, (VOPFUNC)fifo_mkdir }, /* mkdir */+ { &vnop_rmdir_desc, (VOPFUNC)fifo_rmdir }, /* rmdir */+ { &vnop_symlink_desc, (VOPFUNC)fifo_symlink }, /* symlink */+ { &vnop_readdir_desc, (VOPFUNC)fifo_readdir }, /* readdir */+ { &vnop_readlink_desc, (VOPFUNC)fifo_readlink }, /* readlink */+ { &vnop_inactive_desc, (VOPFUNC)hfs_vnop_inactive }, /* inactive */+ { &vnop_reclaim_desc, (VOPFUNC)hfs_vnop_reclaim }, /* reclaim */+ { &vnop_strategy_desc, (VOPFUNC)fifo_strategy }, /* strategy */+ { &vnop_pathconf_desc, (VOPFUNC)fifo_pathconf }, /* pathconf */+ { &vnop_advlock_desc, (VOPFUNC)err_advlock }, /* advlock */+ { &vnop_bwrite_desc, (VOPFUNC)hfs_vnop_bwrite },+ { &vnop_pagein_desc, (VOPFUNC)hfs_vnop_pagein }, /* Pagein */+ { &vnop_pageout_desc, (VOPFUNC)hfs_vnop_pageout }, /* Pageout */+ { &vnop_copyfile_desc, (VOPFUNC)err_copyfile }, /* copyfile */+ { &vnop_blktooff_desc, (VOPFUNC)hfs_vnop_blktooff }, /* blktooff */+ { &vnop_offtoblk_desc, (VOPFUNC)hfs_vnop_offtoblk }, /* offtoblk */+ { &vnop_blockmap_desc, (VOPFUNC)hfs_vnop_blockmap }, /* blockmap */+ { &vnop_getxattr_desc, (VOPFUNC)hfs_vnop_getxattr},+ { &vnop_setxattr_desc, (VOPFUNC)hfs_vnop_setxattr},+ { &vnop_removexattr_desc, (VOPFUNC)hfs_vnop_removexattr},+ { &vnop_listxattr_desc, (VOPFUNC)hfs_vnop_listxattr},+ { (struct vnodeop_desc*)NULL, (VOPFUNC)NULL }+};+const struct vnodeopv_desc hfs_fifoop_opv_desc =+ { &hfs_fifoop_p, hfs_fifoop_entries };+#endif /* FIFO */diff --git a/xnu/files/bsd/hfs/hfs_xattr.c b/xnu/files/bsd/hfs/hfs_xattr.cnew file mode 100644index 0000000..a244114--- /dev/null+++ b/xnu/files/bsd/hfs/hfs_xattr.c@@ -0,0 +1,3413 @@+/*+ * Copyright (c) 2004-2020 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@+ */++#include <sys/param.h>+#include <sys/systm.h>+#include <sys/kernel.h>+#include <sys/malloc.h>+#include <sys/ubc.h>+#include <sys/utfconv.h>+#include <sys/vnode.h>+#include <sys/xattr.h>+#include <sys/fcntl.h>+#include <sys/fsctl.h>+#include <sys/kauth.h>++#include "hfs.h"+#include "hfs_cnode.h"+#include "hfs_mount.h"+#include "hfs_format.h"+#include "hfs_endian.h"+#include "hfs_btreeio.h"+#include "hfs_fsctl.h"+#include "hfs_cprotect.h"++#include "BTreesInternal.h"++#define HFS_XATTR_VERBOSE 0++#define ATTRIBUTE_FILE_NODE_SIZE 8192+++/* State information for the listattr_callback callback function. */+struct listattr_callback_state {+ u_int32_t fileID;+ int result;+ uio_t uio;+ size_t size;+#if HFS_COMPRESSION+ int showcompressed;+ vfs_context_t ctx;+ vnode_t vp;+#endif /* HFS_COMPRESSION */+};+++/* HFS Internal Names */+#define XATTR_XATTREXTENTS_NAME "system.xattrextents"++static u_int32_t emptyfinfo[8] = {0};++static int hfs_zero_hidden_fields (struct cnode *cp, u_int8_t *finderinfo);++const char hfs_attrdatafilename[] = "Attribute Data";++static int listattr_callback(const HFSPlusAttrKey *key, const HFSPlusAttrData *data,+ struct listattr_callback_state *state);++static int remove_attribute_records(struct hfsmount *hfsmp, BTreeIterator * iterator);++static int getnodecount(struct hfsmount *hfsmp, size_t nodesize);++static size_t getmaxinlineattrsize(struct vnode * attrvp);++static int read_attr_data(struct hfsmount *hfsmp, uio_t uio, size_t datasize, HFSPlusExtentDescriptor *extents);++static int write_attr_data(struct hfsmount *hfsmp, uio_t uio, size_t datasize, HFSPlusExtentDescriptor *extents);++static int alloc_attr_blks(struct hfsmount *hfsmp, size_t attrsize, size_t extentbufsize, HFSPlusExtentDescriptor *extents, int *blocks);++static void free_attr_blks(struct hfsmount *hfsmp, int blkcnt, HFSPlusExtentDescriptor *extents);++static int has_overflow_extents(HFSPlusForkData *forkdata);++static int count_extent_blocks(int maxblks, HFSPlusExtentRecord extents);++#if NEW_XATTR++/*+ * Iterator over set bits within an xattr free fext bitmap.+ *+ * See xbm_make_iter() for details on creation.+ */+typedef struct {+ const uint64_t *bitmap;+ size_t i;+ size_t len;+} xbm_iter_t;++// xattr IO subsystem assertion+#define xattr_assert(cond) if(!(cond)) do { \+ panic("xattr_assert() failed: %s",#cond); \+} while(0)++#define xattr_infomsg(...) // errmsg(__VA_ARGS__)++/*+ * Purely for documentation purposes, simulate C++ const_cast<>() in the C+ * language.+ * This makes it quite obvious that the `const' part of a cast is being removed+ * to workaround an api that accepts a non-const pointer but otherwise has no+ * reason to modify its value.+ * E.g.+ *+ * ancient_sum(a, count)+ * int *a; int count;+ * {+ * int s;+ * s = 0;+ * while (count--) {+ * s = s + a[i];+ * }+ * return s;+ * }+ *+ * int modern_sum(const int *a, int count) {+ * return ancient_sum(const_cast(int *, a), count);+ * }+ */+#define const_cast(type, expr) ((type)(expr))++static uint64_t fext2cluster(const HFSPlusExtentDescriptor *fext, uint32_t fs_bsize);+static bool cluster_off_in_fext(uint64_t off, const HFSPlusExtentDescriptor *fext,+ uint32_t fs_bsize);++static bool fext2cluster_check(const HFSPlusExtentDescriptor *fext, uint32_t fs_bsize,+ uint64_t *out);+static uint32_t xattr_cluster_scale(uint32_t fs_bsize);++// xattr fext thread local storage routines+static const HFSPlusExtentDescriptor **_Nullable xattr_fext_alloc(+ xattr_io_info_t *info) __attribute__((warn_unused_result));+static void xattr_fext_free(xattr_io_info_t *info,+ const HFSPlusExtentDescriptor **xfext);+static void xattr_fext_set(xattr_io_info_t *info,+ const HFSPlusExtentDescriptor **xfext, const HFSPlusExtentDescriptor *fext);+static void xattr_fext_clear(xattr_io_info_t *info,+ const HFSPlusExtentDescriptor **xfext);++static size_t xattr_fext_index(const xattr_io_info_t *info,+ const HFSPlusExtentDescriptor **xfext);++// xattr fext free bitmap routines, namespace `xbm_'+static bool xbm_find_free(const xattr_io_info_t *info, size_t *out);+static void xbm_set_used(xattr_io_info_t *info, size_t i);+static void xbm_clear_used(xattr_io_info_t *info, size_t i);++static bool xbm_valid_index(const xattr_io_info_t *info, int64_t i);+static size_t xbm_size(const xattr_io_info_t *info);++// bitmap iterator functions+static xbm_iter_t xbm_make_iter(const uint64_t *bitmap, size_t len);+static bool xbm_iter_next(xbm_iter_t *ier);+static size_t xbm_iter_peek(const xbm_iter_t *ier);++// bitmap_ wrappers under namespace bm_+static bool bm_find(const uint64_t *bm,+ size_t from, size_t len, bool value, size_t *out);+static bool bm_valid_index(int64_t i, size_t len);+#endif++#if NAMEDSTREAMS+/*+ * Obtain the vnode for a stream.+ */+int+hfs_vnop_getnamedstream(struct vnop_getnamedstream_args* ap)+{+ vnode_t vp = ap->a_vp;+ vnode_t *svpp = ap->a_svpp;+ struct cnode *cp;+ int error = 0;++ *svpp = NULL;++ /*+ * We only support the "com.apple.ResourceFork" stream.+ */+ if (strcmp(ap->a_name, XATTR_RESOURCEFORK_NAME) != 0) {+ return (ENOATTR);+ }+ cp = VTOC(vp);+ if ( !S_ISREG(cp->c_mode) ) {+ return (EPERM);+ }+#if HFS_COMPRESSION+ int hide_rsrc = hfs_hides_rsrc(ap->a_context, VTOC(vp), 1);+#endif /* HFS_COMPRESSION */+ if ((error = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ return (error);+ }+ if ((!hfs_has_rsrc(cp)+#if HFS_COMPRESSION+ || hide_rsrc+#endif /* HFS_COMPRESSION */+ ) && (ap->a_operation != NS_OPEN)) {+ hfs_unlock(cp);+ return (ENOATTR);+ }+ error = hfs_vgetrsrc(VTOHFS(vp), vp, svpp);+ hfs_unlock(cp);++ return (error);+}++/*+ * Create a stream.+ */+int+hfs_vnop_makenamedstream(struct vnop_makenamedstream_args* ap)+{+ vnode_t vp = ap->a_vp;+ vnode_t *svpp = ap->a_svpp;+ struct cnode *cp;+ int error = 0;++ *svpp = NULL;++ /*+ * We only support the "com.apple.ResourceFork" stream.+ */+ if (strcmp(ap->a_name, XATTR_RESOURCEFORK_NAME) != 0) {+ return (ENOATTR);+ }+ cp = VTOC(vp);+ if ( !S_ISREG(cp->c_mode) ) {+ return (EPERM);+ }+#if HFS_COMPRESSION+ if (hfs_hides_rsrc(ap->a_context, VTOC(vp), 1)) {+ if (VNODE_IS_RSRC(vp)) {+ return EINVAL;+ } else {+ error = decmpfs_decompress_file(vp, VTOCMP(vp), -1, 1, 0);+ if (error != 0)+ return error;+ }+ }+#endif /* HFS_COMPRESSION */+ if ((error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ return (error);+ }+ error = hfs_vgetrsrc(VTOHFS(vp), vp, svpp);+ hfs_unlock(cp);++ return (error);+}++/*+ * Remove a stream.+ */+int+hfs_vnop_removenamedstream(struct vnop_removenamedstream_args* ap)+{+ vnode_t svp = ap->a_svp;+ cnode_t *scp = VTOC(svp);+ int error = 0;++ /*+ * We only support the "com.apple.ResourceFork" stream.+ */+ if (strcmp(ap->a_name, XATTR_RESOURCEFORK_NAME) != 0) {+ return (ENOATTR);+ }+#if HFS_COMPRESSION+ if (hfs_hides_rsrc(ap->a_context, scp, 1)) {+ /* do nothing */+ return 0;+ }+#endif /* HFS_COMPRESSION */++ hfs_lock_truncate(scp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ if (VTOF(svp)->ff_size) {+ // hfs_truncate will deal with the cnode lock+ error = hfs_truncate(svp, 0, IO_NDELAY, 0, ap->a_context);+ }+ hfs_unlock_truncate(scp, HFS_LOCK_DEFAULT);++ return error;+}+#endif+++/* Zero out the date added field for the specified cnode */+static int hfs_zero_hidden_fields (struct cnode *cp, u_int8_t *finderinfo)+{+ u_int8_t *finfo = finderinfo;++ /* Advance finfo by 16 bytes to the 2nd half of the finderinfo */+ finfo = finfo + 16;++ if (S_ISREG(cp->c_attr.ca_mode) || S_ISLNK(cp->c_attr.ca_mode)) {+ struct FndrExtendedFileInfo *extinfo = (struct FndrExtendedFileInfo *)finfo;+ extinfo->document_id = 0;+ extinfo->date_added = 0;+ extinfo->write_gen_counter = 0;+ } else if (S_ISDIR(cp->c_attr.ca_mode)) {+ struct FndrExtendedDirInfo *extinfo = (struct FndrExtendedDirInfo *)finfo;+ extinfo->document_id = 0;+ extinfo->date_added = 0;+ extinfo->write_gen_counter = 0;+ } else {+ /* Return an error */+ return -1;+ }+ return 0;++}++/*+ * Retrieve the data of an extended attribute.+ */+int+hfs_vnop_getxattr(struct vnop_getxattr_args *ap)+/*+ struct vnop_getxattr_args {+ struct vnodeop_desc *a_desc;+ vnode_t a_vp;+ char * a_name;+ uio_t a_uio;+ size_t *a_size;+ int a_options;+ vfs_context_t a_context;+ };+*/+{+ struct vnode *vp = ap->a_vp;+ struct cnode *cp;+ struct hfsmount *hfsmp;+ uio_t uio = ap->a_uio;+ size_t bufsize;+ int result;++ cp = VTOC(vp);+ if (vp == cp->c_vp) {+#if HFS_COMPRESSION+ int decmpfs_hide = hfs_hides_xattr(ap->a_context, VTOC(vp), ap->a_name, 1); /* 1 == don't take the cnode lock */+ if (decmpfs_hide && !(ap->a_options & XATTR_SHOWCOMPRESSION))+ return ENOATTR;+#endif /* HFS_COMPRESSION */++ /* Get the Finder Info. */+ if (strcmp(ap->a_name, XATTR_FINDERINFO_NAME) == 0) {+ u_int8_t finderinfo[32];+ bufsize = 32;++ if ((result = hfs_lock(cp, HFS_SHARED_LOCK, HFS_LOCK_DEFAULT))) {+ return (result);+ }+ /* Make a copy since we may not export all of it. */+ bcopy(cp->c_finderinfo, finderinfo, sizeof(finderinfo));+ hfs_unlock(cp);++ /* Zero out the date added field in the local copy */+ hfs_zero_hidden_fields (cp, finderinfo);++ /* Don't expose a symlink's private type/creator. */+ if (vnode_islnk(vp)) {+ struct FndrFileInfo *fip;++ fip = (struct FndrFileInfo *)&finderinfo;+ fip->fdType = 0;+ fip->fdCreator = 0;+ }+ /* If Finder Info is empty then it doesn't exist. */+ if (bcmp(finderinfo, emptyfinfo, sizeof(emptyfinfo)) == 0) {+ return (ENOATTR);+ }+ if (uio == NULL) {+ *ap->a_size = bufsize;+ return (0);+ }+ if ((user_size_t)uio_resid(uio) < bufsize)+ return (ERANGE);++ result = uiomove((caddr_t)&finderinfo , bufsize, uio);++ return (result);+ }+ /* Read the Resource Fork. */+ if (strcmp(ap->a_name, XATTR_RESOURCEFORK_NAME) == 0) {+ struct vnode *rvp = NULL;+ int openunlinked = 0;+ int namelen = 0;++ if ( !S_ISREG(cp->c_mode) ) {+ return (EPERM);+ }+ if ((result = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ return (result);+ }+ namelen = cp->c_desc.cd_namelen;++ if (!hfs_has_rsrc(cp)) {+ hfs_unlock(cp);+ return (ENOATTR);+ }+ hfsmp = VTOHFS(vp);+ if ((cp->c_flag & C_DELETED) && (namelen == 0)) {+ openunlinked = 1;+ }++ result = hfs_vgetrsrc(hfsmp, vp, &rvp);+ hfs_unlock(cp);+ if (result) {+ return (result);+ }+ if (uio == NULL) {+ *ap->a_size = (size_t)VTOF(rvp)->ff_size;+ } else {+#if HFS_COMPRESSION+ user_ssize_t uio_size = 0;+ if (decmpfs_hide)+ uio_size = uio_resid(uio);+#endif /* HFS_COMPRESSION */+ result = VNOP_READ(rvp, uio, 0, ap->a_context);+#if HFS_COMPRESSION+ if (decmpfs_hide &&+ (result == 0) &&+ (uio_resid(uio) == uio_size)) {+ /*+ * We intentionally make the above call to VNOP_READ so that+ * it can return an authorization/permission/etc. Error+ * based on ap->a_context and thus deny this operation;+ * in that case, result != 0 and we won't proceed.+ *+ * However, if result == 0, it will have returned no data+ * because hfs_vnop_read hid the resource fork+ * (hence uio_resid(uio) == uio_size, i.e. the uio is untouched)+ *+ * In that case, we try again with the decmpfs_ctx context+ * to get the actual data+ */+ result = VNOP_READ(rvp, uio, 0, decmpfs_ctx);+ }+#endif /* HFS_COMPRESSION */+ }+ /* force the rsrc fork vnode to recycle right away */+ if (openunlinked) {+ int vref;+ vref = vnode_ref (rvp);+ if (vref == 0) {+ vnode_rele (rvp);+ }+ vnode_recycle(rvp);+ }+ vnode_put(rvp);+ return (result);+ }+ }+ hfsmp = VTOHFS(vp);++ if ((result = hfs_lock(cp, HFS_SHARED_LOCK, HFS_LOCK_DEFAULT))) {+ return (result);+ }++ /* Check for non-rsrc, non-finderinfo EAs */+ result = hfs_getxattr_internal (cp, ap, VTOHFS(cp->c_vp), 0);++ hfs_unlock(cp);++ return MacToVFSError(result);+}++// Has same limitations as hfs_getxattr_internal below+int hfs_xattr_read(vnode_t vp, const char *name, void *data, size_t *size)+{+ uio_t uio = uio_create(1, 0, UIO_SYSSPACE, UIO_READ);++ uio_addiov(uio, CAST_USER_ADDR_T(data), *size);++ struct vnop_getxattr_args args = {+ .a_uio = uio,+ .a_name = name,+ .a_size = size+ };++ int ret = hfs_getxattr_internal(VTOC(vp), &args, VTOHFS(vp), 0);++ uio_free(uio);++ return ret;+}++/*+ * getxattr_internal+ *+ * We break out this internal function which searches the attributes B-Tree and the+ * overflow extents file to find non-resource, non-finderinfo EAs. There may be cases+ * where we need to get EAs in contexts where we are already holding the cnode lock,+ * and to re-enter hfs_vnop_getxattr would cause us to double-lock the cnode. Instead,+ * we can just directly call this function.+ *+ * We pass the hfsmp argument directly here because we may not necessarily have a cnode to+ * operate on. Under normal conditions, we have a file or directory to query, but if we+ * are operating on the root directory (id 1), then we may not have a cnode. In this case, if hte+ * 'cp' argument is NULL, then we need to use the 'fileid' argument as the entry to manipulate+ *+ * NOTE: This function assumes the cnode lock for 'cp' is held exclusive or shared.+ */+int hfs_getxattr_internal (struct cnode *cp, struct vnop_getxattr_args *ap,+ struct hfsmount *hfsmp, u_int32_t fileid)+{++ struct filefork *btfile;+ struct BTreeIterator * iterator = NULL;+ size_t bufsize = 0;+ HFSPlusAttrRecord *recp = NULL;+ size_t recp_size = 0;+ FSBufferDescriptor btdata;+ int lockflags = 0;+ int result = 0;+ u_int16_t datasize = 0;+ uio_t uio = ap->a_uio;+ u_int32_t target_id = 0;++ if (cp) {+ target_id = cp->c_fileid;+ } else {+ target_id = fileid;+ }+++ /* Bail if we don't have an EA B-Tree. */+ if ((hfsmp->hfs_attribute_vp == NULL) ||+ ((cp) && (cp->c_attr.ca_recflags & kHFSHasAttributesMask) == 0)) {+ result = ENOATTR;+ goto exit;+ }++ /* Initialize the B-Tree iterator for searching for the proper EA */+ btfile = VTOF(hfsmp->hfs_attribute_vp);++ iterator = hfs_malloc_type(struct BTreeIterator);++ /* Allocate memory for reading in the attribute record. This buffer is+ * big enough to read in all types of attribute records. It is not big+ * enough to read inline attribute data which is read in later.+ */+ recp_size = sizeof(HFSPlusAttrRecord);+ recp = hfs_malloc_data(recp_size);+ btdata.bufferAddress = recp;+ btdata.itemSize = sizeof(HFSPlusAttrRecord);+ btdata.itemCount = 1;++ result = hfs_buildattrkey(target_id, ap->a_name, (HFSPlusAttrKey *)&iterator->key);+ if (result) {+ goto exit;+ }++ /* Lookup the attribute in the Attribute B-Tree */+ lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE, HFS_SHARED_LOCK);+ result = BTSearchRecord(btfile, iterator, &btdata, &datasize, NULL);+ hfs_systemfile_unlock(hfsmp, lockflags);++ if (result) {+ if (result == btNotFound) {+ result = ENOATTR;+ }+ goto exit;+ }++ /*+ * Operate differently if we have inline EAs that can fit in the attribute B-Tree or if+ * we have extent based EAs.+ */+ switch (recp->recordType) {++ /* Attribute fits in the Attribute B-Tree */+ case kHFSPlusAttrInlineData: {+ /*+ * Sanity check record size. It's not required to have any+ * user data, so the minimum size is 2 bytes less that the+ * size of HFSPlusAttrData (since HFSPlusAttrData struct+ * has 2 bytes set aside for attribute data).+ */+ if (datasize < (sizeof(HFSPlusAttrData) - 2)) {+ printf("hfs_getxattr: vol=%s %d,%s invalid record size %d (expecting %lu)\n",+ hfsmp->vcbVN, target_id, ap->a_name, datasize, sizeof(HFSPlusAttrData));+ result = ENOATTR;+ break;+ }+ *ap->a_size = recp->attrData.attrSize;+ if (uio && recp->attrData.attrSize != 0) {+ if (*ap->a_size > (user_size_t)uio_resid(uio)) {+ /* User provided buffer is not large enough for the xattr data */+ result = ERANGE;+ } else {+ /* Previous BTreeSearchRecord() read in only the attribute record,+ * and not the attribute data. Now allocate enough memory for+ * both attribute record and data, and read the attribute record again.+ */+ bufsize = sizeof(HFSPlusAttrData) - 2 + recp->attrData.attrSize;+ hfs_free_data(recp, recp_size);+ recp_size = bufsize;+ recp = hfs_malloc_data(recp_size);++ btdata.bufferAddress = recp;+ btdata.itemSize = bufsize;+ btdata.itemCount = 1;++ bzero(iterator, sizeof(*iterator));+ result = hfs_buildattrkey(target_id, ap->a_name, (HFSPlusAttrKey *)&iterator->key);+ if (result) {+ goto exit;+ }++ /* Lookup the attribute record and inline data */+ lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE, HFS_SHARED_LOCK);+ result = BTSearchRecord(btfile, iterator, &btdata, &datasize, NULL);+ hfs_systemfile_unlock(hfsmp, lockflags);+ if (result) {+ if (result == btNotFound) {+ result = ENOATTR;+ }+ goto exit;+ }++ /* Copy-out the attribute data to the user buffer */+ *ap->a_size = recp->attrData.attrSize;+ result = uiomove((caddr_t) &recp->attrData.attrData , recp->attrData.attrSize, uio);+ }+ }+ break;+ }++ /* Extent-Based EAs */+ case kHFSPlusAttrForkData: {+ if (datasize < sizeof(HFSPlusAttrForkData)) {+ printf("hfs_getxattr: vol=%s %d,%s invalid record size %d (expecting %lu)\n",+ hfsmp->vcbVN, target_id, ap->a_name, datasize, sizeof(HFSPlusAttrForkData));+ result = ENOATTR;+ break;+ }+ *ap->a_size = recp->forkData.theFork.logicalSize;+ if (uio == NULL) {+ break;+ }+ if (*ap->a_size > (user_size_t)uio_resid(uio)) {+ result = ERANGE;+ break;+ }+ /* Process overflow extents if necessary. */+ if (has_overflow_extents(&recp->forkData.theFork)) {+ HFSPlusExtentDescriptor *extentbuf;+ HFSPlusExtentDescriptor *extentptr;+ size_t extentbufsize;+ u_int32_t totalblocks;+ u_int32_t blkcnt;+ u_int32_t attrlen;++ totalblocks = recp->forkData.theFork.totalBlocks;+ /* Ignore bogus block counts. */+ if (totalblocks > howmany(HFS_XATTR_MAXSIZE, hfsmp->blockSize)) {+ result = ERANGE;+ break;+ }+ attrlen = recp->forkData.theFork.logicalSize;++ /* Get a buffer to hold the worst case amount of extents. */+ extentbufsize = totalblocks * sizeof(HFSPlusExtentDescriptor);+ extentbufsize = roundup(extentbufsize, sizeof(HFSPlusExtentRecord));+ extentbuf = hfs_malloc_zero_data(extentbufsize);+ extentptr = extentbuf;++ /* Grab the first 8 extents. */+ bcopy(&recp->forkData.theFork.extents[0], extentptr, sizeof(HFSPlusExtentRecord));+ extentptr += kHFSPlusExtentDensity;+ blkcnt = count_extent_blocks(totalblocks, recp->forkData.theFork.extents);++ /* Now lookup the overflow extents. */+ lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE, HFS_SHARED_LOCK);+ while (blkcnt < totalblocks) {+ ((HFSPlusAttrKey *)&iterator->key)->startBlock = blkcnt;+ result = BTSearchRecord(btfile, iterator, &btdata, &datasize, NULL);+ if (result ||+ (recp->recordType != kHFSPlusAttrExtents) ||+ (datasize < sizeof(HFSPlusAttrExtents))) {+ printf("hfs_getxattr: %s missing extents, only %d blks of %d found\n",+ ap->a_name, blkcnt, totalblocks);+ result = ENOATTR;+ break; /* break from while */+ }+ /* Grab the next 8 extents. */+ bcopy(&recp->overflowExtents.extents[0], extentptr, sizeof(HFSPlusExtentRecord));+ extentptr += kHFSPlusExtentDensity;+ blkcnt += count_extent_blocks(totalblocks, recp->overflowExtents.extents);+ }++ /* Release Attr B-Tree lock */+ hfs_systemfile_unlock(hfsmp, lockflags);++ if (blkcnt < totalblocks) {+ result = ENOATTR;+ } else {+ result = read_attr_data(hfsmp, uio, attrlen, extentbuf);+ }+ hfs_free_data(extentbuf, extentbufsize);++ } else { /* No overflow extents. */+ result = read_attr_data(hfsmp, uio, recp->forkData.theFork.logicalSize, recp->forkData.theFork.extents);+ }+ break;+ }++ default:+ /* We only support Extent or inline EAs. Default to ENOATTR for anything else */+ result = ENOATTR;+ break;+ }++exit:+ hfs_free_type(iterator, struct BTreeIterator);+ hfs_free_data(recp, recp_size);++ return result;++}+++/*+ * Set the data of an extended attribute.+ */+int+hfs_vnop_setxattr(struct vnop_setxattr_args *ap)+/*+ struct vnop_setxattr_args {+ struct vnodeop_desc *a_desc;+ vnode_t a_vp;+ char * a_name;+ uio_t a_uio;+ int a_options;+ vfs_context_t a_context;+ };+*/+{+ struct vnode *vp = ap->a_vp;+ struct cnode *cp = NULL;+ struct hfsmount *hfsmp;+ uio_t uio = ap->a_uio;+ size_t attrsize;+ void * user_data_ptr = NULL;+ int result;+ time_t orig_ctime=VTOC(vp)->c_ctime;++ if (ap->a_name == NULL || ap->a_name[0] == '\0') {+ return (EINVAL); /* invalid name */+ }+ hfsmp = VTOHFS(vp);+ if (VNODE_IS_RSRC(vp)) {+ return (EPERM);+ }++#if HFS_COMPRESSION+ if (hfs_hides_xattr(ap->a_context, VTOC(vp), ap->a_name, 1) ) { /* 1 == don't take the cnode lock */+ result = decmpfs_decompress_file(vp, VTOCMP(vp), -1, 1, 0);+ if (result != 0)+ return result;+ }+#endif /* HFS_COMPRESSION */++ nspace_snapshot_event(vp, orig_ctime, NAMESPACE_HANDLER_METADATA_WRITE_OP, NSPACE_REARM_NO_ARG);++ /* Set the Finder Info. */+ if (strcmp(ap->a_name, XATTR_FINDERINFO_NAME) == 0) {+ union {+ uint8_t data[32];+ char cdata[32];+ struct FndrFileInfo info;+ } fi;+ void * finderinfo_start;+ u_int8_t *finfo = NULL;+ u_int16_t fdFlags;+ u_int32_t dateadded = 0;+ u_int32_t write_gen_counter = 0;+ u_int32_t document_id = 0;++ attrsize = sizeof(VTOC(vp)->c_finderinfo);++ if ((user_size_t)uio_resid(uio) != attrsize) {+ return (ERANGE);+ }+ /* Grab the new Finder Info data. */+ if ((result = uiomove(fi.cdata, attrsize, uio))) {+ return (result);+ }++ if ((result = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ return (result);+ }+ cp = VTOC(vp);++ /* Symlink's don't have an external type/creator. */+ if (vnode_islnk(vp)) {+ /* Skip over type/creator fields. */+ finderinfo_start = &cp->c_finderinfo[8];+ attrsize -= 8;+ } else {+ finderinfo_start = &cp->c_finderinfo[0];+ /*+ * Don't allow the external setting of+ * file type to kHardLinkFileType.+ */+ if (fi.info.fdType == SWAP_BE32(kHardLinkFileType)) {+ hfs_unlock(cp);+ return (EPERM);+ }+ }++ /* Grab the current date added from the cnode */+ dateadded = hfs_get_dateadded (cp);+ if (S_ISREG(cp->c_attr.ca_mode) || S_ISLNK(cp->c_attr.ca_mode)) {+ struct FndrExtendedFileInfo *extinfo = (struct FndrExtendedFileInfo *)((u_int8_t*)cp->c_finderinfo + 16);+ /*+ * Grab generation counter directly from the cnode+ * instead of calling hfs_get_gencount(), because+ * for zero generation count values hfs_get_gencount()+ * lies and bumps it up to one.+ */+ write_gen_counter = extinfo->write_gen_counter;+ document_id = extinfo->document_id;+ } else if (S_ISDIR(cp->c_attr.ca_mode)) {+ struct FndrExtendedDirInfo *extinfo = (struct FndrExtendedDirInfo *)((u_int8_t*)cp->c_finderinfo + 16);+ write_gen_counter = extinfo->write_gen_counter;+ document_id = extinfo->document_id;+ }++ /*+ * Zero out the finder info's reserved fields like date added,+ * generation counter, and document id to ignore user's attempts+ * to set it+ */+ hfs_zero_hidden_fields(cp, fi.data);++ if (bcmp(finderinfo_start, emptyfinfo, attrsize)) {+ /* attr exists and "create" was specified. */+ if (ap->a_options & XATTR_CREATE) {+ hfs_unlock(cp);+ return (EEXIST);+ }+ } else { /* empty */+ /* attr doesn't exists and "replace" was specified. */+ if (ap->a_options & XATTR_REPLACE) {+ hfs_unlock(cp);+ return (ENOATTR);+ }+ }++ /*+ * Now restore the date added and other reserved fields to the finderinfo to+ * be written out. Advance to the 2nd half of the finderinfo to write them+ * out into the buffer.+ *+ * Make sure to endian swap the date added back into big endian. When we used+ * hfs_get_dateadded above to retrieve it, it swapped into local endianness+ * for us. But now that we're writing it out, put it back into big endian.+ */+ finfo = &fi.data[16];+ if (S_ISREG(cp->c_attr.ca_mode) || S_ISLNK(cp->c_attr.ca_mode)) {+ struct FndrExtendedFileInfo *extinfo = (struct FndrExtendedFileInfo *)finfo;+ extinfo->date_added = OSSwapHostToBigInt32(dateadded);+ extinfo->write_gen_counter = write_gen_counter;+ extinfo->document_id = document_id;+ } else if (S_ISDIR(cp->c_attr.ca_mode)) {+ struct FndrExtendedDirInfo *extinfo = (struct FndrExtendedDirInfo *)finfo;+ extinfo->date_added = OSSwapHostToBigInt32(dateadded);+ extinfo->write_gen_counter = write_gen_counter;+ extinfo->document_id = document_id;+ }++ /* Set the cnode's Finder Info. */+ if (attrsize == sizeof(cp->c_finderinfo)) {+ bcopy(&fi.data[0], finderinfo_start, attrsize);+ } else {+ bcopy(&fi.data[8], finderinfo_start, attrsize);+ }++ /* Updating finderInfo updates change time and modified time */+ cp->c_touch_chgtime = TRUE;+ cp->c_flag |= C_MODIFIED;++ /*+ * Mirror the invisible bit to the UF_HIDDEN flag.+ *+ * The fdFlags for files and frFlags for folders are both 8 bytes+ * into the userInfo (the first 16 bytes of the Finder Info). They+ * are both 16-bit fields.+ */+ fdFlags = *((u_int16_t *) &cp->c_finderinfo[8]);+ if (fdFlags & OSSwapHostToBigConstInt16(kFinderInvisibleMask)) {+ cp->c_bsdflags |= UF_HIDDEN;+ } else {+ cp->c_bsdflags &= ~UF_HIDDEN;+ }++ result = hfs_update(vp, 0);++ hfs_unlock(cp);+ return (result);+ }+ /* Write the Resource Fork. */+ if (strcmp(ap->a_name, XATTR_RESOURCEFORK_NAME) == 0) {+ struct vnode *rvp = NULL;+ int namelen = 0;+ int openunlinked = 0;++ if (!vnode_isreg(vp)) {+ return (EPERM);+ }+ if ((result = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ return (result);+ }+ cp = VTOC(vp);+ namelen = cp->c_desc.cd_namelen;++ if (hfs_has_rsrc(cp)) {+ /* attr exists and "create" was specified. */+ if (ap->a_options & XATTR_CREATE) {+ hfs_unlock(cp);+ return (EEXIST);+ }+ } else {+ /* attr doesn't exists and "replace" was specified. */+ if (ap->a_options & XATTR_REPLACE) {+ hfs_unlock(cp);+ return (ENOATTR);+ }+ }++ /*+ * Note that we could be called on to grab the rsrc fork vnode+ * for a file that has become open-unlinked.+ */+ if ((cp->c_flag & C_DELETED) && (namelen == 0)) {+ openunlinked = 1;+ }++ result = hfs_vgetrsrc(hfsmp, vp, &rvp);+ hfs_unlock(cp);+ if (result) {+ return (result);+ }+ /* VNOP_WRITE marks cnode as needing a modtime update */+ result = VNOP_WRITE(rvp, uio, 0, ap->a_context);++ /* if open unlinked, force it inactive */+ if (openunlinked) {+ int vref;+ vref = vnode_ref (rvp);+ if (vref == 0) {+ vnode_rele(rvp);+ }+ vnode_recycle (rvp);+ } else {+ /* cnode is not open-unlinked, so re-lock cnode to sync */+ if ((result = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ vnode_recycle (rvp);+ vnode_put(rvp);+ return result;+ }++ /* hfs fsync rsrc fork to force to disk and update modtime */+ result = hfs_fsync (rvp, MNT_NOWAIT, 0, vfs_context_proc (ap->a_context));+ hfs_unlock (cp);+ }++ vnode_put(rvp);+ return (result);+ }++ attrsize = uio_resid(uio);++ /* Enforce an upper limit. */+ if (attrsize > HFS_XATTR_MAXSIZE) {+ result = E2BIG;+ goto exit;+ }++ /*+ * Attempt to copy the users attr data before taking any locks,+ * only if it will be an inline attribute. For larger attributes,+ * the data will be directly read from the uio.+ */+ if (attrsize > 0 &&+ hfsmp->hfs_max_inline_attrsize != 0 &&+ attrsize < hfsmp->hfs_max_inline_attrsize) {+ user_data_ptr = hfs_malloc_data(attrsize);++ result = uiomove((caddr_t)user_data_ptr, attrsize, uio);+ if (result) {+ goto exit;+ }+ }++ result = hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);+ if (result) {+ goto exit;+ }+ cp = VTOC(vp);++ /*+ * If we're trying to set a non-finderinfo, non-resourcefork EA, then+ * call the breakout function.+ */+ result = hfs_setxattr_internal (cp, user_data_ptr, attrsize, ap, VTOHFS(vp), 0);++ exit:+ if (cp) {+ hfs_unlock(cp);+ }+ if (user_data_ptr) {+ hfs_free_data(user_data_ptr, attrsize);+ }++ return (result == btNotFound ? ENOATTR : MacToVFSError(result));+}++// Has same limitations as hfs_setxattr_internal below+int hfs_xattr_write(vnode_t vp, const char *name, const void *data, size_t size)+{+ struct vnop_setxattr_args args = {+ .a_vp = vp,+ .a_name = name,+ };++ return hfs_setxattr_internal(VTOC(vp), data, size, &args, VTOHFS(vp), 0);+}++/*+ * hfs_setxattr_internal+ *+ * Internal function to set non-rsrc, non-finderinfo EAs to either the attribute B-Tree or+ * extent-based EAs.+ *+ * See comments from hfs_getxattr_internal on why we need to pass 'hfsmp' and fileid here.+ * The gist is that we could end up writing to the root folder which may not have a cnode.+ *+ * Assumptions:+ * 1. cnode 'cp' is locked EXCLUSIVE before calling this function.+ * 2. data_ptr contains data to be written. If gathering data from userland, this must be+ * done before calling this function.+ * 3. If data originates entirely in-kernel, use a null UIO, and ensure the size is less than+ * hfsmp->hfs_max_inline_attrsize bytes long.+ */+int hfs_setxattr_internal (struct cnode *cp, const void *data_ptr, size_t attrsize,+ struct vnop_setxattr_args *ap, struct hfsmount *hfsmp,+ u_int32_t fileid)+{+ uio_t uio = ap->a_uio;+ struct vnode *vp = ap->a_vp;+ int started_transaction = 0;+ struct BTreeIterator * iterator = NULL;+ struct filefork *btfile = NULL;+ FSBufferDescriptor btdata;+ HFSPlusAttrRecord attrdata; /* 90 bytes */+ HFSPlusAttrRecord *recp = NULL;+ size_t recp_size = 0;+ HFSPlusExtentDescriptor *extentptr = NULL;+ size_t extentbufsize = 0;+ int result = 0;+ int lockflags = 0;+ int exists = 0;+ int allocatedblks = 0;+ u_int32_t target_id;++ if (cp) {+ target_id = cp->c_fileid;+ } else {+ target_id = fileid;+ }++ /* Start a transaction for our changes. */+ if (hfs_start_transaction(hfsmp) != 0) {+ result = EINVAL;+ goto exit;+ }+ started_transaction = 1;++ /*+ * Once we started the transaction, nobody can compete+ * with us, so make sure this file is still there.+ */+ if ((cp) && (cp->c_flag & C_NOEXISTS)) {+ result = ENOENT;+ goto exit;+ }++ /*+ * If there isn't an attributes b-tree then create one.+ */+ if (hfsmp->hfs_attribute_vp == NULL) {+ result = hfs_create_attr_btree(hfsmp, ATTRIBUTE_FILE_NODE_SIZE,+ getnodecount(hfsmp, ATTRIBUTE_FILE_NODE_SIZE));+ if (result) {+ goto exit;+ }+ }+ if (hfsmp->hfs_max_inline_attrsize == 0) {+ hfsmp->hfs_max_inline_attrsize = getmaxinlineattrsize(hfsmp->hfs_attribute_vp);+ }++ lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE, HFS_EXCLUSIVE_LOCK);++ /* Build the b-tree key. */+ iterator = hfs_malloc_type(struct BTreeIterator);+ result = hfs_buildattrkey(target_id, ap->a_name, (HFSPlusAttrKey *)&iterator->key);+ if (result) {+ goto exit;+ }++ /* Preflight for replace/create semantics. */+ btfile = VTOF(hfsmp->hfs_attribute_vp);+ btdata.bufferAddress = &attrdata;+ btdata.itemSize = sizeof(attrdata);+ btdata.itemCount = 1;+ exists = BTSearchRecord(btfile, iterator, &btdata, NULL, NULL) == 0;++ /* Replace requires that the attribute already exists. */+ if ((ap->a_options & XATTR_REPLACE) && !exists) {+ result = ENOATTR;+ goto exit;+ }+ /* Create requires that the attribute doesn't exist. */+ if ((ap->a_options & XATTR_CREATE) && exists) {+ result = EEXIST;+ goto exit;+ }++ /* If it won't fit inline then use extent-based attributes. */+ if (attrsize > hfsmp->hfs_max_inline_attrsize) {+ int blkcnt;+ int extentblks;+ u_int32_t *keystartblk;+ int i;++ if (uio == NULL) {+ /*+ * setxattrs originating from in-kernel are not supported if they are bigger+ * than the inline max size. Just return ENOATTR and force them to do it with a+ * smaller EA.+ */+ result = EPERM;+ goto exit;+ }++ /* Get some blocks. */+ blkcnt = howmany(attrsize, hfsmp->blockSize);+ extentbufsize = blkcnt * sizeof(HFSPlusExtentDescriptor);+ extentbufsize = roundup(extentbufsize, sizeof(HFSPlusExtentRecord));+ extentptr = hfs_malloc_zero_data(extentbufsize);+ result = alloc_attr_blks(hfsmp, attrsize, extentbufsize, extentptr, &allocatedblks);+ if (result) {+ allocatedblks = 0;+ goto exit; /* no more space */+ }+ /* Copy data into the blocks. */+ result = write_attr_data(hfsmp, uio, attrsize, extentptr);+ if (result) {+ if (vp) {+ const char *name = vnode_getname(vp);+ printf("hfs_setxattr: write_attr_data vol=%s err (%d) %s:%s\n",+ hfsmp->vcbVN, result, name ? name : "", ap->a_name);+ if (name)+ vnode_putname(name);+ }+ goto exit;+ }++ /* Now remove any previous attribute. */+ if (exists) {+ result = remove_attribute_records(hfsmp, iterator);+ if (result) {+ if (vp) {+ const char *name = vnode_getname(vp);+ printf("hfs_setxattr: remove_attribute_records vol=%s err (%d) %s:%s\n",+ hfsmp->vcbVN, result, name ? name : "", ap->a_name);+ if (name)+ vnode_putname(name);+ }+ goto exit;+ }+ }+ /* Create attribute fork data record. */+ recp_size = sizeof(HFSPlusAttrRecord);+ recp = hfs_malloc_data(recp_size);++ btdata.bufferAddress = recp;+ btdata.itemCount = 1;+ btdata.itemSize = sizeof(HFSPlusAttrForkData);++ recp->recordType = kHFSPlusAttrForkData;+ recp->forkData.reserved = 0;+ recp->forkData.theFork.logicalSize = attrsize;+ recp->forkData.theFork.clumpSize = 0;+ recp->forkData.theFork.totalBlocks = blkcnt;+ bcopy(extentptr, recp->forkData.theFork.extents, sizeof(HFSPlusExtentRecord));++ (void) hfs_buildattrkey(target_id, ap->a_name, (HFSPlusAttrKey *)&iterator->key);++ result = BTInsertRecord(btfile, iterator, &btdata, btdata.itemSize);+ if (result) {+ printf ("hfs_setxattr: BTInsertRecord(): vol=%s %d,%s err=%d\n",+ hfsmp->vcbVN, target_id, ap->a_name, result);+ goto exit;+ }+ extentblks = count_extent_blocks(blkcnt, recp->forkData.theFork.extents);+ blkcnt -= extentblks;+ keystartblk = &((HFSPlusAttrKey *)&iterator->key)->startBlock;+ i = 0;++ /* Create overflow extents as needed. */+ while (blkcnt > 0) {+ /* Initialize the key and record. */+ *keystartblk += (u_int32_t)extentblks;+ btdata.itemSize = sizeof(HFSPlusAttrExtents);+ recp->recordType = kHFSPlusAttrExtents;+ recp->overflowExtents.reserved = 0;++ /* Copy the next set of extents. */+ i += kHFSPlusExtentDensity;+ bcopy(&extentptr[i], recp->overflowExtents.extents, sizeof(HFSPlusExtentRecord));++ result = BTInsertRecord(btfile, iterator, &btdata, btdata.itemSize);+ if (result) {+ printf ("hfs_setxattr: BTInsertRecord() overflow: vol=%s %d,%s err=%d\n",+ hfsmp->vcbVN, target_id, ap->a_name, result);+ goto exit;+ }+ extentblks = count_extent_blocks(blkcnt, recp->overflowExtents.extents);+ blkcnt -= extentblks;+ }+ } else { /* Inline data */+ if (exists) {+ result = remove_attribute_records(hfsmp, iterator);+ if (result) {+ goto exit;+ }+ }++ /* Calculate size of record rounded up to multiple of 2 bytes. */+ btdata.itemSize = sizeof(HFSPlusAttrData) - 2 + attrsize + ((attrsize & 1) ? 1 : 0);+ recp_size = btdata.itemSize;+ recp = hfs_malloc_data(recp_size);++ recp->recordType = kHFSPlusAttrInlineData;+ recp->attrData.reserved[0] = 0;+ recp->attrData.reserved[1] = 0;+ recp->attrData.attrSize = attrsize;++ /* Copy in the attribute data (if any). */+ if (attrsize > 0) {+ if (data_ptr) {+ bcopy(data_ptr, &recp->attrData.attrData, attrsize);+ } else {+ /*+ * A null UIO meant it originated in-kernel. If they didn't supply data_ptr+ * then deny the copy operation.+ */+ if (uio == NULL) {+ result = EPERM;+ goto exit;+ }+ result = uiomove((caddr_t)&recp->attrData.attrData, attrsize, uio);+ }++ if (result) {+ goto exit;+ }+ }++ (void) hfs_buildattrkey(target_id, ap->a_name, (HFSPlusAttrKey *)&iterator->key);++ btdata.bufferAddress = recp;+ btdata.itemCount = 1;+ result = BTInsertRecord(btfile, iterator, &btdata, btdata.itemSize);+ }++exit:+ if (btfile && started_transaction) {+ (void) BTFlushPath(btfile);+ }+ hfs_systemfile_unlock(hfsmp, lockflags);+ if (result == 0) {+ if (vp) {+ cp = VTOC(vp);+ /* Setting an attribute only updates change time and not+ * modified time of the file.+ */+ cp->c_touch_chgtime = TRUE;+ cp->c_flag |= C_MODIFIED;+ cp->c_attr.ca_recflags |= kHFSHasAttributesMask;+ if ((strcmp(ap->a_name, KAUTH_FILESEC_XATTR) == 0)) {+ cp->c_attr.ca_recflags |= kHFSHasSecurityMask;+ }+ (void) hfs_update(vp, 0);+ }+ }+ if (started_transaction) {+ if (result && allocatedblks) {+ free_attr_blks(hfsmp, allocatedblks, extentptr);+ }+ hfs_end_transaction(hfsmp);+ }++ hfs_free_data(recp, recp_size);+ hfs_free_data(extentptr, extentbufsize);+ hfs_free_type(iterator, struct BTreeIterator);++ return result;+}+++++/*+ * Remove an extended attribute.+ */+int+hfs_vnop_removexattr(struct vnop_removexattr_args *ap)+/*+ struct vnop_removexattr_args {+ struct vnodeop_desc *a_desc;+ vnode_t a_vp;+ char * a_name;+ int a_options;+ vfs_context_t a_context;+ };+*/+{+ struct vnode *vp = ap->a_vp;+ struct cnode *cp = VTOC(vp);+ struct hfsmount *hfsmp;+ struct BTreeIterator * iterator = NULL;+ int lockflags;+ int result;+ time_t orig_ctime=VTOC(vp)->c_ctime;++ if (ap->a_name == NULL || ap->a_name[0] == '\0') {+ return (EINVAL); /* invalid name */+ }+ hfsmp = VTOHFS(vp);+ if (VNODE_IS_RSRC(vp)) {+ return (EPERM);+ }++#if HFS_COMPRESSION+ if (hfs_hides_xattr(ap->a_context, VTOC(vp), ap->a_name, 1) && !(ap->a_options & XATTR_SHOWCOMPRESSION)) {+ return ENOATTR;+ }+#endif /* HFS_COMPRESSION */++ nspace_snapshot_event(vp, orig_ctime, NAMESPACE_HANDLER_METADATA_DELETE_OP, NSPACE_REARM_NO_ARG);++ /* If Resource Fork is non-empty then truncate it. */+ if (strcmp(ap->a_name, XATTR_RESOURCEFORK_NAME) == 0) {+ struct vnode *rvp = NULL;++ if ( !vnode_isreg(vp) ) {+ return (EPERM);+ }+ if ((result = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ return (result);+ }+ if (!hfs_has_rsrc(cp)) {+ hfs_unlock(cp);+ return (ENOATTR);+ }+ result = hfs_vgetrsrc(hfsmp, vp, &rvp);+ hfs_unlock(cp);+ if (result) {+ return (result);+ }++ hfs_lock_truncate(VTOC(rvp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);++ // Tell UBC now before we take the cnode lock and start the transaction+ hfs_ubc_setsize(rvp, 0, false);++ if ((result = hfs_lock(VTOC(rvp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ vnode_put(rvp);+ return (result);+ }++ /* Start a transaction for encapsulating changes in+ * hfs_truncate() and hfs_update()+ */+ if ((result = hfs_start_transaction(hfsmp))) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ hfs_unlock(cp);+ vnode_put(rvp);+ return (result);+ }++ result = hfs_truncate(rvp, (off_t)0, IO_NDELAY, 0, ap->a_context);+ if (result == 0) {+ cp->c_touch_chgtime = TRUE;+ cp->c_flag |= C_MODIFIED;+ result = hfs_update(vp, 0);+ }++ hfs_end_transaction(hfsmp);+ hfs_unlock_truncate(VTOC(rvp), HFS_LOCK_DEFAULT);+ hfs_unlock(VTOC(rvp));++ vnode_put(rvp);+ return (result);+ }+ /* Clear out the Finder Info. */+ if (strcmp(ap->a_name, XATTR_FINDERINFO_NAME) == 0) {+ void * finderinfo_start;+ int finderinfo_size;+ u_int8_t finderinfo[32];+ u_int32_t date_added = 0, write_gen_counter = 0, document_id = 0;+ u_int8_t *finfo = NULL;++ if ((result = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ return (result);+ }++ /* Use the local copy to store our temporary changes. */+ bcopy(cp->c_finderinfo, finderinfo, sizeof(finderinfo));+++ /* Zero out the date added field in the local copy */+ hfs_zero_hidden_fields (cp, finderinfo);++ /* Don't expose a symlink's private type/creator. */+ if (vnode_islnk(vp)) {+ struct FndrFileInfo *fip;++ fip = (struct FndrFileInfo *)&finderinfo;+ fip->fdType = 0;+ fip->fdCreator = 0;+ }++ /* Do the byte compare against the local copy */+ if (bcmp(finderinfo, emptyfinfo, sizeof(emptyfinfo)) == 0) {+ hfs_unlock(cp);+ return (ENOATTR);+ }++ /*+ * If there was other content, zero out everything except+ * type/creator and date added. First, save the date added.+ */+ finfo = cp->c_finderinfo;+ finfo = finfo + 16;+ if (S_ISREG(cp->c_attr.ca_mode) || S_ISLNK(cp->c_attr.ca_mode)) {+ struct FndrExtendedFileInfo *extinfo = (struct FndrExtendedFileInfo *)finfo;+ date_added = extinfo->date_added;+ write_gen_counter = extinfo->write_gen_counter;+ document_id = extinfo->document_id;+ } else if (S_ISDIR(cp->c_attr.ca_mode)) {+ struct FndrExtendedDirInfo *extinfo = (struct FndrExtendedDirInfo *)finfo;+ date_added = extinfo->date_added;+ write_gen_counter = extinfo->write_gen_counter;+ document_id = extinfo->document_id;+ }++ if (vnode_islnk(vp)) {+ /* Ignore type/creator */+ finderinfo_start = &cp->c_finderinfo[8];+ finderinfo_size = sizeof(cp->c_finderinfo) - 8;+ } else {+ finderinfo_start = &cp->c_finderinfo[0];+ finderinfo_size = sizeof(cp->c_finderinfo);+ }+ bzero(finderinfo_start, finderinfo_size);+++ /* Now restore the date added */+ if (S_ISREG(cp->c_attr.ca_mode) || S_ISLNK(cp->c_attr.ca_mode)) {+ struct FndrExtendedFileInfo *extinfo = (struct FndrExtendedFileInfo *)finfo;+ extinfo->date_added = date_added;+ extinfo->write_gen_counter = write_gen_counter;+ extinfo->document_id = document_id;+ } else if (S_ISDIR(cp->c_attr.ca_mode)) {+ struct FndrExtendedDirInfo *extinfo = (struct FndrExtendedDirInfo *)finfo;+ extinfo->date_added = date_added;+ extinfo->write_gen_counter = write_gen_counter;+ extinfo->document_id = document_id;+ }++ /* Updating finderInfo updates change time and modified time */+ cp->c_touch_chgtime = TRUE;+ cp->c_flag |= C_MODIFIED;+ hfs_update(vp, 0);++ hfs_unlock(cp);++ return (0);+ }++ if (hfsmp->hfs_attribute_vp == NULL) {+ return (ENOATTR);+ }++ iterator = hfs_malloc_type(struct BTreeIterator);++ if ((result = hfs_lock(cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT))) {+ goto exit_nolock;+ }++ result = hfs_buildattrkey(cp->c_fileid, ap->a_name, (HFSPlusAttrKey *)&iterator->key);+ if (result) {+ goto exit;+ }++ if (hfs_start_transaction(hfsmp) != 0) {+ result = EINVAL;+ goto exit;+ }+ lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);++ result = remove_attribute_records(hfsmp, iterator);++ hfs_systemfile_unlock(hfsmp, lockflags);++ if (result == 0) {+ cp->c_touch_chgtime = TRUE;++ lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE, HFS_SHARED_LOCK);++ /* If no more attributes exist, clear attribute bit */+ result = file_attribute_exist(hfsmp, cp->c_fileid);+ if (result == 0) {+ cp->c_attr.ca_recflags &= ~kHFSHasAttributesMask;+ cp->c_flag |= C_MODIFIED;+ }+ if (result == EEXIST) {+ result = 0;+ }++ hfs_systemfile_unlock(hfsmp, lockflags);++ /* If ACL was removed, clear security bit */+ if (strcmp(ap->a_name, KAUTH_FILESEC_XATTR) == 0) {+ cp->c_attr.ca_recflags &= ~kHFSHasSecurityMask;+ cp->c_flag |= C_MODIFIED;+ }+ (void) hfs_update(vp, 0);+ }++ hfs_end_transaction(hfsmp);+exit:+ hfs_unlock(cp);+exit_nolock:+ hfs_free_type(iterator, struct BTreeIterator);+ return MacToVFSError(result);+}++/*+ * Removes a non rsrc-fork, non-finderinfo EA from the specified file ID.+ * Note that this results in a bit of code duplication for the xattr removal+ * path. This is done because it's a bit messy to deal with things without the+ * cnode. This function is used by exchangedata to port XATTRS to alternate+ * fileIDs while everything is locked, and the cnodes are in a transitional state.+ *+ * Assumes that the cnode backing the fileid specified is LOCKED.+ */++int+hfs_removexattr_by_id (struct hfsmount *hfsmp, uint32_t fileid, const char *xattr_name ) {+ struct BTreeIterator iter; // allocated on the stack to avoid heap allocation mid-txn+ int ret = 0;+ int started_txn = 0;+ int lockflags;++ memset (&iter, 0, sizeof(iter));++ //position the B-Tree iter key before grabbing locks and starting a txn+ ret = hfs_buildattrkey (fileid, xattr_name, (HFSPlusAttrKey*)&iter.key);+ if (ret) {+ goto xattr_out;+ }++ //note: this is likely a nested transaction since there is a global transaction cover+ if (hfs_start_transaction (hfsmp) != 0) {+ ret = EINVAL;+ goto xattr_out;+ }+ started_txn = 1;+++ lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);++ //actually remove the EA from the tree+ ret = remove_attribute_records(hfsmp, &iter);++ hfs_systemfile_unlock(hfsmp, lockflags);++ /*+ * NOTE: Responsibility of the caller to remove the "has XATTRs" bit in the catalog record+ * if this was the last EA.+ */+++xattr_out:+ if (started_txn) {+ hfs_end_transaction(hfsmp);+ }++ return MacToVFSError(ret);++}+++/* Check if any attribute record exist for given fileID. This function+ * is called by hfs_vnop_removexattr to determine if it should clear the+ * attribute bit in the catalog record or not.+ *+ * Note - you must acquire a shared lock on the attribute btree before+ * calling this function.+ *+ * Output:+ * EEXIST - If attribute record was found+ * 0 - Attribute was not found+ * (other) - Other error (such as EIO)+ */+int+file_attribute_exist(struct hfsmount *hfsmp, uint32_t fileID)+{+ HFSPlusAttrKey *key;+ struct BTreeIterator * iterator = NULL;+ struct filefork *btfile;+ int result = 0;++ // if there's no attribute b-tree we sure as heck+ // can't have any attributes!+ if (hfsmp->hfs_attribute_vp == NULL) {+ return false;+ }++ iterator = hfs_malloc_type(struct BTreeIterator);++ key = (HFSPlusAttrKey *)&iterator->key;++ result = hfs_buildattrkey(fileID, NULL, key);+ if (result) {+ goto out;+ }++ btfile = VTOF(hfsmp->hfs_attribute_vp);+ result = BTSearchRecord(btfile, iterator, NULL, NULL, NULL);+ if (result && (result != btNotFound)) {+ goto out;+ }++ result = BTIterateRecord(btfile, kBTreeNextRecord, iterator, NULL, NULL);+ /* If no next record was found or fileID for next record did not match,+ * no more attributes exist for this fileID+ */+ if ((result && (result == btNotFound)) || (key->fileID != fileID)) {+ result = 0;+ } else {+ result = EEXIST;+ }++out:+ hfs_free_type(iterator, struct BTreeIterator);+ return result;+}+++/*+ * Remove all the records for a given attribute.+ *+ * - Used by hfs_vnop_removexattr, hfs_vnop_setxattr and hfs_removeallattr.+ * - A transaction must have been started.+ * - The Attribute b-tree file must be locked exclusive.+ * - The Allocation Bitmap file must be locked exclusive.+ * - The iterator key must be initialized.+ */+int+remove_attribute_records(struct hfsmount *hfsmp, BTreeIterator * iterator)+{+ struct filefork *btfile;+ FSBufferDescriptor btdata;+ HFSPlusAttrRecord attrdata; /* 90 bytes */+ u_int16_t datasize;+ int result;++ btfile = VTOF(hfsmp->hfs_attribute_vp);++ btdata.bufferAddress = &attrdata;+ btdata.itemSize = sizeof(attrdata);+ btdata.itemCount = 1;+ result = BTSearchRecord(btfile, iterator, &btdata, &datasize, NULL);+ if (result) {+ goto exit; /* no records. */+ }+ /*+ * Free the blocks from extent based attributes.+ *+ * Note that the block references (btree records) are removed+ * before releasing the blocks in the allocation bitmap.+ */+ if (attrdata.recordType == kHFSPlusAttrForkData) {+ int totalblks;+ int extentblks;+ u_int32_t *keystartblk;++ if (datasize < sizeof(HFSPlusAttrForkData)) {+ printf("hfs: remove_attribute_records: bad record size %d (expecting %lu)\n", datasize, sizeof(HFSPlusAttrForkData));+ }+ totalblks = attrdata.forkData.theFork.totalBlocks;++ /* Process the first 8 extents. */+ extentblks = count_extent_blocks(totalblks, attrdata.forkData.theFork.extents);+ if (extentblks > totalblks)+ panic("hfs: remove_attribute_records: corruption...");+ if (BTDeleteRecord(btfile, iterator) == 0) {+ free_attr_blks(hfsmp, extentblks, attrdata.forkData.theFork.extents);+ }+ totalblks -= extentblks;+ keystartblk = &((HFSPlusAttrKey *)&iterator->key)->startBlock;++ /* Process any overflow extents. */+ while (totalblks) {+ *keystartblk += (u_int32_t)extentblks;++ result = BTSearchRecord(btfile, iterator, &btdata, &datasize, NULL);+ if (result ||+ (attrdata.recordType != kHFSPlusAttrExtents) ||+ (datasize < sizeof(HFSPlusAttrExtents))) {+ printf("hfs: remove_attribute_records: BTSearchRecord: vol=%s, err=%d (%d), totalblks %d\n",+ hfsmp->vcbVN, MacToVFSError(result), attrdata.recordType != kHFSPlusAttrExtents, totalblks);+ result = ENOATTR;+ break; /* break from while */+ }+ /* Process the next 8 extents. */+ extentblks = count_extent_blocks(totalblks, attrdata.overflowExtents.extents);+ if (extentblks > totalblks)+ panic("hfs: remove_attribute_records: corruption...");+ if (BTDeleteRecord(btfile, iterator) == 0) {+ free_attr_blks(hfsmp, extentblks, attrdata.overflowExtents.extents);+ }+ totalblks -= extentblks;+ }+ } else {+ result = BTDeleteRecord(btfile, iterator);+ }+ (void) BTFlushPath(btfile);+exit:+ return (result == btNotFound ? ENOATTR : MacToVFSError(result));+}+++/*+ * Retrieve the list of extended attribute names.+ */+int+hfs_vnop_listxattr(struct vnop_listxattr_args *ap)+/*+ struct vnop_listxattr_args {+ struct vnodeop_desc *a_desc;+ vnode_t a_vp;+ uio_t a_uio;+ size_t *a_size;+ int a_options;+ vfs_context_t a_context;+*/+{+ struct vnode *vp = ap->a_vp;+ struct cnode *cp = VTOC(vp);+ struct hfsmount *hfsmp;+ uio_t uio = ap->a_uio;+ struct BTreeIterator * iterator = NULL;+ struct filefork *btfile;+ struct listattr_callback_state state;+ user_addr_t user_start = 0;+ user_size_t user_len = 0;+ int lockflags;+ int result;+ u_int8_t finderinfo[32];+++ if (VNODE_IS_RSRC(vp)) {+ return (EPERM);+ }++#if HFS_COMPRESSION+ int compressed = hfs_file_is_compressed(cp, 1); /* 1 == don't take the cnode lock */+#endif /* HFS_COMPRESSION */++ hfsmp = VTOHFS(vp);+ *ap->a_size = 0;++ /*+ * Take the truncate lock; this serializes us against the ioctl+ * to truncate data & reset the decmpfs state+ * in the compressed file handler.+ */+ hfs_lock_truncate(cp, HFS_SHARED_LOCK, HFS_LOCK_DEFAULT);++ /* Now the regular cnode lock (shared) */+ if ((result = hfs_lock(cp, HFS_SHARED_LOCK, HFS_LOCK_DEFAULT))) {+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);+ return (result);+ }++ /*+ * Make a copy of the cnode's finderinfo to a local so we can+ * zero out the date added field. Also zero out the private type/creator+ * for symlinks.+ */+ bcopy(cp->c_finderinfo, finderinfo, sizeof(finderinfo));+ hfs_zero_hidden_fields (cp, finderinfo);++ /* Don't expose a symlink's private type/creator. */+ if (vnode_islnk(vp)) {+ struct FndrFileInfo *fip;++ fip = (struct FndrFileInfo *)&finderinfo;+ fip->fdType = 0;+ fip->fdCreator = 0;+ }+++ /* If Finder Info is non-empty then export it's name. */+ if (bcmp(finderinfo, emptyfinfo, sizeof(emptyfinfo)) != 0) {+ if (uio == NULL) {+ *ap->a_size += sizeof(XATTR_FINDERINFO_NAME);+ } else if ((user_size_t)uio_resid(uio) < sizeof(XATTR_FINDERINFO_NAME)) {+ result = ERANGE;+ goto exit;+ } else {+ result = uiomove(XATTR_FINDERINFO_NAME,+ sizeof(XATTR_FINDERINFO_NAME), uio);+ if (result)+ goto exit;+ }+ }+ /* If Resource Fork is non-empty then export it's name. */+ if (S_ISREG(cp->c_mode) && hfs_has_rsrc(cp)) {+#if HFS_COMPRESSION+ if ((ap->a_options & XATTR_SHOWCOMPRESSION) ||+ !compressed ||+ !decmpfs_hides_rsrc(ap->a_context, VTOCMP(vp))+ )+#endif /* HFS_COMPRESSION */+ {+ if (uio == NULL) {+ *ap->a_size += sizeof(XATTR_RESOURCEFORK_NAME);+ } else if ((user_size_t)uio_resid(uio) < sizeof(XATTR_RESOURCEFORK_NAME)) {+ result = ERANGE;+ goto exit;+ } else {+ result = uiomove(XATTR_RESOURCEFORK_NAME,+ sizeof(XATTR_RESOURCEFORK_NAME), uio);+ if (result)+ goto exit;+ }+ }+ }++ /* Bail if we don't have any extended attributes. */+ if ((hfsmp->hfs_attribute_vp == NULL) ||+ (cp->c_attr.ca_recflags & kHFSHasAttributesMask) == 0) {+ result = 0;+ goto exit;+ }+ btfile = VTOF(hfsmp->hfs_attribute_vp);++ iterator = hfs_malloc_type(struct BTreeIterator);++ result = hfs_buildattrkey(cp->c_fileid, NULL, (HFSPlusAttrKey *)&iterator->key);+ if (result)+ goto exit;++ /*+ * Lock the user's buffer here so that we won't fault on+ * it in uiomove while holding the attributes b-tree lock.+ */+ if (uio && uio_isuserspace(uio)) {+ user_start = uio_curriovbase(uio);+ user_len = uio_curriovlen(uio);++ if ((result = vslock(user_start, user_len)) != 0) {+ user_start = 0;+ goto exit;+ }+ }+ lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE, HFS_SHARED_LOCK);++ result = BTSearchRecord(btfile, iterator, NULL, NULL, NULL);+ if (result && result != btNotFound) {+ hfs_systemfile_unlock(hfsmp, lockflags);+ goto exit;+ }++ state.fileID = cp->c_fileid;+ state.result = 0;+ state.uio = uio;+ state.size = 0;+#if HFS_COMPRESSION+ state.showcompressed = !compressed || ap->a_options & XATTR_SHOWCOMPRESSION;+ state.ctx = ap->a_context;+ state.vp = vp;+#endif /* HFS_COMPRESSION */++ /*+ * Process entries starting just after iterator->key.+ */+ result = BTIterateRecords(btfile, kBTreeNextRecord, iterator,+ (IterateCallBackProcPtr)listattr_callback, &state);+ hfs_systemfile_unlock(hfsmp, lockflags);+ if (uio == NULL) {+ *ap->a_size += state.size;+ }++ if (state.result || result == btNotFound)+ result = state.result;++exit:+ if (user_start) {+ vsunlock(user_start, user_len, TRUE);+ }+ hfs_free_type(iterator, struct BTreeIterator);+ hfs_unlock(cp);+ hfs_unlock_truncate(cp, HFS_LOCK_DEFAULT);++ return MacToVFSError(result);+}+++/*+ * Callback - called for each attribute record+ */+static int+listattr_callback(const HFSPlusAttrKey *key, __unused const HFSPlusAttrData *data, struct listattr_callback_state *state)+{+ char attrname[XATTR_MAXNAMELEN + 1];+ ssize_t bytecount;+ int result;++ if (state->fileID != key->fileID) {+ state->result = 0;+ return (0); /* stop */+ }+ /*+ * Skip over non-primary keys+ */+ if (key->startBlock != 0) {+ return (1); /* continue */+ }++ /* Convert the attribute name into UTF-8. */+ result = utf8_encodestr(key->attrName, key->attrNameLen * sizeof(UniChar),+ (u_int8_t *)attrname, (size_t *)&bytecount, sizeof(attrname), '/', 0);+ if (result) {+ state->result = result;+ return (0); /* stop */+ }+ bytecount++; /* account for null termination char */++ if (xattr_protected(attrname))+ return (1); /* continue */++#if HFS_COMPRESSION+ if (!state->showcompressed && decmpfs_hides_xattr(state->ctx, VTOCMP(state->vp), attrname) )+ return 1; /* continue */+#endif /* HFS_COMPRESSION */++ if (state->uio == NULL) {+ state->size += bytecount;+ } else {+ if (bytecount > uio_resid(state->uio)) {+ state->result = ERANGE;+ return (0); /* stop */+ }+ result = uiomove((caddr_t) attrname, bytecount, state->uio);+ if (result) {+ state->result = result;+ return (0); /* stop */+ }+ }+ return (1); /* continue */+}++/*+ * Remove all the attributes from a cnode.+ *+ * This function creates/ends its own transaction so that each+ * attribute is deleted in its own transaction (to avoid having+ * a transaction grow too large).+ *+ * This function takes the necessary locks on the attribute+ * b-tree file and the allocation (bitmap) file.+ *+ * NOTE: Upon sucecss, this function will return with an open+ * transaction. The reason we do it this way is because when we+ * delete the last attribute, we must make sure the flag in the+ * catalog record that indicates there are no more records is cleared.+ * The caller is responsible for doing this and *must* do it before+ * ending the transaction.+ */+int+hfs_removeallattr(struct hfsmount *hfsmp, u_int32_t fileid,+ bool *open_transaction)+{+ BTreeIterator *iterator = NULL;+ HFSPlusAttrKey *key;+ struct filefork *btfile;+ int result, lockflags = 0;++ *open_transaction = false;++ if (hfsmp->hfs_attribute_vp == NULL)+ return 0;++ btfile = VTOF(hfsmp->hfs_attribute_vp);++ iterator = hfs_malloc_type(BTreeIterator);++ key = (HFSPlusAttrKey *)&iterator->key;++ /* Loop until there are no more attributes for this file id */+ do {+ if (!*open_transaction)+ lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE, HFS_SHARED_LOCK);++ (void) hfs_buildattrkey(fileid, NULL, key);+ result = BTIterateRecord(btfile, kBTreeNextRecord, iterator, NULL, NULL);+ if (result || key->fileID != fileid)+ goto exit;++ hfs_systemfile_unlock(hfsmp, lockflags);+ lockflags = 0;++ if (*open_transaction) {+ hfs_end_transaction(hfsmp);+ *open_transaction = false;+ }++ if (hfs_start_transaction(hfsmp) != 0) {+ result = EINVAL;+ goto exit;+ }++ *open_transaction = true;++ lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);++ result = remove_attribute_records(hfsmp, iterator);++#if HFS_XATTR_VERBOSE+ if (result) {+ printf("hfs_removeallattr: unexpected err %d\n", result);+ }+#endif+ } while (!result);++exit:+ hfs_free_type(iterator, BTreeIterator);++ if (lockflags)+ hfs_systemfile_unlock(hfsmp, lockflags);++ result = result == btNotFound ? 0 : MacToVFSError(result);++ if (result && *open_transaction) {+ hfs_end_transaction(hfsmp);+ *open_transaction = false;+ }++ return result;+}++void+hfs_xattr_init(struct hfsmount * hfsmp)+{++ /*+ * If there isn't an attributes b-tree then create one.+ */+ if ((hfsmp->hfs_attribute_vp == NULL) &&+ !(hfsmp->hfs_flags & HFS_READ_ONLY)) {+ (void) hfs_create_attr_btree(hfsmp, ATTRIBUTE_FILE_NODE_SIZE,+ getnodecount(hfsmp, ATTRIBUTE_FILE_NODE_SIZE));+ }+ if (hfsmp->hfs_attribute_vp)+ hfsmp->hfs_max_inline_attrsize = getmaxinlineattrsize(hfsmp->hfs_attribute_vp);+}++/*+ * Enable/Disable volume attributes stored as EA for root file system.+ * Supported attributes are -+ * 1. Extent-based Extended Attributes+ */+int+hfs_set_volxattr(struct hfsmount *hfsmp, unsigned int xattrtype, int state)+{+ struct BTreeIterator * iterator = NULL;+ struct filefork *btfile;+ int lockflags;+ int result;++ if (xattrtype != HFSIOC_SET_XATTREXTENTS_STATE) {+ return EINVAL;+ }++ /*+ * If there isn't an attributes b-tree then create one.+ */+ if (hfsmp->hfs_attribute_vp == NULL) {+ result = hfs_create_attr_btree(hfsmp, ATTRIBUTE_FILE_NODE_SIZE,+ getnodecount(hfsmp, ATTRIBUTE_FILE_NODE_SIZE));+ if (result) {+ return (result);+ }+ }++ iterator = hfs_malloc_type(struct BTreeIterator);++ /*+ * Build a b-tree key.+ * We use the root's parent id (1) to hold this volume attribute.+ */+ (void) hfs_buildattrkey(kHFSRootParentID, XATTR_XATTREXTENTS_NAME,+ (HFSPlusAttrKey *)&iterator->key);++ /* Start a transaction for our changes. */+ if (hfs_start_transaction(hfsmp) != 0) {+ result = EINVAL;+ goto exit;+ }+ btfile = VTOF(hfsmp->hfs_attribute_vp);++ lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE, HFS_EXCLUSIVE_LOCK);++ if (state == 0) {+ /* Remove the attribute. */+ result = BTDeleteRecord(btfile, iterator);+ if (result == btNotFound)+ result = 0;+ } else {+ FSBufferDescriptor btdata;+ HFSPlusAttrData attrdata;+ u_int16_t datasize;++ datasize = sizeof(attrdata);+ btdata.bufferAddress = &attrdata;+ btdata.itemSize = datasize;+ btdata.itemCount = 1;+ attrdata.recordType = kHFSPlusAttrInlineData;+ attrdata.reserved[0] = 0;+ attrdata.reserved[1] = 0;+ attrdata.attrSize = 2;+ attrdata.attrData[0] = 0;+ attrdata.attrData[1] = 0;++ /* Insert the attribute. */+ result = BTInsertRecord(btfile, iterator, &btdata, datasize);+ if (result == btExists)+ result = 0;+ }+ (void) BTFlushPath(btfile);++ hfs_systemfile_unlock(hfsmp, lockflags);++ /* Finish the transaction of our changes. */+ hfs_end_transaction(hfsmp);++ /* Update the state in the mount point */+ hfs_lock_mount (hfsmp);+ if (state == 0) {+ hfsmp->hfs_flags &= ~HFS_XATTR_EXTENTS;+ } else {+ hfsmp->hfs_flags |= HFS_XATTR_EXTENTS;+ }+ hfs_unlock_mount (hfsmp);++exit:+ hfs_free_type(iterator, struct BTreeIterator);+ return MacToVFSError(result);+}+++/*+ * hfs_attrkeycompare - compare two attribute b-tree keys.+ *+ * The name portion of the key is compared using a 16-bit binary comparison.+ * This is called from the b-tree code.+ */+int+hfs_attrkeycompare(HFSPlusAttrKey *searchKey, HFSPlusAttrKey *trialKey)+{+ u_int32_t searchFileID, trialFileID;+ int result;++ searchFileID = searchKey->fileID;+ trialFileID = trialKey->fileID;+ result = 0;++ if (searchFileID > trialFileID) {+ ++result;+ } else if (searchFileID < trialFileID) {+ --result;+ } else {+ u_int16_t * str1 = &searchKey->attrName[0];+ u_int16_t * str2 = &trialKey->attrName[0];+ int length1 = searchKey->attrNameLen;+ int length2 = trialKey->attrNameLen;+ u_int16_t c1, c2;+ int length;++ if (length1 < length2) {+ length = length1;+ --result;+ } else if (length1 > length2) {+ length = length2;+ ++result;+ } else {+ length = length1;+ }++ while (length--) {+ c1 = *(str1++);+ c2 = *(str2++);++ if (c1 > c2) {+ result = 1;+ break;+ }+ if (c1 < c2) {+ result = -1;+ break;+ }+ }+ if (result)+ return (result);+ /*+ * Names are equal; compare startBlock+ */+ if (searchKey->startBlock == trialKey->startBlock) {+ return (0);+ } else {+ return (searchKey->startBlock < trialKey->startBlock ? -1 : 1);+ }+ }++ return result;+}+++/*+ * hfs_buildattrkey - build an Attribute b-tree key+ */+int+hfs_buildattrkey(u_int32_t fileID, const char *attrname, HFSPlusAttrKey *key)+{+ int result = 0;+ size_t unicodeBytes = 0;++ if (attrname != NULL) {+ /*+ * Convert filename from UTF-8 into Unicode+ */+ result = utf8_decodestr((const u_int8_t *)attrname, strlen(attrname), key->attrName,+ &unicodeBytes, sizeof(key->attrName), 0, 0);+ if (result) {+ if (result != ENAMETOOLONG)+ result = EINVAL; /* name has invalid characters */+ return (result);+ }+ key->attrNameLen = unicodeBytes / sizeof(UniChar);+ key->keyLength = kHFSPlusAttrKeyMinimumLength + unicodeBytes;+ } else {+ key->attrNameLen = 0;+ key->keyLength = kHFSPlusAttrKeyMinimumLength;+ }+ key->pad = 0;+ key->fileID = fileID;+ key->startBlock = 0;++ return (0);+ }++/*+ * getnodecount - calculate starting node count for attributes b-tree.+ */+static int+getnodecount(struct hfsmount *hfsmp, size_t nodesize)+{+ u_int64_t freebytes;+ u_int64_t calcbytes;++ /*+ * 10.4: Scale base on current catalog file size (20 %) up to 20 MB.+ * 10.5: Attempt to be as big as the catalog clump size.+ *+ * Use no more than 10 % of the remaining free space.+ */+ freebytes = (u_int64_t)hfs_freeblks(hfsmp, 0) * (u_int64_t)hfsmp->blockSize;++ calcbytes = MIN(hfsmp->hfs_catalog_cp->c_datafork->ff_size / 5, 20 * 1024 * 1024);++ calcbytes = MAX(calcbytes, hfsmp->hfs_catalog_cp->c_datafork->ff_clumpsize);++ calcbytes = MIN(calcbytes, freebytes / 10);++ return (MAX(2, (int)(calcbytes / nodesize)));+}+++/*+ * getmaxinlineattrsize - calculate maximum inline attribute size.+ *+ * This yields 3,802 bytes for an 8K node size.+ */+static size_t+getmaxinlineattrsize(struct vnode * attrvp)+{+ struct BTreeInfoRec btinfo;+ size_t nodesize = ATTRIBUTE_FILE_NODE_SIZE;+ size_t maxsize;++ if (attrvp != NULL) {+ (void) hfs_lock(VTOC(attrvp), HFS_SHARED_LOCK, HFS_LOCK_DEFAULT);+ if (BTGetInformation(VTOF(attrvp), 0, &btinfo) == 0)+ nodesize = btinfo.nodeSize;+ hfs_unlock(VTOC(attrvp));+ }+ maxsize = nodesize;+ maxsize -= sizeof(BTNodeDescriptor); /* minus node descriptor */+ maxsize -= 3 * sizeof(u_int16_t); /* minus 3 index slots */+ maxsize /= 2; /* 2 key/rec pairs minumum */+ maxsize -= sizeof(HFSPlusAttrKey); /* minus maximum key size */+ maxsize -= sizeof(HFSPlusAttrData) - 2; /* minus data header */+ maxsize &= 0xFFFFFFFE; /* multiple of 2 bytes */++ return (maxsize);+}++/*+ * Initialize vnode for attribute data I/O.+ *+ * On success,+ * - returns zero+ * - the attrdata vnode is initialized as hfsmp->hfs_attrdata_vp+ * - an iocount is taken on the attrdata vnode which exists+ * for the entire duration of the mount. It is only dropped+ * during unmount+ * - the attrdata cnode is not locked+ *+ * On failure,+ * - returns non-zero value+ * - the caller does not have to worry about any locks or references+ */+int init_attrdata_vnode(struct hfsmount *hfsmp)+{+ vnode_t vp;+ int result = 0;+ struct cat_desc cat_desc;+ struct cat_attr cat_attr;+ struct cat_fork cat_fork;+ int newvnode_flags = 0;++ bzero(&cat_desc, sizeof(cat_desc));+ cat_desc.cd_parentcnid = kHFSRootParentID;+ cat_desc.cd_nameptr = (const u_int8_t *)hfs_attrdatafilename;+ cat_desc.cd_namelen = strlen(hfs_attrdatafilename);+ cat_desc.cd_cnid = kHFSAttributeDataFileID;+ /* Tag vnode as system file, note that we can still use cluster I/O */+ cat_desc.cd_flags |= CD_ISMETA;++ bzero(&cat_attr, sizeof(cat_attr));+ cat_attr.ca_linkcount = 1;+ cat_attr.ca_mode = S_IFREG;+ cat_attr.ca_fileid = cat_desc.cd_cnid;+ cat_attr.ca_blocks = hfsmp->totalBlocks;++ /*+ * The attribute data file is a virtual file that spans the+ * entire file system space.+ *+ * Each extent-based attribute occupies a unique portion of+ * in this virtual file. The cluster I/O is done using actual+ * allocation block offsets so no additional mapping is needed+ * for the VNOP_BLOCKMAP call.+ *+ * This approach allows the attribute data to be cached without+ * incurring the high cost of using a separate vnode per attribute.+ *+ * Since we need to acquire the attribute b-tree file lock anyways,+ * the virtual file doesn't introduce any additional serialization.+ */+ bzero(&cat_fork, sizeof(cat_fork));+ cat_fork.cf_size = (u_int64_t)hfsmp->totalBlocks * (u_int64_t)hfsmp->blockSize;+ cat_fork.cf_blocks = hfsmp->totalBlocks;+ cat_fork.cf_extents[0].startBlock = 0;+ cat_fork.cf_extents[0].blockCount = cat_fork.cf_blocks;++ result = hfs_getnewvnode(hfsmp, NULL, NULL, &cat_desc, 0, &cat_attr,+ &cat_fork, &vp, &newvnode_flags);+ if (result == 0) {+ hfsmp->hfs_attrdata_vp = vp;+#if NEW_XATTR+ vnode_setnoreadahead(hfsmp->hfs_attrdata_vp);+#endif+ hfs_unlock(VTOC(vp));+ }+ return (result);+}++/* The following code (inside NEW_XATTR) was ported from apfs. */+#if NEW_XATTR+/*+ * This is the same as fext2cluster_check(), but overflow is asserted against.+ *+ * This is useful for places which hold the invariant that `fext' is already+ * representable when translated but additionally want to assert that that is+ * the case.+ */+static uint64_t+fext2cluster(const HFSPlusExtentDescriptor *fext, uint32_t fs_bsize)+{+ uint64_t off;+ const bool ok = fext2cluster_check(fext, fs_bsize, &off);+ xattr_assert(ok);+ return off;+}++/*+ * Translate `fext' to a cluster layer virtual offset, set via `out', that is+ * suitable for IO to the single xattr vnode.+ *+ * For any particular file extent, this will map to a unique logical offset+ * that may be used to key into the ubc. The returned value has the property+ * such that file extents on adjacent physical blocks will always be mapped to+ * different page sized multiples. Internally, this just multiplies by the+ * larger of the pagesize and the blocksize (see xattr_cluster_scale() for the+ * derivation). For further details on the importance of this in the overall+ * scheme of xattr IO, see uio_set_fext().+ *+ * This return trues if `fext' is representable in cluster layer virtual+ * offset. It may return false for corrupted file extents:+ * - extents that likely extend beyond the size of the underlying drive+ *+ * The second point should not happen under normal circumstances even for large+ * drives. Large drives (by the logic in hfs_newfs()) are automatically+ * formatted to use large block sizes: drives sized >= 16TB use 16kiB fs+ * blocksize, at which point the virtual offset computed is equal to the device+ * offset (even on a 16kiB pagesize system).+ * So as long as a drive does not exceed 2^63 bytes in capacity (which is the+ * precision of `off_t'), the internal multiplication should not overflow.+ */+static bool+fext2cluster_check(const HFSPlusExtentDescriptor *fext, uint32_t fs_bsize,+ uint64_t *out)+{+ const uint64_t pbn = fext->startBlock;++ // xattrs has invalid start block+ if (!pbn) {+ return false;+ }++ // scale pbn+ uint64_t off;+ if (__builtin_mul_overflow(pbn, xattr_cluster_scale(fs_bsize), &off)) {+ return false;+ }++ *out = off;++ // the whole fext should be in range+ if (__builtin_add_overflow(off, fext->blockCount * fs_bsize, &off)) {+ return false;+ }++ // don't exceed signed 64bit precision+ if (off > INT64_MAX) {+ return false;+ }++ return true;+}++/*+ * Return the scale factor for translating xattr physical block numbers into+ * a logical offset into the single xattr vnode's ubc.+ *+ * Translated blocks have two key requirements:+ * - They must not overlap.+ * Otherwise two different blocks' contents will collide.+ * - They must not fall within the same page.+ * Otherwise reading a whole page may pull in multiple xattr's blocks, but+ * only decrypt with one of the xattr's keys.+ *+ * A table of all possible configurations:+ * pagesize, fs blocksize, scale+ * 4k, 4k, 4k+ * 4k, 8k, 8k+ * ...+ * 4k, 64k, 64k+ * 16k, 4k, 16k+ * 16k, 8k, 16k+ * 16k, 16k, 16k+ * 16k, 32k, 32k+ * 16k, 64k, 64k+ *+ * This may be expressed as+ * scale = max(pagesize, fs blocksize)+ */+static uint32_t+xattr_cluster_scale(uint32_t fs_bsize)+{+ return MAX(PAGE_SIZE, fs_bsize);+}++/*+ * See off_in_range().+ */+static bool+off_in_range2(uint64_t off, uint64_t start, uint64_t len)+{+ return (start <= off) && (off < (start + len));+}++/*+ * Return true if `off' returned from fext2cluster() was produced from+ * `fext'.+ */+static bool+cluster_off_in_fext(uint64_t off, const HFSPlusExtentDescriptor *fext,+ uint32_t fs_bsize)+{+ return off_in_range2(off, fext2cluster(fext, fs_bsize), fext->blockCount * fs_bsize);+}++/*+ * Allocate space to save a file extent reference for xattr IO.+ *+ * This provides a mechanism to communicate file extents from top level, stream+ * based xattr IO functions down into lower level IO functions+ * (_blockmap() and _strategy()).+ *+ * This doesn't really return a file extent, it returns a reference into+ * `info->xattr_fexts' which may be pointed to a file extent reference.+ * Alternatively this could just return an integral index index, but then we'd+ * need some way to signal failure.+ *+ * Note: the returned reference cannot be assigned directly; it must be set+ * via xattr_fext_set() to correctly synchronize with a racing call to+ * xattr_fext_find().+ *+ * This call will not block; it will return NULL if no free spaces are+ * available. On success, follow with a call to xattr_fext_free().+ *+ * In terms of the implementation, this is a basic zone allocator for thread+ * local storage in disguise. it supports only one file extent to be+ * set by up to 64 threads.+ * For further details, see the documentation for each field above the+ * definition of `xattr_io_info_t'.+ */+static const HFSPlusExtentDescriptor **+xattr_fext_alloc(xattr_io_info_t *info)+{+ const HFSPlusExtentDescriptor **ret;+ size_t i;++ // search for the first free bit+ lck_spin_lock(&info->lock);+ if (!xbm_find_free(info, &i)) {+ // no free fexts+ ret = NULL;+ goto fail;+ }++ // mark that position as allocated+ xbm_set_used(info, i);+ ret = &info->xattr_fexts[i];+ xattr_assert(!*ret);++fail:+ lck_spin_unlock(&info->lock);+ return ret;+}++/*+ * Free the memory associated with an xattr fext referenced return from+ * xattr_fext_alloc().+ * This simply amounts to clearing the bit within `info->free_bm' that+ * corresponds to `xfext'. While not strictly neccessary, we also clear out the+ * xattr fext itself to hold the invariant that a clear bit within the free+ * bitmap has a corresponding NULL fext reference.+ */+static void+xattr_fext_free(xattr_io_info_t *info, const HFSPlusExtentDescriptor **xfext)+{+ lck_spin_lock(&info->lock);+ const size_t i = xattr_fext_index(info, xfext);+ xbm_clear_used(info, i);+ info->xattr_fexts[i] = NULL;+ lck_spin_unlock(&info->lock);+}++/*+ * Given an allocated xattr fext from xattr_fext_alloc() assign it to reference+ * `fext'. A copy of this fext may be returned by a subsequent call to+ * xattr_fext_find().+ *+ * This may be called multiple times for the same value of `xfext'.+ * `fext' will be borrowed until a subsequent call to xattr_fext_set() for a+ * different file extent or xattr_fext_free() for `xfext'. It must have+ * lifetime that spans at least as long from when it's first set to when it's+ * cleared either by xattr_fext_free() or xattr_fext_clear().+ *+ * Note: `fext' may be introspected by other threads via xattr_fext_find()+ * (and in terms of getxattr(), two threads may use each other's file extents+ * if they race to read the same xattr).+ */+static void+xattr_fext_set(xattr_io_info_t *info, const HFSPlusExtentDescriptor **xfext,+ const HFSPlusExtentDescriptor *fext)+{+ xattr_assert(xbm_valid_index(info, xattr_fext_index(info, xfext)));+ lck_spin_lock(&info->lock);+ *xfext = fext;+ lck_spin_unlock(&info->lock);+}++/*+ * Given a cluster layer virtual offset, attempt to look up a file extent set+ * via a previous call to xattr_fext_set().+ *+ * If such a fext is found, its value is copied to `out' and true is returned.+ * Note: `out' should reference wired memory: it will be stored to while a spin+ * lock is held; accesses must not fault.+ *+ * off_out will contain the "unvirtualized" offset+ */+bool+hfs_xattr_fext_find(xattr_io_info_t *info, uint32_t fs_bsize, uint64_t off,+ HFSPlusExtentDescriptor *out, uint64_t *off_out)+{+ bool found = false;+ lck_spin_lock(&info->lock);++ // search through all in-use fexts+ xbm_iter_t iter = xbm_make_iter(info->free_bm, xbm_size(info));+ while(xbm_iter_next(&iter)) {+ const HFSPlusExtentDescriptor *fext = info->xattr_fexts[xbm_iter_peek(&iter)];+ if (!fext || !cluster_off_in_fext(off, fext, fs_bsize)) {+ continue;+ }+ // `off' intersects; return `fext'+ *out = *fext;+ found = true;+ break;+ }++ lck_spin_unlock(&info->lock);++ if (found) {+ *off_out = ((uint64_t)out->startBlock * fs_bsize) + off - fext2cluster(out, fs_bsize);+ }++ return found;+}++/*+ * Given an allocated xattr fext, clear its reference to any `fext' passed to a+ * previous call to xattr_fext_set().+ *+ * This will end the lifetime of such a fext and prevent xattr_fext_find() from+ * taking a reference to it. From here, its backing memory can be deallocated.+ *+ * Unlike xattr_fext_free(), `xfext' will remain allocated and it may passed to+ * xattr_fext_set() again.+ */+static void+xattr_fext_clear(xattr_io_info_t *info, const HFSPlusExtentDescriptor **xfext)+{+ xattr_assert(xbm_valid_index(info, xattr_fext_index(info, xfext)));+ lck_spin_lock(&info->lock);+ *xfext = NULL;+ lck_spin_unlock(&info->lock);+}++/*+ * For an xattr file extent, `xfext', returned from a previous call to+ * xattr_fext_alloc(), return its index within `info->xattr_fexts'.+ */+static size_t+xattr_fext_index(const xattr_io_info_t *info, const HFSPlusExtentDescriptor **xfext)+{+ xattr_assert((info->xattr_fexts <= xfext) &&+ (xfext < &info->xattr_fexts[xbm_size(info)]));+ return ((uintptr_t)xfext - (uintptr_t)info->xattr_fexts) / sizeof(*xfext);+}++static void+bitmap_set_range(uint64_t *bm, int64_t index, int64_t count)+{+ int dstshift0, dstshift1;+ uint64_t dstmask0, dstmask1;+ int64_t bmi;++ dstshift0 = index % 64;+ dstshift1 = 64 - (index % 64);+ dstmask0 = ~0ULL << (index % 64);+ dstmask1 = (dstshift1 == 64) ? 0ULL : (~0ULL >> (64 - (index % 64)));++ bmi = index / 64;+ while (count >= 64) {+ bm[bmi] = (bm[bmi] & ~dstmask0) | ((~0ULL << dstshift0) & dstmask0);+ if (dstmask1)+ bm[bmi + 1] = (bm[bmi + 1] & ~dstmask1) | ((~0ULL >> dstshift1) & dstmask1);+ bmi++;+ count -= 64;+ }+ if (count) {+ // adjust dstmask to cover just the bits remaining+ dstmask0 = ((1ULL << count) - 1) << (index % 64);+ dstmask1 = (dstshift1 == 64) ? 0ULL : (((1ULL << count) - 1) >> (64 - (index % 64)));+ bm[bmi] = (bm[bmi] & ~dstmask0) | ((~0ULL << dstshift0) & dstmask0);+ if ((count > (64 - dstshift0)) && dstmask1)+ bm[bmi + 1] = (bm[bmi + 1] & ~dstmask1) | ((~0ULL >> dstshift1) & dstmask1);+ }+}++static void+bitmap_clear_range(uint64_t *bm, int64_t index, int64_t count)+{+ int dstshift0, dstshift1;+ uint64_t dstmask0, dstmask1;+ int64_t bmi;++ dstshift0 = index % 64;+ dstshift1 = 64 - (index % 64);+ dstmask0 = ~0ULL << (index % 64);+ dstmask1 = (dstshift1 == 64) ? 0ULL : (~0ULL >> (64 - (index % 64)));++ bmi = index / 64;+ while (count >= 64) {+ bm[bmi] = (bm[bmi] & ~dstmask0) | ((0ULL << dstshift0) & dstmask0);+ if (dstmask1)+ bm[bmi + 1] = (bm[bmi + 1] & ~dstmask1) | ((0ULL >> dstshift1) & dstmask1);+ bmi++;+ count -= 64;+ }+ if (count) {+ // adjust dstmask to cover just the bits remaining+ dstmask0 = ((1ULL << count) - 1) << (index % 64);+ dstmask1 = (dstshift1 == 64) ? 0ULL : (((1ULL << count) - 1) >> (64 - (index % 64)));+ bm[bmi] = (bm[bmi] & ~dstmask0) | ((0ULL << dstshift0) & dstmask0);+ if ((count > (64 - dstshift0)) && dstmask1)+ bm[bmi + 1] = (bm[bmi + 1] & ~dstmask1) | ((0ULL >> dstshift1) & dstmask1);+ }+}++static int+ctzll(uint64_t val)+{+ return (val == 0) ? 64 : __builtin_ctzll(val);+}++// search forwards through range and return index of first "bit" (0 or 1) encountered+static int+bitmap_range_find_first(int bit, const uint64_t *bm, int64_t index, int64_t count, int64_t *clear_index)+{+ int64_t bmi, check_count;+ uint64_t val;+ int pos;++ bmi = index / 64;+ while (count > 0) {+ check_count = 64 - (index % 64);+ if (check_count > count)+ check_count = count;+ val = bm[bmi] >> (index % 64);+ if (!bit)+ val = ~val;+ pos = ctzll(val);+ if (pos < check_count) {+ *clear_index = index + pos;+ return 1;+ }+ index += check_count;+ count -= check_count;+ bmi++;+ }+ return 0;+}++/*+ * Search for the first free (clear) bit within `info's free xattr fext bitmap.+ * Return false if no bits are clear.+ * If some bit is found, its index is set to `*out' and true is returned.+ */+static bool+xbm_find_free(const xattr_io_info_t *info, size_t *out)+{+ return bm_find(info->free_bm, 0, xbm_size(info), false, out);+}++/*+ * Set the bit at index `i' within `info's underlying free xattr fext bitmap.+ *+ * info->lock must be held.+ * It only makes sense to operate on one bit at a time, so this wraps+ * bitmap_set_range().+ */+static void+xbm_set_used(xattr_io_info_t *info, size_t i)+{+ xattr_assert(xbm_valid_index(info, i));+ bitmap_set_range(info->free_bm, i, 1);+}++/*+ * Clear the bit at index `i' within `info's underlying free xattr fext bitmap.+ * This is the opposite of xbm_set_used().+ */+static void+xbm_clear_used(xattr_io_info_t *info, size_t i)+{+ xattr_assert(xbm_valid_index(info, i));+ bitmap_clear_range(info->free_bm, i, 1);+}++/*+ * Return whether the given bitmap index is a valid index into `info's free+ * bitmap.+ */+static bool+xbm_valid_index(const xattr_io_info_t *info, int64_t i)+{+ return bm_valid_index(i, xbm_size(info));+}++#ifndef ARRAY_SIZE+#define ARRAY_SIZE(A) (sizeof(A) / sizeof(A[0]))+#endif++/*+ * Return the total number of *bits* in `info's free xattr fext bitmap.+ */+static size_t+xbm_size(const xattr_io_info_t *info)+{+ // one bit per xattr fext+ return ARRAY_SIZE(info->xattr_fexts);+}++/*+ * Factory for an iterator over all the set (true value) bits in `bitmap'.+ * `len' is the length in *bits* of `bitmap'.+ *+ * The iterator is created in an uninitialized state, a call to xbm_iter_next()+ * is required to find the first set bit (this is different than+ * make_fext_iterator()). As a consequence of this, an iterator may iterate+ * zero times if no bits within `bitmap' are set. After each successful call to+ * xbm_iter_next(), xbm_iter_peek() will return the zero-based index of each+ * set bit.+ *+ * The intended use is along the lines of:+ * uint64_t *bm = ...; // a bitmap 123 bits (two uint64_ts) long+ * xbm_iterator_t iter = xbm_make_iter(bm, 123);+ * while(xbm_iter_next(&iter)) {+ * size_t i = xbm_iter_peek(&iter);+ * printf("index %lu is set\n", i);+ * }+ *+ * In terms of the iterator internals, we hold the invariant that a valid+ * iterator always has `i' in [0, len). A valid iterator is one for which+ * xbm_iter_peek() will return an index in range of `bitmap'. To bootstrap the+ * first iteration, `i' is set to SIZE_MAX; further details are in+ * xbm_iter_next().+ */+static xbm_iter_t+xbm_make_iter(const uint64_t *bitmap, size_t len)+{+ xattr_assert(len);+ return (xbm_iter_t) {+ .bitmap = bitmap,+ .i = SIZE_MAX, // This will overflow-to-zero on the first call to xbm_iter_next()+ .len = len+ };+}++/*+ * Advance `iter' to internally reference the next set bit within the bitmap.+ * If there are no more set bits, this returns false.+ *+ * On success, the index of the next set bit can be retrieved by+ * xbm_iter_peek().+ *+ * Internally, this searches for the first bit set at bit index >= iter->i+1.+ * For a new iterator, the value of `i' is initialized to SIZE_MAX so `i'+1+ * will unsigned integer overflow (which is well defined) to zero.+ */+static bool+xbm_iter_next(xbm_iter_t *iter)+{+ size_t i;+ // find the next set bit > `i'+ const bool found = bm_find(iter->bitmap, iter->i + 1, iter->len, true, &i);++ // if no bit is found, invalidate the iterator by setting i=len+ iter->i = found ? i : iter->len;+ return found;+}++/*+ * Return the index a the set bit after a successful call to xbm_iter_next().+ */+static size_t+xbm_iter_peek(const xbm_iter_t *iter)+{+ xattr_assert(iter->i < iter->len);+ return iter->i;+}++/*+ * Search for the first bit with `value' within bitmap `bm' >= bit index `from'+ * for at most `len' *bits*. Whether such a bit exists is returned and if+ * that's the case, its bit index is written via `out'.+ *+ * This is just a fancy wrapper around bitmap_range_find_first().+ */+static bool+bm_find(const uint64_t *bm, size_t from, size_t len, bool value, size_t *out)+{+ xattr_assert(bm_valid_index(from, len));++ // search for `value' in [from, len)+ int64_t i;+ if (!bitmap_range_find_first(value,+ const_cast(uint64_t *, bm), from, len, &i)) {+ return false;+ }++ // some bit found; check the returned index is valid+ xattr_assert(bm_valid_index(i, len));+ *out = (size_t)i;+ return true;+}++/*+ * Return true if `i' is a valid index into a bit of `len' bits.+ *+ * The underlying bitmap_ routines operate on `int64_t' indices. This is+ * mainly to safely convert to `size_t'.+ */+static bool+bm_valid_index(int64_t i, size_t len)+{+ return (i >= 0) && ((uint64_t)i < len);+}++/*+ * Virtualize `uio' offset to target xattr `fext' before a call to+ * cluster_xattr().+ *+ * The computation of the IO offset is somewhat subtle. The reason for this+ * fact largely has to do with how exactly the single xattr vnode+ * (hfsmp->hfs_attrdata_vp) caches data for multiple xattrs. First,+ * some discussion on the motivation for the single xattr vnode design. At the+ * top level, xattr apis are quite different from normal file data apis. Some+ * key properties are:+ * - xattr IO apis do no support editing or random reads+ * - xattrs may not be mmapped+ * - any one file may have an arbitrary number of xattrs+ * To contrast with a normal file, each file has a corresponding vnode which in+ * turn has its own private ubc. The only way in which xattrs are actually like+ * files is that they the have the same size limits and in+ * terms of their implementation, they use the same on-disk structures.+ * The result of this is that it is too high overhead to have one vnode per+ * xattr, but to instead to maintain a disk block-type cache for xattr data.+ * This cache is implemented as the ubc of a virtual file known as the single+ * xattr vnode. Reads and writes are serviced by the cluster layer. The cluster+ * layer operates in units of the vm pagesize. On a system for which+ * pagesize > fs blocksize, then the naïve approach of using an identity+ * mapping between ubc logical offset and device offset poses a challenge.+ * Consider the following scenario:+ * - 16k vm pagesize+ * - 4k fs blocksize+ *+ * On disk, we have two xattrs that reside on adjacent blocks:+ * xattr A xattr B+ * [aaaa|aaaa|bbbb|bbbb]+ * pbn 4 5 6 7 8+ *+ * Suppose we want to just read xattr A -- pbn 4 and 5 -- the cluster layer can+ * issue just an 8k IO, but it will store it in memory as a whole page, so we+ * would result in+ *+ * xattr A xattr B+ * in memory:+ * [aaaa|aaaa|0000|0000]+ *+ * on disk:+ * [aaaa|aaaa|bbbb|bbbb]+ * pbn 4 5 6 7 8+ *+ * A subsequent read for pbn 6 or 7, as a part of xattr B, will find the page+ * already cached in the ubc and erroneously return zeros.+ * Instead, we could have the cluster layer issue the full 16k IO, but then we+ * run into encryption issues on per-file (really per-xattr) key volumes+ *+ * xattr A xattr B+ * in memory:+ * [aaaa|aaaa|O!#W|JF%R]+ *+ * on disk:+ * [asdf|ghjk|ZXCV|BNM,] encrypted+ * [aaaa|aaaa|bbbb|bbbb] unencrypted+ * pbn 4 5 6 7 8+ *+ * In this case, the issue is that we have the crypto state available to read+ * xattr A, but we do not have the crypto state for xattr B, so we would+ * incorrectly decrypt pbn 6, 7 in the same IO.+ *+ * The solution to this is to use a scaled mapping between ubc logical offset+ * and device offset. In this case, we use+ * logical offset = physical block number * pagesize+ * and result looks like+ *+ * xattr A xattr B+ * in memory:+ * [aaaa|aaaa|0000|0000] ... [bbbb|bbbb|0000|0000]+ * 64k 96k+ *+ * on disk:+ * [asdf|ghjk|ZXCV|BNM,] encrypted+ * [aaaa|aaaa|bbbb|bbbb] unencrypted+ * pbn 4 5 6 7 8+ *+ * In memory, xattr A occupies the virtual range of [64k, 96k), but its+ * contents are representable in the first 8k out of [64k, 80k). Note that the+ * mapping here is not per block but rather per xattr file extent. The contents+ * tracked by an individual file extent are logically contiguous in memory. In+ * the example above, xattr A has one file extent spanning [0, 8k). Suppose it+ * instead had two file extents -- [0, 4k) at pbn 4 and [4k, 8k) at pbn 5 --+ * the above diagram would instead look like+ * in memory:+ * [aaaa|0000|0000|0000][aaaa|0000|0000|0000]+ * 64k 80k+ * on disk:+ * [aaaa|aaaa] unencrypted+ * pbn 4 5+ *+ * This scaled mapping approach guarantees that xattrs are always on different+ * pages from other xattrs, but it comes at an increased memory cost for+ * non-page multiple sized xattrs.+ * --+ *+ * If `fext' is not representable as a virtual offset (e.g. its phys_block_num+ * is corrupt), this function returns false.+ */+static bool+uio_set_fext(uio_t uio, const HFSPlusExtentDescriptor *fext, uint32_t fs_bsize)+{+ uint64_t off;+ if (!fext2cluster_check(fext, fs_bsize, &off)) {+ // `fext' is out of range+ return false;+ }++ uio_setoffset(uio, off);+ return true;+}+#endif // NEW_XATTR+/*+ * Read an extent based attribute.+ */+static int+read_attr_data(struct hfsmount *hfsmp, uio_t uio, size_t datasize, HFSPlusExtentDescriptor *extents)+{+ vnode_t evp = hfsmp->hfs_attrdata_vp;+ off_t filesize;+ int bufsize;+ int64_t iosize;+ int attrsize;+ int blksize;+ int i;+ int result = 0;++ hfs_lock_truncate(VTOC(evp), HFS_SHARED_LOCK, HFS_LOCK_DEFAULT);++ bufsize = (int)uio_resid(uio);+ attrsize = (int)datasize;+ blksize = (int)hfsmp->blockSize;+ filesize = VTOF(evp)->ff_size;++#if NEW_XATTR+ // allocate an xattr fext for tls through the cluster layer+ const HFSPlusExtentDescriptor **xattr_fext;+ if (!(xattr_fext = xattr_fext_alloc(&hfsmp->hfs_xattr_io))) {+ result = ENOMEM;+ goto exit;+ }+#endif+ /*+ * Read the attribute data one extent at a time.+ * For the typical case there is only one extent.+ */+ for (i = 0; (attrsize > 0) && (bufsize > 0) && (extents[i].startBlock != 0); ++i) {+ iosize = extents[i].blockCount * blksize;+ iosize = MIN(iosize, attrsize);+ iosize = MIN(iosize, bufsize);+ uio_setresid(uio, iosize);+#if NEW_XATTR+ // virtualize the IO offset to target this fext+ if (!uio_set_fext(uio, &extents[i], blksize)) {+ // `fext' is corrupted+ result = EILSEQ;+ break;+ }++ // stage the next xattr fext for IO+ xattr_fext_set(&hfsmp->hfs_xattr_io, xattr_fext, &extents[i]);++ // Set filesize to end of data read to prevent cluster read-ahead+ filesize = uio_offset(uio) + iosize;+#else+ uio_setoffset(uio, (u_int64_t)extents[i].startBlock * (u_int64_t)blksize);+#endif+ result = cluster_read(evp, uio, filesize, IO_SYNC | IO_UNIT);++#if NEW_XATTR+ // post IO, unstage this xattr fext+ xattr_fext_clear(&hfsmp->hfs_xattr_io, xattr_fext);+#endif++#if HFS_XATTR_VERBOSE+ printf("hfs: read_attr_data: cr iosize %lld [%d, %d] (%d)\n",+ iosize, extents[i].startBlock, extents[i].blockCount, result);+#endif+ if (result)+ break;+ attrsize -= iosize;+ bufsize -= iosize;+ }+ uio_setresid(uio, bufsize);+ uio_setoffset(uio, datasize);++#if NEW_XATTR+ xattr_fext_free(&hfsmp->hfs_xattr_io, xattr_fext);++exit:+#endif+ hfs_unlock_truncate(VTOC(evp), HFS_LOCK_DEFAULT);+ return (result);+}++/*+ * Write an extent based attribute.+ */+static int+write_attr_data(struct hfsmount *hfsmp, uio_t uio, size_t datasize, HFSPlusExtentDescriptor *extents)+{+ vnode_t evp = hfsmp->hfs_attrdata_vp;+ off_t filesize;+ int bufsize;+ int attrsize;+ int64_t iosize;+ int blksize;+ int i;+ int result = 0;++ hfs_lock_truncate(VTOC(evp), HFS_SHARED_LOCK, HFS_LOCK_DEFAULT);++ bufsize = uio_resid(uio);+ attrsize = (int) datasize;+ blksize = (int) hfsmp->blockSize;+ filesize = VTOF(evp)->ff_size;++#if NEW_XATTR+ // allocate an xattr fext for tls through the cluster layer+ const HFSPlusExtentDescriptor **xattr_fext;+ if (!(xattr_fext = xattr_fext_alloc(&hfsmp->hfs_xattr_io))) {+ result = ENOMEM;+ goto exit;+ }+#endif++ /*+ * Write the attribute data one extent at a time.+ */+ for (i = 0; (attrsize > 0) && (bufsize > 0) && (extents[i].startBlock != 0); ++i) {+ iosize = extents[i].blockCount * blksize;+ iosize = MIN(iosize, attrsize);+ iosize = MIN(iosize, bufsize);+ uio_setresid(uio, iosize);+#if NEW_XATTR+ // virtualize the IO offset to target this fext+ if (!uio_set_fext(uio, &extents[i], blksize)) {+ // `fext' is corrupted+ result = EILSEQ;+ break;+ }++ // stage the next xattr fext for IO+ xattr_fext_set(&hfsmp->hfs_xattr_io, xattr_fext, &extents[i]);++ filesize = uio_offset(uio) + iosize;+#else+ uio_setoffset(uio, (u_int64_t)extents[i].startBlock * (u_int64_t)blksize);+#endif+ result = cluster_write(evp, uio, filesize, filesize, filesize,+ (off_t) 0, IO_SYNC | IO_UNIT);++#if NEW_XATTR+ // post IO, unstage this xattr fext+ xattr_fext_clear(&hfsmp->hfs_xattr_io, xattr_fext);+#endif++#if HFS_XATTR_VERBOSE+ printf("hfs: write_attr_data: cw iosize %lld [%d, %d] (%d)\n",+ iosize, extents[i].startBlock, extents[i].blockCount, result);+#endif+ if (result)+ break;+ attrsize -= iosize;+ bufsize -= iosize;+ }+ uio_setresid(uio, bufsize);+ uio_setoffset(uio, datasize);++#if NEW_XATTR+ xattr_fext_free(&hfsmp->hfs_xattr_io, xattr_fext);++exit:+#endif+ hfs_unlock_truncate(VTOC(evp), HFS_LOCK_DEFAULT);+ return (result);+}++/*+ * Allocate blocks for an extent based attribute.+ */+static int+alloc_attr_blks(struct hfsmount *hfsmp, size_t attrsize, size_t extentbufsize, HFSPlusExtentDescriptor *extents, int *blocks)+{+ int blkcnt;+ int startblk;+ int lockflags;+ int i;+ int maxextents;+ int result = 0;++ startblk = hfsmp->hfs_metazone_end;+ blkcnt = howmany(attrsize, hfsmp->blockSize);+ if (blkcnt > (int)hfs_freeblks(hfsmp, 0)) {+ return (ENOSPC);+ }+ *blocks = blkcnt;+ maxextents = extentbufsize / sizeof(HFSPlusExtentDescriptor);++ lockflags = hfs_systemfile_lock(hfsmp, SFL_BITMAP, HFS_EXCLUSIVE_LOCK);++ for (i = 0; (blkcnt > 0) && (i < maxextents); i++) {+ /* Try allocating and see if we find something decent */+ result = BlockAllocate(hfsmp, startblk, blkcnt, blkcnt, 0,+ &extents[i].startBlock, &extents[i].blockCount);+ /*+ * If we couldn't find anything, then re-try the allocation but allow+ * journal flushes.+ */+ if (result == dskFulErr) {+ result = BlockAllocate(hfsmp, startblk, blkcnt, blkcnt, HFS_ALLOC_FLUSHTXN,+ &extents[i].startBlock, &extents[i].blockCount);+ }+++#if HFS_XATTR_VERBOSE+ printf("hfs: alloc_attr_blks: BA blkcnt %d [%d, %d] (%d)\n",+ blkcnt, extents[i].startBlock, extents[i].blockCount, result);+#endif+ if (result) {+ extents[i].startBlock = 0;+ extents[i].blockCount = 0;+ break;+ }+ blkcnt -= extents[i].blockCount;+ startblk = extents[i].startBlock + extents[i].blockCount;+ }+ /*+ * If it didn't fit in the extents buffer then bail.+ */+ if (blkcnt) {+ result = ENOSPC;++#if HFS_XATTR_VERBOSE+ printf("hfs: alloc_attr_blks: unexpected failure, %d blocks unallocated\n", blkcnt);+#endif+ for (; i >= 0; i--) {+ if ((blkcnt = extents[i].blockCount) != 0) {+ (void) BlockDeallocate(hfsmp, extents[i].startBlock, blkcnt, 0);+ extents[i].startBlock = 0;+ extents[i].blockCount = 0;+ }+ }+ }++ hfs_systemfile_unlock(hfsmp, lockflags);+ return MacToVFSError(result);+}++/*+ * Release blocks from an extent based attribute.+ */+static void+free_attr_blks(struct hfsmount *hfsmp, int blkcnt, HFSPlusExtentDescriptor *extents)+{+ vnode_t evp = hfsmp->hfs_attrdata_vp;+ int remblks = blkcnt;+ int lockflags;+ int i;++ lockflags = hfs_systemfile_lock(hfsmp, SFL_BITMAP, HFS_EXCLUSIVE_LOCK);++ for (i = 0; (remblks > 0) && (extents[i].blockCount != 0); i++) {+ if (extents[i].blockCount > (u_int32_t)blkcnt) {+#if HFS_XATTR_VERBOSE+ printf("hfs: free_attr_blks: skipping bad extent [%d, %d]\n",+ extents[i].startBlock, extents[i].blockCount);+#endif+ extents[i].blockCount = 0;+ continue;+ }+ if (extents[i].startBlock == 0) {+ break;+ }+ (void)BlockDeallocate(hfsmp, extents[i].startBlock, extents[i].blockCount, 0);+ remblks -= extents[i].blockCount;+ extents[i].startBlock = 0;+ extents[i].blockCount = 0;++#if HFS_XATTR_VERBOSE+ printf("hfs: free_attr_blks: BlockDeallocate [%d, %d]\n",+ extents[i].startBlock, extents[i].blockCount);+#endif+ /* Discard any resident pages for this block range. */+ if (evp) {+ off_t start, end;++ start = (u_int64_t)extents[i].startBlock * (u_int64_t)hfsmp->blockSize;+ end = start + (u_int64_t)extents[i].blockCount * (u_int64_t)hfsmp->blockSize;+ (void) ubc_msync(hfsmp->hfs_attrdata_vp, start, end, &start, UBC_INVALIDATE);+ }+ }++ hfs_systemfile_unlock(hfsmp, lockflags);+}++static int+has_overflow_extents(HFSPlusForkData *forkdata)+{+ u_int32_t blocks;++ if (forkdata->extents[7].blockCount == 0)+ return (0);++ blocks = forkdata->extents[0].blockCount ++ forkdata->extents[1].blockCount ++ forkdata->extents[2].blockCount ++ forkdata->extents[3].blockCount ++ forkdata->extents[4].blockCount ++ forkdata->extents[5].blockCount ++ forkdata->extents[6].blockCount ++ forkdata->extents[7].blockCount;++ return (forkdata->totalBlocks > blocks);+}++static int+count_extent_blocks(int maxblks, HFSPlusExtentRecord extents)+{+ int blocks;+ int i;++ for (i = 0, blocks = 0; i < kHFSPlusExtentDensity; ++i) {+ /* Ignore obvious bogus extents. */+ if (extents[i].blockCount > (u_int32_t)maxblks)+ continue;+ if (extents[i].startBlock == 0 || extents[i].blockCount == 0)+ break;+ blocks += extents[i].blockCount;+ }+ return (blocks);+}+diff --git a/xnu/files/bsd/hfs/kext-config.h b/xnu/files/bsd/hfs/kext-config.hnew file mode 100644index 0000000..66b1862--- /dev/null+++ b/xnu/files/bsd/hfs/kext-config.h@@ -0,0 +1,16 @@+/*+ * HakiOS: HFS Plus built into the kernel (bsd/hfs, from Apple's hfs-627.100.6) rather than a kext, for the data+ * volume on the phone's flash. FIFO, CONFIG_PROTECT and NAMEDSTREAMS are the kernel's own options (config/MASTER);+ * what is HFS's alone is decided here.+ */+#ifndef _hfs_config_+#define _hfs_config_+#define HFS_COMPRESSION 1 /* (the code does not build without it; decmpfs is the kernel's) */+#ifndef QUOTA+#define QUOTA 0+#endif+#define CONFIG_SECLUDED_RENAME 0+/* content protection's keys are AppleKeyStore's, which this kernel does not have (bsd/hfs/hfs_builtin.c) */+#undef CONFIG_PROTECT+#define CONFIG_PROTECT 0+#endif /* defined(_hfs_config_) */diff --git a/xnu/files/bsd/hfs/rangelist.c b/xnu/files/bsd/hfs/rangelist.cnew file mode 100644index 0000000..b92407c--- /dev/null+++ b/xnu/files/bsd/hfs/rangelist.c@@ -0,0 +1,429 @@+/*+ * Copyright (c) 2001-2015 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@+ */++#include <sys/param.h>+#include <mach/boolean.h>+#include <sys/time.h>+#include <sys/malloc.h>++#if !RANGELIST_TEST+#include <kern/debug.h>+#include "hfs.h"+#endif++#include "rangelist.h"++static enum rl_overlaptype rl_scan_from(struct rl_head *rangelist, off_t start, off_t end, struct rl_entry **overlap, struct rl_entry *range);+static void rl_collapse_forwards(struct rl_head *rangelist, struct rl_entry *range);+static void rl_collapse_backwards(struct rl_head *rangelist, struct rl_entry *range);+static void rl_collapse_neighbors(struct rl_head *rangelist, struct rl_entry *range);+++#ifdef RL_DIAGNOSTIC+static void+rl_verify(struct rl_head *rangelist) {+ struct rl_entry *entry;+ struct rl_entry *next;+ off_t limit = 0;++ TAILQ_FOREACH_SAFE(rangelist, entry, rl_link, next) {+ if ((limit > 0) && (entry->rl_start <= limit)) panic("hfs: rl_verify: bad entry start?!");+ if (entry->rl_end < entry->rl_start) panic("hfs: rl_verify: bad entry end?!");+ limit = entry->rl_end;+ };+}+#endif++++/*+ * Initialize a range list head+ */+void+rl_init(struct rl_head *rangelist)+{+ TAILQ_INIT(rangelist);+}++/*+ * Add a range to the list+ */+void+rl_add(off_t start, off_t end, struct rl_head *rangelist)+{+ struct rl_entry *range;+ struct rl_entry *overlap;+ enum rl_overlaptype ovcase;++#ifdef RL_DIAGNOSTIC+ if (end < start) panic("hfs: rl_add: end < start?!");+#endif++ ovcase = rl_scan(rangelist, start, end, &overlap);++ /*+ * Six cases:+ * 0) no overlap+ * 1) overlap == range+ * 2) overlap contains range+ * 3) range contains overlap+ * 4) overlap starts before range+ * 5) overlap ends after range+ */+ switch (ovcase) {+ case RL_NOOVERLAP: /* 0: no overlap */+ /*+ * overlap points to the entry we should insert before, or+ * if NULL, we should insert at the end.+ */+ range = hfs_malloc_type(struct rl_entry);+ range->rl_start = start;+ range->rl_end = end;++ /* Link in the new range: */+ if (overlap) {+ TAILQ_INSERT_BEFORE(overlap, range, rl_link);+ } else {+ TAILQ_INSERT_TAIL(rangelist, range, rl_link);+ }++ /* Check to see if any ranges can be combined (possibly including the immediately+ preceding range entry)+ */+ rl_collapse_neighbors(rangelist, range);+ break;++ case RL_MATCHINGOVERLAP: /* 1: overlap == range */+ case RL_OVERLAPCONTAINSRANGE: /* 2: overlap contains range */+ break;++ case RL_OVERLAPISCONTAINED: /* 3: range contains overlap */+ /*+ * Replace the overlap with the new, larger range:+ */+ overlap->rl_start = start;+ overlap->rl_end = end;+ rl_collapse_neighbors(rangelist, overlap);+ break;++ case RL_OVERLAPSTARTSBEFORE: /* 4: overlap starts before range */+ /*+ * Expand the overlap area to cover the new range:+ */+ overlap->rl_end = end;+ rl_collapse_forwards(rangelist, overlap);+ break;++ case RL_OVERLAPENDSAFTER: /* 5: overlap ends after range */+ /*+ * Expand the overlap area to cover the new range:+ */+ overlap->rl_start = start;+ rl_collapse_backwards(rangelist, overlap);+ break;+ }++#ifdef RL_DIAGNOSTIC+ rl_verify(rangelist);+#endif+}++++/*+ * Remove a range from a range list.+ *+ * Generally, find the range (or an overlap to that range)+ * and remove it (or shrink it), then wakeup anyone we can.+ */+void+rl_remove(off_t start, off_t end, struct rl_head *rangelist)+{+ struct rl_entry *range, *next_range, *overlap, *splitrange;+ int ovcase;++#ifdef RL_DIAGNOSTIC+ if (end < start) panic("hfs: rl_remove: end < start?!");+#endif++ if (TAILQ_EMPTY(rangelist)) {+ return;+ };++ range = TAILQ_FIRST(rangelist);+ while ((ovcase = rl_scan_from(rangelist, start, end, &overlap, range))) {+ switch (ovcase) {++ case RL_MATCHINGOVERLAP: /* 1: overlap == range */+ TAILQ_REMOVE(rangelist, overlap, rl_link);+ hfs_free_type(overlap, struct rl_entry);+ break;++ case RL_OVERLAPCONTAINSRANGE: /* 2: overlap contains range: split it */+ if (overlap->rl_start == start) {+ overlap->rl_start = end + 1;+ break;+ };++ if (overlap->rl_end == end) {+ overlap->rl_end = start - 1;+ break;+ };++ /*+ * Make a new range consisting of the last part of the encompassing range+ */+ splitrange = hfs_malloc_type(struct rl_entry);+ splitrange->rl_start = end + 1;+ splitrange->rl_end = overlap->rl_end;+ overlap->rl_end = start - 1;++ /*+ * Now link the new entry into the range list after the range from which it was split:+ */+ TAILQ_INSERT_AFTER(rangelist, overlap, splitrange, rl_link);+ break;++ case RL_OVERLAPISCONTAINED: /* 3: range contains overlap */+ /* Check before discarding overlap entry */+ next_range = TAILQ_NEXT(overlap, rl_link);+ TAILQ_REMOVE(rangelist, overlap, rl_link);+ hfs_free_type(overlap, struct rl_entry);+ if (next_range) {+ range = next_range;+ continue;+ };+ break;++ case RL_OVERLAPSTARTSBEFORE: /* 4: overlap starts before range */+ overlap->rl_end = start - 1;+ range = TAILQ_NEXT(overlap, rl_link);+ if (range) {+ continue;+ }+ break;++ case RL_OVERLAPENDSAFTER: /* 5: overlap ends after range */+ overlap->rl_start = (end == RL_INFINITY ? RL_INFINITY : end + 1);+ break;+ }+ break;+ }++#ifdef RL_DIAGNOSTIC+ rl_verify(rangelist);+#endif+}++++/*+ * Scan a range list for an entry in a specified range (if any):+ *+ * NOTE: this returns only the FIRST overlapping range.+ * There may be more than one.+ */++enum rl_overlaptype+rl_scan(struct rl_head *rangelist,+ off_t start,+ off_t end,+ struct rl_entry **overlap) {++ return rl_scan_from(rangelist, start, end, overlap, TAILQ_FIRST(rangelist));+}++enum rl_overlaptype+rl_overlap(const struct rl_entry *range, off_t start, off_t end)+{+ /*+ * OK, check for overlap+ *+ * Six cases:+ * 0) no overlap (RL_NOOVERLAP)+ * 1) overlap == range (RL_MATCHINGOVERLAP)+ * 2) overlap contains range (RL_OVERLAPCONTAINSRANGE)+ * 3) range contains overlap (RL_OVERLAPISCONTAINED)+ * 4) overlap starts before range (RL_OVERLAPSTARTSBEFORE)+ * 5) overlap ends after range (RL_OVERLAPENDSAFTER)+ */+ if (start > range->rl_end || range->rl_start > end) {+ /* Case 0 (RL_NOOVERLAP) */+ return RL_NOOVERLAP;+ }++ if (range->rl_start == start && range->rl_end == end) {+ /* Case 1 (RL_MATCHINGOVERLAP) */+ return RL_MATCHINGOVERLAP;+ }++ if (range->rl_start <= start && range->rl_end >= end) {+ /* Case 2 (RL_OVERLAPCONTAINSRANGE) */+ return RL_OVERLAPCONTAINSRANGE;+ }++ if (start <= range->rl_start && end >= range->rl_end) {+ /* Case 3 (RL_OVERLAPISCONTAINED) */+ return RL_OVERLAPISCONTAINED;+ }++ if (range->rl_start < start && range->rl_end < end) {+ /* Case 4 (RL_OVERLAPSTARTSBEFORE) */+ return RL_OVERLAPSTARTSBEFORE;+ }++ /* Case 5 (RL_OVERLAPENDSAFTER) */+ // range->rl_start > start && range->rl_end > end+ return RL_OVERLAPENDSAFTER;+}++/*+ * Walk the list of ranges for an entry to+ * find an overlapping range (if any).+ *+ * NOTE: this returns only the FIRST overlapping range.+ * There may be more than one.+ */+static enum rl_overlaptype+rl_scan_from(struct rl_head *rangelist __unused,+ off_t start,+ off_t end,+ struct rl_entry **overlap,+ struct rl_entry *range)+{+#ifdef RL_DIAGNOSTIC+ rl_verify(rangelist);+#endif++ while (range) {+ enum rl_overlaptype ot = rl_overlap(range, start, end);++ if (ot != RL_NOOVERLAP || range->rl_start > end) {+ *overlap = range;+ return ot;+ }++ range = TAILQ_NEXT(range, rl_link);+ }++ *overlap = NULL;+ return RL_NOOVERLAP;+}+++static void+rl_collapse_forwards(struct rl_head *rangelist, struct rl_entry *range) {+ struct rl_entry *next_range;++ while ((next_range = TAILQ_NEXT(range, rl_link))) {+ if ((range->rl_end != RL_INFINITY) && (range->rl_end < next_range->rl_start - 1)) return;++ /* Expand this range to include the next range: */+ range->rl_end = next_range->rl_end;++ /* Remove the now covered range from the list: */+ TAILQ_REMOVE(rangelist, next_range, rl_link);+ hfs_free_type(next_range, struct rl_entry);++#ifdef RL_DIAGNOSTIC+ rl_verify(rangelist);+#endif+ };+}++++static void+rl_collapse_backwards(struct rl_head *rangelist, struct rl_entry *range) {+ struct rl_entry *prev_range;++ while ((prev_range = TAILQ_PREV(range, rl_head, rl_link))) {+ if (prev_range->rl_end < range->rl_start -1) {+#ifdef RL_DIAGNOSTIC+ rl_verify(rangelist);+#endif+ return;+ };++ /* Expand this range to include the previous range: */+ range->rl_start = prev_range->rl_start;++ /* Remove the now covered range from the list: */+ TAILQ_REMOVE(rangelist, prev_range, rl_link);+ hfs_free_type(prev_range, struct rl_entry);+ };+}++++static void+rl_collapse_neighbors(struct rl_head *rangelist, struct rl_entry *range)+{+ rl_collapse_forwards(rangelist, range);+ rl_collapse_backwards(rangelist, range);+}++void rl_remove_all(struct rl_head *rangelist)+{+ struct rl_entry *r, *nextr;+ TAILQ_FOREACH_SAFE(r, rangelist, rl_link, nextr)+ hfs_free_type(r, struct rl_entry);+ TAILQ_INIT(rangelist);+}++/*+ * In the case where b is contained by a, we return the the largest part+ * remaining. The result is stored in a.+ */+void rl_subtract(struct rl_entry *a, const struct rl_entry *b)+{+ switch (rl_overlap(b, a->rl_start, a->rl_end)) {+ case RL_MATCHINGOVERLAP:+ case RL_OVERLAPCONTAINSRANGE:+ a->rl_end = a->rl_start - 1;+ break;+ case RL_OVERLAPISCONTAINED:+ // Keep the bigger part+ if (b->rl_start - a->rl_start >= a->rl_end - b->rl_end) {+ // Keep left+ a->rl_end = b->rl_start - 1;+ } else {+ // Keep right+ a->rl_start = b->rl_end + 1;+ }+ break;+ case RL_OVERLAPSTARTSBEFORE:+ a->rl_start = b->rl_end + 1;+ break;+ case RL_OVERLAPENDSAFTER:+ a->rl_end = b->rl_start - 1;+ break;+ case RL_NOOVERLAP:+ break;+ }+}diff --git a/xnu/files/bsd/hfs/rangelist.h b/xnu/files/bsd/hfs/rangelist.hnew file mode 100644index 0000000..b0bb7d1--- /dev/null+++ b/xnu/files/bsd/hfs/rangelist.h@@ -0,0 +1,86 @@+/*+ * Copyright (c) 2001-2014 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@+ */+#ifndef _HFS_RANGELIST_H_+#define _HFS_RANGELIST_H_++#include <sys/appleapiopts.h>++#ifdef KERNEL+#ifdef __APPLE_API_PRIVATE+#include <sys/types.h>+#include <sys/queue.h>++enum rl_overlaptype {+ RL_NOOVERLAP = 0, /* 0 */+ RL_MATCHINGOVERLAP, /* 1 */+ RL_OVERLAPCONTAINSRANGE, /* 2 */+ RL_OVERLAPISCONTAINED, /* 3 */+ RL_OVERLAPSTARTSBEFORE, /* 4 */+ RL_OVERLAPENDSAFTER /* 5 */+};++#define RL_INFINITY INT64_MAX++TAILQ_HEAD(rl_head, rl_entry);++struct rl_entry {+ TAILQ_ENTRY(rl_entry) rl_link;+ off_t rl_start;+ off_t rl_end;+};++__BEGIN_DECLS+void rl_init(struct rl_head *rangelist);+void rl_add(off_t start, off_t end, struct rl_head *rangelist);+void rl_remove(off_t start, off_t end, struct rl_head *rangelist);+void rl_remove_all(struct rl_head *rangelist);+enum rl_overlaptype rl_scan(struct rl_head *rangelist,+ off_t start,+ off_t end,+ struct rl_entry **overlap);+enum rl_overlaptype rl_overlap(const struct rl_entry *range,+ off_t start, off_t end);++static __attribute__((pure)) inline+off_t rl_len(const struct rl_entry *range)+{+ return range->rl_end - range->rl_start + 1;+}++void rl_subtract(struct rl_entry *a, const struct rl_entry *b);++static inline struct rl_entry rl_make(off_t start, off_t end)+{+ return (struct rl_entry){ .rl_start = start, .rl_end = end };+}++__END_DECLS++#endif /* __APPLE_API_PRIVATE */+#endif /* KERNEL */+#endif /* ! _HFS_RANGELIST_H_ */diff --git a/xnu/files/bsd/hfs_encodings/hfs_encodinghint.c b/xnu/files/bsd/hfs_encodings/hfs_encodinghint.cnew file mode 100644index 0000000..06c0aa9--- /dev/null+++ b/xnu/files/bsd/hfs_encodings/hfs_encodinghint.c@@ -0,0 +1,105 @@+/*+ * Copyright (c) 2001-2015 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@+ */++#include <sys/param.h>+#include "../core/hfs.h"+++/* CJK Mac Encoding Bits */+#define CJK_JAPAN 0x1+#define CJK_KOREAN 0x2+#define CJK_CHINESE_TRAD 0x4+#define CJK_CHINESE_SIMP 0x8+#define CJK_ALL 0xF++#define CJK_CHINESE (CJK_CHINESE_TRAD | CJK_CHINESE_SIMP)+#define CJK_KATAKANA (CJK_JAPAN)+++/* Remember the last unique CJK bit */+u_int8_t cjk_lastunique = 0;++/* Encoding bias */+u_int32_t hfs_encodingbias = 0;+int hfs_islatinbias = 0;++extern lck_mtx_t encodinglst_mutex;+++/* Map CJK bits to Mac encoding */+u_int8_t cjk_encoding[] = {+ /* 0000 */ kTextEncodingMacUnicode,+ /* 0001 */ kTextEncodingMacJapanese,+ /* 0010 */ kTextEncodingMacKorean,+ /* 0011 */ kTextEncodingMacJapanese,+ /* 0100 */ kTextEncodingMacChineseTrad,+ /* 0101 */ kTextEncodingMacJapanese,+ /* 0110 */ kTextEncodingMacKorean,+ /* 0111 */ kTextEncodingMacJapanese,+ /* 1000 */ kTextEncodingMacChineseSimp,+ /* 1001 */ kTextEncodingMacJapanese,+ /* 1010 */ kTextEncodingMacKorean,+ /* 1011 */ kTextEncodingMacJapanese,+ /* 1100 */ kTextEncodingMacChineseTrad,+ /* 1101 */ kTextEncodingMacJapanese,+ /* 1110 */ kTextEncodingMacKorean,+ /* 1111 */ kTextEncodingMacJapanese+};+++u_int32_t+hfs_pickencoding(__unused const u_int16_t *src, __unused int len) {+ /* Just return kTextEncodingMacRoman if HFS standard is not supported. */+ return kTextEncodingMacRoman;+}+++u_int32_t hfs_getencodingbias(void)+{+ return (hfs_encodingbias);+}+++void hfs_setencodingbias(u_int32_t bias)+{+ hfs_encodingbias = bias;++ switch (bias) {+ case kTextEncodingMacRoman:+ case kTextEncodingMacCentralEurRoman:+ case kTextEncodingMacTurkish:+ case kTextEncodingMacCroatian:+ case kTextEncodingMacIcelandic:+ case kTextEncodingMacRomanian:+ hfs_islatinbias = 1;+ break;+ default:+ hfs_islatinbias = 0;+ break;+ }+}diff --git a/xnu/files/bsd/hfs_encodings/hfs_encodings.c b/xnu/files/bsd/hfs_encodings/hfs_encodings.cnew file mode 100644index 0000000..c507b09--- /dev/null+++ b/xnu/files/bsd/hfs_encodings/hfs_encodings.c@@ -0,0 +1,623 @@+/*+ * Copyright (c) 2000-2015 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@+ */++#include <IOKit/IOLib.h>++#include <sys/types.h>+#include <sys/errno.h>++#include <sys/param.h>+#include <sys/systm.h>+#include <sys/kernel.h>+#include <sys/malloc.h>+#include <sys/queue.h>+#include <sys/utfconv.h>+#include <kern/host.h>+#include <mach/host_priv.h>+#include <libkern/OSKextLib.h>+#include <libkern/OSKextLibPrivate.h>++#include "hfs_encodings.h"+#include "../core/hfs_macos_defs.h"+#include "../core/hfs.h"++uint64_t hfs_allocated __attribute__((aligned(8)));++lck_grp_t * encodinglst_lck_grp;+lck_grp_attr_t * encodinglst_lck_grp_attr;+lck_attr_t * encodinglst_lck_attr;+++/* hfs encoding converter list */+SLIST_HEAD(encodinglst, hfs_encoding) hfs_encoding_list = {0};++lck_mtx_t encodinglst_mutex;++/* hfs encoding converter entry */+struct hfs_encoding {+ SLIST_ENTRY(hfs_encoding) link;+ int refcount;+ int kmod_id;+ u_int32_t encoding;+ hfs_to_unicode_func_t get_unicode_func;+ unicode_to_hfs_func_t get_hfsname_func;+};++void+hfs_converterinit(void)+{+ SLIST_INIT(&hfs_encoding_list);++ encodinglst_lck_grp_attr= lck_grp_attr_alloc_init();+ encodinglst_lck_grp = lck_grp_alloc_init("cnode_hash", encodinglst_lck_grp_attr);+ encodinglst_lck_attr = lck_attr_alloc_init();++ lck_mtx_init(&encodinglst_mutex, encodinglst_lck_grp, encodinglst_lck_attr);++ /*+ * add resident MacRoman converter and take a reference+ * since its always "loaded". MacRoman is the default converter+ * for HFS standard volumes.+ *+ * Only do this if we are actually supporting HFS standard+ * volumes. The converter is not used on configurations+ * that do not support HFS standard.+ */+ hfs_addconverter(0, kTextEncodingMacRoman, mac_roman_to_unicode, unicode_to_mac_roman);+ SLIST_FIRST(&hfs_encoding_list)->refcount++;+}++void hfs_converterdone(void)+{+ if (encodinglst_lck_grp_attr)+ lck_grp_attr_free(encodinglst_lck_grp_attr);+ if (encodinglst_lck_grp)+ lck_grp_free(encodinglst_lck_grp);+ if (encodinglst_lck_attr)+ lck_attr_free(encodinglst_lck_attr);+}++/*+ * For configurations that do support HFS standard, we need all of these..+ */++/*+ * hfs_addconverter - add an HFS encoding converter+ *+ * This is called exclusivly by kernel loadable modules+ * (like HFS_Japanese.kmod) to register hfs encoding+ * conversion routines.+ *+ */+int+hfs_addconverter(int id, u_int32_t encoding, hfs_to_unicode_func_t get_unicode, unicode_to_hfs_func_t get_hfsname)+{+ struct hfs_encoding *encp = hfs_malloc_type(struct hfs_encoding);++ lck_mtx_lock(&encodinglst_mutex);++ encp->link.sle_next = NULL;+ encp->refcount = 0;+ encp->encoding = encoding;+ encp->get_unicode_func = get_unicode;+ encp->get_hfsname_func = get_hfsname;+ encp->kmod_id = id;+ SLIST_INSERT_HEAD(&hfs_encoding_list, encp, link);++ lck_mtx_unlock(&encodinglst_mutex);++ if (id)+ OSKextRetainKextWithLoadTag(id);++ return (0);+}+++/*+ * hfs_remconverter - remove an HFS encoding converter+ *+ * Can be called by a kernel loadable module's finalize+ * routine to remove an encoding converter so that the+ * module (i.e. the code) can be unloaded.+ *+ * However, in the normal case, the removing and unloading+ * of these converters is done in hfs_relconverter.+ * The call is initiated from within the kernel during the unmounting of an hfs voulume.+ */+int+hfs_remconverter(int id, u_int32_t encoding)+{+ struct hfs_encoding *encp;++ lck_mtx_lock(&encodinglst_mutex);+ SLIST_FOREACH(encp, &hfs_encoding_list, link) {+ if (encp->encoding == encoding && encp->kmod_id == id) {+ encp->refcount--;++ /* if converter is no longer in use, release it */+ if (encp->refcount <= 0 && encp->kmod_id != 0) {+ SLIST_REMOVE(&hfs_encoding_list, encp, hfs_encoding, link);+ lck_mtx_unlock(&encodinglst_mutex);+ OSKextReleaseKextWithLoadTag(encp->kmod_id);+ hfs_free_type(encp, struct hfs_encoding);+ return (0);+ } else {+ lck_mtx_unlock(&encodinglst_mutex);+ return (1); /* busy */+ }+ break;+ }+ }+ lck_mtx_unlock(&encodinglst_mutex);++ return (0);+}++/*+ * hfs_getconverter - get HFS encoding converters+ *+ * Normally called during the mounting of an hfs voulume.+ */+int+hfs_getconverter(u_int32_t encoding, hfs_to_unicode_func_t *get_unicode, unicode_to_hfs_func_t *get_hfsname)+{+ struct hfs_encoding *encp;+ int found = 0;++ lck_mtx_lock(&encodinglst_mutex);+ SLIST_FOREACH(encp, &hfs_encoding_list, link) {+ if (encp->encoding == encoding) {+ found = 1;+ *get_unicode = encp->get_unicode_func;+ *get_hfsname = encp->get_hfsname_func;+ ++encp->refcount;+ break;+ }+ }+ lck_mtx_unlock(&encodinglst_mutex);++ if (!found) {+ *get_unicode = NULL;+ *get_hfsname = NULL;+ return (EINVAL);+ }++ return (0);+}+++/*+ * hfs_relconverter - release interest in an HFS encoding converter+ *+ * Normally called during the unmounting of an hfs voulume.+ */+int+hfs_relconverter(u_int32_t encoding)+{+ struct hfs_encoding *encp;++ lck_mtx_lock(&encodinglst_mutex);+ SLIST_FOREACH(encp, &hfs_encoding_list, link) {+ if (encp->encoding == encoding) {+ encp->refcount--;++ /* if converter is no longer in use, release it */+ if (encp->refcount <= 0 && encp->kmod_id != 0) {+ SLIST_REMOVE(&hfs_encoding_list, encp, hfs_encoding, link);+ lck_mtx_unlock(&encodinglst_mutex);++ OSKextReleaseKextWithLoadTag(encp->kmod_id);+ hfs_free_type(encp, struct hfs_encoding);+ return (0);+ }+ lck_mtx_unlock(&encodinglst_mutex);+ return (0);+ }+ }+ lck_mtx_unlock(&encodinglst_mutex);++ return (EINVAL);+}++/*+ * When an HFS name cannot be encoded with the current+ * volume encoding then MacRoman is used as a fallback.+ */+int+mac_roman_to_utf8(const Str31 hfs_str, ByteCount maxDstLen, ByteCount *actualDstLen, unsigned char* dstStr)+{+ int error;+ UniChar uniStr[MAX_HFS_UNICODE_CHARS];+ ItemCount uniCount;+ size_t utf8len;+ u_int8_t pascal_length = 0;++ /*+ * Validate the length of the Pascal-style string before passing it+ * down to the decoding engine.+ */+ pascal_length = *((const u_int8_t*)(hfs_str));+ if (pascal_length > 31) {+ /* invalid string; longer than 31 bytes */+ error = EINVAL;+ return error;+ }++ error = mac_roman_to_unicode(hfs_str, uniStr, MAX_HFS_UNICODE_CHARS, &uniCount);++ if (uniCount == 0)+ error = EINVAL;++ if (error == 0) {+ error = utf8_encodestr(uniStr, uniCount * sizeof(UniChar), dstStr, &utf8len, maxDstLen , ':', 0);+ if (error == ENAMETOOLONG)+ *actualDstLen = utf8_encodelen(uniStr, uniCount * sizeof(UniChar), ':', 0);+ else+ *actualDstLen = utf8len;+ }++ return error;+}++int+utf8_to_mac_roman(ByteCount srcLen, const unsigned char* srcStr, Str31 dstStr)+{+ int error;+ UniChar uniStr[MAX_HFS_UNICODE_CHARS];+ size_t ucslen;++ error = utf8_decodestr(srcStr, srcLen, uniStr, &ucslen, sizeof(uniStr), ':', 0);+ if (error == 0)+ error = unicode_to_mac_roman(uniStr, ucslen/sizeof(UniChar), dstStr);++ return error;+}++/*+ * HFS MacRoman to/from Unicode conversions are built into the kernel+ * All others hfs encodings are loadable.+ */++/* 0x00A0 - 0x00FF = Latin 1 Supplement (30 total) */+static u_int8_t gLatin1Table[] = {+ /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */+ /* 0x00A0 */ 0xCA, 0xC1, 0xA2, 0xA3, 0xDB, 0xB4, '?', 0xA4, 0xAC, 0xA9, 0xBB, 0xC7, 0xC2, '?', 0xA8, 0xF8,+ /* 0x00B0 */ 0xA1, 0XB1, '?', '?', 0xAB, 0xB5, 0xA6, 0xe1, 0xFC, '?', 0xBC, 0xC8, '?', '?', '?', 0xC0,+ /* 0x00C0 */ '?', '?', '?', '?', '?', '?', 0xAE, '?', '?', '?', '?', '?', '?', '?', '?', '?',+ /* 0x00D0 */ '?', '?', '?', '?', '?', '?', '?', '?', 0xAF, '?', '?', '?', '?', '?', '?', 0xA7,+ /* 0x00E0 */ '?', '?', '?', '?', '?', '?', 0xBE, '?', '?', '?', '?', '?', '?', '?', '?', '?',+ /* 0x00F0 */ '?', '?', '?', '?', '?', '?', '?', 0xD6, 0xBF, '?', '?', '?', '?', '?', '?', '?'+};++/* 0x02C0 - 0x02DF = Spacing Modifiers (8 total) */+static u_int8_t gSpaceModsTable[] = {+ /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */+ /* 0x02C0 */ '?', '?', '?', '?', '?', '?', 0xF6, 0xFF, '?', '?', '?', '?', '?', '?', '?', '?',+ /* 0x02D0 */ '?', '?', '?', '?', '?', '?', '?', '?', 0xF9, 0xFA, 0xFB, 0xFE, 0xF7, 0xFD, '?', '?'+};++/* 0x2010 - 0x20AF = General Punctuation (17 total) */+static u_int8_t gPunctTable[] = {+ /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */+ /* 0x2010 */ '?', '?', '?', 0xd0, 0xd1, '?', '?', '?', 0xd4, 0xd5, 0xe2, '?', 0xd2, 0xd3, 0xe3, '?',+ /* 0x2020 */ 0xa0, 0xe0, 0xa5, '?', '?', '?', 0xc9, '?', '?', '?', '?', '?', '?', '?', '?', '?',+ /* 0x2030 */ 0xe4, '?', '?', '?', '?', '?', '?', '?', '?', 0xdc, 0xdd, '?', '?', '?', '?', '?',+ /* 0x2040 */ '?', '?', '?', '?', 0xda, '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',+ /* 0x2050 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',+ /* 0x2060 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',+ /* 0x2070 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',+ /* 0x2080 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',+ /* 0x2090 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',+ /* 0x20A0 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', 0xdb, '?', '?', '?'+};++/* 0x22xx = Mathematical Operators (11 total) */+static u_int8_t gMathTable[] = {+ /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */+ /* 0x2200 */ '?', '?', 0xb6, '?', '?', '?', 0xc6, '?', '?', '?', '?', '?', '?', '?', '?', 0xb8,+ /* 0x2210 */ '?', 0xb7, '?', '?', '?', '?', '?', '?', '?', '?', 0xc3, '?', '?', '?', 0xb0, '?',+ /* 0x2220 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', 0xba, '?', '?', '?', '?',+ /* 0x2230 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',+ /* 0x2240 */ '?', '?', '?', '?', '?', '?', '?', '?', 0xc5, '?', '?', '?', '?', '?', '?', '?',+ /* 0x2250 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',+ /* 0x2260 */ 0xad, '?', '?', '?', 0xb2, 0xb3, '?', '?'+};++/* */+static u_int8_t gReverseCombTable[] = {+ /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */+ /* 0x40 */ 0xDA, 0x40, 0xDA, 0xDA, 0xDA, 0x56, 0xDA, 0xDA, 0xDA, 0x6C, 0xDA, 0xDA, 0xDA, 0xDA, 0x82, 0x98,+ /* 0x50 */ 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xAE, 0xDA, 0xDA, 0xDA, 0xC4, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA,+ /* 0x60 */ 0xDA, 0x4B, 0xDA, 0xDA, 0xDA, 0x61, 0xDA, 0xDA, 0xDA, 0x77, 0xDA, 0xDA, 0xDA, 0xDA, 0x8D, 0xA3,+ /* 0x70 */ 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xB9, 0xDA, 0xDA, 0xDA, 0xCF, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA,++ /* Combining Diacritical Marks (0x0300 - 0x030A) */+ /* 0 1 2 3 4 5 6 7 8 9 A */+ /* 'A' */+ /* 0x0300 */ 0xCB, 0xE7, 0xE5, 0xCC, '?', '?', '?', '?', 0x80, '?', 0x81,++ /* 'a' */+ /* 0x0300 */ 0x88, 0x87, 0x89, 0x8B, '?', '?', '?', '?', 0x8A, '?', 0x8C,++ /* 'E' */+ /* 0x0300 */ 0xE9, 0x83, 0xE6, '?', '?', '?', '?', '?', 0xE8, '?', '?',++ /* 'e' */+ /* 0x0300 */ 0x8F, 0x8E, 0x90, '?', '?', '?', '?', '?', 0x91, '?', '?',++ /* 'I' */+ /* 0x0300 */ 0xED, 0xEA, 0xEB, '?', '?', '?', '?', '?', 0xEC, '?', '?',++ /* 'i' */+ /* 0x0300 */ 0x93, 0x92, 0x94, '?', '?', '?', '?', '?', 0x95, '?', '?',++ /* 'N' */+ /* 0x0300 */ '?', '?', '?', 0x84, '?', '?', '?', '?', '?', '?', '?',++ /* 'n' */+ /* 0x0300 */ '?', '?', '?', 0x96, '?', '?', '?', '?', '?', '?', '?',++ /* 'O' */+ /* 0x0300 */ 0xF1, 0xEE, 0xEF, 0xCD, '?', '?', '?', '?', 0x85, '?', '?',++ /* 'o' */+ /* 0x0300 */ 0x98, 0x97, 0x99, 0x9B, '?', '?', '?', '?', 0x9A, '?', '?',++ /* 'U' */+ /* 0x0300 */ 0xF4, 0xF2, 0xF3, '?', '?', '?', '?', '?', 0x86, '?', '?',++ /* 'u' */+ /* 0x0300 */ 0x9D, 0x9C, 0x9E, '?', '?', '?', '?', '?', 0x9F, '?', '?',++ /* 'Y' */+ /* 0x0300 */ '?', '?', '?', '?', '?', '?', '?', '?', 0xD9, '?', '?',++ /* 'y' */+ /* 0x0300 */ '?', '?', '?', '?', '?', '?', '?', '?', 0xD8, '?', '?',++ /* else */+ /* 0x0300 */ '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?'+};+++/*+ * Convert Unicode string into HFS MacRoman encoding+ *+ * Assumes Unicode input is fully decomposed+ */+int unicode_to_mac_roman(UniChar *uni_str, u_int32_t unicodeChars, Str31 hfs_str)+{+ u_int8_t *p;+ const UniChar *u;+ UniChar c;+ UniChar mask;+ u_int16_t inputChars;+ u_int16_t pascalChars;+ OSErr result = noErr;+ u_int8_t lsb;+ u_int8_t prevChar;+ u_int8_t mc;++ mask = (UniChar) 0xFF80;+ p = &hfs_str[1];+ u = uni_str;+ inputChars = unicodeChars;+ pascalChars = prevChar = 0;++ while (inputChars) {+ c = *(u++);+ lsb = (u_int8_t) c;++ /*+ * If its not 7-bit ascii, then we need to map it+ */+ if ( c & mask ) {+ mc = '?';+ switch (c & 0xFF00) {+ case 0x0000:+ if (lsb >= 0xA0)+ mc = gLatin1Table[lsb - 0xA0];+ break;++ case 0x0200:+ if (lsb >= 0xC0 && lsb <= 0xDF)+ mc = gSpaceModsTable[lsb - 0xC0];+ break;++ case 0x2000:+ if (lsb >= 0x10 && lsb <= 0xAF)+ mc = gPunctTable[lsb- 0x10];+ break;++ case 0x2200:+ if (lsb < 0x68)+ mc = gMathTable[lsb];+ break;++ case 0x0300:+ if (c <= 0x030A) {+ if (prevChar >= 'A' && prevChar < 'z') {+ mc = gReverseCombTable[gReverseCombTable[prevChar - 0x40] + lsb];+ --p; /* backup over base char */+ --pascalChars;+ }+ } else {+ switch (c) {+ case 0x0327: /* combining cedilla */+ if (prevChar == 'C')+ mc = 0x82;+ else if (prevChar == 'c')+ mc = 0x8D;+ else+ break;+ --p; /* backup over base char */+ --pascalChars;+ break;++ case 0x03A9: mc = 0xBD; break; /* omega */++ case 0x03C0: mc = 0xB9; break; /* pi */+ }+ }+ break;++ default:+ switch (c) {+ case 0x0131: mc = 0xf5; break; /* dotless i */++ case 0x0152: mc = 0xce; break; /* OE */++ case 0x0153: mc = 0xcf; break; /* oe */++ case 0x0192: mc = 0xc4; break; /* � */++ case 0x2122: mc = 0xaa; break; /* TM */++ case 0x25ca: mc = 0xd7; break; /* diamond */++ case 0xf8ff: mc = 0xf0; break; /* apple logo */++ case 0xfb01: mc = 0xde; break; /* fi */++ case 0xfb02: mc = 0xdf; break; /* fl */+ }+ } /* end switch (c & 0xFF00) */++ /*+ * If we have an unmapped character then we need to mangle the name...+ */+ if (mc == '?')+ result = kTECUsedFallbacksStatus;++ prevChar = 0;+ lsb = mc;++ } else {+ prevChar = lsb;+ }++ if (pascalChars >= 31)+ break;++ *(p++) = lsb;+ ++pascalChars;+ --inputChars;++ } /* end while */++ hfs_str[0] = pascalChars;++ if (inputChars > 0)+ result = ENAMETOOLONG; /* ran out of room! */++ return result;+}+++static UniChar gHiBitBaseUnicode[128] = {+ /* 0x80 */ 0x0041, 0x0041, 0x0043, 0x0045, 0x004e, 0x004f, 0x0055, 0x0061,+ /* 0x88 */ 0x0061, 0x0061, 0x0061, 0x0061, 0x0061, 0x0063, 0x0065, 0x0065,+ /* 0x90 */ 0x0065, 0x0065, 0x0069, 0x0069, 0x0069, 0x0069, 0x006e, 0x006f,+ /* 0x98 */ 0x006f, 0x006f, 0x006f, 0x006f, 0x0075, 0x0075, 0x0075, 0x0075,+ /* 0xa0 */ 0x2020, 0x00b0, 0x00a2, 0x00a3, 0x00a7, 0x2022, 0x00b6, 0x00df,+ /* 0xa8 */ 0x00ae, 0x00a9, 0x2122, 0x00b4, 0x00a8, 0x2260, 0x00c6, 0x00d8,+ /* 0xb0 */ 0x221e, 0x00b1, 0x2264, 0x2265, 0x00a5, 0x00b5, 0x2202, 0x2211,+ /* 0xb8 */ 0x220f, 0x03c0, 0x222b, 0x00aa, 0x00ba, 0x03a9, 0x00e6, 0x00f8,+ /* 0xc0 */ 0x00bf, 0x00a1, 0x00ac, 0x221a, 0x0192, 0x2248, 0x2206, 0x00ab,+ /* 0xc8 */ 0x00bb, 0x2026, 0x00a0, 0x0041, 0x0041, 0x004f, 0x0152, 0x0153,+ /* 0xd0 */ 0x2013, 0x2014, 0x201c, 0x201d, 0x2018, 0x2019, 0x00f7, 0x25ca,+ /* 0xd8 */ 0x0079, 0x0059, 0x2044, 0x20ac, 0x2039, 0x203a, 0xfb01, 0xfb02,+ /* 0xe0 */ 0x2021, 0x00b7, 0x201a, 0x201e, 0x2030, 0x0041, 0x0045, 0x0041,+ /* 0xe8 */ 0x0045, 0x0045, 0x0049, 0x0049, 0x0049, 0x0049, 0x004f, 0x004f,+ /* 0xf0 */ 0xf8ff, 0x004f, 0x0055, 0x0055, 0x0055, 0x0131, 0x02c6, 0x02dc,+ /* 0xf8 */ 0x00af, 0x02d8, 0x02d9, 0x02da, 0x00b8, 0x02dd, 0x02db, 0x02c7+};++static UniChar gHiBitCombUnicode[128] = {+ /* 0x80 */ 0x0308, 0x030a, 0x0327, 0x0301, 0x0303, 0x0308, 0x0308, 0x0301,+ /* 0x88 */ 0x0300, 0x0302, 0x0308, 0x0303, 0x030a, 0x0327, 0x0301, 0x0300,+ /* 0x90 */ 0x0302, 0x0308, 0x0301, 0x0300, 0x0302, 0x0308, 0x0303, 0x0301,+ /* 0x98 */ 0x0300, 0x0302, 0x0308, 0x0303, 0x0301, 0x0300, 0x0302, 0x0308,+ /* 0xa0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 0xa8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 0xb0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 0xb8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 0xc0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 0xc8 */ 0x0000, 0x0000, 0x0000, 0x0300, 0x0303, 0x0303, 0x0000, 0x0000,+ /* 0xd0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 0xd8 */ 0x0308, 0x0308, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,+ /* 0xe0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0302, 0x0302, 0x0301,+ /* 0xe8 */ 0x0308, 0x0300, 0x0301, 0x0302, 0x0308, 0x0300, 0x0301, 0x0302,+ /* 0xf0 */ 0x0000, 0x0300, 0x0301, 0x0302, 0x0300, 0x0000, 0x0000, 0x0000,+ /* 0xf8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000+};+++/*+ * Convert HFS MacRoman encoded string into Unicode+ *+ * Unicode output is fully decomposed+ */+int+mac_roman_to_unicode(const Str31 hfs_str, UniChar *uni_str,+ __unused u_int32_t maxCharLen, u_int32_t *unicodeChars)+{+ const u_int8_t *p;+ UniChar *u;+ u_int16_t pascalChars;+ u_int8_t c;++ p = hfs_str;+ u = uni_str;++ *unicodeChars = pascalChars = *(p++); /* pick up length byte */++ while (pascalChars--) {+ c = *(p++);++ if ( (int8_t) c >= 0 ) { /* check if seven bit ascii */+ *(u++) = (UniChar) c; /* just pad high byte with zero */+ } else { /* its a hi bit character */+ UniChar uc;++ c &= 0x7F;+ *(u++) = uc = gHiBitBaseUnicode[c];++ /*+ * if the unicode character we get back is an alpha char+ * then we must have an additional combining character+ */+ if ((uc <= (UniChar) 'z') && (uc >= (UniChar) 'A')) {+ *(u++) = gHiBitCombUnicode[c];+ ++(*unicodeChars);+ }+ }+ }++ return noErr;+}diff --git a/xnu/files/bsd/hfs_encodings/hfs_encodings.h b/xnu/files/bsd/hfs_encodings/hfs_encodings.hnew file mode 100644index 0000000..02b1336--- /dev/null+++ b/xnu/files/bsd/hfs_encodings/hfs_encodings.h@@ -0,0 +1,89 @@+/*+ * Copyright (c) 2000-2015 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@+ */+/*+ * Copyright (c) 1997-2000 Apple Inc. All Rights Reserved+ */++#ifndef _HFS_ENCODINGS_H_+#define _HFS_ENCODINGS_H_++#if !TARGET_OS_IPHONE++#include <sys/appleapiopts.h>++#ifdef __APPLE_API_UNSTABLE++#define CTL_HFS_NAMES { \+ { 0, 0 }, \+ { "encodingbias", CTLTYPE_INT }, \+}++__BEGIN_DECLS++/*+ * HFS Filename Encoding Converters Interface+ *+ * Private Interface for adding hfs filename+ * encoding converters. These are not needed+ * for HFS Plus volumes (since they already+ * have Unicode filenames).+ *+ * Used by HFS Encoding Converter Kernel Modules+ * to register their encoding conversion routines.+ */++typedef int (* hfs_to_unicode_func_t)(const uint8_t hfs_str[32], uint16_t *uni_str,+ u_int32_t maxCharLen, u_int32_t *usedCharLen);++typedef int (* unicode_to_hfs_func_t)(uint16_t *uni_str, u_int32_t unicodeChars,+ uint8_t hfs_str[32]);++int hfs_relconverter (u_int32_t encoding);+int hfs_getconverter(u_int32_t encoding, hfs_to_unicode_func_t *get_unicode,+ unicode_to_hfs_func_t *get_hfsname);+int hfs_addconverter(int kmod_id, u_int32_t encoding,+ hfs_to_unicode_func_t get_unicode,+ unicode_to_hfs_func_t get_hfsname);+int hfs_remconverter(int kmod_id, u_int32_t encoding);++u_int32_t hfs_pickencoding(const u_int16_t *src, int len);+u_int32_t hfs_getencodingbias(void);+void hfs_setencodingbias(u_int32_t bias);+int mac_roman_to_utf8(const uint8_t hfs_str[32], uint32_t maxDstLen, uint32_t *actualDstLen,+ unsigned char* dstStr);+int utf8_to_mac_roman(uint32_t srcLen, const unsigned char* srcStr, uint8_t dstStr[32]);+int mac_roman_to_unicode(const uint8_t hfs_str[32], uint16_t *uni_str, u_int32_t maxCharLen, u_int32_t *usedCharLen);+int unicode_to_mac_roman(uint16_t *uni_str, u_int32_t unicodeChars, uint8_t hfs_str[32]);++__END_DECLS++#endif /* __APPLE_API_UNSTABLE */++#endif // !TARGET_OS_IPHONE++#endif /* ! _HFS_ENCODINGS_H_ */diff --git a/xnu/files/bsd/hfs_encodings/hfs_encodings_internal.h b/xnu/files/bsd/hfs_encodings/hfs_encodings_internal.hnew file mode 100644index 0000000..c885821--- /dev/null+++ b/xnu/files/bsd/hfs_encodings/hfs_encodings_internal.h@@ -0,0 +1,41 @@+/*+ * Copyright (c) 2015 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@+ */++#ifndef hfs_encodings_internal_h+#define hfs_encodings_internal_h++#include <sys/cdefs.h>++__BEGIN_DECLS++void hfs_converterinit(void);+void hfs_converterdone(void);++__END_DECLS++#endif /* hfs_encodings_internal_h */diff --git a/xnu/hakios.patch b/xnu/hakios.patchindex 0386087..d6ddd19 100644--- a/xnu/hakios.patch+++ b/xnu/hakios.patch@@ -100,8 +100,26 @@ index a4d25040f38f..aad72993d139 100644kern_csr.o_INCFLAGS += -I$(SRCROOT)/osfmkkern_debug.o_INCFLAGS += -I$(SRCROOT)/osfmk+diff --git a/bsd/conf/Makefile.template b/bsd/conf/Makefile.template+index 4b83160780c3..8997af1f0e1b 100644+--- a/bsd/conf/Makefile.template++++ b/bsd/conf/Makefile.template+@@ -588,5 +588,13 @@ do_build_all:: do_all++ %RULES+++# HakiOS: HFS Plus built in (bsd/hfs, Apple's hfs-627.100.6), compiled as its kext was: against the kernel's KPI,++# not its insides (no XNU/BSD/MACH_KERNEL_PRIVATE), kext-config.h first, its own headers beside it, and its warnings++# its own (it is Apple's code as it was published, not this kernel's)++HFS_OBJS = $(patsubst %.c,%.o,$(notdir $(wildcard $(SRCROOT)/bsd/hfs/*.c)))++$(foreach o,$(HFS_OBJS),$(eval $(o)_CFLAGS_ADD += -UXNU_KERNEL_PRIVATE -UBSD_KERNEL_PRIVATE -UMACH_KERNEL_PRIVATE \++ -include $(SRCROOT)/bsd/hfs/kext-config.h -I$(SRCROOT)/bsd/hfs -idirafter $(SDKROOT)/usr/include))++$(foreach o,$(HFS_OBJS),$(eval $(o)_CWARNFLAGS_ADD += -w))+++ include $(MakeInc_rule)+ include $(MakeInc_dir)diff --git a/bsd/conf/files b/bsd/conf/files-index 44274016a4cf..086752d95378 100644+index 44274016a4cf..27cccab98c8e 100644--- a/bsd/conf/files+++ b/bsd/conf/files@@ -109,6 +109,51 @@ bsd/dev/munge.c optional config_requires_u32_munging@@ -156,7 +174,7 @@ index 44274016a4cf..086752d95378 100644bsd/dev/dev_perfmon.c optional config_perfmonbsd/libkern/crc32.c standard-@@ -155,6 +200,14 @@ bsd/miscfs/devfs/devfs_vfsops.c optional devfs+@@ -155,6 +200,52 @@ bsd/miscfs/devfs/devfs_vfsops.c optional devfsbsd/miscfs/mockfs/mockfs_fsnode.c optional mockfsbsd/miscfs/mockfs/mockfs_vfsops.c optional mockfsbsd/miscfs/mockfs/mockfs_vnops.c optional mockfs@@ -168,10 +186,48 @@ index 44274016a4cf..086752d95378 100644+bsd/miscfs/apfs/apfs_vfsops.c optional apfs+bsd/miscfs/apfs/apfs_vnops.c optional apfs+bsd/miscfs/ramfs/ramfs.c optional ramfs++bsd/hfs/BTree.c optional hfs++bsd/hfs/BTreeAllocate.c optional hfs++bsd/hfs/BTreeMiscOps.c optional hfs++bsd/hfs/BTreeNodeOps.c optional hfs++bsd/hfs/BTreeNodeReserve.c optional hfs++bsd/hfs/BTreeScanner.c optional hfs++bsd/hfs/BTreeTreeOps.c optional hfs++bsd/hfs/BTreeWrapper.c optional hfs++bsd/hfs/CatalogUtilities.c optional hfs++bsd/hfs/FileExtentMapping.c optional hfs++bsd/hfs/FileIDsServices.c optional hfs++bsd/hfs/MacOSStubs.c optional hfs++bsd/hfs/UnicodeWrappers.c optional hfs++bsd/hfs/VolumeAllocation.c optional hfs++bsd/hfs/hfs_attrlist.c optional hfs++bsd/hfs/hfs_btreeio.c optional hfs++bsd/hfs/hfs_builtin.c optional hfs++bsd/hfs/hfs_catalog.c optional hfs++bsd/hfs/hfs_chash.c optional hfs++bsd/hfs/hfs_cnode.c optional hfs++bsd/hfs/hfs_cprotect.c optional hfs++bsd/hfs/hfs_endian.c optional hfs++bsd/hfs/hfs_extents.c optional hfs++bsd/hfs/hfs_fsinfo.c optional hfs++bsd/hfs/hfs_hotfiles.c optional hfs++bsd/hfs/hfs_journal.c optional hfs++bsd/hfs/hfs_link.c optional hfs++bsd/hfs/hfs_lookup.c optional hfs++bsd/hfs/hfs_notification.c optional hfs++bsd/hfs/hfs_quota.c optional hfs++bsd/hfs/hfs_readwrite.c optional hfs++bsd/hfs/hfs_resize.c optional hfs++bsd/hfs/hfs_search.c optional hfs++bsd/hfs/hfs_vfsops.c optional hfs++bsd/hfs/hfs_vfsutils.c optional hfs++bsd/hfs/hfs_vnops.c optional hfs++bsd/hfs/hfs_xattr.c optional hfs++bsd/hfs/rangelist.c optional hfsbsd/miscfs/routefs/routefs_ops.c optional routefs-@@ -361,6 +414,7 @@ bsd/security/audit/audit_syscalls.c standard+@@ -361,6 +452,7 @@ bsd/security/audit/audit_syscalls.c standardbsd/security/audit/audit_worker.c optional config_auditbsd/pthread/pthread_shims.c standard@@ -179,7 +235,7 @@ index 44274016a4cf..086752d95378 100644bsd/pthread/pthread_priority.c standardbsd/pthread/pthread_workqueue.c standard-@@ -383,6 +437,7 @@ bsd/kern/kern_debug.c standard+@@ -383,6 +475,7 @@ bsd/kern/kern_debug.c standardbsd/kern/kern_symfile.c standardbsd/kern/kern_descrip.c standardbsd/kern/kern_guarded.c standard@@ -1197,10 +1253,10 @@ index cbaa0b221894..78315a2d54cf 100644int eofflag;uint64_t options;diff --git a/bsd/vfs/vfs_conf.c b/bsd/vfs/vfs_conf.c-index bae70cda3a96..031613b10643 100644+index bae70cda3a96..63814100c68f 100644--- a/bsd/vfs/vfs_conf.c+++ b/bsd/vfs/vfs_conf.c-@@ -103,6 +103,15 @@ extern struct vfsops mockfs_vfsops;+@@ -103,6 +103,19 @@ extern struct vfsops mockfs_vfsops;extern int mockfs_mountroot(mount_t, vnode_t, vfs_context_t);#endif /* MOCKFS */@@ -1208,6 +1264,10 @@ index bae70cda3a96..031613b10643 100644+extern struct vfsops ramfs_vfsops;+#endif /* RAMFS */+++#if HFS++extern struct vfsops hfs_vfsops;++#endif /* HFS */+++#if APFS+extern struct vfsops apfs_vfsops;+extern int apfs_mountroot(mount_t, vnode_t, vfs_context_t);@@ -1216,18 +1276,19 @@ index bae70cda3a96..031613b10643 100644enum fs_type_num {FT_NFS = 2,FT_DEVFS = 19,-@@ -110,7 +119,9 @@ enum fs_type_num {+@@ -110,7 +123,10 @@ enum fs_type_num {FT_ROUTEFS = 21,FT_NULLFS = 22,FT_BINDFS = 23,- FT_MOCKFS = 0x6D6F636B+ FT_MOCKFS = 0x6D6F636B,+ FT_RAMFS = 0x72616D66,++ FT_HFS = 0x11,+ FT_APFS = 0x61706673};int fstypenumstart = FT_BINDFS + 1;-@@ -194,6 +205,54 @@ static struct vfstable vfstbllist[] = {+@@ -194,6 +210,79 @@ static struct vfstable vfstbllist[] = {},#endif /* BINDFS */@@ -1250,6 +1311,31 @@ index bae70cda3a96..031613b10643 100644+ },+#endif /* RAMFS */+++#if HFS++ /*++ * HFS Plus, read-write, built in rather than a kext (bsd/hfs, Apple's hfs-627.100.6): the data volume on the++ * phone's flash, /private/var, where ramfs keeps it in memory. Its own arguments (struct hfs_mount_args) and++ * local ones, as the kext registered itself (no VFS_TBLGENERICMNTARGS): the kernel looks up the device named++ * by their first field and hands its vnode to hfs_mount(). Mounted by init, from user space.++ */++ {++ .vfc_vfsops = &hfs_vfsops,++ .vfc_name = "hfs",++ .vfc_typenum = FT_HFS,++ .vfc_refcount = 0,++ .vfc_flags = MNT_LOCAL | MNT_DOVOLFS,++ .vfc_mountroot = NULL,++ .vfc_next = NULL,++ .vfc_reserved1 = 0,++ .vfc_reserved2 = 0,++ .vfc_vfsflags = VFC_VFSLOCALARGS | VFC_VFSREADDIR_EXTENDED | VFC_VFS64BITREADY | VFC_VFSVNOP_PAGEOUTV2 |++ VFC_VFSVNOP_PAGEINV2 | VFC_VFSNATIVEXATTR,++ .vfc_descptr = NULL,++ .vfc_descsize = 0,++ .vfc_sysctl = NULL++ },++#endif /* HFS */+++#if APFS+ /*+ * Apple File System, read only: the root and every image of this port's (the RAM@@ -1282,7 +1368,7 @@ index bae70cda3a96..031613b10643 100644#if MOCKFS/* If we are configured for it, mockfs should always be the last standard entry (and thus the last FS we attempt mountroot with) */{-@@ -298,6 +357,15 @@ extern const struct vnodeopv_desc devfs_fdesc_vnodeop_opv_desc;+@@ -298,6 +387,21 @@ extern const struct vnodeopv_desc devfs_fdesc_vnodeop_opv_desc;extern const struct vnodeopv_desc mockfs_vnodeop_opv_desc;#endif /* MOCKFS */@@ -1291,6 +1377,12 @@ index bae70cda3a96..031613b10643 100644+extern const struct vnodeopv_desc ramfs_vnodeop_opv_desc;+#endif /* RAMFS */+++#if HFS++extern const struct vnodeopv_desc hfs_vnodeop_opv_desc;++extern const struct vnodeopv_desc hfs_specop_opv_desc;++extern const struct vnodeopv_desc hfs_fifoop_opv_desc;++#endif /* HFS */+++#if APFS+extern const struct vnodeopv_desc apfs_vnodeop_opv_desc;+#endif /* APFS */@@ -1298,13 +1390,18 @@ index bae70cda3a96..031613b10643 100644extern const struct vnodeopv_desc nullfs_vnodeop_opv_desc;extern const struct vnodeopv_desc bindfs_vnodeop_opv_desc;-@@ -327,5 +395,11 @@ const struct vnodeopv_desc *vfs_opv_descs[] = {+@@ -327,5 +431,16 @@ const struct vnodeopv_desc *vfs_opv_descs[] = {#if MOCKFS&mockfs_vnodeop_opv_desc,#endif /* MOCKFS */+#if RAMFS+ &ramfs_vnodeop_opv_desc,+#endif /* RAMFS */++#if HFS++ &hfs_vnodeop_opv_desc,++ &hfs_specop_opv_desc,++ &hfs_fifoop_opv_desc,++#endif /* HFS */+#if APFS+ &apfs_vnodeop_opv_desc,+#endif /* APFS */@@ -1509,20 +1606,21 @@ index 60c8b9eedd50..b0029de5ef21 100644("shared_region: %p [%d(%s)] map(%p:'%s'): ""not on process' root volume nor preboot volume\n",diff --git a/config/MASTER b/config/MASTER-index 07147cb3188b..e937e62bf4c3 100644+index 07147cb3188b..86e9eefb5ec7 100644--- a/config/MASTER+++ b/config/MASTER-@@ -113,6 +113,8 @@ options CONFIG_WORKLOOP_DEBUG # <config_workloop_debug>+@@ -113,6 +113,9 @@ options CONFIG_WORKLOOP_DEBUG # <config_workloop_debug># 4.4 filesystems#options MOCKFS # Boot from an executable # <mockfs>+options APFS # Apple File System, read only # <apfs>+options RAMFS # Read-write filesystem in memory # <ramfs>++options HFS # HFS Plus, read-write: the data volume on the flash # <hfs>options FIFO # fifo support # <fifo>options FDESC # fdesc_fs support # <fdesc>options DEVFS # devfs support # <devfs>diff --git a/config/MASTER.arm64.bcm2837 b/config/MASTER.arm64.bcm2837-index 1ed75eea2052..117891784c1a 100644+index 1ed75eea2052..4c67d211fb60 100644--- a/config/MASTER.arm64.bcm2837+++ b/config/MASTER.arm64.bcm2837@@ -16,15 +16,15 @@@@ -1541,7 +1639,7 @@ index 1ed75eea2052..117891784c1a 100644-# FILESYS_BASE = [ devfs fifo fs_compression config_protect config_mnt_rootsnap config_fse routefs namedstreams bindfs]+# BSD_DEV = [ BSD_BASE config_netboot config_imageboot config_coredump config_vnguard ]+# BSD_DEBUG = [ BSD_BASE config_netboot config_imageboot config_coredump config_vnguard ]-+# FILESYS_BASE = [ devfs fifo fs_compression config_protect config_mnt_rootsnap config_fse routefs namedstreams bindfs mockfs ramfs apfs ]++# FILESYS_BASE = [ devfs fifo fs_compression config_protect config_mnt_rootsnap config_fse routefs namedstreams bindfs mockfs ramfs apfs hfs ]# FILESYS_RELEASE= [ FILESYS_BASE ]# FILESYS_DEV = [ FILESYS_BASE config_union_mounts fdesc ]# FILESYS_DEBUG = [ FILESYS_BASE config_union_mounts fdesc ]