File size: 7,342 Bytes
e249c6d | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 | import path from "node:path";
import koffi from "koffi";
const kernel32 = koffi.load("kernel32.dll");
const getLastError = kernel32.func("uint32_t __stdcall GetLastError()");
const getVolumePath = kernel32.func(
"int32_t __stdcall GetVolumePathNameW(str16 path, _Out_ void *volume, uint32_t length)",
);
const getVolumeInformation = kernel32.func(
"int32_t __stdcall GetVolumeInformationW(str16 root, void *label, uint32_t labelLength, void *serial, void *componentLength, _Out_ uint32_t *flags, _Out_ void *filesystem, uint32_t filesystemLength)",
);
const getDiskFreeSpace = kernel32.func(
"int32_t __stdcall GetDiskFreeSpaceW(str16 root, _Out_ uint32_t *sectors, _Out_ uint32_t *bytes, _Out_ uint32_t *freeClusters, _Out_ uint32_t *clusters)",
);
const createFile = kernel32.func(
"void * __stdcall CreateFileW(str16 path, uint32_t access, uint32_t sharing, void *security, uint32_t disposition, uint32_t flags, void *templateFile)",
);
const closeHandle = kernel32.func("int32_t __stdcall CloseHandle(void *handle)");
const getFileInformation = kernel32.func(
"int32_t __stdcall GetFileInformationByHandle(void *handle, _Out_ void *information)",
);
const setFileInformation = kernel32.func(
"int32_t __stdcall SetFileInformationByHandle(void *handle, int32_t informationClass, void *information, uint32_t size)",
);
const setFileTime = kernel32.func(
"int32_t __stdcall SetFileTime(void *handle, void *created, void *accessed, void *written)",
);
const setFileAttributes = kernel32.func(
"int32_t __stdcall SetFileAttributesW(str16 path, uint32_t attributes)",
);
const copyFile = kernel32.func(
"int32_t __stdcall CopyFileExW(str16 source, str16 destination, void *progress, void *data, void *cancel, uint32_t flags)",
);
const deviceIoControl = kernel32.func(
"int32_t __stdcall DeviceIoControl(void *handle, uint32_t code, void *input, uint32_t inputSize, _Out_ void *output, uint32_t outputSize, _Out_ uint32_t *returned, void *overlapped)",
);
const duplicateExtents = koffi.struct({
file: "void *",
sourceOffset: "int64_t",
targetOffset: "int64_t",
length: "int64_t",
});
function failure(operation: string): Error {
const errno: number = getLastError();
return Object.assign(new Error(`${operation} failed (Win32 error ${errno})`), {
code: errno === 80 || errno === 183 ? "EEXIST" : "EIO",
errno,
});
}
function openFile(filePath: string, access: number, disposition: number, flags: number): unknown {
const handle: unknown = createFile(filePath, access, 1, null, disposition, flags, null);
if (handle === null || BigInt.asIntN(64, koffi.address(handle)) === -1n) {
throw failure(`CreateFileW(${filePath})`);
}
return handle;
}
function control(handle: unknown, code: number, input: Buffer | null, output: Buffer | null) {
if (
!deviceIoControl(
handle,
code,
input,
input?.length ?? 0,
output,
output?.length ?? 0,
[0],
null,
)
) {
throw failure(`DeviceIoControl(0x${code.toString(16)})`);
}
}
export const refsFilesystem = {
probe(parentPath: string): { clusterSize: number } | null {
// Resolve the containing volume, including volumes mounted under NTFS folders.
const root = Buffer.alloc(32768 * 2);
if (!getVolumePath(path.toNamespacedPath(path.resolve(parentPath)), root, root.length / 2)) {
throw failure("GetVolumePathNameW");
}
const volume = root.toString("utf16le").split("\0", 1)[0];
const filesystem = Buffer.alloc(64);
const flags: [number] = [0];
if (
!getVolumeInformation(volume, null, 0, null, null, flags, filesystem, filesystem.length / 2)
) {
throw failure("GetVolumeInformationW");
}
// FILE_SUPPORTS_BLOCK_REFCOUNTING is the filesystem's advertised clone capability.
if (filesystem.toString("utf16le").split("\0", 1)[0] !== "ReFS" || !(flags[0] & 0x08000000)) {
return null;
}
const sectors: [number] = [0];
const bytes: [number] = [0];
if (!getDiskFreeSpace(volume, sectors, bytes, [0], [0])) {
throw failure("GetDiskFreeSpaceW");
}
return { clusterSize: sectors[0] * bytes[0] };
},
cloneFile(this: void, source: string, destination: string, clusterSize: number): void {
const from = path.toNamespacedPath(path.resolve(source));
const to = path.toNamespacedPath(path.resolve(destination));
// OPEN_EXISTING, NO_BUFFERING | OPEN_REPARSE_POINT: never dereference a template link.
const sourceHandle = openFile(from, 0x80000000, 3, 0x20200000);
try {
const information = Buffer.alloc(52); // BY_HANDLE_FILE_INFORMATION
if (!getFileInformation(sourceHandle, information)) {
throw failure("GetFileInformationByHandle");
}
const attributes = information.readUInt32LE(0);
if (attributes & 0x400) {
// COPY_FILE_FAIL_IF_EXISTS | COPY_FILE_COPY_SYMLINK copies the link itself.
if (!copyFile(from, to, null, null, null, 0x801)) {
throw failure("CopyFileExW(symlink)");
}
return;
}
// CREATE_NEW preserves existing destinations; ACLs inherit from the destination parent.
const targetHandle = openFile(to, 0xc0000000, 1, 0x80);
try {
const integrity = Buffer.alloc(16);
control(sourceHandle, 0x9027c, null, integrity); // FSCTL_GET_INTEGRITY_INFORMATION
control(targetHandle, 0x9c280, integrity.subarray(0, 8), null); // FSCTL_SET_INTEGRITY_INFORMATION
control(targetHandle, 0x900c4, null, null); // FSCTL_SET_SPARSE avoids allocating zeroes.
const size =
(BigInt(information.readUInt32LE(32)) << 32n) | BigInt(information.readUInt32LE(36));
const eof = Buffer.alloc(8);
eof.writeBigInt64LE(size);
if (!setFileInformation(targetHandle, 6, eof, eof.length)) {
// FileEndOfFileInfo
throw failure("SetFileInformationByHandle(EOF)");
}
// ReFS accepts the final partial cluster past logical EOF. Keep the exact file size,
// round only the clone range, and stay below the API's 4 GiB limit per operation.
const cluster = BigInt(clusterSize);
const roundedSize = ((size + cluster - 1n) / cluster) * cluster;
const request = Buffer.alloc(koffi.sizeof(duplicateExtents));
for (let offset = 0n; offset < size;) {
const length = roundedSize - offset < 0x80000000n ? roundedSize - offset : 0x80000000n;
koffi.encode(request, duplicateExtents, {
file: sourceHandle,
sourceOffset: offset,
targetOffset: offset,
length,
});
control(targetHandle, 0x98344, request, null); // FSCTL_DUPLICATE_EXTENTS_TO_FILE
offset += length;
}
if (
!setFileTime(
targetHandle,
information.subarray(4, 12),
information.subarray(12, 20),
information.subarray(20, 28),
)
) {
throw failure("SetFileTime");
}
} finally {
closeHandle(targetHandle);
}
// Sparse/integrity flags belong to their FSCTL owners, not SetFileAttributesW.
if (!setFileAttributes(to, attributes & 0x3127 || 0x80)) {
throw failure("SetFileAttributesW");
}
} finally {
closeHandle(sourceHandle);
}
},
};
|