reactos/drivers/filesystems/btrfs/reparse.c

673 lines
22 KiB
C
Raw Normal View History

/* Copyright (c) Mark Harmstone 2016-17
*
* This file is part of WinBtrfs.
*
* WinBtrfs is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public Licence as published by
* the Free Software Foundation, either version 3 of the Licence, or
* (at your option) any later version.
*
* WinBtrfs is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public Licence for more details.
*
* You should have received a copy of the GNU Lesser General Public Licence
* along with WinBtrfs. If not, see <http://www.gnu.org/licenses/>. */
#include "btrfs_drv.h"
2019-09-01 12:53:20 +00:00
extern tFsRtlValidateReparsePointBuffer fFsRtlValidateReparsePointBuffer;
typedef struct {
uint32_t unknown;
char name[1];
} REPARSE_DATA_BUFFER_LX_SYMLINK;
NTSTATUS get_reparse_point(PFILE_OBJECT FileObject, void* buffer, DWORD buflen, ULONG_PTR* retlen) {
USHORT subnamelen, printnamelen, i;
ULONG stringlen;
DWORD reqlen;
REPARSE_DATA_BUFFER* rdb = buffer;
fcb* fcb = FileObject->FsContext;
ccb* ccb = FileObject->FsContext2;
NTSTATUS Status;
TRACE("(%p, %p, %lx, %p)\n", FileObject, buffer, buflen, retlen);
if (!ccb)
return STATUS_INVALID_PARAMETER;
2019-09-01 12:53:20 +00:00
ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, true);
ExAcquireResourceSharedLite(fcb->Header.Resource, true);
if (fcb->type == BTRFS_TYPE_SYMLINK) {
if (ccb->lxss) {
2019-09-01 12:53:20 +00:00
reqlen = offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) + sizeof(uint32_t);
if (buflen < reqlen) {
Status = STATUS_BUFFER_OVERFLOW;
goto end;
}
rdb->ReparseTag = IO_REPARSE_TAG_LX_SYMLINK;
2019-09-01 12:53:20 +00:00
rdb->ReparseDataLength = offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) + sizeof(uint32_t);
rdb->Reserved = 0;
2019-09-01 12:53:20 +00:00
*((uint32_t*)rdb->GenericReparseBuffer.DataBuffer) = 1;
*retlen = reqlen;
} else {
char* data;
if (fcb->inode_item.st_size == 0 || fcb->inode_item.st_size > 0xffff) {
Status = STATUS_INVALID_PARAMETER;
goto end;
}
data = ExAllocatePoolWithTag(PagedPool, (ULONG)fcb->inode_item.st_size, ALLOC_TAG);
if (!data) {
ERR("out of memory\n");
Status = STATUS_INSUFFICIENT_RESOURCES;
goto end;
}
TRACE("data = %p, size = %I64x\n", data, fcb->inode_item.st_size);
2019-09-01 12:53:20 +00:00
Status = read_file(fcb, (uint8_t*)data, 0, fcb->inode_item.st_size, NULL, NULL);
if (!NT_SUCCESS(Status)) {
ERR("read_file returned %08lx\n", Status);
ExFreePool(data);
goto end;
}
2019-09-01 12:53:20 +00:00
Status = utf8_to_utf16(NULL, 0, &stringlen, data, (ULONG)fcb->inode_item.st_size);
if (!NT_SUCCESS(Status)) {
ERR("utf8_to_utf16 1 returned %08lx\n", Status);
ExFreePool(data);
goto end;
}
2019-09-01 12:53:20 +00:00
subnamelen = (uint16_t)stringlen;
printnamelen = (uint16_t)stringlen;
reqlen = offsetof(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer) + subnamelen + printnamelen;
if (buflen >= offsetof(REPARSE_DATA_BUFFER, ReparseDataLength))
rdb->ReparseTag = IO_REPARSE_TAG_SYMLINK;
if (buflen >= offsetof(REPARSE_DATA_BUFFER, Reserved))
rdb->ReparseDataLength = (USHORT)(reqlen - offsetof(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer));
if (buflen >= offsetof(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.SubstituteNameOffset))
rdb->Reserved = 0;
if (buflen < reqlen) {
ExFreePool(data);
Status = STATUS_BUFFER_OVERFLOW;
*retlen = min(buflen, offsetof(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.SubstituteNameOffset));
goto end;
}
rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset = 0;
rdb->SymbolicLinkReparseBuffer.SubstituteNameLength = subnamelen;
rdb->SymbolicLinkReparseBuffer.PrintNameOffset = subnamelen;
rdb->SymbolicLinkReparseBuffer.PrintNameLength = printnamelen;
rdb->SymbolicLinkReparseBuffer.Flags = SYMLINK_FLAG_RELATIVE;
2019-09-01 12:53:20 +00:00
Status = utf8_to_utf16(&rdb->SymbolicLinkReparseBuffer.PathBuffer[rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)],
stringlen, &stringlen, data, (ULONG)fcb->inode_item.st_size);
if (!NT_SUCCESS(Status)) {
ERR("utf8_to_utf16 2 returned %08lx\n", Status);
ExFreePool(data);
goto end;
}
for (i = 0; i < stringlen / sizeof(WCHAR); i++) {
if (rdb->SymbolicLinkReparseBuffer.PathBuffer[(rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)) + i] == '/')
rdb->SymbolicLinkReparseBuffer.PathBuffer[(rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)) + i] = '\\';
}
RtlCopyMemory(&rdb->SymbolicLinkReparseBuffer.PathBuffer[rdb->SymbolicLinkReparseBuffer.PrintNameOffset / sizeof(WCHAR)],
&rdb->SymbolicLinkReparseBuffer.PathBuffer[rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)],
rdb->SymbolicLinkReparseBuffer.SubstituteNameLength);
*retlen = reqlen;
ExFreePool(data);
}
Status = STATUS_SUCCESS;
} else if (fcb->atts & FILE_ATTRIBUTE_REPARSE_POINT) {
if (fcb->type == BTRFS_TYPE_FILE) {
ULONG len;
Status = read_file(fcb, buffer, 0, buflen, &len, NULL);
if (!NT_SUCCESS(Status)) {
ERR("read_file returned %08lx\n", Status);
}
*retlen = len;
} else if (fcb->type == BTRFS_TYPE_DIRECTORY) {
if (!fcb->reparse_xattr.Buffer || fcb->reparse_xattr.Length < sizeof(ULONG)) {
Status = STATUS_NOT_A_REPARSE_POINT;
goto end;
}
if (buflen > 0) {
*retlen = min(buflen, fcb->reparse_xattr.Length);
RtlCopyMemory(buffer, fcb->reparse_xattr.Buffer, *retlen);
} else
*retlen = 0;
Status = *retlen == fcb->reparse_xattr.Length ? STATUS_SUCCESS : STATUS_BUFFER_OVERFLOW;
} else
Status = STATUS_NOT_A_REPARSE_POINT;
} else {
Status = STATUS_NOT_A_REPARSE_POINT;
}
end:
ExReleaseResourceLite(fcb->Header.Resource);
ExReleaseResourceLite(&fcb->Vcb->tree_lock);
return Status;
}
static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, fcb* fcb, ccb* ccb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, LIST_ENTRY* rollback) {
NTSTATUS Status;
ULONG tlength;
ANSI_STRING target;
bool target_alloc = false;
LARGE_INTEGER offset, time;
BTRFS_TIME now;
if (rdb->ReparseTag == IO_REPARSE_TAG_SYMLINK) {
UNICODE_STRING subname;
ULONG minlen, len;
minlen = offsetof(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer) + sizeof(WCHAR);
if (buflen < minlen) {
WARN("buffer was less than minimum length (%lu < %lu)\n", buflen, minlen);
return STATUS_INVALID_PARAMETER;
}
if (rdb->SymbolicLinkReparseBuffer.SubstituteNameLength < sizeof(WCHAR)) {
WARN("rdb->SymbolicLinkReparseBuffer.SubstituteNameLength was too short\n");
return STATUS_INVALID_PARAMETER;
}
subname.Buffer = &rdb->SymbolicLinkReparseBuffer.PathBuffer[rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)];
subname.MaximumLength = subname.Length = rdb->SymbolicLinkReparseBuffer.SubstituteNameLength;
TRACE("substitute name = %.*S\n", (int)(subname.Length / sizeof(WCHAR)), subname.Buffer);
Status = utf16_to_utf8(NULL, 0, &len, subname.Buffer, subname.Length);
if (!NT_SUCCESS(Status)) {
ERR("utf16_to_utf8 1 failed with error %08lx\n", Status);
return Status;
}
target.MaximumLength = target.Length = (USHORT)len;
target.Buffer = ExAllocatePoolWithTag(PagedPool, target.MaximumLength, ALLOC_TAG);
if (!target.Buffer) {
ERR("out of memory\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
target_alloc = true;
Status = utf16_to_utf8(target.Buffer, target.Length, &len, subname.Buffer, subname.Length);
if (!NT_SUCCESS(Status)) {
ERR("utf16_to_utf8 2 failed with error %08lx\n", Status);
ExFreePool(target.Buffer);
return Status;
}
for (USHORT i = 0; i < target.Length; i++) {
if (target.Buffer[i] == '\\')
target.Buffer[i] = '/';
}
} else if (rdb->ReparseTag == IO_REPARSE_TAG_LX_SYMLINK) {
REPARSE_DATA_BUFFER_LX_SYMLINK* buf;
if (buflen < offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) + rdb->ReparseDataLength) {
WARN("buffer was less than expected length (%lu < %lu)\n", buflen,
(unsigned long)(offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) + rdb->ReparseDataLength));
return STATUS_INVALID_PARAMETER;
}
buf = (REPARSE_DATA_BUFFER_LX_SYMLINK*)rdb->GenericReparseBuffer.DataBuffer;
if (buflen < offsetof(REPARSE_DATA_BUFFER_LX_SYMLINK, name)) {
WARN("buffer was less than minimum length (%u < %lu)\n", rdb->ReparseDataLength,
(unsigned long)(offsetof(REPARSE_DATA_BUFFER_LX_SYMLINK, name)));
return STATUS_INVALID_PARAMETER;
}
target.Buffer = buf->name;
target.Length = target.MaximumLength = rdb->ReparseDataLength - offsetof(REPARSE_DATA_BUFFER_LX_SYMLINK, name);
} else {
ERR("unexpected reparse tag %08lx\n", rdb->ReparseTag);
return STATUS_INTERNAL_ERROR;
}
fcb->type = BTRFS_TYPE_SYMLINK;
fcb->inode_item.st_mode &= ~__S_IFMT;
fcb->inode_item.st_mode |= __S_IFLNK;
fcb->inode_item.generation = fcb->Vcb->superblock.generation; // so we don't confuse btrfs send on Linux
if (fileref && fileref->dc)
fileref->dc->type = fcb->type;
Status = truncate_file(fcb, 0, Irp, rollback);
if (!NT_SUCCESS(Status)) {
ERR("truncate_file returned %08lx\n", Status);
if (target_alloc)
ExFreePool(target.Buffer);
return Status;
}
offset.QuadPart = 0;
tlength = target.Length;
Status = write_file2(fcb->Vcb, Irp, offset, target.Buffer, &tlength, false, true,
true, false, false, rollback);
if (target_alloc)
ExFreePool(target.Buffer);
KeQuerySystemTime(&time);
win_time_to_unix(time, &now);
2018-12-16 11:03:16 +00:00
fcb->inode_item.transid = fcb->Vcb->superblock.generation;
fcb->inode_item.sequence++;
2018-12-16 11:03:16 +00:00
if (!ccb || !ccb->user_set_change_time)
fcb->inode_item.st_ctime = now;
2018-12-16 11:03:16 +00:00
if (!ccb || !ccb->user_set_write_time)
fcb->inode_item.st_mtime = now;
2018-12-16 11:03:16 +00:00
fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
fcb->subvol->root_item.ctime = now;
2019-09-01 12:53:20 +00:00
fcb->inode_item_changed = true;
2018-12-16 11:03:16 +00:00
mark_fcb_dirty(fcb);
2018-12-16 11:03:16 +00:00
if (fileref)
mark_fileref_dirty(fileref);
return Status;
}
2018-12-16 11:03:16 +00:00
NTSTATUS set_reparse_point2(fcb* fcb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, ccb* ccb, file_ref* fileref, PIRP Irp, LIST_ENTRY* rollback) {
NTSTATUS Status;
ULONG tag;
if (fcb->type == BTRFS_TYPE_SYMLINK) {
WARN("tried to set a reparse point on an existing symlink\n");
2018-12-16 11:03:16 +00:00
return STATUS_INVALID_PARAMETER;
}
// FIXME - fail if we already have the attribute FILE_ATTRIBUTE_REPARSE_POINT
// FIXME - die if not file or directory
if (fcb->type == BTRFS_TYPE_DIRECTORY && fcb->inode_item.st_size > 0) {
TRACE("directory not empty\n");
return STATUS_DIRECTORY_NOT_EMPTY;
}
if (buflen < sizeof(ULONG)) {
WARN("buffer was not long enough to hold tag\n");
2018-12-16 11:03:16 +00:00
return STATUS_INVALID_BUFFER_SIZE;
}
2019-09-01 12:53:20 +00:00
Status = fFsRtlValidateReparsePointBuffer(buflen, rdb);
if (!NT_SUCCESS(Status)) {
ERR("FsRtlValidateReparsePointBuffer returned %08lx\n", Status);
2018-12-16 11:03:16 +00:00
return Status;
}
tag = *(ULONG*)rdb;
if (tag == IO_REPARSE_TAG_MOUNT_POINT && fcb->type != BTRFS_TYPE_DIRECTORY)
return STATUS_NOT_A_DIRECTORY;
if (fcb->type == BTRFS_TYPE_FILE &&
((tag == IO_REPARSE_TAG_SYMLINK && rdb->SymbolicLinkReparseBuffer.Flags & SYMLINK_FLAG_RELATIVE) || tag == IO_REPARSE_TAG_LX_SYMLINK)) {
Status = set_symlink(Irp, fileref, fcb, ccb, rdb, buflen, rollback);
fcb->atts |= FILE_ATTRIBUTE_REPARSE_POINT;
} else {
LARGE_INTEGER offset, time;
BTRFS_TIME now;
2018-12-16 11:03:16 +00:00
if (fcb->type == BTRFS_TYPE_DIRECTORY || fcb->type == BTRFS_TYPE_CHARDEV || fcb->type == BTRFS_TYPE_BLOCKDEV) { // store as xattr
ANSI_STRING buf;
buf.Buffer = ExAllocatePoolWithTag(PagedPool, buflen, ALLOC_TAG);
if (!buf.Buffer) {
ERR("out of memory\n");
2018-12-16 11:03:16 +00:00
return STATUS_INSUFFICIENT_RESOURCES;
}
2019-09-01 12:53:20 +00:00
buf.Length = buf.MaximumLength = (uint16_t)buflen;
if (fcb->reparse_xattr.Buffer)
ExFreePool(fcb->reparse_xattr.Buffer);
fcb->reparse_xattr = buf;
2018-12-16 11:03:16 +00:00
RtlCopyMemory(buf.Buffer, rdb, buflen);
2019-09-01 12:53:20 +00:00
fcb->reparse_xattr_changed = true;
Status = STATUS_SUCCESS;
} else { // otherwise, store as file data
2018-12-16 11:03:16 +00:00
Status = truncate_file(fcb, 0, Irp, rollback);
if (!NT_SUCCESS(Status)) {
ERR("truncate_file returned %08lx\n", Status);
2018-12-16 11:03:16 +00:00
return Status;
}
offset.QuadPart = 0;
2019-09-01 12:53:20 +00:00
Status = write_file2(fcb->Vcb, Irp, offset, rdb, &buflen, false, true, true, false, false, rollback);
if (!NT_SUCCESS(Status)) {
ERR("write_file2 returned %08lx\n", Status);
2018-12-16 11:03:16 +00:00
return Status;
}
}
KeQuerySystemTime(&time);
win_time_to_unix(time, &now);
fcb->inode_item.transid = fcb->Vcb->superblock.generation;
fcb->inode_item.sequence++;
2018-12-16 11:03:16 +00:00
if (!ccb || !ccb->user_set_change_time)
fcb->inode_item.st_ctime = now;
2018-12-16 11:03:16 +00:00
if (!ccb || !ccb->user_set_write_time)
fcb->inode_item.st_mtime = now;
fcb->atts |= FILE_ATTRIBUTE_REPARSE_POINT;
2019-09-01 12:53:20 +00:00
fcb->atts_changed = true;
fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
fcb->subvol->root_item.ctime = now;
2019-09-01 12:53:20 +00:00
fcb->inode_item_changed = true;
mark_fcb_dirty(fcb);
}
2018-12-16 11:03:16 +00:00
return STATUS_SUCCESS;
}
NTSTATUS set_reparse_point(PIRP Irp) {
2018-12-16 11:03:16 +00:00
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
PFILE_OBJECT FileObject = IrpSp->FileObject;
void* buffer = Irp->AssociatedIrp.SystemBuffer;
REPARSE_DATA_BUFFER* rdb = buffer;
DWORD buflen = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
NTSTATUS Status = STATUS_SUCCESS;
fcb* fcb;
ccb* ccb;
file_ref* fileref;
LIST_ENTRY rollback;
TRACE("(%p)\n", Irp);
2018-12-16 11:03:16 +00:00
InitializeListHead(&rollback);
if (!FileObject) {
ERR("FileObject was NULL\n");
return STATUS_INVALID_PARAMETER;
}
// IFSTest insists on this, for some reason...
if (Irp->UserBuffer)
return STATUS_INVALID_PARAMETER;
fcb = FileObject->FsContext;
ccb = FileObject->FsContext2;
if (!ccb) {
ERR("ccb was NULL\n");
return STATUS_INVALID_PARAMETER;
}
if (Irp->RequestorMode == UserMode && !(ccb->access & (FILE_WRITE_ATTRIBUTES | FILE_WRITE_DATA))) {
WARN("insufficient privileges\n");
return STATUS_ACCESS_DENIED;
}
fileref = ccb->fileref;
if (!fileref) {
ERR("fileref was NULL\n");
return STATUS_INVALID_PARAMETER;
}
if (fcb->ads) {
fileref = fileref->parent;
fcb = fileref->fcb;
}
2019-09-01 12:53:20 +00:00
ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, true);
ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
2018-12-16 11:03:16 +00:00
Status = set_reparse_point2(fcb, rdb, buflen, ccb, fileref, Irp, &rollback);
if (!NT_SUCCESS(Status)) {
ERR("set_reparse_point2 returned %08lx\n", Status);
2018-12-16 11:03:16 +00:00
goto end;
}
2019-11-12 18:32:46 +00:00
queue_notification_fcb(fileref, FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_ATTRIBUTES, FILE_ACTION_MODIFIED, NULL);
end:
if (NT_SUCCESS(Status))
clear_rollback(&rollback);
else
do_rollback(fcb->Vcb, &rollback);
ExReleaseResourceLite(fcb->Header.Resource);
ExReleaseResourceLite(&fcb->Vcb->tree_lock);
return Status;
}
NTSTATUS delete_reparse_point(PIRP Irp) {
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
PFILE_OBJECT FileObject = IrpSp->FileObject;
REPARSE_DATA_BUFFER* rdb = Irp->AssociatedIrp.SystemBuffer;
DWORD buflen = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
NTSTATUS Status;
fcb* fcb;
ccb* ccb;
file_ref* fileref;
LIST_ENTRY rollback;
TRACE("(%p)\n", Irp);
InitializeListHead(&rollback);
if (!FileObject) {
ERR("FileObject was NULL\n");
return STATUS_INVALID_PARAMETER;
}
fcb = FileObject->FsContext;
if (!fcb) {
ERR("fcb was NULL\n");
return STATUS_INVALID_PARAMETER;
}
ccb = FileObject->FsContext2;
if (!ccb) {
ERR("ccb was NULL\n");
return STATUS_INVALID_PARAMETER;
}
if (Irp->RequestorMode == UserMode && !(ccb->access & FILE_WRITE_ATTRIBUTES)) {
WARN("insufficient privileges\n");
return STATUS_ACCESS_DENIED;
}
fileref = ccb->fileref;
if (!fileref) {
ERR("fileref was NULL\n");
return STATUS_INVALID_PARAMETER;
}
2019-09-01 12:53:20 +00:00
ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, true);
ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
if (buflen < offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer)) {
ERR("buffer was too short\n");
Status = STATUS_INVALID_PARAMETER;
goto end;
}
if (rdb->ReparseDataLength > 0) {
WARN("rdb->ReparseDataLength was not zero\n");
Status = STATUS_INVALID_PARAMETER;
goto end;
}
if (fcb->ads) {
WARN("tried to delete reparse point on ADS\n");
Status = STATUS_INVALID_PARAMETER;
goto end;
}
if (fcb->type == BTRFS_TYPE_SYMLINK) {
LARGE_INTEGER time;
BTRFS_TIME now;
if (rdb->ReparseTag != IO_REPARSE_TAG_SYMLINK) {
WARN("reparse tag was not IO_REPARSE_TAG_SYMLINK\n");
Status = STATUS_INVALID_PARAMETER;
goto end;
}
KeQuerySystemTime(&time);
win_time_to_unix(time, &now);
fileref->fcb->type = BTRFS_TYPE_FILE;
fileref->fcb->inode_item.st_mode &= ~__S_IFLNK;
fileref->fcb->inode_item.st_mode |= __S_IFREG;
fileref->fcb->inode_item.generation = fileref->fcb->Vcb->superblock.generation; // so we don't confuse btrfs send on Linux
fileref->fcb->inode_item.transid = fileref->fcb->Vcb->superblock.generation;
fileref->fcb->inode_item.sequence++;
if (!ccb->user_set_change_time)
fileref->fcb->inode_item.st_ctime = now;
if (!ccb->user_set_write_time)
fileref->fcb->inode_item.st_mtime = now;
fileref->fcb->atts &= ~FILE_ATTRIBUTE_REPARSE_POINT;
if (fileref->dc)
fileref->dc->type = fileref->fcb->type;
mark_fileref_dirty(fileref);
2019-09-01 12:53:20 +00:00
fileref->fcb->inode_item_changed = true;
mark_fcb_dirty(fileref->fcb);
fileref->fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
fileref->fcb->subvol->root_item.ctime = now;
} else if (fcb->type == BTRFS_TYPE_FILE) {
LARGE_INTEGER time;
BTRFS_TIME now;
// FIXME - do we need to check that the reparse tags match?
Status = truncate_file(fcb, 0, Irp, &rollback);
if (!NT_SUCCESS(Status)) {
ERR("truncate_file returned %08lx\n", Status);
goto end;
}
fcb->atts &= ~FILE_ATTRIBUTE_REPARSE_POINT;
2019-09-01 12:53:20 +00:00
fcb->atts_changed = true;
KeQuerySystemTime(&time);
win_time_to_unix(time, &now);
fcb->inode_item.transid = fcb->Vcb->superblock.generation;
fcb->inode_item.sequence++;
if (!ccb->user_set_change_time)
fcb->inode_item.st_ctime = now;
if (!ccb->user_set_write_time)
fcb->inode_item.st_mtime = now;
2019-09-01 12:53:20 +00:00
fcb->inode_item_changed = true;
mark_fcb_dirty(fcb);
fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
fcb->subvol->root_item.ctime = now;
} else if (fcb->type == BTRFS_TYPE_DIRECTORY) {
LARGE_INTEGER time;
BTRFS_TIME now;
// FIXME - do we need to check that the reparse tags match?
fcb->atts &= ~FILE_ATTRIBUTE_REPARSE_POINT;
2019-09-01 12:53:20 +00:00
fcb->atts_changed = true;
if (fcb->reparse_xattr.Buffer) {
ExFreePool(fcb->reparse_xattr.Buffer);
fcb->reparse_xattr.Buffer = NULL;
}
2019-09-01 12:53:20 +00:00
fcb->reparse_xattr_changed = true;
KeQuerySystemTime(&time);
win_time_to_unix(time, &now);
fcb->inode_item.transid = fcb->Vcb->superblock.generation;
fcb->inode_item.sequence++;
if (!ccb->user_set_change_time)
fcb->inode_item.st_ctime = now;
if (!ccb->user_set_write_time)
fcb->inode_item.st_mtime = now;
2019-09-01 12:53:20 +00:00
fcb->inode_item_changed = true;
mark_fcb_dirty(fcb);
fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
fcb->subvol->root_item.ctime = now;
} else {
ERR("unsupported file type %u\n", fcb->type);
Status = STATUS_INVALID_PARAMETER;
goto end;
}
Status = STATUS_SUCCESS;
2019-11-12 18:32:46 +00:00
queue_notification_fcb(fileref, FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_ATTRIBUTES, FILE_ACTION_MODIFIED, NULL);
end:
if (NT_SUCCESS(Status))
clear_rollback(&rollback);
else
do_rollback(fcb->Vcb, &rollback);
ExReleaseResourceLite(fcb->Header.Resource);
ExReleaseResourceLite(&fcb->Vcb->tree_lock);
return Status;
}