fileinfo.c File Reference

#include "btrfs_drv.h"
#include "crc32c.h"

Include dependency graph for fileinfo.c:

Go to the source code of this file.

Classes
struct	_FILE_ID_INFORMATION
struct	_FILE_STAT_INFORMATION
struct	_FILE_STAT_LX_INFORMATION
struct	_FILE_RENAME_INFORMATION_EX
struct	_FILE_DISPOSITION_INFORMATION_EX
struct	_FILE_LINK_INFORMATION_EX
struct	_FILE_CASE_SENSITIVE_INFORMATION
struct	_FILE_LINK_ENTRY_FULL_ID_INFORMATION
struct	_FILE_LINKS_FULL_ID_INFORMATION
struct	_move_entry

Macros
#define	FileIdInformation   (enum _FILE_INFORMATION_CLASS)59
#define	FileHardLinkFullIdInformation   (enum _FILE_INFORMATION_CLASS)62
#define	FileDispositionInformationEx   (enum _FILE_INFORMATION_CLASS)64
#define	FileRenameInformationEx   (enum _FILE_INFORMATION_CLASS)65
#define	FileStatInformation   (enum _FILE_INFORMATION_CLASS)68
#define	FileStatLxInformation   (enum _FILE_INFORMATION_CLASS)70
#define	FileCaseSensitiveInformation   (enum _FILE_INFORMATION_CLASS)71
#define	FileLinkInformationEx   (enum _FILE_INFORMATION_CLASS)72
#define	FileStorageReserveIdInformation   (enum _FILE_INFORMATION_CLASS)74
#define	LX_FILE_METADATA_HAS_UID   0x01
#define	LX_FILE_METADATA_HAS_GID   0x02
#define	LX_FILE_METADATA_HAS_MODE   0x04
#define	LX_FILE_METADATA_HAS_DEVICE_ID   0x08
#define	LX_FILE_CASE_SENSITIVE_DIR   0x10
#define	FILE_RENAME_REPLACE_IF_EXISTS   0x001
#define	FILE_RENAME_POSIX_SEMANTICS   0x002
#define	FILE_RENAME_SUPPRESS_PIN_STATE_INHERITANCE   0x004
#define	FILE_RENAME_SUPPRESS_STORAGE_RESERVE_INHERITANCE   0x008
#define	FILE_RENAME_NO_INCREASE_AVAILABLE_SPACE   0x010
#define	FILE_RENAME_NO_DECREASE_AVAILABLE_SPACE   0x020
#define	FILE_RENAME_IGNORE_READONLY_ATTRIBUTE   0x040
#define	FILE_RENAME_FORCE_RESIZE_TARGET_SR   0x080
#define	FILE_RENAME_FORCE_RESIZE_SOURCE_SR   0x100
#define	FILE_DISPOSITION_DELETE   0x1
#define	FILE_DISPOSITION_POSIX_SEMANTICS   0x2
#define	FILE_DISPOSITION_FORCE_IMAGE_SECTION_CHECK   0x4
#define	FILE_DISPOSITION_ON_CLOSE   0x8
#define	FILE_LINK_REPLACE_IF_EXISTS   0x001
#define	FILE_LINK_POSIX_SEMANTICS   0x002
#define	FILE_LINK_SUPPRESS_STORAGE_RESERVE_INHERITANCE   0x008
#define	FILE_LINK_NO_INCREASE_AVAILABLE_SPACE   0x010
#define	FILE_LINK_NO_DECREASE_AVAILABLE_SPACE   0x020
#define	FILE_LINK_IGNORE_READONLY_ATTRIBUTE   0x040
#define	FILE_LINK_FORCE_RESIZE_TARGET_SR   0x080
#define	FILE_LINK_FORCE_RESIZE_SOURCE_SR   0x100

Typedefs
typedef struct _FILE_ID_INFORMATION	FILE_ID_INFORMATION
typedef struct _FILE_ID_INFORMATION *	PFILE_ID_INFORMATION
typedef struct _FILE_STAT_INFORMATION	FILE_STAT_INFORMATION
typedef struct _FILE_STAT_INFORMATION *	PFILE_STAT_INFORMATION
typedef struct _FILE_STAT_LX_INFORMATION	FILE_STAT_LX_INFORMATION
typedef struct _FILE_STAT_LX_INFORMATION *	PFILE_STAT_LX_INFORMATION
typedef struct _FILE_RENAME_INFORMATION_EX	FILE_RENAME_INFORMATION_EX
typedef struct _FILE_RENAME_INFORMATION_EX *	PFILE_RENAME_INFORMATION_EX
typedef struct _FILE_DISPOSITION_INFORMATION_EX	FILE_DISPOSITION_INFORMATION_EX
typedef struct _FILE_DISPOSITION_INFORMATION_EX *	PFILE_DISPOSITION_INFORMATION_EX
typedef struct _FILE_LINK_INFORMATION_EX	FILE_LINK_INFORMATION_EX
typedef struct _FILE_LINK_INFORMATION_EX *	PFILE_LINK_INFORMATION_EX
typedef struct _FILE_CASE_SENSITIVE_INFORMATION	FILE_CASE_SENSITIVE_INFORMATION
typedef struct _FILE_CASE_SENSITIVE_INFORMATION *	PFILE_CASE_SENSITIVE_INFORMATION
typedef struct _FILE_LINK_ENTRY_FULL_ID_INFORMATION	FILE_LINK_ENTRY_FULL_ID_INFORMATION
typedef struct _FILE_LINK_ENTRY_FULL_ID_INFORMATION *	PFILE_LINK_ENTRY_FULL_ID_INFORMATION
typedef struct _FILE_LINKS_FULL_ID_INFORMATION	FILE_LINKS_FULL_ID_INFORMATION
typedef struct _FILE_LINKS_FULL_ID_INFORMATION *	PFILE_LINKS_FULL_ID_INFORMATION
typedef struct _move_entry	move_entry

Functions
static NTSTATUS	set_basic_information (device_extension *Vcb, PIRP Irp, PFILE_OBJECT FileObject)
static NTSTATUS	set_disposition_information (device_extension *Vcb, PIRP Irp, PFILE_OBJECT FileObject, bool ex)
bool	has_open_children (file_ref *fileref)
static NTSTATUS	duplicate_fcb (fcb *oldfcb, fcb **pfcb)
static NTSTATUS	add_children_to_move_list (device_extension *Vcb, move_entry *me, PIRP Irp)
void	remove_dir_child_from_hash_lists (fcb *fcb, dir_child *dc)
static NTSTATUS	create_directory_fcb (device_extension *Vcb, root *r, fcb *parfcb, fcb **pfcb)
void	add_fcb_to_subvol (_In_ _Requires_exclusive_lock_held_(_Curr_->Vcb->fcb_lock) fcb *fcb)
void	remove_fcb_from_subvol (_In_ _Requires_exclusive_lock_held_(_Curr_->Vcb->fcb_lock) fcb *fcb)
static NTSTATUS	move_across_subvols (file_ref *fileref, ccb *ccb, file_ref *destdir, PANSI_STRING utf8, PUNICODE_STRING fnus, PIRP Irp, LIST_ENTRY *rollback)
void	insert_dir_child_into_hash_lists (fcb *fcb, dir_child *dc)
static NTSTATUS	rename_stream_to_file (device_extension *Vcb, file_ref *fileref, ccb *ccb, ULONG flags, PIRP Irp, LIST_ENTRY *rollback)
static NTSTATUS	rename_stream (device_extension *Vcb, file_ref *fileref, ccb *ccb, FILE_RENAME_INFORMATION_EX *fri, ULONG flags, PIRP Irp, LIST_ENTRY *rollback)
static NTSTATUS	rename_file_to_stream (device_extension *Vcb, file_ref *fileref, ccb *ccb, FILE_RENAME_INFORMATION_EX *fri, ULONG flags, PIRP Irp, LIST_ENTRY *rollback)
static NTSTATUS	set_rename_information (device_extension *Vcb, PIRP Irp, PFILE_OBJECT FileObject, PFILE_OBJECT tfo, bool ex)
NTSTATUS	stream_set_end_of_file_information (device_extension *Vcb, uint16_t end, fcb *fcb, file_ref *fileref, bool advance_only)
static NTSTATUS	set_end_of_file_information (device_extension *Vcb, PIRP Irp, PFILE_OBJECT FileObject, bool advance_only, bool prealloc)
static NTSTATUS	set_position_information (PFILE_OBJECT FileObject, PIRP Irp)
static NTSTATUS	set_link_information (device_extension *Vcb, PIRP Irp, PFILE_OBJECT FileObject, PFILE_OBJECT tfo, bool ex)
static NTSTATUS	set_valid_data_length_information (device_extension *Vcb, PIRP Irp, PFILE_OBJECT FileObject)
static NTSTATUS	set_case_sensitive_information (PIRP Irp)
	_Dispatch_type_ (IRP_MJ_SET_INFORMATION)
static NTSTATUS	fill_in_file_basic_information (FILE_BASIC_INFORMATION *fbi, INODE_ITEM *ii, LONG *length, fcb *fcb, file_ref *fileref)
static NTSTATUS	fill_in_file_network_open_information (FILE_NETWORK_OPEN_INFORMATION *fnoi, fcb *fcb, file_ref *fileref, LONG *length)
static NTSTATUS	fill_in_file_standard_information (FILE_STANDARD_INFORMATION *fsi, fcb *fcb, file_ref *fileref, LONG *length)
static NTSTATUS	fill_in_file_internal_information (FILE_INTERNAL_INFORMATION *fii, fcb *fcb, LONG *length)
static NTSTATUS	fill_in_file_ea_information (FILE_EA_INFORMATION *eai, fcb *fcb, LONG *length)
static NTSTATUS	fill_in_file_position_information (FILE_POSITION_INFORMATION *fpi, PFILE_OBJECT FileObject, LONG *length)
NTSTATUS	fileref_get_filename (file_ref *fileref, PUNICODE_STRING fn, USHORT *name_offset, ULONG *preqlen)
static NTSTATUS	fill_in_file_name_information (FILE_NAME_INFORMATION *fni, fcb *fcb, file_ref *fileref, LONG *length)
static NTSTATUS	fill_in_file_attribute_information (FILE_ATTRIBUTE_TAG_INFORMATION *ati, fcb *fcb, ccb *ccb, LONG *length)
static NTSTATUS	fill_in_file_stream_information (FILE_STREAM_INFORMATION *fsi, file_ref *fileref, LONG *length)
static NTSTATUS	fill_in_file_standard_link_information (FILE_STANDARD_LINK_INFORMATION *fsli, fcb *fcb, file_ref *fileref, LONG *length)
static NTSTATUS	fill_in_hard_link_information (FILE_LINKS_INFORMATION *fli, file_ref *fileref, PIRP Irp, LONG *length)
static NTSTATUS	fill_in_hard_link_full_id_information (FILE_LINKS_FULL_ID_INFORMATION *flfii, file_ref *fileref, PIRP Irp, LONG *length)
static NTSTATUS	fill_in_file_id_information (FILE_ID_INFORMATION *fii, fcb *fcb, LONG *length)
static NTSTATUS	fill_in_file_stat_information (FILE_STAT_INFORMATION *fsi, fcb *fcb, ccb *ccb, LONG *length)
static NTSTATUS	fill_in_file_stat_lx_information (FILE_STAT_LX_INFORMATION *fsli, fcb *fcb, ccb *ccb, LONG *length)
static NTSTATUS	fill_in_file_case_sensitive_information (FILE_CASE_SENSITIVE_INFORMATION *fcsi, fcb *fcb, LONG *length)
static NTSTATUS	fill_in_file_compression_information (FILE_COMPRESSION_INFORMATION *fci, LONG *length, fcb *fcb)
static NTSTATUS	query_info (device_extension *Vcb, PFILE_OBJECT FileObject, PIRP Irp)
	_Dispatch_type_ (IRP_MJ_QUERY_INFORMATION)
	_Dispatch_type_ (IRP_MJ_QUERY_EA)
	_Dispatch_type_ (IRP_MJ_SET_EA)

Macro Definition Documentation

FILE_DISPOSITION_DELETE

#define FILE_DISPOSITION_DELETE   0x1

Definition at line 130 of file fileinfo.c.

FILE_DISPOSITION_FORCE_IMAGE_SECTION_CHECK

#define FILE_DISPOSITION_FORCE_IMAGE_SECTION_CHECK   0x4

Definition at line 132 of file fileinfo.c.

FILE_DISPOSITION_ON_CLOSE

#define FILE_DISPOSITION_ON_CLOSE   0x8

Definition at line 133 of file fileinfo.c.

FILE_DISPOSITION_POSIX_SEMANTICS

#define FILE_DISPOSITION_POSIX_SEMANTICS   0x2

Definition at line 131 of file fileinfo.c.

FILE_LINK_FORCE_RESIZE_SOURCE_SR

#define FILE_LINK_FORCE_RESIZE_SOURCE_SR   0x100

Definition at line 142 of file fileinfo.c.

FILE_LINK_FORCE_RESIZE_TARGET_SR

#define FILE_LINK_FORCE_RESIZE_TARGET_SR   0x080

Definition at line 141 of file fileinfo.c.

FILE_LINK_IGNORE_READONLY_ATTRIBUTE

#define FILE_LINK_IGNORE_READONLY_ATTRIBUTE   0x040

Definition at line 140 of file fileinfo.c.

FILE_LINK_NO_DECREASE_AVAILABLE_SPACE

#define FILE_LINK_NO_DECREASE_AVAILABLE_SPACE   0x020

Definition at line 139 of file fileinfo.c.

FILE_LINK_NO_INCREASE_AVAILABLE_SPACE

#define FILE_LINK_NO_INCREASE_AVAILABLE_SPACE   0x010

Definition at line 138 of file fileinfo.c.

FILE_LINK_POSIX_SEMANTICS

#define FILE_LINK_POSIX_SEMANTICS   0x002

Definition at line 136 of file fileinfo.c.

FILE_LINK_REPLACE_IF_EXISTS

#define FILE_LINK_REPLACE_IF_EXISTS   0x001

Definition at line 135 of file fileinfo.c.

FILE_LINK_SUPPRESS_STORAGE_RESERVE_INHERITANCE

#define FILE_LINK_SUPPRESS_STORAGE_RESERVE_INHERITANCE   0x008

Definition at line 137 of file fileinfo.c.

FILE_RENAME_FORCE_RESIZE_SOURCE_SR

#define FILE_RENAME_FORCE_RESIZE_SOURCE_SR   0x100

Definition at line 128 of file fileinfo.c.

FILE_RENAME_FORCE_RESIZE_TARGET_SR

#define FILE_RENAME_FORCE_RESIZE_TARGET_SR   0x080

Definition at line 127 of file fileinfo.c.

FILE_RENAME_IGNORE_READONLY_ATTRIBUTE

#define FILE_RENAME_IGNORE_READONLY_ATTRIBUTE   0x040

Definition at line 126 of file fileinfo.c.

FILE_RENAME_NO_DECREASE_AVAILABLE_SPACE

#define FILE_RENAME_NO_DECREASE_AVAILABLE_SPACE   0x020

Definition at line 125 of file fileinfo.c.

FILE_RENAME_NO_INCREASE_AVAILABLE_SPACE

#define FILE_RENAME_NO_INCREASE_AVAILABLE_SPACE   0x010

Definition at line 124 of file fileinfo.c.

FILE_RENAME_POSIX_SEMANTICS

#define FILE_RENAME_POSIX_SEMANTICS   0x002

Definition at line 121 of file fileinfo.c.

FILE_RENAME_REPLACE_IF_EXISTS

#define FILE_RENAME_REPLACE_IF_EXISTS   0x001

Definition at line 120 of file fileinfo.c.

FILE_RENAME_SUPPRESS_PIN_STATE_INHERITANCE

#define FILE_RENAME_SUPPRESS_PIN_STATE_INHERITANCE   0x004

Definition at line 122 of file fileinfo.c.

FILE_RENAME_SUPPRESS_STORAGE_RESERVE_INHERITANCE

#define FILE_RENAME_SUPPRESS_STORAGE_RESERVE_INHERITANCE   0x008

Definition at line 123 of file fileinfo.c.

FileCaseSensitiveInformation

#define FileCaseSensitiveInformation   (enum _FILE_INFORMATION_CLASS)71

Definition at line 30 of file fileinfo.c.

FileDispositionInformationEx

#define FileDispositionInformationEx   (enum _FILE_INFORMATION_CLASS)64

Definition at line 26 of file fileinfo.c.

FileHardLinkFullIdInformation

#define FileHardLinkFullIdInformation   (enum _FILE_INFORMATION_CLASS)62

Definition at line 25 of file fileinfo.c.

FileIdInformation

#define FileIdInformation   (enum _FILE_INFORMATION_CLASS)59

Definition at line 24 of file fileinfo.c.

FileLinkInformationEx

#define FileLinkInformationEx   (enum _FILE_INFORMATION_CLASS)72

Definition at line 31 of file fileinfo.c.

FileRenameInformationEx

#define FileRenameInformationEx   (enum _FILE_INFORMATION_CLASS)65

Definition at line 27 of file fileinfo.c.

FileStatInformation

#define FileStatInformation   (enum _FILE_INFORMATION_CLASS)68

Definition at line 28 of file fileinfo.c.

FileStatLxInformation

#define FileStatLxInformation   (enum _FILE_INFORMATION_CLASS)70

Definition at line 29 of file fileinfo.c.

FileStorageReserveIdInformation

#define FileStorageReserveIdInformation   (enum _FILE_INFORMATION_CLASS)74

Definition at line 32 of file fileinfo.c.

LX_FILE_CASE_SENSITIVE_DIR

#define LX_FILE_CASE_SENSITIVE_DIR   0x10

Definition at line 77 of file fileinfo.c.

LX_FILE_METADATA_HAS_DEVICE_ID

#define LX_FILE_METADATA_HAS_DEVICE_ID   0x08

Definition at line 76 of file fileinfo.c.

LX_FILE_METADATA_HAS_GID

#define LX_FILE_METADATA_HAS_GID   0x02

Definition at line 74 of file fileinfo.c.

LX_FILE_METADATA_HAS_MODE

#define LX_FILE_METADATA_HAS_MODE   0x04

Definition at line 75 of file fileinfo.c.

LX_FILE_METADATA_HAS_UID

#define LX_FILE_METADATA_HAS_UID   0x01

Definition at line 73 of file fileinfo.c.

Typedef Documentation

FILE_CASE_SENSITIVE_INFORMATION

typedef struct _FILE_CASE_SENSITIVE_INFORMATION FILE_CASE_SENSITIVE_INFORMATION

FILE_DISPOSITION_INFORMATION_EX

typedef struct _FILE_DISPOSITION_INFORMATION_EX FILE_DISPOSITION_INFORMATION_EX

FILE_ID_INFORMATION

typedef struct _FILE_ID_INFORMATION FILE_ID_INFORMATION

FILE_LINK_ENTRY_FULL_ID_INFORMATION

typedef struct _FILE_LINK_ENTRY_FULL_ID_INFORMATION FILE_LINK_ENTRY_FULL_ID_INFORMATION

FILE_LINK_INFORMATION_EX

typedef struct _FILE_LINK_INFORMATION_EX FILE_LINK_INFORMATION_EX

FILE_LINKS_FULL_ID_INFORMATION

typedef struct _FILE_LINKS_FULL_ID_INFORMATION FILE_LINKS_FULL_ID_INFORMATION

FILE_RENAME_INFORMATION_EX

typedef struct _FILE_RENAME_INFORMATION_EX FILE_RENAME_INFORMATION_EX

FILE_STAT_INFORMATION

typedef struct _FILE_STAT_INFORMATION FILE_STAT_INFORMATION

FILE_STAT_LX_INFORMATION

typedef struct _FILE_STAT_LX_INFORMATION FILE_STAT_LX_INFORMATION

move_entry

typedef struct _move_entry move_entry

PFILE_CASE_SENSITIVE_INFORMATION

typedef struct _FILE_CASE_SENSITIVE_INFORMATION * PFILE_CASE_SENSITIVE_INFORMATION

PFILE_DISPOSITION_INFORMATION_EX

typedef struct _FILE_DISPOSITION_INFORMATION_EX * PFILE_DISPOSITION_INFORMATION_EX

PFILE_ID_INFORMATION

typedef struct _FILE_ID_INFORMATION * PFILE_ID_INFORMATION

PFILE_LINK_ENTRY_FULL_ID_INFORMATION

typedef struct _FILE_LINK_ENTRY_FULL_ID_INFORMATION * PFILE_LINK_ENTRY_FULL_ID_INFORMATION

PFILE_LINK_INFORMATION_EX

typedef struct _FILE_LINK_INFORMATION_EX * PFILE_LINK_INFORMATION_EX

PFILE_LINKS_FULL_ID_INFORMATION

typedef struct _FILE_LINKS_FULL_ID_INFORMATION * PFILE_LINKS_FULL_ID_INFORMATION

PFILE_RENAME_INFORMATION_EX

typedef struct _FILE_RENAME_INFORMATION_EX * PFILE_RENAME_INFORMATION_EX

PFILE_STAT_INFORMATION

typedef struct _FILE_STAT_INFORMATION * PFILE_STAT_INFORMATION

PFILE_STAT_LX_INFORMATION

typedef struct _FILE_STAT_LX_INFORMATION * PFILE_STAT_LX_INFORMATION

Function Documentation

_Dispatch_type_() [1/4]

_Dispatch_type_

(

IRP_MJ_QUERY_EA

)

Definition at line 5466 of file fileinfo.c.

                                                                             {
    NTSTATUS Status;
    bool top_level;
    device_extension* Vcb = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    PFILE_OBJECT FileObject = IrpSp->FileObject;
    fcb* fcb;
    ccb* ccb;
    FILE_FULL_EA_INFORMATION* ffei;
    ULONG retlen = 0;
 
    FsRtlEnterFileSystem();
 
    TRACE("(%p, %p)\n", DeviceObject, Irp);
 
    top_level = is_top_level(Irp);
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = STATUS_INVALID_DEVICE_REQUEST;
        goto end;
    } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    ffei = map_user_buffer(Irp, NormalPagePriority);
    if (!ffei) {
        ERR("could not get output buffer\n");
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    if (!FileObject) {
        ERR("no file object\n");
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    fcb = FileObject->FsContext;
 
    if (!fcb) {
        ERR("no fcb\n");
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    if (fcb == fcb->Vcb->volume_fcb) {
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    ccb = FileObject->FsContext2;
 
    if (!ccb) {
        ERR("no ccb\n");
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    if (Irp->RequestorMode == UserMode && !(ccb->access & (FILE_READ_EA | FILE_WRITE_EA))) {
        WARN("insufficient privileges\n");
        Status = STATUS_ACCESS_DENIED;
        goto end;
    }
 
    if (fcb->ads)
        fcb = ccb->fileref->parent->fcb;
 
    ExAcquireResourceSharedLite(fcb->Header.Resource, true);
 
    if (fcb->ea_xattr.Length == 0) {
        Status = STATUS_NO_EAS_ON_FILE;
        goto end2;
    }
 
    Status = STATUS_SUCCESS;
 
    if (IrpSp->Parameters.QueryEa.EaList) {
        FILE_FULL_EA_INFORMATION *ea, *out;
        FILE_GET_EA_INFORMATION* in;
 
        in = IrpSp->Parameters.QueryEa.EaList;
        do {
            STRING s;
 
            s.Length = s.MaximumLength = in->EaNameLength;
            s.Buffer = in->EaName;
 
            RtlUpperString(&s, &s);
 
            if (in->NextEntryOffset == 0)
                break;
 
            in = (FILE_GET_EA_INFORMATION*)(((uint8_t*)in) + in->NextEntryOffset);
        } while (true);
 
        ea = (FILE_FULL_EA_INFORMATION*)fcb->ea_xattr.Buffer;
        out = NULL;
 
        do {
            bool found = false;
 
            in = IrpSp->Parameters.QueryEa.EaList;
            do {
                if (in->EaNameLength == ea->EaNameLength &&
                    RtlCompareMemory(in->EaName, ea->EaName, in->EaNameLength) == in->EaNameLength) {
                    found = true;
                    break;
                }
 
                if (in->NextEntryOffset == 0)
                    break;
 
                in = (FILE_GET_EA_INFORMATION*)(((uint8_t*)in) + in->NextEntryOffset);
            } while (true);
 
            if (found) {
                uint8_t padding = retlen % 4 > 0 ? (4 - (retlen % 4)) : 0;
 
                if (offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + ea->EaNameLength + 1 + ea->EaValueLength > IrpSp->Parameters.QueryEa.Length - retlen - padding) {
                    Status = STATUS_BUFFER_OVERFLOW;
                    retlen = 0;
                    goto end2;
                }
 
                retlen += padding;
 
                if (out) {
                    out->NextEntryOffset = (ULONG)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + out->EaNameLength + 1 + out->EaValueLength + padding;
                    out = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)out) + out->NextEntryOffset);
                } else
                    out = ffei;
 
                out->NextEntryOffset = 0;
                out->Flags = ea->Flags;
                out->EaNameLength = ea->EaNameLength;
                out->EaValueLength = ea->EaValueLength;
                RtlCopyMemory(out->EaName, ea->EaName, ea->EaNameLength + ea->EaValueLength + 1);
 
                retlen += (ULONG)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + ea->EaNameLength + 1 + ea->EaValueLength;
 
                if (IrpSp->Flags & SL_RETURN_SINGLE_ENTRY)
                    break;
            }
 
            if (ea->NextEntryOffset == 0)
                break;
 
            ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
        } while (true);
    } else {
        FILE_FULL_EA_INFORMATION *ea, *out;
        ULONG index;
 
        if (IrpSp->Flags & SL_INDEX_SPECIFIED) {
            // The index is 1-based
            if (IrpSp->Parameters.QueryEa.EaIndex == 0) {
                Status = STATUS_NONEXISTENT_EA_ENTRY;
                goto end2;
            } else
                index = IrpSp->Parameters.QueryEa.EaIndex - 1;
        } else if (IrpSp->Flags & SL_RESTART_SCAN)
            index = ccb->ea_index = 0;
        else
            index = ccb->ea_index;
 
        ea = (FILE_FULL_EA_INFORMATION*)fcb->ea_xattr.Buffer;
 
        if (index > 0) {
            ULONG i;
 
            for (i = 0; i < index; i++) {
                if (ea->NextEntryOffset == 0) { // last item
                    Status = STATUS_NO_MORE_EAS;
                    goto end2;
                }
 
                ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
            }
        }
 
        out = NULL;
 
        do {
            uint8_t padding = retlen % 4 > 0 ? (4 - (retlen % 4)) : 0;
 
            if (offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + ea->EaNameLength + 1 + ea->EaValueLength > IrpSp->Parameters.QueryEa.Length - retlen - padding) {
                Status = retlen == 0 ? STATUS_BUFFER_TOO_SMALL : STATUS_BUFFER_OVERFLOW;
                goto end2;
            }
 
            retlen += padding;
 
            if (out) {
                out->NextEntryOffset = (ULONG)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + out->EaNameLength + 1 + out->EaValueLength + padding;
                out = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)out) + out->NextEntryOffset);
            } else
                out = ffei;
 
            out->NextEntryOffset = 0;
            out->Flags = ea->Flags;
            out->EaNameLength = ea->EaNameLength;
            out->EaValueLength = ea->EaValueLength;
            RtlCopyMemory(out->EaName, ea->EaName, ea->EaNameLength + ea->EaValueLength + 1);
 
            retlen += (ULONG)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + ea->EaNameLength + 1 + ea->EaValueLength;
 
            if (!(IrpSp->Flags & SL_INDEX_SPECIFIED))
                ccb->ea_index++;
 
            if (ea->NextEntryOffset == 0 || IrpSp->Flags & SL_RETURN_SINGLE_ENTRY)
                break;
 
            ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
        } while (true);
    }
 
end2:
    ExReleaseResourceLite(fcb->Header.Resource);
 
end:
    TRACE("returning %08lx\n", Status);
 
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW ? retlen : 0;
 
    IoCompleteRequest( Irp, IO_NO_INCREMENT );
 
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    FsRtlExitFileSystem();
 
    return Status;
}

_Dispatch_type_() [2/4]

_Dispatch_type_

(

IRP_MJ_QUERY_INFORMATION

)

Definition at line 5418 of file fileinfo.c.

                                                                                      {
    PIO_STACK_LOCATION IrpSp;
    NTSTATUS Status;
    fcb* fcb;
    device_extension* Vcb = DeviceObject->DeviceExtension;
    bool top_level;
 
    FsRtlEnterFileSystem();
 
    top_level = is_top_level(Irp);
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = STATUS_INVALID_DEVICE_REQUEST;
        goto end;
    } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    Irp->IoStatus.Information = 0;
 
    TRACE("query information\n");
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    fcb = IrpSp->FileObject->FsContext;
    TRACE("fcb = %p\n", fcb);
    TRACE("fcb->subvol = %p\n", fcb->subvol);
 
    Status = query_info(fcb->Vcb, IrpSp->FileObject, Irp);
 
end:
    TRACE("returning %08lx\n", Status);
 
    Irp->IoStatus.Status = Status;
 
    IoCompleteRequest( Irp, IO_NO_INCREMENT );
 
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    FsRtlExitFileSystem();
 
    return Status;
}

_Dispatch_type_() [3/4]

_Dispatch_type_

(

IRP_MJ_SET_EA

)

Definition at line 5704 of file fileinfo.c.

                                                                           {
    device_extension* Vcb = DeviceObject->DeviceExtension;
    NTSTATUS Status;
    bool top_level;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    PFILE_OBJECT FileObject = IrpSp->FileObject;
    fcb* fcb;
    ccb* ccb;
    file_ref* fileref;
    FILE_FULL_EA_INFORMATION* ffei;
    ULONG offset;
    LIST_ENTRY ealist;
    ea_item* item;
    FILE_FULL_EA_INFORMATION* ea;
    LIST_ENTRY* le;
    LARGE_INTEGER time;
    BTRFS_TIME now;
 
    FsRtlEnterFileSystem();
 
    TRACE("(%p, %p)\n", DeviceObject, Irp);
 
    top_level = is_top_level(Irp);
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = STATUS_INVALID_DEVICE_REQUEST;
        goto end;
    } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    if (Vcb->readonly) {
        Status = STATUS_MEDIA_WRITE_PROTECTED;
        goto end;
    }
 
    ffei = map_user_buffer(Irp, NormalPagePriority);
    if (!ffei) {
        ERR("could not get output buffer\n");
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    Status = IoCheckEaBufferValidity(ffei, IrpSp->Parameters.SetEa.Length, &offset);
    if (!NT_SUCCESS(Status)) {
        ERR("IoCheckEaBufferValidity returned %08lx (error at offset %lu)\n", Status, offset);
        goto end;
    }
 
    if (!FileObject) {
        ERR("no file object\n");
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    fcb = FileObject->FsContext;
 
    if (!fcb) {
        ERR("no fcb\n");
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    if (fcb == fcb->Vcb->volume_fcb) {
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    ccb = FileObject->FsContext2;
 
    if (!ccb) {
        ERR("no ccb\n");
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    if (Irp->RequestorMode == UserMode && !(ccb->access & FILE_WRITE_EA)) {
        WARN("insufficient privileges\n");
        Status = STATUS_ACCESS_DENIED;
        goto end;
    }
 
    if (fcb->ads) {
        fileref = ccb->fileref->parent;
        fcb = fileref->fcb;
    } else
        fileref = ccb->fileref;
 
    InitializeListHead(&ealist);
 
    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
    if (fcb->ea_xattr.Length > 0) {
        ea = (FILE_FULL_EA_INFORMATION*)fcb->ea_xattr.Buffer;
 
        do {
            item = ExAllocatePoolWithTag(PagedPool, sizeof(ea_item), ALLOC_TAG);
            if (!item) {
                ERR("out of memory\n");
                Status = STATUS_INSUFFICIENT_RESOURCES;
                goto end2;
            }
 
            item->name.Length = item->name.MaximumLength = ea->EaNameLength;
            item->name.Buffer = ea->EaName;
 
            item->value.Length = item->value.MaximumLength = ea->EaValueLength;
            item->value.Buffer = &ea->EaName[ea->EaNameLength + 1];
 
            item->flags = ea->Flags;
 
            InsertTailList(&ealist, &item->list_entry);
 
            if (ea->NextEntryOffset == 0)
                break;
 
            ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
        } while (true);
    }
 
    ea = ffei;
 
    do {
        STRING s;
        bool found = false;
 
        s.Length = s.MaximumLength = ea->EaNameLength;
        s.Buffer = ea->EaName;
 
        RtlUpperString(&s, &s);
 
        le = ealist.Flink;
        while (le != &ealist) {
            item = CONTAINING_RECORD(le, ea_item, list_entry);
 
            if (item->name.Length == s.Length &&
                RtlCompareMemory(item->name.Buffer, s.Buffer, s.Length) == s.Length) {
                item->flags = ea->Flags;
                item->value.Length = item->value.MaximumLength = ea->EaValueLength;
                item->value.Buffer = &ea->EaName[ea->EaNameLength + 1];
                found = true;
                break;
            }
 
            le = le->Flink;
        }
 
        if (!found) {
            item = ExAllocatePoolWithTag(PagedPool, sizeof(ea_item), ALLOC_TAG);
            if (!item) {
                ERR("out of memory\n");
                Status = STATUS_INSUFFICIENT_RESOURCES;
                goto end2;
            }
 
            item->name.Length = item->name.MaximumLength = ea->EaNameLength;
            item->name.Buffer = ea->EaName;
 
            item->value.Length = item->value.MaximumLength = ea->EaValueLength;
            item->value.Buffer = &ea->EaName[ea->EaNameLength + 1];
 
            item->flags = ea->Flags;
 
            InsertTailList(&ealist, &item->list_entry);
        }
 
        if (ea->NextEntryOffset == 0)
            break;
 
        ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
    } while (true);
 
    // remove entries with zero-length value
    le = ealist.Flink;
    while (le != &ealist) {
        LIST_ENTRY* le2 = le->Flink;
 
        item = CONTAINING_RECORD(le, ea_item, list_entry);
 
        if (item->value.Length == 0) {
            RemoveEntryList(&item->list_entry);
            ExFreePool(item);
        }
 
        le = le2;
    }
 
    // handle LXSS values
    le = ealist.Flink;
    while (le != &ealist) {
        LIST_ENTRY* le2 = le->Flink;
 
        item = CONTAINING_RECORD(le, ea_item, list_entry);
 
        if (item->name.Length == sizeof(lxuid) - 1 && RtlCompareMemory(item->name.Buffer, lxuid, item->name.Length) == item->name.Length) {
            if (item->value.Length < sizeof(uint32_t)) {
                ERR("uid value was shorter than expected\n");
                Status = STATUS_INVALID_PARAMETER;
                goto end2;
            }
 
            if (Irp->RequestorMode == KernelMode || ccb->access & FILE_WRITE_ATTRIBUTES) {
                RtlCopyMemory(&fcb->inode_item.st_uid, item->value.Buffer, sizeof(uint32_t));
                fcb->sd_dirty = true;
                fcb->sd_deleted = false;
            }
 
            RemoveEntryList(&item->list_entry);
            ExFreePool(item);
        } else if (item->name.Length == sizeof(lxgid) - 1 && RtlCompareMemory(item->name.Buffer, lxgid, item->name.Length) == item->name.Length) {
            if (item->value.Length < sizeof(uint32_t)) {
                ERR("gid value was shorter than expected\n");
                Status = STATUS_INVALID_PARAMETER;
                goto end2;
            }
 
            if (Irp->RequestorMode == KernelMode || ccb->access & FILE_WRITE_ATTRIBUTES)
                RtlCopyMemory(&fcb->inode_item.st_gid, item->value.Buffer, sizeof(uint32_t));
 
            RemoveEntryList(&item->list_entry);
            ExFreePool(item);
        } else if (item->name.Length == sizeof(lxmod) - 1 && RtlCompareMemory(item->name.Buffer, lxmod, item->name.Length) == item->name.Length) {
            if (item->value.Length < sizeof(uint32_t)) {
                ERR("mode value was shorter than expected\n");
                Status = STATUS_INVALID_PARAMETER;
                goto end2;
            }
 
            if (Irp->RequestorMode == KernelMode || ccb->access & FILE_WRITE_ATTRIBUTES) {
                uint32_t allowed = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH | S_ISGID | S_ISVTX | S_ISUID;
                uint32_t val;
 
                RtlCopyMemory(&val, item->value.Buffer, sizeof(uint32_t));
 
                fcb->inode_item.st_mode &= ~allowed;
                fcb->inode_item.st_mode |= val & allowed;
            }
 
            RemoveEntryList(&item->list_entry);
            ExFreePool(item);
        }
 
        le = le2;
    }
 
    if (IsListEmpty(&ealist)) {
        fcb->ealen = 0;
 
        if (fcb->ea_xattr.Buffer)
            ExFreePool(fcb->ea_xattr.Buffer);
 
        fcb->ea_xattr.Length = fcb->ea_xattr.MaximumLength = 0;
        fcb->ea_xattr.Buffer = NULL;
    } else {
        uint16_t size = 0;
        char *buf, *oldbuf;
 
        le = ealist.Flink;
        while (le != &ealist) {
            item = CONTAINING_RECORD(le, ea_item, list_entry);
 
            if (size % 4 > 0)
                size += 4 - (size % 4);
 
            size += (uint16_t)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + item->name.Length + 1 + item->value.Length;
 
            le = le->Flink;
        }
 
        buf = ExAllocatePoolWithTag(PagedPool, size, ALLOC_TAG);
        if (!buf) {
            ERR("out of memory\n");
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto end2;
        }
 
        oldbuf = fcb->ea_xattr.Buffer;
 
        fcb->ea_xattr.Length = fcb->ea_xattr.MaximumLength = size;
        fcb->ea_xattr.Buffer = buf;
 
        fcb->ealen = 4;
        ea = NULL;
 
        le = ealist.Flink;
        while (le != &ealist) {
            item = CONTAINING_RECORD(le, ea_item, list_entry);
 
            if (ea) {
                ea->NextEntryOffset = (ULONG)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + ea->EaNameLength + ea->EaValueLength;
 
                if (ea->NextEntryOffset % 4 > 0)
                    ea->NextEntryOffset += 4 - (ea->NextEntryOffset % 4);
 
                ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
            } else
                ea = (FILE_FULL_EA_INFORMATION*)fcb->ea_xattr.Buffer;
 
            ea->NextEntryOffset = 0;
            ea->Flags = item->flags;
            ea->EaNameLength = (UCHAR)item->name.Length;
            ea->EaValueLength = item->value.Length;
 
            RtlCopyMemory(ea->EaName, item->name.Buffer, item->name.Length);
            ea->EaName[item->name.Length] = 0;
            RtlCopyMemory(&ea->EaName[item->name.Length + 1], item->value.Buffer, item->value.Length);
 
            fcb->ealen += 5 + item->name.Length + item->value.Length;
 
            le = le->Flink;
        }
 
        if (oldbuf)
            ExFreePool(oldbuf);
    }
 
    fcb->ea_changed = true;
 
    KeQuerySystemTime(&time);
    win_time_to_unix(time, &now);
 
    fcb->inode_item.transid = Vcb->superblock.generation;
    fcb->inode_item.sequence++;
 
    if (!ccb->user_set_change_time)
        fcb->inode_item.st_ctime = now;
 
    fcb->inode_item_changed = true;
    mark_fcb_dirty(fcb);
 
    send_notification_fileref(fileref, FILE_NOTIFY_CHANGE_EA, FILE_ACTION_MODIFIED, NULL);
 
    Status = STATUS_SUCCESS;
 
end2:
    ExReleaseResourceLite(fcb->Header.Resource);
 
    while (!IsListEmpty(&ealist)) {
        le = RemoveHeadList(&ealist);
 
        item = CONTAINING_RECORD(le, ea_item, list_entry);
 
        ExFreePool(item);
    }
 
end:
    TRACE("returning %08lx\n", Status);
 
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    FsRtlExitFileSystem();
 
    return Status;
}

_Dispatch_type_() [4/4]

_Dispatch_type_

(

IRP_MJ_SET_INFORMATION

)

Definition at line 3889 of file fileinfo.c.

                                                                                    {
    NTSTATUS Status;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    device_extension* Vcb = DeviceObject->DeviceExtension;
    fcb* fcb = IrpSp->FileObject->FsContext;
    ccb* ccb = IrpSp->FileObject->FsContext2;
    bool top_level;
 
    FsRtlEnterFileSystem();
 
    top_level = is_top_level(Irp);
 
    Irp->IoStatus.Information = 0;
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = STATUS_INVALID_DEVICE_REQUEST;
        goto end;
    } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    if (!(Vcb->Vpb->Flags & VPB_MOUNTED)) {
        Status = STATUS_ACCESS_DENIED;
        goto end;
    }
 
    if (Vcb->readonly && IrpSp->Parameters.SetFile.FileInformationClass != FilePositionInformation) {
        Status = STATUS_MEDIA_WRITE_PROTECTED;
        goto end;
    }
 
    if (!fcb) {
        ERR("no fcb\n");
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    if (!ccb) {
        ERR("no ccb\n");
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    if (fcb != Vcb->dummy_fcb && is_subvol_readonly(fcb->subvol, Irp) && IrpSp->Parameters.SetFile.FileInformationClass != FilePositionInformation &&
#ifndef __REACTOS__
        (fcb->inode != SUBVOL_ROOT_INODE || (IrpSp->Parameters.SetFile.FileInformationClass != FileBasicInformation && IrpSp->Parameters.SetFile.FileInformationClass != FileRenameInformation && IrpSp->Parameters.SetFile.FileInformationClass != FileRenameInformationEx))) {
#else
        (fcb->inode != SUBVOL_ROOT_INODE || (IrpSp->Parameters.SetFile.FileInformationClass != FileBasicInformation && IrpSp->Parameters.SetFile.FileInformationClass != FileRenameInformation))) {
#endif
        Status = STATUS_ACCESS_DENIED;
        goto end;
    }
 
    Status = STATUS_NOT_IMPLEMENTED;
 
    TRACE("set information\n");
 
    FsRtlCheckOplock(fcb_oplock(fcb), Irp, NULL, NULL, NULL);
 
    switch (IrpSp->Parameters.SetFile.FileInformationClass) {
        case FileAllocationInformation:
        {
            TRACE("FileAllocationInformation\n");
 
            if (Irp->RequestorMode == UserMode && !(ccb->access & FILE_WRITE_DATA)) {
                WARN("insufficient privileges\n");
                Status = STATUS_ACCESS_DENIED;
                break;
            }
 
            Status = set_end_of_file_information(Vcb, Irp, IrpSp->FileObject, false, true);
            break;
        }
 
        case FileBasicInformation:
        {
            TRACE("FileBasicInformation\n");
 
            if (Irp->RequestorMode == UserMode && !(ccb->access & FILE_WRITE_ATTRIBUTES)) {
                WARN("insufficient privileges\n");
                Status = STATUS_ACCESS_DENIED;
                break;
            }
 
            Status = set_basic_information(Vcb, Irp, IrpSp->FileObject);
 
            break;
        }
 
        case FileDispositionInformation:
        {
            TRACE("FileDispositionInformation\n");
 
            if (Irp->RequestorMode == UserMode && !(ccb->access & DELETE)) {
                WARN("insufficient privileges\n");
                Status = STATUS_ACCESS_DENIED;
                break;
            }
 
            Status = set_disposition_information(Vcb, Irp, IrpSp->FileObject, false);
 
            break;
        }
 
        case FileEndOfFileInformation:
        {
            TRACE("FileEndOfFileInformation\n");
 
            if (Irp->RequestorMode == UserMode && !(ccb->access & (FILE_WRITE_DATA | FILE_APPEND_DATA))) {
                WARN("insufficient privileges\n");
                Status = STATUS_ACCESS_DENIED;
                break;
            }
 
            Status = set_end_of_file_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.AdvanceOnly, false);
 
            break;
        }
 
        case FileLinkInformation:
            TRACE("FileLinkInformation\n");
            Status = set_link_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.FileObject, false);
            break;
 
        case FilePositionInformation:
            TRACE("FilePositionInformation\n");
            Status = set_position_information(IrpSp->FileObject, Irp);
            break;
 
        case FileRenameInformation:
            TRACE("FileRenameInformation\n");
            Status = set_rename_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.FileObject, false);
            break;
 
        case FileValidDataLengthInformation:
        {
            TRACE("FileValidDataLengthInformation\n");
 
            if (Irp->RequestorMode == UserMode && !(ccb->access & (FILE_WRITE_DATA | FILE_APPEND_DATA))) {
                WARN("insufficient privileges\n");
                Status = STATUS_ACCESS_DENIED;
                break;
            }
 
            Status = set_valid_data_length_information(Vcb, Irp, IrpSp->FileObject);
 
            break;
        }
 
#ifndef __REACTOS__
#ifndef _MSC_VER
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wswitch"
#endif
        case FileDispositionInformationEx:
        {
            TRACE("FileDispositionInformationEx\n");
 
            if (Irp->RequestorMode == UserMode && !(ccb->access & DELETE)) {
                WARN("insufficient privileges\n");
                Status = STATUS_ACCESS_DENIED;
                break;
            }
 
            Status = set_disposition_information(Vcb, Irp, IrpSp->FileObject, true);
 
            break;
        }
 
        case FileRenameInformationEx:
            TRACE("FileRenameInformationEx\n");
            Status = set_rename_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.FileObject, true);
            break;
 
        case FileLinkInformationEx:
            TRACE("FileLinkInformationEx\n");
            Status = set_link_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.FileObject, true);
            break;
 
        case FileCaseSensitiveInformation:
            TRACE("FileCaseSensitiveInformation\n");
 
            if (Irp->RequestorMode == UserMode && !(ccb->access & FILE_WRITE_ATTRIBUTES)) {
                WARN("insufficient privileges\n");
                Status = STATUS_ACCESS_DENIED;
                break;
            }
 
            Status = set_case_sensitive_information(Irp);
            break;
 
        case FileStorageReserveIdInformation:
            WARN("unimplemented FileInformationClass FileStorageReserveIdInformation\n");
            break;
 
#ifndef _MSC_VER
#pragma GCC diagnostic pop
#endif
#endif
 
        default:
            WARN("unknown FileInformationClass %u\n", IrpSp->Parameters.SetFile.FileInformationClass);
    }
 
end:
    Irp->IoStatus.Status = Status;
 
    TRACE("returning %08lx\n", Status);
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    FsRtlExitFileSystem();
 
    return Status;
}

add_children_to_move_list()

static NTSTATUS add_children_to_move_list ( device_extension *  Vcb, move_entry *  me, PIRP  Irp  )

static

Definition at line 701 of file fileinfo.c.

                                                                                           {
    NTSTATUS Status;
    LIST_ENTRY* le;
 
    ExAcquireResourceSharedLite(&me->fileref->fcb->nonpaged->dir_children_lock, true);
 
    le = me->fileref->fcb->dir_children_index.Flink;
 
    while (le != &me->fileref->fcb->dir_children_index) {
        dir_child* dc = CONTAINING_RECORD(le, dir_child, list_entry_index);
        file_ref* fr;
        move_entry* me2;
 
        Status = open_fileref_child(Vcb, me->fileref, &dc->name, true, true, dc->index == 0 ? true : false, PagedPool, &fr, Irp);
 
        if (!NT_SUCCESS(Status)) {
            ERR("open_fileref_child returned %08lx\n", Status);
            ExReleaseResourceLite(&me->fileref->fcb->nonpaged->dir_children_lock);
            return Status;
        }
 
        me2 = ExAllocatePoolWithTag(PagedPool, sizeof(move_entry), ALLOC_TAG);
        if (!me2) {
            ERR("out of memory\n");
            ExReleaseResourceLite(&me->fileref->fcb->nonpaged->dir_children_lock);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        me2->fileref = fr;
        me2->dummyfcb = NULL;
        me2->dummyfileref = NULL;
        me2->parent = me;
 
        InsertHeadList(&me->list_entry, &me2->list_entry);
 
        le = le->Flink;
    }
 
    ExReleaseResourceLite(&me->fileref->fcb->nonpaged->dir_children_lock);
 
    return STATUS_SUCCESS;
}

Referenced by move_across_subvols().

add_fcb_to_subvol()

void add_fcb_to_subvol

(

_In_ _Requires_exclusive_lock_held_(_Curr_->Vcb->fcb_lock) fcb *

fcb

)

Definition at line 888 of file fileinfo.c.

                                                                                            {
    LIST_ENTRY* lastle = NULL;
    uint32_t hash = fcb->hash;
 
    if (fcb->subvol->fcbs_ptrs[hash >> 24]) {
        LIST_ENTRY* le = fcb->subvol->fcbs_ptrs[hash >> 24];
 
        while (le != &fcb->subvol->fcbs) {
            struct _fcb* fcb2 = CONTAINING_RECORD(le, struct _fcb, list_entry);
 
            if (fcb2->hash > hash) {
                lastle = le->Blink;
                break;
            }
 
            le = le->Flink;
        }
    }
 
    if (!lastle) {
        uint8_t c = hash >> 24;
 
        if (c != 0xff) {
            uint8_t d = c + 1;
 
            do {
                if (fcb->subvol->fcbs_ptrs[d]) {
                    lastle = fcb->subvol->fcbs_ptrs[d]->Blink;
                    break;
                }
 
                d++;
            } while (d != 0);
        }
    }
 
    if (lastle) {
        InsertHeadList(lastle, &fcb->list_entry);
 
        if (lastle == &fcb->subvol->fcbs || (CONTAINING_RECORD(lastle, struct _fcb, list_entry)->hash >> 24) != (hash >> 24))
            fcb->subvol->fcbs_ptrs[hash >> 24] = &fcb->list_entry;
    } else {
        InsertTailList(&fcb->subvol->fcbs, &fcb->list_entry);
 
        if (fcb->list_entry.Blink == &fcb->subvol->fcbs || (CONTAINING_RECORD(fcb->list_entry.Blink, struct _fcb, list_entry)->hash >> 24) != (hash >> 24))
            fcb->subvol->fcbs_ptrs[hash >> 24] = &fcb->list_entry;
    }
}

Referenced by allocate_cache_chunk(), create_directory_fcb(), create_subvol(), mknod(), move_across_subvols(), rename_stream(), and rename_stream_to_file().

create_directory_fcb()

static NTSTATUS create_directory_fcb ( device_extension *  Vcb, root *  r, fcb *  parfcb, fcb **  pfcb  )

static

Definition at line 782 of file fileinfo.c.

                                                                                              {
    NTSTATUS Status;
    fcb* fcb;
    SECURITY_SUBJECT_CONTEXT subjcont;
    PSID owner;
    BOOLEAN defaulted;
    LARGE_INTEGER time;
    BTRFS_TIME now;
 
    fcb = create_fcb(Vcb, PagedPool);
    if (!fcb) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    KeQuerySystemTime(&time);
    win_time_to_unix(time, &now);
 
    fcb->Vcb = Vcb;
 
    fcb->subvol = r;
    fcb->inode = InterlockedIncrement64(&r->lastinode);
    fcb->hash = calc_crc32c(0xffffffff, (uint8_t*)&fcb->inode, sizeof(uint64_t));
    fcb->type = BTRFS_TYPE_DIRECTORY;
 
    fcb->inode_item.generation = Vcb->superblock.generation;
    fcb->inode_item.transid = Vcb->superblock.generation;
    fcb->inode_item.st_nlink = 1;
    fcb->inode_item.st_mode = __S_IFDIR | inherit_mode(parfcb, true);
    fcb->inode_item.st_atime = fcb->inode_item.st_ctime = fcb->inode_item.st_mtime = fcb->inode_item.otime = now;
    fcb->inode_item.st_gid = GID_NOBODY;
 
    fcb->atts = get_file_attributes(Vcb, fcb->subvol, fcb->inode, fcb->type, false, true, NULL);
 
    SeCaptureSubjectContext(&subjcont);
 
    Status = SeAssignSecurity(parfcb->sd, NULL, (void**)&fcb->sd, true, &subjcont, IoGetFileObjectGenericMapping(), PagedPool);
 
    if (!NT_SUCCESS(Status)) {
        reap_fcb(fcb);
        ERR("SeAssignSecurity returned %08lx\n", Status);
        return Status;
    }
 
    if (!fcb->sd) {
        reap_fcb(fcb);
        ERR("SeAssignSecurity returned NULL security descriptor\n");
        return STATUS_INTERNAL_ERROR;
    }
 
    Status = RtlGetOwnerSecurityDescriptor(fcb->sd, &owner, &defaulted);
    if (!NT_SUCCESS(Status)) {
        ERR("RtlGetOwnerSecurityDescriptor returned %08lx\n", Status);
        fcb->inode_item.st_uid = UID_NOBODY;
        fcb->sd_dirty = true;
    } else {
        fcb->inode_item.st_uid = sid_to_uid(owner);
        fcb->sd_dirty = fcb->inode_item.st_uid == UID_NOBODY;
    }
 
    find_gid(fcb, parfcb, &subjcont);
 
    fcb->inode_item_changed = true;
 
    fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
    fcb->Header.AllocationSize.QuadPart = 0;
    fcb->Header.FileSize.QuadPart = 0;
    fcb->Header.ValidDataLength.QuadPart = 0;
 
    fcb->created = true;
 
    if (parfcb->inode_item.flags & BTRFS_INODE_COMPRESS)
        fcb->inode_item.flags |= BTRFS_INODE_COMPRESS;
 
    fcb->prop_compression = parfcb->prop_compression;
    fcb->prop_compression_changed = fcb->prop_compression != PropCompression_None;
 
    fcb->hash_ptrs = ExAllocatePoolWithTag(PagedPool, sizeof(LIST_ENTRY*) * 256, ALLOC_TAG);
    if (!fcb->hash_ptrs) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlZeroMemory(fcb->hash_ptrs, sizeof(LIST_ENTRY*) * 256);
 
    fcb->hash_ptrs_uc = ExAllocatePoolWithTag(PagedPool, sizeof(LIST_ENTRY*) * 256, ALLOC_TAG);
    if (!fcb->hash_ptrs_uc) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlZeroMemory(fcb->hash_ptrs_uc, sizeof(LIST_ENTRY*) * 256);
 
    acquire_fcb_lock_exclusive(Vcb);
    add_fcb_to_subvol(fcb);
    InsertTailList(&Vcb->all_fcbs, &fcb->list_entry_all);
    r->fcbs_version++;
    release_fcb_lock(Vcb);
 
    mark_fcb_dirty(fcb);
 
    *pfcb = fcb;
 
    return STATUS_SUCCESS;
}

Referenced by move_across_subvols().

duplicate_fcb()

static NTSTATUS duplicate_fcb ( fcb *  oldfcb, fcb **  pfcb  )

static

Definition at line 463 of file fileinfo.c.

                                                       {
    device_extension* Vcb = oldfcb->Vcb;
    fcb* fcb;
    LIST_ENTRY* le;
 
    // FIXME - we can skip a lot of this if the inode is about to be deleted
 
    fcb = create_fcb(Vcb, PagedPool); // FIXME - what if we duplicate the paging file?
    if (!fcb) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    fcb->Vcb = Vcb;
 
    fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
    fcb->Header.AllocationSize = oldfcb->Header.AllocationSize;
    fcb->Header.FileSize = oldfcb->Header.FileSize;
    fcb->Header.ValidDataLength = oldfcb->Header.ValidDataLength;
 
    fcb->type = oldfcb->type;
 
    if (oldfcb->ads) {
        fcb->ads = true;
        fcb->adshash = oldfcb->adshash;
        fcb->adsmaxlen = oldfcb->adsmaxlen;
 
        if (oldfcb->adsxattr.Buffer && oldfcb->adsxattr.Length > 0) {
            fcb->adsxattr.Length = oldfcb->adsxattr.Length;
            fcb->adsxattr.MaximumLength = fcb->adsxattr.Length + 1;
            fcb->adsxattr.Buffer = ExAllocatePoolWithTag(PagedPool, fcb->adsxattr.MaximumLength, ALLOC_TAG);
 
            if (!fcb->adsxattr.Buffer) {
                ERR("out of memory\n");
                free_fcb(fcb);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            RtlCopyMemory(fcb->adsxattr.Buffer, oldfcb->adsxattr.Buffer, fcb->adsxattr.Length);
            fcb->adsxattr.Buffer[fcb->adsxattr.Length] = 0;
        }
 
        if (oldfcb->adsdata.Buffer && oldfcb->adsdata.Length > 0) {
            fcb->adsdata.Length = fcb->adsdata.MaximumLength = oldfcb->adsdata.Length;
            fcb->adsdata.Buffer = ExAllocatePoolWithTag(PagedPool, fcb->adsdata.MaximumLength, ALLOC_TAG);
 
            if (!fcb->adsdata.Buffer) {
                ERR("out of memory\n");
                free_fcb(fcb);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            RtlCopyMemory(fcb->adsdata.Buffer, oldfcb->adsdata.Buffer, fcb->adsdata.Length);
        }
 
        goto end;
    }
 
    RtlCopyMemory(&fcb->inode_item, &oldfcb->inode_item, sizeof(INODE_ITEM));
    fcb->inode_item_changed = true;
 
    if (oldfcb->sd && RtlLengthSecurityDescriptor(oldfcb->sd) > 0) {
        fcb->sd = ExAllocatePoolWithTag(PagedPool, RtlLengthSecurityDescriptor(oldfcb->sd), ALLOC_TAG);
        if (!fcb->sd) {
            ERR("out of memory\n");
            free_fcb(fcb);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        RtlCopyMemory(fcb->sd, oldfcb->sd, RtlLengthSecurityDescriptor(oldfcb->sd));
    }
 
    fcb->atts = oldfcb->atts;
 
    le = oldfcb->extents.Flink;
    while (le != &oldfcb->extents) {
        extent* ext = CONTAINING_RECORD(le, extent, list_entry);
 
        if (!ext->ignore) {
            extent* ext2 = ExAllocatePoolWithTag(PagedPool, offsetof(extent, extent_data) + ext->datalen, ALLOC_TAG);
 
            if (!ext2) {
                ERR("out of memory\n");
                free_fcb(fcb);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            ext2->offset = ext->offset;
            ext2->datalen = ext->datalen;
 
            if (ext2->datalen > 0)
                RtlCopyMemory(&ext2->extent_data, &ext->extent_data, ext2->datalen);
 
            ext2->unique = false;
            ext2->ignore = false;
            ext2->inserted = true;
 
            if (ext->csum) {
                ULONG len;
                EXTENT_DATA2* ed2 = (EXTENT_DATA2*)ext->extent_data.data;
 
                if (ext->extent_data.compression == BTRFS_COMPRESSION_NONE)
                    len = (ULONG)ed2->num_bytes;
                else
                    len = (ULONG)ed2->size;
 
                len = (len * sizeof(uint32_t)) >> Vcb->sector_shift;
 
                ext2->csum = ExAllocatePoolWithTag(PagedPool, len, ALLOC_TAG);
                if (!ext2->csum) {
                    ERR("out of memory\n");
                    free_fcb(fcb);
                    return STATUS_INSUFFICIENT_RESOURCES;
                }
 
                RtlCopyMemory(ext2->csum, ext->csum, len);
            } else
                ext2->csum = NULL;
 
            InsertTailList(&fcb->extents, &ext2->list_entry);
        }
 
        le = le->Flink;
    }
 
    le = oldfcb->hardlinks.Flink;
    while (le != &oldfcb->hardlinks) {
        hardlink *hl = CONTAINING_RECORD(le, hardlink, list_entry), *hl2;
 
        hl2 = ExAllocatePoolWithTag(PagedPool, sizeof(hardlink), ALLOC_TAG);
 
        if (!hl2) {
            ERR("out of memory\n");
            free_fcb(fcb);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        hl2->parent = hl->parent;
        hl2->index = hl->index;
 
        hl2->name.Length = hl2->name.MaximumLength = hl->name.Length;
        hl2->name.Buffer = ExAllocatePoolWithTag(PagedPool, hl2->name.MaximumLength, ALLOC_TAG);
 
        if (!hl2->name.Buffer) {
            ERR("out of memory\n");
            ExFreePool(hl2);
            free_fcb(fcb);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        RtlCopyMemory(hl2->name.Buffer, hl->name.Buffer, hl->name.Length);
 
        hl2->utf8.Length = hl2->utf8.MaximumLength = hl->utf8.Length;
        hl2->utf8.Buffer = ExAllocatePoolWithTag(PagedPool, hl2->utf8.MaximumLength, ALLOC_TAG);
 
        if (!hl2->utf8.Buffer) {
            ERR("out of memory\n");
            ExFreePool(hl2->name.Buffer);
            ExFreePool(hl2);
            free_fcb(fcb);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        RtlCopyMemory(hl2->utf8.Buffer, hl->utf8.Buffer, hl->utf8.Length);
 
        InsertTailList(&fcb->hardlinks, &hl2->list_entry);
 
        le = le->Flink;
    }
 
    if (oldfcb->reparse_xattr.Buffer && oldfcb->reparse_xattr.Length > 0) {
        fcb->reparse_xattr.Length = fcb->reparse_xattr.MaximumLength = oldfcb->reparse_xattr.Length;
 
        fcb->reparse_xattr.Buffer = ExAllocatePoolWithTag(PagedPool, fcb->reparse_xattr.MaximumLength, ALLOC_TAG);
        if (!fcb->reparse_xattr.Buffer) {
            ERR("out of memory\n");
            free_fcb(fcb);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        RtlCopyMemory(fcb->reparse_xattr.Buffer, oldfcb->reparse_xattr.Buffer, fcb->reparse_xattr.Length);
    }
 
    if (oldfcb->ea_xattr.Buffer && oldfcb->ea_xattr.Length > 0) {
        fcb->ea_xattr.Length = fcb->ea_xattr.MaximumLength = oldfcb->ea_xattr.Length;
 
        fcb->ea_xattr.Buffer = ExAllocatePoolWithTag(PagedPool, fcb->ea_xattr.MaximumLength, ALLOC_TAG);
        if (!fcb->ea_xattr.Buffer) {
            ERR("out of memory\n");
            free_fcb(fcb);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        RtlCopyMemory(fcb->ea_xattr.Buffer, oldfcb->ea_xattr.Buffer, fcb->ea_xattr.Length);
    }
 
    fcb->prop_compression = oldfcb->prop_compression;
 
    le = oldfcb->xattrs.Flink;
    while (le != &oldfcb->xattrs) {
        xattr* xa = CONTAINING_RECORD(le, xattr, list_entry);
 
        if (xa->valuelen > 0) {
            xattr* xa2;
 
            xa2 = ExAllocatePoolWithTag(PagedPool, offsetof(xattr, data[0]) + xa->namelen + xa->valuelen, ALLOC_TAG);
 
            if (!xa2) {
                ERR("out of memory\n");
                free_fcb(fcb);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            xa2->namelen = xa->namelen;
            xa2->valuelen = xa->valuelen;
            xa2->dirty = xa->dirty;
            memcpy(xa2->data, xa->data, xa->namelen + xa->valuelen);
 
            InsertTailList(&fcb->xattrs, &xa2->list_entry);
        }
 
        le = le->Flink;
    }
 
end:
    *pfcb = fcb;
 
    return STATUS_SUCCESS;
}

Referenced by move_across_subvols(), and rename_file_to_stream().

fileref_get_filename()

NTSTATUS fileref_get_filename	(	file_ref *	fileref,
		PUNICODE_STRING	fn,
		USHORT *	name_offset,
		ULONG *	preqlen
	)

Definition at line 4245 of file fileinfo.c.

                                                                                                          {
    file_ref* fr;
    NTSTATUS Status;
    ULONG reqlen = 0;
    USHORT offset;
    bool overflow = false;
 
    // FIXME - we need a lock on filerefs' filepart
 
    if (fileref == fileref->fcb->Vcb->root_fileref) {
        if (fn->MaximumLength >= sizeof(WCHAR)) {
            fn->Buffer[0] = '\\';
            fn->Length = sizeof(WCHAR);
 
            if (name_offset)
                *name_offset = 0;
 
            return STATUS_SUCCESS;
        } else {
            if (preqlen)
                *preqlen = sizeof(WCHAR);
            fn->Length = 0;
 
            return STATUS_BUFFER_OVERFLOW;
        }
    }
 
    fr = fileref;
    offset = 0;
 
    while (fr->parent) {
        USHORT movelen;
 
        if (!fr->dc)
            return STATUS_INTERNAL_ERROR;
 
        if (!overflow) {
            if (fr->dc->name.Length + sizeof(WCHAR) + fn->Length > fn->MaximumLength)
                overflow = true;
        }
 
        if (overflow)
            movelen = fn->MaximumLength - fr->dc->name.Length - sizeof(WCHAR);
        else
            movelen = fn->Length;
 
        if ((!overflow || fn->MaximumLength > fr->dc->name.Length + sizeof(WCHAR)) && movelen > 0) {
            RtlMoveMemory(&fn->Buffer[(fr->dc->name.Length / sizeof(WCHAR)) + 1], fn->Buffer, movelen);
            offset += fr->dc->name.Length + sizeof(WCHAR);
        }
 
        if (fn->MaximumLength >= sizeof(WCHAR)) {
            fn->Buffer[0] = fr->fcb->ads ? ':' : '\\';
            fn->Length += sizeof(WCHAR);
 
            if (fn->MaximumLength > sizeof(WCHAR)) {
                RtlCopyMemory(&fn->Buffer[1], fr->dc->name.Buffer, min(fr->dc->name.Length, fn->MaximumLength - sizeof(WCHAR)));
                fn->Length += fr->dc->name.Length;
            }
 
            if (fn->Length > fn->MaximumLength) {
                fn->Length = fn->MaximumLength;
                overflow = true;
            }
        }
 
        reqlen += sizeof(WCHAR) + fr->dc->name.Length;
 
        fr = fr->parent;
    }
 
    offset += sizeof(WCHAR);
 
    if (overflow) {
        if (preqlen)
            *preqlen = reqlen;
        Status = STATUS_BUFFER_OVERFLOW;
    } else {
        if (name_offset)
            *name_offset = offset;
 
        Status = STATUS_SUCCESS;
    }
 
    return Status;
}

Referenced by fill_in_file_name_information(), get_subvol_path(), notify_change_directory(), send_notification_fcb(), send_notification_fileref(), and set_rename_information().

fill_in_file_attribute_information()

static NTSTATUS fill_in_file_attribute_information ( FILE_ATTRIBUTE_TAG_INFORMATION *  ati, fcb *  fcb, ccb *  ccb, LONG *  length  )

static

Definition at line 4389 of file fileinfo.c.

                                                                                                                          {
    *length -= sizeof(FILE_ATTRIBUTE_TAG_INFORMATION);
 
    if (fcb->ads) {
        if (!ccb->fileref || !ccb->fileref->parent) {
            ERR("no fileref for stream\n");
            return STATUS_INTERNAL_ERROR;
        }
 
        ati->FileAttributes = ccb->fileref->parent->fcb->atts;
    } else
        ati->FileAttributes = fcb->atts;
 
    if (!(ati->FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT))
        ati->ReparseTag = 0;
    else
        ati->ReparseTag = get_reparse_tag_fcb(fcb);
 
    return STATUS_SUCCESS;
}

Referenced by query_info().

fill_in_file_basic_information()

static NTSTATUS fill_in_file_basic_information ( FILE_BASIC_INFORMATION *  fbi, INODE_ITEM *  ii, LONG *  length, fcb *  fcb, file_ref *  fileref  )

static

Definition at line 4111 of file fileinfo.c.

                                                                                                                                       {
    RtlZeroMemory(fbi, sizeof(FILE_BASIC_INFORMATION));
 
    *length -= sizeof(FILE_BASIC_INFORMATION);
 
    if (fcb == fcb->Vcb->dummy_fcb) {
        LARGE_INTEGER time;
 
        KeQuerySystemTime(&time);
        fbi->CreationTime = fbi->LastAccessTime = fbi->LastWriteTime = fbi->ChangeTime = time;
    } else {
        fbi->CreationTime.QuadPart = unix_time_to_win(&ii->otime);
        fbi->LastAccessTime.QuadPart = unix_time_to_win(&ii->st_atime);
        fbi->LastWriteTime.QuadPart = unix_time_to_win(&ii->st_mtime);
        fbi->ChangeTime.QuadPart = unix_time_to_win(&ii->st_ctime);
    }
 
    if (fcb->ads) {
        if (!fileref || !fileref->parent) {
            ERR("no fileref for stream\n");
            return STATUS_INTERNAL_ERROR;
        } else
            fbi->FileAttributes = fileref->parent->fcb->atts == 0 ? FILE_ATTRIBUTE_NORMAL : fileref->parent->fcb->atts;
    } else
        fbi->FileAttributes = fcb->atts == 0 ? FILE_ATTRIBUTE_NORMAL : fcb->atts;
 
    return STATUS_SUCCESS;
}

Referenced by query_info().

fill_in_file_case_sensitive_information()

static NTSTATUS fill_in_file_case_sensitive_information ( FILE_CASE_SENSITIVE_INFORMATION *  fcsi, fcb *  fcb, LONG *  length  )

static

Definition at line 5019 of file fileinfo.c.

                                                                                                                       {
    fcsi->Flags = fcb->case_sensitive ? FILE_CS_FLAG_CASE_SENSITIVE_DIR : 0;
 
    *length -= sizeof(FILE_CASE_SENSITIVE_INFORMATION);
 
    return STATUS_SUCCESS;
}

Referenced by query_info().

fill_in_file_compression_information()

static NTSTATUS fill_in_file_compression_information ( FILE_COMPRESSION_INFORMATION *  fci, LONG *  length, fcb *  fcb  )

static

Definition at line 5029 of file fileinfo.c.

                                                                                                                {
    *length -= sizeof(FILE_COMPRESSION_INFORMATION);
 
    memset(fci, 0, sizeof(FILE_COMPRESSION_INFORMATION));
 
    if (fcb->ads)
        fci->CompressedFileSize.QuadPart = fcb->adsdata.Length;
    else if (!S_ISDIR(fcb->inode_item.st_mode))
        fci->CompressedFileSize.QuadPart = fcb->inode_item.st_size;
 
    return STATUS_SUCCESS;
}

Referenced by query_info().

fill_in_file_ea_information()

static NTSTATUS fill_in_file_ea_information ( FILE_EA_INFORMATION *  eai, fcb *  fcb, LONG *  length  )

static

Definition at line 4222 of file fileinfo.c.

                                                                                              {
    *length -= sizeof(FILE_EA_INFORMATION);
 
    /* This value appears to be the size of the structure NTFS stores on disk, and not,
     * as might be expected, the size of FILE_FULL_EA_INFORMATION (which is what we store).
     * The formula is 4 bytes as a header, followed by 5 + NameLength + ValueLength for each
     * item. */
 
    eai->EaSize = fcb->ealen;
 
    return STATUS_SUCCESS;
}

Referenced by query_info().

fill_in_file_id_information()

static NTSTATUS fill_in_file_id_information ( FILE_ID_INFORMATION *  fii, fcb *  fcb, LONG *  length  )

static

Definition at line 4875 of file fileinfo.c.

                                                                                              {
    RtlCopyMemory(&fii->VolumeSerialNumber, &fcb->Vcb->superblock.uuid.uuid[8], sizeof(uint64_t));
    RtlCopyMemory(&fii->FileId.Identifier[0], &fcb->inode, sizeof(uint64_t));
    RtlCopyMemory(&fii->FileId.Identifier[sizeof(uint64_t)], &fcb->subvol->id, sizeof(uint64_t));
 
    *length -= sizeof(FILE_ID_INFORMATION);
 
    return STATUS_SUCCESS;
}

Referenced by query_info().

fill_in_file_internal_information()

static NTSTATUS fill_in_file_internal_information ( FILE_INTERNAL_INFORMATION *  fii, fcb *  fcb, LONG *  length  )

static

Definition at line 4214 of file fileinfo.c.

                                                                                                          {
    *length -= sizeof(FILE_INTERNAL_INFORMATION);
 
    fii->IndexNumber.QuadPart = make_file_id(fcb->subvol, fcb->inode);
 
    return STATUS_SUCCESS;
}

Referenced by query_info().

fill_in_file_name_information()

static NTSTATUS fill_in_file_name_information ( FILE_NAME_INFORMATION *  fni, fcb *  fcb, file_ref *  fileref, LONG *  length  )

static

Definition at line 4332 of file fileinfo.c.

                                                                                                                     {
    ULONG reqlen;
    UNICODE_STRING fn;
    NTSTATUS Status;
    static const WCHAR datasuf[] = {':','$','D','A','T','A',0};
    uint16_t datasuflen = sizeof(datasuf) - sizeof(WCHAR);
 
    if (!fileref) {
        ERR("called without fileref\n");
        return STATUS_INVALID_PARAMETER;
    }
 
    *length -= (LONG)offsetof(FILE_NAME_INFORMATION, FileName[0]);
 
    TRACE("maximum length is %li\n", *length);
    fni->FileNameLength = 0;
 
    fni->FileName[0] = 0;
 
    fn.Buffer = fni->FileName;
    fn.Length = 0;
    fn.MaximumLength = (uint16_t)*length;
 
    Status = fileref_get_filename(fileref, &fn, NULL, &reqlen);
    if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW) {
        ERR("fileref_get_filename returned %08lx\n", Status);
        return Status;
    }
 
    if (fcb->ads) {
        if (Status == STATUS_BUFFER_OVERFLOW)
            reqlen += datasuflen;
        else {
            if (fn.Length + datasuflen > fn.MaximumLength) {
                RtlCopyMemory(&fn.Buffer[fn.Length / sizeof(WCHAR)], datasuf, fn.MaximumLength - fn.Length);
                reqlen += datasuflen;
                Status = STATUS_BUFFER_OVERFLOW;
            } else {
                RtlCopyMemory(&fn.Buffer[fn.Length / sizeof(WCHAR)], datasuf, datasuflen);
                fn.Length += datasuflen;
            }
        }
    }
 
    if (Status == STATUS_BUFFER_OVERFLOW) {
        *length = -1;
        fni->FileNameLength = reqlen;
        TRACE("%.*S (truncated)\n", (int)(fn.Length / sizeof(WCHAR)), fn.Buffer);
    } else {
        *length -= fn.Length;
        fni->FileNameLength = fn.Length;
        TRACE("%.*S\n", (int)(fn.Length / sizeof(WCHAR)), fn.Buffer);
    }
 
    return Status;
}

Referenced by query_info().

fill_in_file_network_open_information()

static NTSTATUS fill_in_file_network_open_information ( FILE_NETWORK_OPEN_INFORMATION *  fnoi, fcb *  fcb, file_ref *  fileref, LONG *  length  )

static

Definition at line 4140 of file fileinfo.c.

                                                                                                                                      {
    INODE_ITEM* ii;
 
    if (*length < (LONG)sizeof(FILE_NETWORK_OPEN_INFORMATION)) {
        WARN("overflow\n");
        return STATUS_BUFFER_OVERFLOW;
    }
 
    RtlZeroMemory(fnoi, sizeof(FILE_NETWORK_OPEN_INFORMATION));
 
    *length -= sizeof(FILE_NETWORK_OPEN_INFORMATION);
 
    if (fcb->ads) {
        if (!fileref || !fileref->parent) {
            ERR("no fileref for stream\n");
            return STATUS_INTERNAL_ERROR;
        }
 
        ii = &fileref->parent->fcb->inode_item;
    } else
        ii = &fcb->inode_item;
 
    if (fcb == fcb->Vcb->dummy_fcb) {
        LARGE_INTEGER time;
 
        KeQuerySystemTime(&time);
        fnoi->CreationTime = fnoi->LastAccessTime = fnoi->LastWriteTime = fnoi->ChangeTime = time;
    } else {
        fnoi->CreationTime.QuadPart = unix_time_to_win(&ii->otime);
        fnoi->LastAccessTime.QuadPart = unix_time_to_win(&ii->st_atime);
        fnoi->LastWriteTime.QuadPart = unix_time_to_win(&ii->st_mtime);
        fnoi->ChangeTime.QuadPart = unix_time_to_win(&ii->st_ctime);
    }
 
    if (fcb->ads) {
        fnoi->AllocationSize.QuadPart = fnoi->EndOfFile.QuadPart = fcb->adsdata.Length;
        fnoi->FileAttributes = fileref->parent->fcb->atts == 0 ? FILE_ATTRIBUTE_NORMAL : fileref->parent->fcb->atts;
    } else {
        fnoi->AllocationSize.QuadPart = fcb_alloc_size(fcb);
        fnoi->EndOfFile.QuadPart = S_ISDIR(fcb->inode_item.st_mode) ? 0 : fcb->inode_item.st_size;
        fnoi->FileAttributes = fcb->atts == 0 ? FILE_ATTRIBUTE_NORMAL : fcb->atts;
    }
 
    return STATUS_SUCCESS;
}

Referenced by query_info().

fill_in_file_position_information()

static NTSTATUS fill_in_file_position_information ( FILE_POSITION_INFORMATION *  fpi, PFILE_OBJECT  FileObject, LONG *  length  )

static

Definition at line 4235 of file fileinfo.c.

                                                                                                                         {
    RtlZeroMemory(fpi, sizeof(FILE_POSITION_INFORMATION));
 
    *length -= sizeof(FILE_POSITION_INFORMATION);
 
    fpi->CurrentByteOffset = FileObject->CurrentByteOffset;
 
    return STATUS_SUCCESS;
}

Referenced by query_info().

fill_in_file_standard_information()

static NTSTATUS fill_in_file_standard_information ( FILE_STANDARD_INFORMATION *  fsi, fcb *  fcb, file_ref *  fileref, LONG *  length  )

static

Definition at line 4186 of file fileinfo.c.

                                                                                                                             {
    RtlZeroMemory(fsi, sizeof(FILE_STANDARD_INFORMATION));
 
    *length -= sizeof(FILE_STANDARD_INFORMATION);
 
    if (fcb->ads) {
        if (!fileref || !fileref->parent) {
            ERR("no fileref for stream\n");
            return STATUS_INTERNAL_ERROR;
        }
 
        fsi->AllocationSize.QuadPart = fsi->EndOfFile.QuadPart = fcb->adsdata.Length;
        fsi->NumberOfLinks = fileref->parent->fcb->inode_item.st_nlink;
        fsi->Directory = false;
    } else {
        fsi->AllocationSize.QuadPart = fcb_alloc_size(fcb);
        fsi->EndOfFile.QuadPart = S_ISDIR(fcb->inode_item.st_mode) ? 0 : fcb->inode_item.st_size;
        fsi->NumberOfLinks = fcb->inode_item.st_nlink;
        fsi->Directory = S_ISDIR(fcb->inode_item.st_mode);
    }
 
    TRACE("length = %I64u\n", fsi->EndOfFile.QuadPart);
 
    fsi->DeletePending = fileref ? fileref->delete_on_close : false;
 
    return STATUS_SUCCESS;
}

Referenced by query_info().

fill_in_file_standard_link_information()

static NTSTATUS fill_in_file_standard_link_information ( FILE_STANDARD_LINK_INFORMATION *  fsli, fcb *  fcb, file_ref *  fileref, LONG *  length  )

static

Definition at line 4520 of file fileinfo.c.

                                                                                                                                        {
    TRACE("FileStandardLinkInformation\n");
 
    // FIXME - NumberOfAccessibleLinks should subtract open links which have been marked as delete_on_close
 
    fsli->NumberOfAccessibleLinks = fcb->inode_item.st_nlink;
    fsli->TotalNumberOfLinks = fcb->inode_item.st_nlink;
    fsli->DeletePending = fileref ? fileref->delete_on_close : false;
    fsli->Directory = (!fcb->ads && fcb->type == BTRFS_TYPE_DIRECTORY) ? true : false;
 
    *length -= sizeof(FILE_STANDARD_LINK_INFORMATION);
 
    return STATUS_SUCCESS;
}

Referenced by query_info().

fill_in_file_stat_information()

static NTSTATUS fill_in_file_stat_information ( FILE_STAT_INFORMATION *  fsi, fcb *  fcb, ccb *  ccb, LONG *  length  )

static

Definition at line 4885 of file fileinfo.c.

                                                                                                            {
    INODE_ITEM* ii;
 
    fsi->FileId.QuadPart = make_file_id(fcb->subvol, fcb->inode);
 
    if (fcb->ads)
        ii = &ccb->fileref->parent->fcb->inode_item;
    else
        ii = &fcb->inode_item;
 
    if (fcb == fcb->Vcb->dummy_fcb) {
        LARGE_INTEGER time;
 
        KeQuerySystemTime(&time);
        fsi->CreationTime = fsi->LastAccessTime = fsi->LastWriteTime = fsi->ChangeTime = time;
    } else {
        fsi->CreationTime.QuadPart = unix_time_to_win(&ii->otime);
        fsi->LastAccessTime.QuadPart = unix_time_to_win(&ii->st_atime);
        fsi->LastWriteTime.QuadPart = unix_time_to_win(&ii->st_mtime);
        fsi->ChangeTime.QuadPart = unix_time_to_win(&ii->st_ctime);
    }
 
    if (fcb->ads) {
        fsi->AllocationSize.QuadPart = fsi->EndOfFile.QuadPart = fcb->adsdata.Length;
        fsi->FileAttributes = ccb->fileref->parent->fcb->atts == 0 ? FILE_ATTRIBUTE_NORMAL : ccb->fileref->parent->fcb->atts;
    } else {
        fsi->AllocationSize.QuadPart = fcb_alloc_size(fcb);
        fsi->EndOfFile.QuadPart = S_ISDIR(fcb->inode_item.st_mode) ? 0 : fcb->inode_item.st_size;
        fsi->FileAttributes = fcb->atts == 0 ? FILE_ATTRIBUTE_NORMAL : fcb->atts;
    }
 
    if (fcb->type == BTRFS_TYPE_SOCKET)
        fsi->ReparseTag = IO_REPARSE_TAG_AF_UNIX;
    else if (fcb->type == BTRFS_TYPE_FIFO)
        fsi->ReparseTag = IO_REPARSE_TAG_LX_FIFO;
    else if (fcb->type == BTRFS_TYPE_CHARDEV)
        fsi->ReparseTag = IO_REPARSE_TAG_LX_CHR;
    else if (fcb->type == BTRFS_TYPE_BLOCKDEV)
        fsi->ReparseTag = IO_REPARSE_TAG_LX_BLK;
    else if (!(fsi->FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT))
        fsi->ReparseTag = 0;
    else
        fsi->ReparseTag = get_reparse_tag_fcb(fcb);
 
    if (fcb->type == BTRFS_TYPE_SOCKET || fcb->type == BTRFS_TYPE_FIFO || fcb->type == BTRFS_TYPE_CHARDEV || fcb->type == BTRFS_TYPE_BLOCKDEV)
        fsi->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
 
    if (fcb->ads)
        fsi->NumberOfLinks = ccb->fileref->parent->fcb->inode_item.st_nlink;
    else
        fsi->NumberOfLinks = fcb->inode_item.st_nlink;
 
    fsi->EffectiveAccess = ccb->access;
 
    *length -= sizeof(FILE_STAT_INFORMATION);
 
    return STATUS_SUCCESS;
}

Referenced by query_info().

fill_in_file_stat_lx_information()

static NTSTATUS fill_in_file_stat_lx_information ( FILE_STAT_LX_INFORMATION *  fsli, fcb *  fcb, ccb *  ccb, LONG *  length  )

static

Definition at line 4944 of file fileinfo.c.

                                                                                                                   {
    INODE_ITEM* ii;
 
    fsli->FileId.QuadPart = make_file_id(fcb->subvol, fcb->inode);
 
    if (fcb->ads)
        ii = &ccb->fileref->parent->fcb->inode_item;
    else
        ii = &fcb->inode_item;
 
    if (fcb == fcb->Vcb->dummy_fcb) {
        LARGE_INTEGER time;
 
        KeQuerySystemTime(&time);
        fsli->CreationTime = fsli->LastAccessTime = fsli->LastWriteTime = fsli->ChangeTime = time;
    } else {
        fsli->CreationTime.QuadPart = unix_time_to_win(&ii->otime);
        fsli->LastAccessTime.QuadPart = unix_time_to_win(&ii->st_atime);
        fsli->LastWriteTime.QuadPart = unix_time_to_win(&ii->st_mtime);
        fsli->ChangeTime.QuadPart = unix_time_to_win(&ii->st_ctime);
    }
 
    if (fcb->ads) {
        fsli->AllocationSize.QuadPart = fsli->EndOfFile.QuadPart = fcb->adsdata.Length;
        fsli->FileAttributes = ccb->fileref->parent->fcb->atts == 0 ? FILE_ATTRIBUTE_NORMAL : ccb->fileref->parent->fcb->atts;
    } else {
        fsli->AllocationSize.QuadPart = fcb_alloc_size(fcb);
        fsli->EndOfFile.QuadPart = S_ISDIR(fcb->inode_item.st_mode) ? 0 : fcb->inode_item.st_size;
        fsli->FileAttributes = fcb->atts == 0 ? FILE_ATTRIBUTE_NORMAL : fcb->atts;
    }
 
    if (fcb->type == BTRFS_TYPE_SOCKET)
        fsli->ReparseTag = IO_REPARSE_TAG_AF_UNIX;
    else if (fcb->type == BTRFS_TYPE_FIFO)
        fsli->ReparseTag = IO_REPARSE_TAG_LX_FIFO;
    else if (fcb->type == BTRFS_TYPE_CHARDEV)
        fsli->ReparseTag = IO_REPARSE_TAG_LX_CHR;
    else if (fcb->type == BTRFS_TYPE_BLOCKDEV)
        fsli->ReparseTag = IO_REPARSE_TAG_LX_BLK;
    else if (!(fsli->FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT))
        fsli->ReparseTag = 0;
    else
        fsli->ReparseTag = get_reparse_tag_fcb(fcb);
 
    if (fcb->type == BTRFS_TYPE_SOCKET || fcb->type == BTRFS_TYPE_FIFO || fcb->type == BTRFS_TYPE_CHARDEV || fcb->type == BTRFS_TYPE_BLOCKDEV)
        fsli->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
 
    if (fcb->ads)
        fsli->NumberOfLinks = ccb->fileref->parent->fcb->inode_item.st_nlink;
    else
        fsli->NumberOfLinks = fcb->inode_item.st_nlink;
 
    fsli->EffectiveAccess = ccb->access;
    fsli->LxFlags = LX_FILE_METADATA_HAS_UID | LX_FILE_METADATA_HAS_GID | LX_FILE_METADATA_HAS_MODE | LX_FILE_METADATA_HAS_DEVICE_ID;
 
    if (fcb->case_sensitive)
        fsli->LxFlags |= LX_FILE_CASE_SENSITIVE_DIR;
 
    fsli->LxUid = ii->st_uid;
    fsli->LxGid = ii->st_gid;
    fsli->LxMode = ii->st_mode;
 
    if (ii->st_mode & __S_IFBLK || ii->st_mode & __S_IFCHR) {
        fsli->LxDeviceIdMajor = (ii->st_rdev & 0xFFFFFFFFFFF00000) >> 20;
        fsli->LxDeviceIdMinor = (ii->st_rdev & 0xFFFFF);
    } else {
        fsli->LxDeviceIdMajor = 0;
        fsli->LxDeviceIdMinor = 0;
    }
 
    *length -= sizeof(FILE_STAT_LX_INFORMATION);
 
    return STATUS_SUCCESS;
}

Referenced by query_info().

fill_in_file_stream_information()

static NTSTATUS fill_in_file_stream_information ( FILE_STREAM_INFORMATION *  fsi, file_ref *  fileref, LONG *  length  )

static

Definition at line 4410 of file fileinfo.c.

                                                                                                               {
    LONG reqsize;
    LIST_ENTRY* le;
    FILE_STREAM_INFORMATION *entry, *lastentry;
    NTSTATUS Status;
 
    static const WCHAR datasuf[] = L":$DATA";
    UNICODE_STRING suf;
 
    if (!fileref) {
        ERR("fileref was NULL\n");
        return STATUS_INVALID_PARAMETER;
    }
 
    suf.Buffer = (WCHAR*)datasuf;
    suf.Length = suf.MaximumLength = sizeof(datasuf) - sizeof(WCHAR);
 
    if (fileref->fcb->type != BTRFS_TYPE_DIRECTORY)
        reqsize = sizeof(FILE_STREAM_INFORMATION) - sizeof(WCHAR) + suf.Length + sizeof(WCHAR);
    else
        reqsize = 0;
 
    ExAcquireResourceSharedLite(&fileref->fcb->nonpaged->dir_children_lock, true);
 
    le = fileref->fcb->dir_children_index.Flink;
    while (le != &fileref->fcb->dir_children_index) {
        dir_child* dc = CONTAINING_RECORD(le, dir_child, list_entry_index);
 
        if (dc->index == 0) {
            reqsize = (ULONG)sector_align(reqsize, sizeof(LONGLONG));
            reqsize += sizeof(FILE_STREAM_INFORMATION) - sizeof(WCHAR) + suf.Length + sizeof(WCHAR) + dc->name.Length;
        } else
            break;
 
        le = le->Flink;
    }
 
    TRACE("length = %li, reqsize = %lu\n", *length, reqsize);
 
    if (reqsize > *length) {
        Status = STATUS_BUFFER_OVERFLOW;
        goto end;
    }
 
    entry = fsi;
    lastentry = NULL;
 
    if (fileref->fcb->type != BTRFS_TYPE_DIRECTORY) {
        ULONG off;
 
        entry->NextEntryOffset = 0;
        entry->StreamNameLength = suf.Length + sizeof(WCHAR);
        entry->StreamSize.QuadPart = fileref->fcb->inode_item.st_size;
        entry->StreamAllocationSize.QuadPart = fcb_alloc_size(fileref->fcb);
 
        entry->StreamName[0] = ':';
        RtlCopyMemory(&entry->StreamName[1], suf.Buffer, suf.Length);
 
        off = (ULONG)sector_align(sizeof(FILE_STREAM_INFORMATION) - sizeof(WCHAR) + suf.Length + sizeof(WCHAR), sizeof(LONGLONG));
 
        lastentry = entry;
        entry = (FILE_STREAM_INFORMATION*)((uint8_t*)entry + off);
    }
 
    le = fileref->fcb->dir_children_index.Flink;
    while (le != &fileref->fcb->dir_children_index) {
        dir_child* dc = CONTAINING_RECORD(le, dir_child, list_entry_index);
 
        if (dc->index == 0) {
            ULONG off;
 
            entry->NextEntryOffset = 0;
            entry->StreamNameLength = dc->name.Length + suf.Length + sizeof(WCHAR);
 
            if (dc->fileref)
                entry->StreamSize.QuadPart = dc->fileref->fcb->adsdata.Length;
            else
                entry->StreamSize.QuadPart = dc->size;
 
            entry->StreamAllocationSize.QuadPart = entry->StreamSize.QuadPart;
 
            entry->StreamName[0] = ':';
 
            RtlCopyMemory(&entry->StreamName[1], dc->name.Buffer, dc->name.Length);
            RtlCopyMemory(&entry->StreamName[1 + (dc->name.Length / sizeof(WCHAR))], suf.Buffer, suf.Length);
 
            if (lastentry)
                lastentry->NextEntryOffset = (uint32_t)((uint8_t*)entry - (uint8_t*)lastentry);
 
            off = (ULONG)sector_align(sizeof(FILE_STREAM_INFORMATION) - sizeof(WCHAR) + suf.Length + sizeof(WCHAR) + dc->name.Length, sizeof(LONGLONG));
 
            lastentry = entry;
            entry = (FILE_STREAM_INFORMATION*)((uint8_t*)entry + off);
        } else
            break;
 
        le = le->Flink;
    }
 
    *length -= reqsize;
 
    Status = STATUS_SUCCESS;
 
end:
    ExReleaseResourceLite(&fileref->fcb->nonpaged->dir_children_lock);
 
    return Status;
}

Referenced by query_info().

fill_in_hard_link_full_id_information()

static NTSTATUS fill_in_hard_link_full_id_information ( FILE_LINKS_FULL_ID_INFORMATION *  flfii, file_ref *  fileref, PIRP  Irp, LONG *  length  )

static

Definition at line 4704 of file fileinfo.c.

                                                                                                                                        {
    NTSTATUS Status;
    LIST_ENTRY* le;
    LONG bytes_needed;
    FILE_LINK_ENTRY_FULL_ID_INFORMATION* flefii;
    bool overflow = false;
    fcb* fcb = fileref->fcb;
    ULONG len;
 
    if (fcb->ads)
        return STATUS_INVALID_PARAMETER;
 
    if (*length < (LONG)offsetof(FILE_LINKS_FULL_ID_INFORMATION, Entry))
        return STATUS_INVALID_PARAMETER;
 
    RtlZeroMemory(flfii, *length);
 
    bytes_needed = offsetof(FILE_LINKS_FULL_ID_INFORMATION, Entry);
    len = bytes_needed;
    flefii = NULL;
 
    ExAcquireResourceSharedLite(fcb->Header.Resource, true);
 
    if (fcb->inode == SUBVOL_ROOT_INODE) {
        ULONG namelen;
 
        if (fcb == fcb->Vcb->root_fileref->fcb)
            namelen = sizeof(WCHAR);
        else
            namelen = fileref->dc->name.Length;
 
        bytes_needed += offsetof(FILE_LINK_ENTRY_FULL_ID_INFORMATION, FileName[0]) + namelen;
 
        if (bytes_needed > *length)
            overflow = true;
 
        if (!overflow) {
            flefii = &flfii->Entry;
 
            flefii->NextEntryOffset = 0;
 
            if (fcb == fcb->Vcb->root_fileref->fcb) {
                RtlZeroMemory(&flefii->ParentFileId.Identifier[0], sizeof(FILE_ID_128));
                flefii->FileNameLength = 1;
                flefii->FileName[0] = '.';
            } else {
                RtlCopyMemory(&flefii->ParentFileId.Identifier[0], &fileref->parent->fcb->inode, sizeof(uint64_t));
                RtlCopyMemory(&flefii->ParentFileId.Identifier[sizeof(uint64_t)], &fileref->parent->fcb->subvol->id, sizeof(uint64_t));
 
                flefii->FileNameLength = fileref->dc->name.Length / sizeof(WCHAR);
                RtlCopyMemory(flefii->FileName, fileref->dc->name.Buffer, fileref->dc->name.Length);
            }
 
            flfii->EntriesReturned++;
 
            len = bytes_needed;
        }
    } else {
        ExAcquireResourceExclusiveLite(&fcb->Vcb->fileref_lock, true);
 
        if (IsListEmpty(&fcb->hardlinks)) {
            bytes_needed += offsetof(FILE_LINK_ENTRY_FULL_ID_INFORMATION, FileName[0]) + fileref->dc->name.Length;
 
            if (bytes_needed > *length)
                overflow = true;
 
            if (!overflow) {
                flefii = &flfii->Entry;
 
                flefii->NextEntryOffset = 0;
 
                RtlCopyMemory(&flefii->ParentFileId.Identifier[0], &fileref->parent->fcb->inode, sizeof(uint64_t));
                RtlCopyMemory(&flefii->ParentFileId.Identifier[sizeof(uint64_t)], &fileref->parent->fcb->subvol->id, sizeof(uint64_t));
 
                flefii->FileNameLength = fileref->dc->name.Length / sizeof(WCHAR);
                RtlCopyMemory(flefii->FileName, fileref->dc->name.Buffer, fileref->dc->name.Length);
 
                flfii->EntriesReturned++;
 
                len = bytes_needed;
            }
        } else {
            le = fcb->hardlinks.Flink;
            while (le != &fcb->hardlinks) {
                hardlink* hl = CONTAINING_RECORD(le, hardlink, list_entry);
                file_ref* parfr;
 
                TRACE("parent %I64x, index %I64x, name %.*S\n", hl->parent, hl->index, (int)(hl->name.Length / sizeof(WCHAR)), hl->name.Buffer);
 
                Status = open_fileref_by_inode(fcb->Vcb, fcb->subvol, hl->parent, &parfr, Irp);
 
                if (!NT_SUCCESS(Status)) {
                    ERR("open_fileref_by_inode returned %08lx\n", Status);
                } else if (!parfr->deleted) {
                    LIST_ENTRY* le2;
                    bool found = false, deleted = false;
                    UNICODE_STRING* fn = NULL;
 
                    le2 = parfr->children.Flink;
                    while (le2 != &parfr->children) {
                        file_ref* fr2 = CONTAINING_RECORD(le2, file_ref, list_entry);
 
                        if (fr2->dc->index == hl->index) {
                            found = true;
                            deleted = fr2->deleted;
 
                            if (!deleted)
                                fn = &fr2->dc->name;
 
                            break;
                        }
 
                        le2 = le2->Flink;
                    }
 
                    if (!found)
                        fn = &hl->name;
 
                    if (!deleted) {
                        TRACE("fn = %.*S (found = %u)\n", (int)(fn->Length / sizeof(WCHAR)), fn->Buffer, found);
 
                        if (flefii)
                            bytes_needed = (LONG)sector_align(bytes_needed, 8);
 
                        bytes_needed += offsetof(FILE_LINK_ENTRY_FULL_ID_INFORMATION, FileName[0]) + fn->Length;
 
                        if (bytes_needed > *length)
                            overflow = true;
 
                        if (!overflow) {
                            if (flefii) {
                                flefii->NextEntryOffset = (ULONG)sector_align(offsetof(FILE_LINK_ENTRY_FULL_ID_INFORMATION, FileName[0]) + (flefii->FileNameLength * sizeof(WCHAR)), 8);
                                flefii = (FILE_LINK_ENTRY_FULL_ID_INFORMATION*)((uint8_t*)flefii + flefii->NextEntryOffset);
                            } else
                                flefii = &flfii->Entry;
 
                            flefii->NextEntryOffset = 0;
 
                            RtlCopyMemory(&flefii->ParentFileId.Identifier[0], &parfr->fcb->inode, sizeof(uint64_t));
                            RtlCopyMemory(&flefii->ParentFileId.Identifier[sizeof(uint64_t)], &parfr->fcb->subvol->id, sizeof(uint64_t));
 
                            flefii->FileNameLength = fn->Length / sizeof(WCHAR);
                            RtlCopyMemory(flefii->FileName, fn->Buffer, fn->Length);
 
                            flfii->EntriesReturned++;
 
                            len = bytes_needed;
                        }
                    }
 
                    free_fileref(parfr);
                }
 
                le = le->Flink;
            }
        }
 
        ExReleaseResourceLite(&fcb->Vcb->fileref_lock);
    }
 
    flfii->BytesNeeded = bytes_needed;
 
    *length -= len;
 
    Status = overflow ? STATUS_BUFFER_OVERFLOW : STATUS_SUCCESS;
 
    ExReleaseResourceLite(fcb->Header.Resource);
 
    return Status;
}

Referenced by query_info().

fill_in_hard_link_information()

static NTSTATUS fill_in_hard_link_information ( FILE_LINKS_INFORMATION *  fli, file_ref *  fileref, PIRP  Irp, LONG *  length  )

static

Definition at line 4535 of file fileinfo.c.

                                                                                                                      {
    NTSTATUS Status;
    LIST_ENTRY* le;
    LONG bytes_needed;
    FILE_LINK_ENTRY_INFORMATION* feli;
    bool overflow = false;
    fcb* fcb = fileref->fcb;
    ULONG len;
 
    if (fcb->ads)
        return STATUS_INVALID_PARAMETER;
 
    if (*length < (LONG)offsetof(FILE_LINKS_INFORMATION, Entry))
        return STATUS_INVALID_PARAMETER;
 
    RtlZeroMemory(fli, *length);
 
    bytes_needed = offsetof(FILE_LINKS_INFORMATION, Entry);
    len = bytes_needed;
    feli = NULL;
 
    ExAcquireResourceSharedLite(fcb->Header.Resource, true);
 
    if (fcb->inode == SUBVOL_ROOT_INODE) {
        ULONG namelen;
 
        if (fcb == fcb->Vcb->root_fileref->fcb)
            namelen = sizeof(WCHAR);
        else
            namelen = fileref->dc->name.Length;
 
        bytes_needed += sizeof(FILE_LINK_ENTRY_INFORMATION) - sizeof(WCHAR) + namelen;
 
        if (bytes_needed > *length)
            overflow = true;
 
        if (!overflow) {
            feli = &fli->Entry;
 
            feli->NextEntryOffset = 0;
            feli->ParentFileId = 0; // we use an inode of 0 to mean the parent of a subvolume
 
            if (fcb == fcb->Vcb->root_fileref->fcb) {
                feli->FileNameLength = 1;
                feli->FileName[0] = '.';
            } else {
                feli->FileNameLength = fileref->dc->name.Length / sizeof(WCHAR);
                RtlCopyMemory(feli->FileName, fileref->dc->name.Buffer, fileref->dc->name.Length);
            }
 
            fli->EntriesReturned++;
 
            len = bytes_needed;
        }
    } else {
        ExAcquireResourceExclusiveLite(&fcb->Vcb->fileref_lock, true);
 
        if (IsListEmpty(&fcb->hardlinks)) {
            if (!fileref->dc) {
                ExReleaseResourceLite(&fcb->Vcb->fileref_lock);
                Status = STATUS_INVALID_PARAMETER;
                goto end;
            }
 
            bytes_needed += sizeof(FILE_LINK_ENTRY_INFORMATION) + fileref->dc->name.Length - sizeof(WCHAR);
 
            if (bytes_needed > *length)
                overflow = true;
 
            if (!overflow) {
                feli = &fli->Entry;
 
                feli->NextEntryOffset = 0;
                feli->ParentFileId = fileref->parent->fcb->inode;
                feli->FileNameLength = fileref->dc->name.Length / sizeof(WCHAR);
                RtlCopyMemory(feli->FileName, fileref->dc->name.Buffer, fileref->dc->name.Length);
 
                fli->EntriesReturned++;
 
                len = bytes_needed;
            }
        } else {
            le = fcb->hardlinks.Flink;
            while (le != &fcb->hardlinks) {
                hardlink* hl = CONTAINING_RECORD(le, hardlink, list_entry);
                file_ref* parfr;
 
                TRACE("parent %I64x, index %I64x, name %.*S\n", hl->parent, hl->index, (int)(hl->name.Length / sizeof(WCHAR)), hl->name.Buffer);
 
                Status = open_fileref_by_inode(fcb->Vcb, fcb->subvol, hl->parent, &parfr, Irp);
 
                if (!NT_SUCCESS(Status)) {
                    ERR("open_fileref_by_inode returned %08lx\n", Status);
                } else if (!parfr->deleted) {
                    LIST_ENTRY* le2;
                    bool found = false, deleted = false;
                    UNICODE_STRING* fn = NULL;
 
                    le2 = parfr->children.Flink;
                    while (le2 != &parfr->children) {
                        file_ref* fr2 = CONTAINING_RECORD(le2, file_ref, list_entry);
 
                        if (fr2->dc && fr2->dc->index == hl->index) {
                            found = true;
                            deleted = fr2->deleted;
 
                            if (!deleted)
                                fn = &fr2->dc->name;
 
                            break;
                        }
 
                        le2 = le2->Flink;
                    }
 
                    if (!found)
                        fn = &hl->name;
 
                    if (!deleted) {
                        TRACE("fn = %.*S (found = %u)\n", (int)(fn->Length / sizeof(WCHAR)), fn->Buffer, found);
 
                        if (feli)
                            bytes_needed = (LONG)sector_align(bytes_needed, 8);
 
                        bytes_needed += sizeof(FILE_LINK_ENTRY_INFORMATION) + fn->Length - sizeof(WCHAR);
 
                        if (bytes_needed > *length)
                            overflow = true;
 
                        if (!overflow) {
                            if (feli) {
                                feli->NextEntryOffset = (ULONG)sector_align(sizeof(FILE_LINK_ENTRY_INFORMATION) + ((feli->FileNameLength - 1) * sizeof(WCHAR)), 8);
                                feli = (FILE_LINK_ENTRY_INFORMATION*)((uint8_t*)feli + feli->NextEntryOffset);
                            } else
                                feli = &fli->Entry;
 
                            feli->NextEntryOffset = 0;
                            feli->ParentFileId = parfr->fcb->inode;
                            feli->FileNameLength = fn->Length / sizeof(WCHAR);
                            RtlCopyMemory(feli->FileName, fn->Buffer, fn->Length);
 
                            fli->EntriesReturned++;
 
                            len = bytes_needed;
                        }
                    }
 
                    free_fileref(parfr);
                }
 
                le = le->Flink;
            }
        }
 
        ExReleaseResourceLite(&fcb->Vcb->fileref_lock);
    }
 
    fli->BytesNeeded = bytes_needed;
 
    *length -= len;
 
    Status = overflow ? STATUS_BUFFER_OVERFLOW : STATUS_SUCCESS;
 
end:
    ExReleaseResourceLite(fcb->Header.Resource);
 
    return Status;
}

Referenced by query_info().

has_open_children()

bool has_open_children

(

file_ref *

fileref

)

Definition at line 442 of file fileinfo.c.

                                          {
    LIST_ENTRY* le = fileref->children.Flink;
 
    if (IsListEmpty(&fileref->children))
        return false;
 
    while (le != &fileref->children) {
        file_ref* c = CONTAINING_RECORD(le, file_ref, list_entry);
 
        if (c->open_count > 0)
            return true;
 
        if (has_open_children(c))
            return true;
 
        le = le->Flink;
    }
 
    return false;
}

Referenced by has_open_children(), lock_volume(), pnp_query_remove_device(), set_link_information(), and set_rename_information().

insert_dir_child_into_hash_lists()

void insert_dir_child_into_hash_lists	(	fcb *	fcb,
		dir_child *	dc
	)

Definition at line 1470 of file fileinfo.c.

                                                               {
    bool inserted;
    LIST_ENTRY* le;
    uint8_t c, d;
 
    c = dc->hash >> 24;
 
    inserted = false;
 
    d = c;
    do {
        le = fcb->hash_ptrs[d];
 
        if (d == 0)
            break;
 
        d--;
    } while (!le);
 
    if (!le)
        le = fcb->dir_children_hash.Flink;
 
    while (le != &fcb->dir_children_hash) {
        dir_child* dc2 = CONTAINING_RECORD(le, dir_child, list_entry_hash);
 
        if (dc2->hash > dc->hash) {
            InsertHeadList(le->Blink, &dc->list_entry_hash);
            inserted = true;
            break;
        }
 
        le = le->Flink;
    }
 
    if (!inserted)
        InsertTailList(&fcb->dir_children_hash, &dc->list_entry_hash);
 
    if (!fcb->hash_ptrs[c])
        fcb->hash_ptrs[c] = &dc->list_entry_hash;
    else {
        dir_child* dc2 = CONTAINING_RECORD(fcb->hash_ptrs[c], dir_child, list_entry_hash);
 
        if (dc2->hash > dc->hash)
            fcb->hash_ptrs[c] = &dc->list_entry_hash;
    }
 
    c = dc->hash_uc >> 24;
 
    inserted = false;
 
    d = c;
    do {
        le = fcb->hash_ptrs_uc[d];
 
        if (d == 0)
            break;
 
        d--;
    } while (!le);
 
    if (!le)
        le = fcb->dir_children_hash_uc.Flink;
 
    while (le != &fcb->dir_children_hash_uc) {
        dir_child* dc2 = CONTAINING_RECORD(le, dir_child, list_entry_hash_uc);
 
        if (dc2->hash_uc > dc->hash_uc) {
            InsertHeadList(le->Blink, &dc->list_entry_hash_uc);
            inserted = true;
            break;
        }
 
        le = le->Flink;
    }
 
    if (!inserted)
        InsertTailList(&fcb->dir_children_hash_uc, &dc->list_entry_hash_uc);
 
    if (!fcb->hash_ptrs_uc[c])
        fcb->hash_ptrs_uc[c] = &dc->list_entry_hash_uc;
    else {
        dir_child* dc2 = CONTAINING_RECORD(fcb->hash_ptrs_uc[c], dir_child, list_entry_hash_uc);
 
        if (dc2->hash_uc > dc->hash_uc)
            fcb->hash_ptrs_uc[c] = &dc->list_entry_hash_uc;
    }
}

Referenced by add_dir_child(), load_dir_children(), move_across_subvols(), and set_rename_information().

move_across_subvols()

static NTSTATUS move_across_subvols ( file_ref *  fileref, ccb *  ccb, file_ref *  destdir, PANSI_STRING  utf8, PUNICODE_STRING  fnus, PIRP  Irp, LIST_ENTRY *  rollback  )

static

Definition at line 950 of file fileinfo.c.

                                                                                                                                                             {
    NTSTATUS Status;
    LIST_ENTRY move_list, *le;
    move_entry* me;
    LARGE_INTEGER time;
    BTRFS_TIME now;
    file_ref* origparent;
 
    // FIXME - make sure me->dummyfileref and me->dummyfcb get freed properly
 
    InitializeListHead(&move_list);
 
    KeQuerySystemTime(&time);
    win_time_to_unix(time, &now);
 
    acquire_fcb_lock_exclusive(fileref->fcb->Vcb);
 
    me = ExAllocatePoolWithTag(PagedPool, sizeof(move_entry), ALLOC_TAG);
 
    if (!me) {
        ERR("out of memory\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto end;
    }
 
    origparent = fileref->parent;
 
    me->fileref = fileref;
    increase_fileref_refcount(me->fileref);
    me->dummyfcb = NULL;
    me->dummyfileref = NULL;
    me->parent = NULL;
 
    InsertTailList(&move_list, &me->list_entry);
 
    le = move_list.Flink;
    while (le != &move_list) {
        me = CONTAINING_RECORD(le, move_entry, list_entry);
 
        ExAcquireResourceSharedLite(me->fileref->fcb->Header.Resource, true);
 
        if (!me->fileref->fcb->ads && me->fileref->fcb->subvol == origparent->fcb->subvol) {
            Status = add_children_to_move_list(fileref->fcb->Vcb, me, Irp);
 
            if (!NT_SUCCESS(Status)) {
                ERR("add_children_to_move_list returned %08lx\n", Status);
                ExReleaseResourceLite(me->fileref->fcb->Header.Resource);
                goto end;
            }
        }
 
        ExReleaseResourceLite(me->fileref->fcb->Header.Resource);
 
        le = le->Flink;
    }
 
    send_notification_fileref(fileref, fileref->fcb->type == BTRFS_TYPE_DIRECTORY ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME, FILE_ACTION_REMOVED, NULL);
 
    // loop through list and create new inodes
 
    le = move_list.Flink;
    while (le != &move_list) {
        me = CONTAINING_RECORD(le, move_entry, list_entry);
 
        if (me->fileref->fcb->inode != SUBVOL_ROOT_INODE && me->fileref->fcb != fileref->fcb->Vcb->dummy_fcb) {
            if (!me->dummyfcb) {
                ULONG defda;
 
                ExAcquireResourceExclusiveLite(me->fileref->fcb->Header.Resource, true);
 
                Status = duplicate_fcb(me->fileref->fcb, &me->dummyfcb);
                if (!NT_SUCCESS(Status)) {
                    ERR("duplicate_fcb returned %08lx\n", Status);
                    ExReleaseResourceLite(me->fileref->fcb->Header.Resource);
                    goto end;
                }
 
                me->dummyfcb->subvol = me->fileref->fcb->subvol;
                me->dummyfcb->inode = me->fileref->fcb->inode;
                me->dummyfcb->hash = me->fileref->fcb->hash;
 
                if (!me->dummyfcb->ads) {
                    me->dummyfcb->sd_dirty = me->fileref->fcb->sd_dirty;
                    me->dummyfcb->atts_changed = me->fileref->fcb->atts_changed;
                    me->dummyfcb->atts_deleted = me->fileref->fcb->atts_deleted;
                    me->dummyfcb->extents_changed = me->fileref->fcb->extents_changed;
                    me->dummyfcb->reparse_xattr_changed = me->fileref->fcb->reparse_xattr_changed;
                    me->dummyfcb->ea_changed = me->fileref->fcb->ea_changed;
                }
 
                me->dummyfcb->created = me->fileref->fcb->created;
                me->dummyfcb->deleted = me->fileref->fcb->deleted;
                mark_fcb_dirty(me->dummyfcb);
 
                if (!me->fileref->fcb->ads) {
                    LIST_ENTRY* le2;
 
                    me->fileref->fcb->subvol = destdir->fcb->subvol;
                    me->fileref->fcb->inode = InterlockedIncrement64(&destdir->fcb->subvol->lastinode);
                    me->fileref->fcb->hash = calc_crc32c(0xffffffff, (uint8_t*)&me->fileref->fcb->inode, sizeof(uint64_t));
                    me->fileref->fcb->inode_item.st_nlink = 1;
 
                    defda = get_file_attributes(me->fileref->fcb->Vcb, me->fileref->fcb->subvol, me->fileref->fcb->inode,
                                                me->fileref->fcb->type, me->fileref->dc && me->fileref->dc->name.Length >= sizeof(WCHAR) && me->fileref->dc->name.Buffer[0] == '.',
                                                true, Irp);
 
                    me->fileref->fcb->sd_dirty = !!me->fileref->fcb->sd;
                    me->fileref->fcb->atts_changed = defda != me->fileref->fcb->atts;
                    me->fileref->fcb->extents_changed = !IsListEmpty(&me->fileref->fcb->extents);
                    me->fileref->fcb->reparse_xattr_changed = !!me->fileref->fcb->reparse_xattr.Buffer;
                    me->fileref->fcb->ea_changed = !!me->fileref->fcb->ea_xattr.Buffer;
                    me->fileref->fcb->xattrs_changed = !IsListEmpty(&me->fileref->fcb->xattrs);
                    me->fileref->fcb->inode_item_changed = true;
 
                    le2 = me->fileref->fcb->xattrs.Flink;
                    while (le2 != &me->fileref->fcb->xattrs) {
                        xattr* xa = CONTAINING_RECORD(le2, xattr, list_entry);
 
                        xa->dirty = true;
 
                        le2 = le2->Flink;
                    }
 
                    if (le == move_list.Flink) { // first entry
                        me->fileref->fcb->inode_item.transid = me->fileref->fcb->Vcb->superblock.generation;
                        me->fileref->fcb->inode_item.sequence++;
 
                        if (!ccb->user_set_change_time)
                            me->fileref->fcb->inode_item.st_ctime = now;
                    }
 
                    le2 = me->fileref->fcb->extents.Flink;
                    while (le2 != &me->fileref->fcb->extents) {
                        extent* ext = CONTAINING_RECORD(le2, extent, list_entry);
 
                        if (!ext->ignore && (ext->extent_data.type == EXTENT_TYPE_REGULAR || ext->extent_data.type == EXTENT_TYPE_PREALLOC)) {
                            EXTENT_DATA2* ed2 = (EXTENT_DATA2*)ext->extent_data.data;
 
                            if (ed2->size != 0) {
                                chunk* c = get_chunk_from_address(me->fileref->fcb->Vcb, ed2->address);
 
                                if (!c) {
                                    ERR("get_chunk_from_address(%I64x) failed\n", ed2->address);
                                } else {
                                    Status = update_changed_extent_ref(me->fileref->fcb->Vcb, c, ed2->address, ed2->size, me->fileref->fcb->subvol->id, me->fileref->fcb->inode,
                                                                       ext->offset - ed2->offset, 1, me->fileref->fcb->inode_item.flags & BTRFS_INODE_NODATASUM, false, Irp);
 
                                    if (!NT_SUCCESS(Status)) {
                                        ERR("update_changed_extent_ref returned %08lx\n", Status);
                                        ExReleaseResourceLite(me->fileref->fcb->Header.Resource);
                                        goto end;
                                    }
                                }
 
                            }
                        }
 
                        le2 = le2->Flink;
                    }
 
                    add_fcb_to_subvol(me->dummyfcb);
                    remove_fcb_from_subvol(me->fileref->fcb);
                    add_fcb_to_subvol(me->fileref->fcb);
                } else {
                    me->fileref->fcb->subvol = me->parent->fileref->fcb->subvol;
                    me->fileref->fcb->inode = me->parent->fileref->fcb->inode;
                    me->fileref->fcb->hash = me->parent->fileref->fcb->hash;
 
                    // put stream after parent in FCB list
                    InsertHeadList(&me->parent->fileref->fcb->list_entry, &me->fileref->fcb->list_entry);
                }
 
                me->fileref->fcb->created = true;
 
                InsertTailList(&me->fileref->fcb->Vcb->all_fcbs, &me->dummyfcb->list_entry_all);
 
                while (!IsListEmpty(&me->fileref->fcb->hardlinks)) {
                    hardlink* hl = CONTAINING_RECORD(RemoveHeadList(&me->fileref->fcb->hardlinks), hardlink, list_entry);
 
                    if (hl->name.Buffer)
                        ExFreePool(hl->name.Buffer);
 
                    if (hl->utf8.Buffer)
                        ExFreePool(hl->utf8.Buffer);
 
                    ExFreePool(hl);
                }
 
                me->fileref->fcb->inode_item_changed = true;
                mark_fcb_dirty(me->fileref->fcb);
 
                if ((!me->dummyfcb->ads && me->dummyfcb->inode_item.st_nlink > 1) || (me->dummyfcb->ads && me->parent->dummyfcb->inode_item.st_nlink > 1)) {
                    LIST_ENTRY* le2 = le->Flink;
 
                    while (le2 != &move_list) {
                        move_entry* me2 = CONTAINING_RECORD(le2, move_entry, list_entry);
 
                        if (me2->fileref->fcb == me->fileref->fcb && !me2->fileref->fcb->ads) {
                            me2->dummyfcb = me->dummyfcb;
                            InterlockedIncrement(&me->dummyfcb->refcount);
                        }
 
                        le2 = le2->Flink;
                    }
                }
 
                ExReleaseResourceLite(me->fileref->fcb->Header.Resource);
            } else {
                ExAcquireResourceExclusiveLite(me->fileref->fcb->Header.Resource, true);
                me->fileref->fcb->inode_item.st_nlink++;
                me->fileref->fcb->inode_item_changed = true;
                ExReleaseResourceLite(me->fileref->fcb->Header.Resource);
            }
        }
 
        le = le->Flink;
    }
 
    fileref->fcb->subvol->root_item.ctransid = fileref->fcb->Vcb->superblock.generation;
    fileref->fcb->subvol->root_item.ctime = now;
 
    // loop through list and create new filerefs
 
    le = move_list.Flink;
    while (le != &move_list) {
        hardlink* hl;
        bool name_changed = false;
 
        me = CONTAINING_RECORD(le, move_entry, list_entry);
 
        me->dummyfileref = create_fileref(fileref->fcb->Vcb);
        if (!me->dummyfileref) {
            ERR("out of memory\n");
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto end;
        }
 
        if (me->fileref->fcb == me->fileref->fcb->Vcb->dummy_fcb) {
            root* r = me->parent ? me->parent->fileref->fcb->subvol : destdir->fcb->subvol;
 
            Status = create_directory_fcb(me->fileref->fcb->Vcb, r, me->fileref->parent->fcb, &me->fileref->fcb);
            if (!NT_SUCCESS(Status)) {
                ERR("create_directory_fcb returned %08lx\n", Status);
                goto