ReactOS  0.4.15-dev-5461-g062a8f2
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_INFORMATIONPFILE_ID_INFORMATION
 
typedef struct _FILE_STAT_INFORMATION FILE_STAT_INFORMATION
 
typedef struct _FILE_STAT_INFORMATIONPFILE_STAT_INFORMATION
 
typedef struct _FILE_STAT_LX_INFORMATION FILE_STAT_LX_INFORMATION
 
typedef struct _FILE_STAT_LX_INFORMATIONPFILE_STAT_LX_INFORMATION
 
typedef struct _FILE_RENAME_INFORMATION_EX FILE_RENAME_INFORMATION_EX
 
typedef struct _FILE_RENAME_INFORMATION_EXPFILE_RENAME_INFORMATION_EX
 
typedef struct _FILE_DISPOSITION_INFORMATION_EX FILE_DISPOSITION_INFORMATION_EX
 
typedef struct _FILE_DISPOSITION_INFORMATION_EXPFILE_DISPOSITION_INFORMATION_EX
 
typedef struct _FILE_LINK_INFORMATION_EX FILE_LINK_INFORMATION_EX
 
typedef struct _FILE_LINK_INFORMATION_EXPFILE_LINK_INFORMATION_EX
 
typedef struct _FILE_CASE_SENSITIVE_INFORMATION FILE_CASE_SENSITIVE_INFORMATION
 
typedef struct _FILE_CASE_SENSITIVE_INFORMATIONPFILE_CASE_SENSITIVE_INFORMATION
 
typedef struct _FILE_LINK_ENTRY_FULL_ID_INFORMATION FILE_LINK_ENTRY_FULL_ID_INFORMATION
 
typedef struct _FILE_LINK_ENTRY_FULL_ID_INFORMATIONPFILE_LINK_ENTRY_FULL_ID_INFORMATION
 
typedef struct _FILE_LINKS_FULL_ID_INFORMATION FILE_LINKS_FULL_ID_INFORMATION
 
typedef struct _FILE_LINKS_FULL_ID_INFORMATIONPFILE_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

◆ FILE_DISPOSITION_INFORMATION_EX

◆ FILE_ID_INFORMATION

◆ FILE_LINK_ENTRY_FULL_ID_INFORMATION

◆ FILE_LINK_INFORMATION_EX

◆ FILE_LINKS_FULL_ID_INFORMATION

◆ FILE_RENAME_INFORMATION_EX

◆ FILE_STAT_INFORMATION

◆ FILE_STAT_LX_INFORMATION

◆ move_entry

◆ PFILE_CASE_SENSITIVE_INFORMATION

◆ PFILE_DISPOSITION_INFORMATION_EX

◆ PFILE_ID_INFORMATION

◆ PFILE_LINK_ENTRY_FULL_ID_INFORMATION

◆ PFILE_LINK_INFORMATION_EX

◆ PFILE_LINKS_FULL_ID_INFORMATION

◆ PFILE_RENAME_INFORMATION_EX

◆ PFILE_STAT_INFORMATION

◆ PFILE_STAT_LX_INFORMATION

Function Documentation

◆ _Dispatch_type_() [1/4]

_Dispatch_type_ ( IRP_MJ_SET_INFORMATION  )

Definition at line 3889 of file fileinfo.c.

3891  {
3892  NTSTATUS Status;
3894  device_extension* Vcb = DeviceObject->DeviceExtension;
3895  fcb* fcb = IrpSp->FileObject->FsContext;
3896  ccb* ccb = IrpSp->FileObject->FsContext2;
3897  bool top_level;
3898 
3900 
3901  top_level = is_top_level(Irp);
3902 
3903  Irp->IoStatus.Information = 0;
3904 
3905  if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
3907  goto end;
3908  } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
3910  goto end;
3911  }
3912 
3913  if (!(Vcb->Vpb->Flags & VPB_MOUNTED)) {
3915  goto end;
3916  }
3917 
3918  if (Vcb->readonly && IrpSp->Parameters.SetFile.FileInformationClass != FilePositionInformation) {
3920  goto end;
3921  }
3922 
3923  if (!fcb) {
3924  ERR("no fcb\n");
3926  goto end;
3927  }
3928 
3929  if (!ccb) {
3930  ERR("no ccb\n");
3932  goto end;
3933  }
3934 
3935  if (fcb != Vcb->dummy_fcb && is_subvol_readonly(fcb->subvol, Irp) && IrpSp->Parameters.SetFile.FileInformationClass != FilePositionInformation &&
3936 #ifndef __REACTOS__
3937  (fcb->inode != SUBVOL_ROOT_INODE || (IrpSp->Parameters.SetFile.FileInformationClass != FileBasicInformation && IrpSp->Parameters.SetFile.FileInformationClass != FileRenameInformation && IrpSp->Parameters.SetFile.FileInformationClass != FileRenameInformationEx))) {
3938 #else
3939  (fcb->inode != SUBVOL_ROOT_INODE || (IrpSp->Parameters.SetFile.FileInformationClass != FileBasicInformation && IrpSp->Parameters.SetFile.FileInformationClass != FileRenameInformation))) {
3940 #endif
3942  goto end;
3943  }
3944 
3946 
3947  TRACE("set information\n");
3948 
3950 
3951  switch (IrpSp->Parameters.SetFile.FileInformationClass) {
3953  {
3954  TRACE("FileAllocationInformation\n");
3955 
3956  if (Irp->RequestorMode == UserMode && !(ccb->access & FILE_WRITE_DATA)) {
3957  WARN("insufficient privileges\n");
3959  break;
3960  }
3961 
3963  break;
3964  }
3965 
3966  case FileBasicInformation:
3967  {
3968  TRACE("FileBasicInformation\n");
3969 
3970  if (Irp->RequestorMode == UserMode && !(ccb->access & FILE_WRITE_ATTRIBUTES)) {
3971  WARN("insufficient privileges\n");
3973  break;
3974  }
3975 
3977 
3978  break;
3979  }
3980 
3982  {
3983  TRACE("FileDispositionInformation\n");
3984 
3985  if (Irp->RequestorMode == UserMode && !(ccb->access & DELETE)) {
3986  WARN("insufficient privileges\n");
3988  break;
3989  }
3990 
3992 
3993  break;
3994  }
3995 
3997  {
3998  TRACE("FileEndOfFileInformation\n");
3999 
4000  if (Irp->RequestorMode == UserMode && !(ccb->access & (FILE_WRITE_DATA | FILE_APPEND_DATA))) {
4001  WARN("insufficient privileges\n");
4003  break;
4004  }
4005 
4006  Status = set_end_of_file_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.AdvanceOnly, false);
4007 
4008  break;
4009  }
4010 
4011  case FileLinkInformation:
4012  TRACE("FileLinkInformation\n");
4013  Status = set_link_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.FileObject, false);
4014  break;
4015 
4017  TRACE("FilePositionInformation\n");
4019  break;
4020 
4021  case FileRenameInformation:
4022  TRACE("FileRenameInformation\n");
4023  Status = set_rename_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.FileObject, false);
4024  break;
4025 
4027  {
4028  TRACE("FileValidDataLengthInformation\n");
4029 
4030  if (Irp->RequestorMode == UserMode && !(ccb->access & (FILE_WRITE_DATA | FILE_APPEND_DATA))) {
4031  WARN("insufficient privileges\n");
4033  break;
4034  }
4035 
4037 
4038  break;
4039  }
4040 
4041 #ifndef __REACTOS__
4042 #ifndef _MSC_VER
4043 #pragma GCC diagnostic push
4044 #pragma GCC diagnostic ignored "-Wswitch"
4045 #endif
4047  {
4048  TRACE("FileDispositionInformationEx\n");
4049 
4050  if (Irp->RequestorMode == UserMode && !(ccb->access & DELETE)) {
4051  WARN("insufficient privileges\n");
4053  break;
4054  }
4055 
4057 
4058  break;
4059  }
4060 
4062  TRACE("FileRenameInformationEx\n");
4063  Status = set_rename_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.FileObject, true);
4064  break;
4065 
4066  case FileLinkInformationEx:
4067  TRACE("FileLinkInformationEx\n");
4068  Status = set_link_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.FileObject, true);
4069  break;
4070 
4072  TRACE("FileCaseSensitiveInformation\n");
4073 
4074  if (Irp->RequestorMode == UserMode && !(ccb->access & FILE_WRITE_ATTRIBUTES)) {
4075  WARN("insufficient privileges\n");
4077  break;
4078  }
4079 
4081  break;
4082 
4084  WARN("unimplemented FileInformationClass FileStorageReserveIdInformation\n");
4085  break;
4086 
4087 #ifndef _MSC_VER
4088 #pragma GCC diagnostic pop
4089 #endif
4090 #endif
4091 
4092  default:
4093  WARN("unknown FileInformationClass %u\n", IrpSp->Parameters.SetFile.FileInformationClass);
4094  }
4095 
4096 end:
4097  Irp->IoStatus.Status = Status;
4098 
4099  TRACE("returning %08lx\n", Status);
4100 
4102 
4103  if (top_level)
4105 
4107 
4108  return Status;
4109 }
static NTSTATUS set_basic_information(device_extension *Vcb, PIRP Irp, PFILE_OBJECT FileObject)
Definition: fileinfo.c:190
#define FsRtlEnterFileSystem
#define FsRtlExitFileSystem
static NTSTATUS set_case_sensitive_information(PIRP Irp)
Definition: fileinfo.c:3856
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define SUBVOL_ROOT_INODE
Definition: propsheet.cpp:42
#define WARN(fmt,...)
Definition: debug.h:112
LONG NTSTATUS
Definition: precomp.h:26
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
#define VCB_TYPE_FS
Definition: btrfs_drv.h:687
#define FileDispositionInformationEx
Definition: fileinfo.c:26
ACCESS_MASK access
Definition: btrfs_drv.h:382
#define FILE_APPEND_DATA
Definition: nt_native.h:634
bool is_top_level(_In_ PIRP Irp)
Definition: btrfs.c:278
#define FileStorageReserveIdInformation
Definition: fileinfo.c:32
static NTSTATUS set_valid_data_length_information(device_extension *Vcb, PIRP Irp, PFILE_OBJECT FileObject)
Definition: fileinfo.c:3760
#define FILE_WRITE_ATTRIBUTES
Definition: nt_native.h:649
static NTSTATUS set_position_information(PFILE_OBJECT FileObject, PIRP Irp)
Definition: fileinfo.c:3394
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
return STATUS_NOT_IMPLEMENTED
_In_ PIRP Irp
Definition: csq.h:116
static __inline bool is_subvol_readonly(root *r, PIRP Irp)
Definition: btrfs_drv.h:1033
static NTSTATUS set_disposition_information(device_extension *Vcb, PIRP Irp, PFILE_OBJECT FileObject, bool ex)
Definition: fileinfo.c:357
#define IoCompleteRequest
Definition: irp.c:1240
#define STATUS_MEDIA_WRITE_PROTECTED
Definition: udferr_usr.h:161
#define FILE_WRITE_DATA
Definition: nt_native.h:631
Status
Definition: gdiplustypes.h:24
#define TRACE(s)
Definition: solgame.cpp:4
#define VCB_TYPE_VOLUME
Definition: btrfs_drv.h:689
uint64_t inode
Definition: btrfs_drv.h:289
#define Vcb
Definition: cdprocs.h:1415
static NTSTATUS set_rename_information(device_extension *Vcb, PIRP Irp, PFILE_OBJECT FileObject, PFILE_OBJECT tfo, bool ex)
Definition: fileinfo.c:2527
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
static NTSTATUS set_end_of_file_information(device_extension *Vcb, PIRP Irp, PFILE_OBJECT FileObject, bool advance_only, bool prealloc)
Definition: fileinfo.c:3240
GLuint GLuint end
Definition: gl.h:1545
static NTSTATUS set_link_information(device_extension *Vcb, PIRP Irp, PFILE_OBJECT FileObject, PFILE_OBJECT tfo, bool ex)
Definition: fileinfo.c:3406
VOID NTAPI IoSetTopLevelIrp(IN PIRP Irp)
Definition: irp.c:2000
#define ERR(fmt,...)
Definition: debug.h:110
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
PFILE_OBJECT FileObject
Definition: iotypes.h:3169
#define FileRenameInformationEx
Definition: fileinfo.c:27
struct _root * subvol
Definition: btrfs_drv.h:288
#define NULL
Definition: types.h:112
static __inline POPLOCK fcb_oplock(fcb *fcb)
Definition: btrfs_drv.h:1677
#define FileLinkInformationEx
Definition: fileinfo.c:31
#define IO_NO_INCREMENT
Definition: iotypes.h:598
NTSTATUS NTAPI FsRtlCheckOplock(IN POPLOCK Oplock, IN PIRP Irp, IN PVOID Context, IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine OPTIONAL, IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine OPTIONAL)
Definition: oplock.c:1170
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:3128
#define VPB_MOUNTED
Definition: iotypes.h:1807
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4137
#define DELETE
Definition: nt_native.h:57
#define FileCaseSensitiveInformation
Definition: fileinfo.c:30

◆ _Dispatch_type_() [2/4]

_Dispatch_type_ ( IRP_MJ_QUERY_INFORMATION  )

Definition at line 5418 of file fileinfo.c.

5420  {
5422  NTSTATUS Status;
5423  fcb* fcb;
5424  device_extension* Vcb = DeviceObject->DeviceExtension;
5425  bool top_level;
5426 
5428 
5429  top_level = is_top_level(Irp);
5430 
5431  if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
5433  goto end;
5434  } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
5436  goto end;
5437  }
5438 
5439  Irp->IoStatus.Information = 0;
5440 
5441  TRACE("query information\n");
5442 
5444 
5445  fcb = IrpSp->FileObject->FsContext;
5446  TRACE("fcb = %p\n", fcb);
5447  TRACE("fcb->subvol = %p\n", fcb->subvol);
5448 
5450 
5451 end:
5452  TRACE("returning %08lx\n", Status);
5453 
5454  Irp->IoStatus.Status = Status;
5455 
5457 
5458  if (top_level)
5460 
5462 
5463  return Status;
5464 }
#define FsRtlEnterFileSystem
#define FsRtlExitFileSystem
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
LONG NTSTATUS
Definition: precomp.h:26
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
#define VCB_TYPE_FS
Definition: btrfs_drv.h:687
bool is_top_level(_In_ PIRP Irp)
Definition: btrfs.c:278
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_In_ PIRP Irp
Definition: csq.h:116
#define IoCompleteRequest
Definition: irp.c:1240
Status
Definition: gdiplustypes.h:24
#define TRACE(s)
Definition: solgame.cpp:4
struct _fcb fcb
Definition: btrfs_drv.h:1364
#define VCB_TYPE_VOLUME
Definition: btrfs_drv.h:689
#define Vcb
Definition: cdprocs.h:1415
GLuint GLuint end
Definition: gl.h:1545
VOID NTAPI IoSetTopLevelIrp(IN PIRP Irp)
Definition: irp.c:2000
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
PFILE_OBJECT FileObject
Definition: iotypes.h:3169
struct _root * subvol
Definition: btrfs_drv.h:288
#define NULL
Definition: types.h:112
#define IO_NO_INCREMENT
Definition: iotypes.h:598
static NTSTATUS query_info(device_extension *Vcb, PFILE_OBJECT FileObject, PIRP Irp)
Definition: fileinfo.c:5042
struct _device_extension * Vcb
Definition: btrfs_drv.h:287
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4137

◆ _Dispatch_type_() [3/4]

_Dispatch_type_ ( IRP_MJ_QUERY_EA  )

Definition at line 5466 of file fileinfo.c.

5468  {
5469  NTSTATUS Status;
5470  bool top_level;
5471  device_extension* Vcb = DeviceObject->DeviceExtension;
5474  fcb* fcb;
5475  ccb* ccb;
5477  ULONG retlen = 0;
5478 
5480 
5481  TRACE("(%p, %p)\n", DeviceObject, Irp);
5482 
5483  top_level = is_top_level(Irp);
5484 
5485  if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
5487  goto end;
5488  } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
5490  goto end;
5491  }
5492 
5494  if (!ffei) {
5495  ERR("could not get output buffer\n");
5497  goto end;
5498  }
5499 
5500  if (!FileObject) {
5501  ERR("no file object\n");
5503  goto end;
5504  }
5505 
5506  fcb = FileObject->FsContext;
5507 
5508  if (!fcb) {
5509  ERR("no fcb\n");
5511  goto end;
5512  }
5513 
5514  if (fcb == fcb->Vcb->volume_fcb) {
5516  goto end;
5517  }
5518 
5519  ccb = FileObject->FsContext2;
5520 
5521  if (!ccb) {
5522  ERR("no ccb\n");
5524  goto end;
5525  }
5526 
5527  if (Irp->RequestorMode == UserMode && !(ccb->access & (FILE_READ_EA | FILE_WRITE_EA))) {
5528  WARN("insufficient privileges\n");
5530  goto end;
5531  }
5532 
5533  if (fcb->ads)
5534  fcb = ccb->fileref->parent->fcb;
5535 
5536  ExAcquireResourceSharedLite(fcb->Header.Resource, true);
5537 
5538  if (fcb->ea_xattr.Length == 0) {
5540  goto end2;
5541  }
5542 
5544 
5545  if (IrpSp->Parameters.QueryEa.EaList) {
5548 
5549  in = IrpSp->Parameters.QueryEa.EaList;
5550  do {
5551  STRING s;
5552 
5553  s.Length = s.MaximumLength = in->EaNameLength;
5554  s.Buffer = in->EaName;
5555 
5556  RtlUpperString(&s, &s);
5557 
5558  if (in->NextEntryOffset == 0)
5559  break;
5560 
5561  in = (FILE_GET_EA_INFORMATION*)(((uint8_t*)in) + in->NextEntryOffset);
5562  } while (true);
5563 
5565  out = NULL;
5566 
5567  do {
5568  bool found = false;
5569 
5570  in = IrpSp->Parameters.QueryEa.EaList;
5571  do {
5572  if (in->EaNameLength == ea->EaNameLength &&
5573  RtlCompareMemory(in->EaName, ea->EaName, in->EaNameLength) == in->EaNameLength) {
5574  found = true;
5575  break;
5576  }
5577 
5578  if (in->NextEntryOffset == 0)
5579  break;
5580 
5581  in = (FILE_GET_EA_INFORMATION*)(((uint8_t*)in) + in->NextEntryOffset);
5582  } while (true);
5583 
5584  if (found) {
5585  uint8_t padding = retlen % 4 > 0 ? (4 - (retlen % 4)) : 0;
5586 
5587  if (offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + ea->EaNameLength + 1 + ea->EaValueLength > IrpSp->Parameters.QueryEa.Length - retlen - padding) {
5589  retlen = 0;
5590  goto end2;
5591  }
5592 
5593  retlen += padding;
5594 
5595  if (out) {
5596  out->NextEntryOffset = (ULONG)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + out->EaNameLength + 1 + out->EaValueLength + padding;
5597  out = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)out) + out->NextEntryOffset);
5598  } else
5599  out = ffei;
5600 
5601  out->NextEntryOffset = 0;
5602  out->Flags = ea->Flags;
5603  out->EaNameLength = ea->EaNameLength;
5604  out->EaValueLength = ea->EaValueLength;
5605  RtlCopyMemory(out->EaName, ea->EaName, ea->EaNameLength + ea->EaValueLength + 1);
5606 
5607  retlen += (ULONG)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + ea->EaNameLength + 1 + ea->EaValueLength;
5608 
5610  break;
5611  }
5612 
5613  if (ea->NextEntryOffset == 0)
5614  break;
5615 
5616  ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
5617  } while (true);
5618  } else {
5620  ULONG index;
5621 
5622  if (IrpSp->Flags & SL_INDEX_SPECIFIED) {
5623  // The index is 1-based
5624  if (IrpSp->Parameters.QueryEa.EaIndex == 0) {
5626  goto end2;
5627  } else
5628  index = IrpSp->Parameters.QueryEa.EaIndex - 1;
5629  } else if (IrpSp->Flags & SL_RESTART_SCAN)
5630  index = ccb->ea_index = 0;
5631  else
5632  index = ccb->ea_index;
5633 
5635 
5636  if (index > 0) {
5637  ULONG i;
5638 
5639  for (i = 0; i < index; i++) {
5640  if (ea->NextEntryOffset == 0) { // last item
5642  goto end2;
5643  }
5644 
5645  ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
5646  }
5647  }
5648 
5649  out = NULL;
5650 
5651  do {
5652  uint8_t padding = retlen % 4 > 0 ? (4 - (retlen % 4)) : 0;
5653 
5654  if (offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + ea->EaNameLength + 1 + ea->EaValueLength > IrpSp->Parameters.QueryEa.Length - retlen - padding) {
5656  goto end2;
5657  }
5658 
5659  retlen += padding;
5660 
5661  if (out) {
5662  out->NextEntryOffset = (ULONG)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + out->EaNameLength + 1 + out->EaValueLength + padding;
5663  out = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)out) + out->NextEntryOffset);
5664  } else
5665  out = ffei;
5666 
5667  out->NextEntryOffset = 0;
5668  out->Flags = ea->Flags;
5669  out->EaNameLength = ea->EaNameLength;
5670  out->EaValueLength = ea->EaValueLength;
5671  RtlCopyMemory(out->EaName, ea->EaName, ea->EaNameLength + ea->EaValueLength + 1);
5672 
5673  retlen += (ULONG)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + ea->EaNameLength + 1 + ea->EaValueLength;
5674 
5675  if (!(IrpSp->Flags & SL_INDEX_SPECIFIED))
5676  ccb->ea_index++;
5677 
5679  break;
5680 
5681  ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
5682  } while (true);
5683  }
5684 
5685 end2:
5686  ExReleaseResourceLite(fcb->Header.Resource);
5687 
5688 end:
5689  TRACE("returning %08lx\n", Status);
5690 
5691  Irp->IoStatus.Status = Status;
5692  Irp->IoStatus.Information = NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW ? retlen : 0;
5693 
5695 
5696  if (top_level)
5698 
5700 
5701  return Status;
5702 }
struct _file_ref * parent
Definition: btrfs_drv.h:352
NTSYSAPI VOID NTAPI RtlUpperString(PSTRING DestinationString, PSTRING SourceString)
#define FILE_WRITE_EA
Definition: nt_native.h:640
#define FsRtlEnterFileSystem
#define SL_INDEX_SPECIFIED
Definition: iotypes.h:1837
#define FsRtlExitFileSystem
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define WARN(fmt,...)
Definition: debug.h:112
LONG NTSTATUS
Definition: precomp.h:26
ANSI_STRING ea_xattr
Definition: btrfs_drv.h:302
#define STATUS_NO_EAS_ON_FILE
Definition: ntstatus.h:318
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
#define VCB_TYPE_FS
Definition: btrfs_drv.h:687
ACCESS_MASK access
Definition: btrfs_drv.h:382
if(dx==0 &&dy==0)
Definition: linetemp.h:174
bool is_top_level(_In_ PIRP Irp)
Definition: btrfs.c:278
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_In_ PIRP Irp
Definition: csq.h:116
#define offsetof(TYPE, MEMBER)
#define IoCompleteRequest
Definition: irp.c:1240
GLuint index
Definition: glext.h:6031
ULONG ea_index
Definition: btrfs_drv.h:385
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:547
#define STATUS_NO_MORE_EAS
Definition: ntstatus.h:198
FSRTL_ADVANCED_FCB_HEADER Header
Definition: btrfs_drv.h:283
Status
Definition: gdiplustypes.h:24
#define TRACE(s)
Definition: solgame.cpp:4
unsigned int padding
Definition: isohybrid.c:50
struct _fcb fcb
Definition: btrfs_drv.h:1364
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_NONEXISTENT_EA_ENTRY
Definition: ntstatus.h:317
#define VCB_TYPE_VOLUME
Definition: btrfs_drv.h:689
#define Vcb
Definition: cdprocs.h:1415
static __inline void * map_user_buffer(PIRP Irp, ULONG priority)
Definition: btrfs_drv.h:977
static FILE * out
Definition: regtests2xml.c:44
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817
* PFILE_OBJECT
Definition: iotypes.h:1998
GLuint GLuint end
Definition: gl.h:1545
std::wstring STRING
Definition: fontsub.cpp:33
VOID NTAPI IoSetTopLevelIrp(IN PIRP Irp)
Definition: irp.c:2000
#define index(s, c)
Definition: various.h:29
GLdouble s
Definition: gl.h:2039
BYTE uint8_t
Definition: msvideo1.c:66
#define ERR(fmt,...)
Definition: debug.h:110
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
PFILE_OBJECT FileObject
Definition: iotypes.h:3169
#define SL_RETURN_SINGLE_ENTRY
Definition: iotypes.h:1836
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLuint in
Definition: glext.h:9616
#define FILE_READ_EA
Definition: nt_native.h:638
#define NULL
Definition: types.h:112
#define SL_RESTART_SCAN
Definition: iotypes.h:1835
BOOLEAN NTAPI ExAcquireResourceSharedLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:885
bool ads
Definition: btrfs_drv.h:330
unsigned int ULONG
Definition: retypes.h:1
#define IO_NO_INCREMENT
Definition: iotypes.h:598
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define STATUS_SUCCESS
Definition: shellext.h:65
struct _ccb ccb
file_ref * fileref
Definition: btrfs_drv.h:383
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:3128
struct _device_extension * Vcb
Definition: btrfs_drv.h:287
#define RtlCompareMemory(s1, s2, l)
Definition: env_spec_w32.h:465
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4137

◆ _Dispatch_type_() [4/4]

_Dispatch_type_ ( IRP_MJ_SET_EA  )

Definition at line 5704 of file fileinfo.c.

5706  {
5707  device_extension* Vcb = DeviceObject->DeviceExtension;
5708  NTSTATUS Status;
5709  bool top_level;
5712  fcb* fcb;
5713  ccb* ccb;
5714  file_ref* fileref;
5716  ULONG offset;
5717  LIST_ENTRY ealist;
5718  ea_item* item;
5720  LIST_ENTRY* le;
5722  BTRFS_TIME now;
5723 
5725 
5726  TRACE("(%p, %p)\n", DeviceObject, Irp);
5727 
5728  top_level = is_top_level(Irp);
5729 
5730  if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
5732  goto end;
5733  } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
5735  goto end;
5736  }
5737 
5738  if (Vcb->readonly) {
5740  goto end;
5741  }
5742 
5744  if (!ffei) {
5745  ERR("could not get output buffer\n");
5747  goto end;
5748  }
5749 
5750  Status = IoCheckEaBufferValidity(ffei, IrpSp->Parameters.SetEa.Length, &offset);
5751  if (!NT_SUCCESS(Status)) {
5752  ERR("IoCheckEaBufferValidity returned %08lx (error at offset %lu)\n", Status, offset);
5753  goto end;
5754  }
5755 
5756  if (!FileObject) {
5757  ERR("no file object\n");
5759  goto end;
5760  }
5761 
5762  fcb = FileObject->FsContext;
5763 
5764  if (!fcb) {
5765  ERR("no fcb\n");
5767  goto end;
5768  }
5769 
5770  if (fcb == fcb->Vcb->volume_fcb) {
5772  goto end;
5773  }
5774 
5775  ccb = FileObject->FsContext2;
5776 
5777  if (!ccb) {
5778  ERR("no ccb\n");
5780  goto end;
5781  }
5782 
5783  if (Irp->RequestorMode == UserMode && !(ccb->access & FILE_WRITE_EA)) {
5784  WARN("insufficient privileges\n");
5786  goto end;
5787  }
5788 
5789  if (fcb->ads) {
5790  fileref = ccb->fileref->parent;
5791  fcb = fileref->fcb;
5792  } else
5793  fileref = ccb->fileref;
5794 
5795  InitializeListHead(&ealist);
5796 
5797  ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
5798 
5799  if (fcb->ea_xattr.Length > 0) {
5801 
5802  do {
5804  if (!item) {
5805  ERR("out of memory\n");
5807  goto end2;
5808  }
5809 
5810  item->name.Length = item->name.MaximumLength = ea->EaNameLength;
5811  item->name.Buffer = ea->EaName;
5812 
5813  item->value.Length = item->value.MaximumLength = ea->EaValueLength;
5814  item->value.Buffer = &ea->EaName[ea->EaNameLength + 1];
5815 
5816  item->flags = ea->Flags;
5817 
5818  InsertTailList(&ealist, &item->list_entry);
5819 
5820  if (ea->NextEntryOffset == 0)
5821  break;
5822 
5823  ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
5824  } while (true);
5825  }
5826 
5827  ea = ffei;
5828 
5829  do {
5830  STRING s;
5831  bool found = false;
5832 
5833  s.Length = s.MaximumLength = ea->EaNameLength;
5834  s.Buffer = ea->EaName;
5835 
5836  RtlUpperString(&s, &s);
5837 
5838  le = ealist.Flink;
5839  while (le != &ealist) {
5841 
5842  if (item->name.Length == s.Length &&
5843  RtlCompareMemory(item->name.Buffer, s.Buffer, s.Length) == s.Length) {
5844  item->flags = ea->Flags;
5845  item->value.Length = item->value.MaximumLength = ea->EaValueLength;
5846  item->value.Buffer = &ea->EaName[ea->EaNameLength + 1];
5847  found = true;
5848  break;
5849  }
5850 
5851  le = le->Flink;
5852  }
5853 
5854  if (!found) {
5856  if (!item) {
5857  ERR("out of memory\n");
5859  goto end2;
5860  }
5861 
5862  item->name.Length = item->name.MaximumLength = ea->EaNameLength;
5863  item->name.Buffer = ea->EaName;
5864 
5865  item->value.Length = item->value.MaximumLength = ea->EaValueLength;
5866  item->value.Buffer = &ea->EaName[ea->EaNameLength + 1];
5867 
5868  item->flags = ea->Flags;
5869 
5870  InsertTailList(&ealist, &item->list_entry);
5871  }
5872 
5873  if (ea->NextEntryOffset == 0)
5874  break;
5875 
5876  ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
5877  } while (true);
5878 
5879  // remove entries with zero-length value
5880  le = ealist.Flink;
5881  while (le != &ealist) {
5882  LIST_ENTRY* le2 = le->Flink;
5883 
5885 
5886  if (item->value.Length == 0) {
5887  RemoveEntryList(&item->list_entry);
5888  ExFreePool(item);
5889  }
5890 
5891  le = le2;
5892  }
5893 
5894  // handle LXSS values
5895  le = ealist.Flink;
5896  while (le != &ealist) {
5897  LIST_ENTRY* le2 = le->Flink;
5898 
5900 
5901  if (item->name.Length == sizeof(lxuid) - 1 && RtlCompareMemory(item->name.Buffer, lxuid, item->name.Length) == item->name.Length) {
5902  if (item->value.Length < sizeof(uint32_t)) {
5903  ERR("uid value was shorter than expected\n");
5905  goto end2;
5906  }
5907 
5908  if (Irp->RequestorMode == KernelMode || ccb->access & FILE_WRITE_ATTRIBUTES) {
5909  RtlCopyMemory(&fcb->inode_item.st_uid, item->value.Buffer, sizeof(uint32_t));
5910  fcb->sd_dirty = true;
5911  fcb->sd_deleted = false;
5912  }
5913 
5914  RemoveEntryList(&item->list_entry);
5915  ExFreePool(item);
5916  } else if (item->name.Length == sizeof(lxgid) - 1 && RtlCompareMemory(item->name.Buffer, lxgid, item->name.Length) == item->name.Length) {
5917  if (item->value.Length < sizeof(uint32_t)) {
5918  ERR("gid value was shorter than expected\n");
5920  goto end2;
5921  }
5922 
5923  if (Irp->RequestorMode == KernelMode || ccb->access & FILE_WRITE_ATTRIBUTES)
5924  RtlCopyMemory(&fcb->inode_item.st_gid, item->value.Buffer, sizeof(uint32_t));
5925 
5926  RemoveEntryList(&item->list_entry);
5927  ExFreePool(item);
5928  } else if (item->name.Length == sizeof(lxmod) - 1 && RtlCompareMemory(item->name.Buffer, lxmod, item->name.Length) == item->name.Length) {
5929  if (item->value.Length < sizeof(uint32_t)) {
5930  ERR("mode value was shorter than expected\n");
5932  goto end2;
5933  }
5934 
5935  if (Irp->RequestorMode == KernelMode || ccb->access & FILE_WRITE_ATTRIBUTES) {
5937  uint32_t val;
5938 
5939  RtlCopyMemory(&val, item->value.Buffer, sizeof(uint32_t));
5940 
5941  fcb->inode_item.st_mode &= ~allowed;
5942  fcb->inode_item.st_mode |= val & allowed;
5943  }
5944 
5945  RemoveEntryList(&item->list_entry);
5946  ExFreePool(item);
5947  }
5948 
5949  le = le2;
5950  }
5951 
5952  if (IsListEmpty(&ealist)) {
5953  fcb->ealen = 0;
5954 
5955  if (fcb->ea_xattr.Buffer)
5957 
5959  fcb->ea_xattr.Buffer = NULL;
5960  } else {
5961  uint16_t size = 0;
5962  char *buf, *oldbuf;
5963 
5964  le = ealist.Flink;
5965  while (le != &ealist) {
5967 
5968  if (size % 4 > 0)
5969  size += 4 - (size % 4);
5970 
5971  size += (uint16_t)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + item->name.Length + 1 + item->value.Length;
5972 
5973  le = le->Flink;
5974  }
5975 
5977  if (!buf) {
5978  ERR("out of memory\n");
5980  goto end2;
5981  }
5982 
5983  oldbuf = fcb->ea_xattr.Buffer;
5984 
5986  fcb->ea_xattr.Buffer = buf;
5987 
5988  fcb->ealen = 4;
5989  ea = NULL;
5990 
5991  le = ealist.Flink;
5992  while (le != &ealist) {
5994 
5995  if (ea) {
5997 
5998  if (ea->NextEntryOffset % 4 > 0)
5999  ea->NextEntryOffset += 4 - (ea->NextEntryOffset % 4);
6000 
6001  ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
6002  } else
6004 
6005  ea->NextEntryOffset = 0;
6006  ea->Flags = item->flags;
6007  ea->EaNameLength = (UCHAR)item->name.Length;
6008  ea->EaValueLength = item->value.Length;
6009 
6010  RtlCopyMemory(ea->EaName, item->name.Buffer, item->name.Length);
6011  ea->EaName[item->name.Length] = 0;
6012  RtlCopyMemory(&ea->EaName[item->name.Length + 1], item->value.Buffer, item->value.Length);
6013 
6014  fcb->ealen += 5 + item->name.Length + item->value.Length;
6015 
6016  le = le->Flink;
6017  }
6018 
6019  if (oldbuf)
6020  ExFreePool(oldbuf);
6021  }
6022 
6023  fcb->ea_changed = true;
6024 
6027 
6028  fcb->inode_item.transid = Vcb->superblock.generation;
6029  fcb->inode_item.sequence++;
6030 
6031  if (!ccb->user_set_change_time)
6033 
6034  fcb->inode_item_changed = true;
6036 
6038 
6040 
6041 end2:
6042  ExReleaseResourceLite(fcb->Header.Resource);
6043 
6044  while (!IsListEmpty(&ealist)) {
6045  le = RemoveHeadList(&ealist);
6046 
6048 
6049  ExFreePool(item);
6050  }
6051 
6052 end:
6053  TRACE("returning %08lx\n", Status);
6054 
6055  Irp->IoStatus.Status = Status;
6056  Irp->IoStatus.Information = 0;
6057 
6059 
6060  if (top_level)
6062 
6064 
6065  return Status;
6066 }
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
struct _file_ref * parent
Definition: btrfs_drv.h:352
NTSYSAPI VOID NTAPI RtlUpperString(PSTRING DestinationString, PSTRING SourceString)
#define FILE_WRITE_EA
Definition: nt_native.h:640
static const char lxuid[]
Definition: btrfs_drv.h:1287
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define FsRtlEnterFileSystem
#define FsRtlExitFileSystem
#define S_ISGID
Definition: propsheet.h:69
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define WARN(fmt,...)
Definition: debug.h:112
LONG NTSTATUS
Definition: precomp.h:26
bool sd_deleted
Definition: btrfs_drv.h:321
ANSI_STRING ea_xattr
Definition: btrfs_drv.h:302
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
#define VCB_TYPE_FS
Definition: btrfs_drv.h:687
__u16 time
Definition: mkdosfs.c:366
ACCESS_MASK access
Definition: btrfs_drv.h:382
unsigned short int uint16_t
Definition: acefiex.h:54
#define uint16_t
Definition: nsiface.idl:60
#define InsertTailList(ListHead, Entry)
bool is_top_level(_In_ PIRP Irp)
Definition: btrfs.c:278
void send_notification_fileref(_In_ file_ref *fileref, _In_ ULONG filter_match, _In_ ULONG action, _In_opt_ PUNICODE_STRING stream)
Definition: btrfs.c:1517
BTRFS_TIME st_ctime
Definition: btrfs.h:302
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
#define FILE_WRITE_ATTRIBUTES
Definition: nt_native.h:649
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
BOOLEAN NTAPI ExAcquireResourceExclusiveLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:770
#define ALLOC_TAG
Definition: btrfs_drv.h:87
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
bool ea_changed
Definition: btrfs_drv.h:325
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
uint32_t st_gid
Definition: btrfs.h:294
_In_ PIRP Irp
Definition: csq.h:116
#define S_IRGRP
Definition: propsheet.h:41
#define S_IXOTH
Definition: propsheet.h:61
uint64_t sequence
Definition: btrfs.h:299
time_t now
Definition: finger.c:65
#define FILE_ACTION_MODIFIED
#define offsetof(TYPE, MEMBER)
void mark_fcb_dirty(_In_ fcb *fcb)
Definition: btrfs.c:1695
NTSTATUS NTAPI IoCheckEaBufferValidity(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: util.c:191
#define IoCompleteRequest
Definition: irp.c:1240
FORCEINLINE PLIST_ENTRY RemoveHeadList(_Inout_ PLIST_ENTRY ListHead)
Definition: rtlfuncs.h:128
#define STATUS_MEDIA_WRITE_PROTECTED
Definition: udferr_usr.h:161
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:547
GLuint GLfloat * val
Definition: glext.h:7180
ULONG ealen
Definition: btrfs_drv.h:303
FSRTL_ADVANCED_FCB_HEADER Header
Definition: btrfs_drv.h:283
Status
Definition: gdiplustypes.h:24
USHORT MaximumLength
Definition: env_spec_w32.h:377
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
#define S_IWGRP
Definition: propsheet.h:45
#define S_IXGRP
Definition: propsheet.h:49
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
#define S_IWUSR
Definition: propsheet.h:33
struct _fcb fcb
Definition: btrfs_drv.h:1364
bool sd_dirty
Definition: btrfs_drv.h:321
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define VCB_TYPE_VOLUME
Definition: btrfs_drv.h:689
GLintptr offset
Definition: glext.h:5920
bool user_set_change_time
Definition: btrfs_drv.h:390
#define Vcb
Definition: cdprocs.h:1415
static __inline void * map_user_buffer(PIRP Irp, ULONG priority)
Definition: btrfs_drv.h:977
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817
* PFILE_OBJECT
Definition: iotypes.h:1998
GLuint GLuint end
Definition: gl.h:1545
std::wstring STRING
Definition: fontsub.cpp:33
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
unsigned char UCHAR
Definition: xmlstorage.h:181
VOID NTAPI IoSetTopLevelIrp(IN PIRP Irp)
Definition: irp.c:2000
#define S_IXUSR
Definition: propsheet.h:37
#define S_IROTH
Definition: propsheet.h:53
GLdouble s
Definition: gl.h:2039
fcb * fcb
Definition: btrfs_drv.h:342
Definition: typedefs.h:119
INODE_ITEM inode_item
Definition: btrfs_drv.h:292
BYTE uint8_t
Definition: msvideo1.c:66
#define S_IWOTH
Definition: propsheet.h:57
#define ERR(fmt,...)
Definition: debug.h:110
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
PFILE_OBJECT FileObject
Definition: iotypes.h:3169
static ATOM item
Definition: dde.c:856
#define FILE_NOTIFY_CHANGE_EA
static const char lxgid[]
Definition: btrfs_drv.h:1288
#define S_ISUID
Definition: propsheet.h:65
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
uint64_t transid
Definition: btrfs.h:288
static const char lxmod[]
Definition: btrfs_drv.h:1289
#define S_IRUSR
Definition: propsheet.h:29
Definition: list.h:27
#define NULL
Definition: types.h:112
UINT32 uint32_t
Definition: types.h:75
bool ads
Definition: btrfs_drv.h:330
static __inline void win_time_to_unix(LARGE_INTEGER t, BTRFS_TIME *out)
Definition: btrfs_drv.h:989
unsigned int ULONG
Definition: retypes.h:1
#define IO_NO_INCREMENT
Definition: iotypes.h:598
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define STATUS_SUCCESS
Definition: shellext.h:65
struct _ccb ccb
file_ref * fileref
Definition: btrfs_drv.h:383
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:3128
uint32_t st_uid
Definition: btrfs.h:293
bool inode_item_changed
Definition: btrfs_drv.h:306
struct _device_extension * Vcb
Definition: btrfs_drv.h:287
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define S_ISVTX
Definition: propsheet.h:73
#define RtlCompareMemory(s1, s2, l)
Definition: env_spec_w32.h:465
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4137
uint32_t st_mode
Definition: btrfs.h:295

◆ 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.

701  {
703  LIST_ENTRY* le;
704 
705  ExAcquireResourceSharedLite(&me->fileref->fcb->nonpaged->dir_children_lock, true);
706 
707  le = me->fileref->fcb->dir_children_index.Flink;
708 
709  while (le != &me->fileref->fcb->dir_children_index) {
710  dir_child* dc = CONTAINING_RECORD(le, dir_child, list_entry_index);
711  file_ref* fr;
712  move_entry* me2;
713 
714  Status = open_fileref_child(Vcb, me->fileref, &dc->name, true, true, dc->index == 0 ? true : false, PagedPool, &fr, Irp);
715 
716  if (!NT_SUCCESS(Status)) {
717  ERR("open_fileref_child returned %08lx\n", Status);
718  ExReleaseResourceLite(&me->fileref->fcb->nonpaged->dir_children_lock);
719  return Status;
720  }
721 
723  if (!me2) {
724  ERR("out of memory\n");
725  ExReleaseResourceLite(&me->fileref->fcb->nonpaged->dir_children_lock);
727  }
728 
729  me2->fileref = fr;
730  me2->dummyfcb = NULL;
731  me2->dummyfileref = NULL;
732  me2->parent = me;
733 
734  InsertHeadList(&me->list_entry, &me2->list_entry);
735 
736  le = le->Flink;
737  }
738 
739  ExReleaseResourceLite(&me->fileref->fcb->nonpaged->dir_children_lock);
740 
741  return STATUS_SUCCESS;
742 }
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
FORCEINLINE VOID InsertHeadList(_Inout_ PLIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
Definition: rtlfuncs.h:201
LONG NTSTATUS
Definition: precomp.h:26
file_ref * fileref
Definition: fileinfo.c:694
NTSTATUS open_fileref_child(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lock_held_(_Curr_->fcb_lock) _In_ device_extension *Vcb, _In_ file_ref *sf, _In_ PUNICODE_STRING name, _In_ bool case_sensitive, _In_ bool lastpart, _In_ bool streampart, _In_ POOL_TYPE pooltype, _Out_ file_ref **psf2, _In_opt_ PIRP Irp)
Definition: create.c:1459
file_ref * dummyfileref
Definition: fileinfo.c:696
#define ALLOC_TAG
Definition: btrfs_drv.h:87
struct _move_entry * parent
Definition: fileinfo.c:697
_In_ PIRP Irp
Definition: csq.h:116
fcb * dummyfcb
Definition: fileinfo.c:695
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
Status
Definition: gdiplustypes.h:24
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
LIST_ENTRY dir_children_index
Definition: btrfs_drv.h:314
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define Vcb
Definition: cdprocs.h:1415
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
Definition: fileinfo.c:693
fcb * fcb
Definition: btrfs_drv.h:342
Definition: typedefs.h:119
LIST_ENTRY list_entry
Definition: fileinfo.c:698
#define ERR(fmt,...)
Definition: debug.h:110
struct _fcb_nonpaged * nonpaged
Definition: btrfs_drv.h:284
#define NULL
Definition: types.h:112
BOOLEAN NTAPI ExAcquireResourceSharedLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:885
static const WCHAR dc[]
#define STATUS_SUCCESS
Definition: shellext.h:65

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.

888  {
889  LIST_ENTRY* lastle = NULL;
890  uint32_t hash = fcb->hash;
891 
892  if (fcb->subvol->fcbs_ptrs[hash >> 24]) {
893  LIST_ENTRY* le = fcb->subvol->fcbs_ptrs[hash >> 24];
894 
895  while (le != &fcb->subvol->fcbs) {
896  struct _fcb* fcb2 = CONTAINING_RECORD(le, struct _fcb, list_entry);
897 
898  if (fcb2->hash > hash) {
899  lastle = le->Blink;
900  break;
901  }
902 
903  le = le->Flink;
904  }
905  }
906 
907  if (!lastle) {
908  uint8_t c = hash >> 24;
909 
910  if (c != 0xff) {
911  uint8_t d = c + 1;
912 
913  do {
914  if (fcb->subvol->fcbs_ptrs[d]) {
915  lastle = fcb->subvol->fcbs_ptrs[d]->Blink;
916  break;
917  }
918 
919  d++;
920  } while (d != 0);
921  }
922  }
923 
924  if (lastle) {
925  InsertHeadList(lastle, &fcb->list_entry);
926 
927  if (lastle == &fcb->subvol->fcbs || (CONTAINING_RECORD(lastle, struct _fcb, list_entry)->hash >> 24) != (hash >> 24))
928  fcb->subvol->fcbs_ptrs[hash >> 24] = &fcb->list_entry;
929  } else {
930  InsertTailList(&fcb->subvol->fcbs, &fcb->list_entry);
931 
932  if (fcb->list_entry.Blink == &fcb->subvol->fcbs || (CONTAINING_RECORD(fcb->list_entry.Blink, struct _fcb, list_entry)->hash >> 24) != (hash >> 24))
933  fcb->subvol->fcbs_ptrs[hash >> 24] = &fcb->list_entry;
934  }
935 }
struct _LIST_ENTRY * Blink
Definition: typedefs.h:122
FORCEINLINE VOID InsertHeadList(_Inout_ PLIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
Definition: rtlfuncs.h:201
#define InsertTailList(ListHead, Entry)
LIST_ENTRY list_entry
Definition: btrfs_drv.h:336
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
const GLubyte * c
Definition: glext.h:8905
uint32_t hash
Definition: btrfs_drv.h:290
Definition: typedefs.h:119
BYTE uint8_t
Definition: msvideo1.c:66
struct _root * subvol
Definition: btrfs_drv.h:288
Definition: list.h:27
#define NULL
Definition: types.h:112
UINT32 uint32_t
Definition: types.h:75
Definition: _hash_fun.h:40
#define d
Definition: ke_i.h:81

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.

782  {
784  fcb* fcb;
785  SECURITY_SUBJECT_CONTEXT subjcont;
786  PSID owner;
787  BOOLEAN defaulted;
789  BTRFS_TIME now;
790 
792  if (!fcb) {
793  ERR("out of memory\n");
795  }
796 
799 
800  fcb->Vcb = Vcb;
801 
802  fcb->subvol = r;
803  fcb->inode = InterlockedIncrement64(&r->lastinode);
804  fcb->hash = calc_crc32c(0xffffffff, (uint8_t*)&fcb->inode, sizeof(uint64_t));
806 
807  fcb->inode_item.generation = Vcb->superblock.generation;
808  fcb->inode_item.transid = Vcb->superblock.generation;
809  fcb->inode_item.st_nlink = 1;
810  fcb->inode_item.st_mode = __S_IFDIR | inherit_mode(parfcb, true);
813 
814  fcb->atts = get_file_attributes(Vcb, fcb->subvol, fcb->inode, fcb->type, false, true, NULL);
815 
816  SeCaptureSubjectContext(&subjcont);
817 
818  Status = SeAssignSecurity(parfcb->sd, NULL, (void**)&fcb->sd, true, &subjcont, IoGetFileObjectGenericMapping(), PagedPool);
819 
820  if (!NT_SUCCESS(Status)) {
821  reap_fcb(fcb);
822  ERR("SeAssignSecurity returned %08lx\n", Status);
823  return Status;
824  }
825 
826  if (!fcb->sd) {
827  reap_fcb(fcb);
828  ERR("SeAssignSecurity returned NULL security descriptor\n");
829  return STATUS_INTERNAL_ERROR;
830  }
831 
832  Status = RtlGetOwnerSecurityDescriptor(fcb->sd, &owner, &defaulted);
833  if (!NT_SUCCESS(Status)) {
834  ERR("RtlGetOwnerSecurityDescriptor returned %08lx\n", Status);
836  fcb->sd_dirty = true;
837  } else {
838  fcb->inode_item.st_uid = sid_to_uid(owner);
840  }
841 
842  find_gid(fcb, parfcb, &subjcont);
843 
844  fcb->inode_item_changed = true;
845 
846  fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
847  fcb->Header.AllocationSize.QuadPart = 0;
848  fcb->Header.FileSize.QuadPart = 0;
849  fcb->Header.ValidDataLength.QuadPart = 0;
850 
851  fcb->created = true;
852 
853  if (parfcb->inode_item.flags & BTRFS_INODE_COMPRESS)
855 
858 
860  if (!fcb->hash_ptrs) {
861  ERR("out of memory\n");
863  }
864 
865  RtlZeroMemory(fcb->hash_ptrs, sizeof(LIST_ENTRY*) * 256);
866 
868  if (!fcb->hash_ptrs_uc) {
869  ERR("out of memory\n");
871  }
872 
873  RtlZeroMemory(fcb->hash_ptrs_uc, sizeof(LIST_ENTRY*) * 256);
874 
875  acquire_fcb_lock_exclusive(Vcb);
877  InsertTailList(&Vcb->all_fcbs, &fcb->list_entry_all);
878  r->fcbs_version++;
879  release_fcb_lock(Vcb);
880 
882 
883  *pfcb = fcb;
884 
885  return STATUS_SUCCESS;
886 }
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
PGENERIC_MAPPING NTAPI IoGetFileObjectGenericMapping(VOID)
Definition: file.c:3266
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
BTRFS_TIME otime
Definition: btrfs.h:304
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
fcb * create_fcb(device_extension *Vcb, POOL_TYPE pool_type)
Definition: create.c:91
LONG NTSTATUS
Definition: precomp.h:26
enum prop_compression_type prop_compression
Definition: btrfs_drv.h:307
__u16 time
Definition: mkdosfs.c:366
#define InsertTailList(ListHead, Entry)
uint32_t flags
Definition: btrfs.h:297
BTRFS_TIME st_ctime
Definition: btrfs.h:302
LIST_ENTRY list_entry_all
Definition: btrfs_drv.h:337
#define STATUS_INTERNAL_ERROR
Definition: ntstatus.h:465
uint32_t sid_to_uid(PSID sid)
Definition: security.c:310
#define ALLOC_TAG
Definition: btrfs_drv.h:87
uint32_t st_gid
Definition: btrfs.h:294
SECURITY_DESCRIPTOR * sd
Definition: btrfs_drv.h:293
#define BTRFS_INODE_COMPRESS
Definition: propsheet.h:87
uint32_t st_nlink
Definition: btrfs.h:292
time_t now
Definition: finger.c:65
#define BTRFS_TYPE_DIRECTORY
Definition: shellext.h:86
unsigned char BOOLEAN
void reap_fcb(fcb *fcb)
Definition: btrfs.c:1743
LIST_ENTRY ** hash_ptrs_uc
Definition: btrfs_drv.h:318
void mark_fcb_dirty(_In_ fcb *fcb)
Definition: btrfs.c:1695
uint8_t type
Definition: btrfs_drv.h:291
BTRFS_TIME st_mtime
Definition: btrfs.h:303
bool prop_compression_changed
Definition: btrfs_drv.h:326
void find_gid(struct _fcb *fcb, struct _fcb *parfcb, PSECURITY_SUBJECT_CONTEXT subjcont)
Definition: security.c:924
void add_fcb_to_subvol(_In_ _Requires_exclusive_lock_held_(_Curr_->Vcb->fcb_lock) fcb *fcb)
Definition: fileinfo.c:888
FSRTL_ADVANCED_FCB_HEADER Header
Definition: btrfs_drv.h:283
Status
Definition: gdiplustypes.h:24
struct _fcb fcb
Definition: btrfs_drv.h:1364
bool sd_dirty
Definition: btrfs_drv.h:321
ULONG get_file_attributes(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_ root *r, _In_ uint64_t inode, _In_ uint8_t type, _In_ bool dotfile, _In_ bool ignore_xa, _In_opt_ PIRP Irp)
Definition: btrfs.c:2664
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
uint64_t inode
Definition: btrfs_drv.h:289
#define Vcb
Definition: cdprocs.h:1415
#define InterlockedIncrement64(a)
Definition: btrfs_drv.h:143
uint32_t hash
Definition: btrfs_drv.h:290
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
BTRFS_TIME st_atime
Definition: btrfs.h:301
crc_func calc_crc32c
Definition: crc32c.c:23
bool created
Definition: btrfs_drv.h:328
Definition: typedefs.h:119
static __inline FAST_IO_POSSIBLE fast_io_possible(fcb *fcb)
Definition: btrfs_drv.h:1684
INODE_ITEM inode_item
Definition: btrfs_drv.h:292
uint64_t generation
Definition: btrfs.h:287
BYTE uint8_t
Definition: msvideo1.c:66
#define ERR(fmt,...)
Definition: debug.h:110
VOID NTAPI SeCaptureSubjectContext(_Out_ PSECURITY_SUBJECT_CONTEXT SubjectContext)
Captures the security subject context of the calling thread and calling process.
Definition: subject.c:85
UINT64 uint64_t
Definition: types.h:77
ULONG atts
Definition: btrfs_drv.h:297
uint32_t inherit_mode(fcb *parfcb, bool is_dir)
Definition: create.c:1948
uint64_t transid
Definition: btrfs.h:288
struct _root * subvol
Definition: btrfs_drv.h:288
#define NULL
Definition: types.h:112
NTSYSAPI NTSTATUS NTAPI RtlGetOwnerSecurityDescriptor(IN PSECURITY_DESCRIPTOR SecurityDescriptor, OUT PSID *Owner, OUT PBOOLEAN OwnerDefaulted)
Definition: sd.c:257
#define __S_IFDIR
Definition: btrfs_drv.h:1754
static __inline void win_time_to_unix(LARGE_INTEGER t, BTRFS_TIME *out)
Definition: btrfs_drv.h:989
LIST_ENTRY ** hash_ptrs
Definition: btrfs_drv.h:317
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define STATUS_SUCCESS
Definition: shellext.h:65
uint32_t st_uid
Definition: btrfs.h:293
bool inode_item_changed
Definition: btrfs_drv.h:306
#define GID_NOBODY
Definition: btrfs_drv.h:91
struct _device_extension * Vcb
Definition: btrfs_drv.h:287
#define UID_NOBODY
Definition: btrfs_drv.h:90
uint32_t st_mode
Definition: btrfs.h:295

Referenced by move_across_subvols().

◆ duplicate_fcb()

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

Definition at line 463 of file fileinfo.c.

463  {
464  device_extension* Vcb = oldfcb->Vcb;
465  fcb* fcb;
466  LIST_ENTRY* le;
467 
468  // FIXME - we can skip a lot of this if the inode is about to be deleted
469 
470  fcb = create_fcb(Vcb, PagedPool); // FIXME - what if we duplicate the paging file?
471  if (!fcb) {
472  ERR("out of memory\n");
474  }
475 
476  fcb->Vcb = Vcb;
477 
478  fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
479  fcb->Header.AllocationSize = oldfcb->Header.AllocationSize;
480  fcb->Header.FileSize = oldfcb->Header.FileSize;
481  fcb->Header.ValidDataLength = oldfcb->Header.ValidDataLength;
482 
483  fcb->type = oldfcb->type;
484 
485  if (oldfcb->ads) {
486  fcb->ads = true;
487  fcb->adshash = oldfcb->adshash;
488  fcb->adsmaxlen = oldfcb->adsmaxlen;
489 
490  if (oldfcb->adsxattr.Buffer && oldfcb->adsxattr.Length > 0) {
491  fcb->adsxattr.Length = oldfcb->adsxattr.Length;
494 
495  if (!fcb->adsxattr.Buffer) {
496  ERR("out of memory\n");
497  free_fcb(fcb);
499  }
500 
503  }
504 
505  if (oldfcb->adsdata.Buffer && oldfcb->adsdata.Length > 0) {
508 
509  if (!fcb->adsdata.Buffer) {
510  ERR("out of memory\n");
511  free_fcb(fcb);
513  }
514 
516  }
517 
518  goto end;
519  }
520 
521  RtlCopyMemory(&fcb->inode_item, &oldfcb->inode_item, sizeof(INODE_ITEM));
522  fcb->inode_item_changed = true;
523 
524  if (oldfcb->sd && RtlLengthSecurityDescriptor(oldfcb->sd) > 0) {
526  if (!fcb->sd) {
527  ERR("out of memory\n");
528  free_fcb(fcb);
530  }
531 
532  RtlCopyMemory(fcb->sd, oldfcb->sd, RtlLengthSecurityDescriptor(oldfcb->sd));
533  }
534 
535  fcb->atts = oldfcb->atts;
536 
537  le = oldfcb->extents.Flink;
538  while (le != &oldfcb->extents) {
540 
541  if (!ext->ignore) {
542  extent* ext2 = ExAllocatePoolWithTag(PagedPool, offsetof(extent, extent_data) + ext->datalen, ALLOC_TAG);
543 
544  if (!ext2) {
545  ERR("out of memory\n");
546  free_fcb(fcb);
548  }
549 
550  ext2->offset = ext->offset;
551  ext2->datalen = ext->datalen;
552 
553  if (ext2->datalen > 0)
554  RtlCopyMemory(&ext2->extent_data, &ext->extent_data, ext2->datalen);
555 
556  ext2->unique = false;
557  ext2->ignore = false;
558  ext2->inserted = true;
559 
560  if (ext->csum) {
561  ULONG len;
562  EXTENT_DATA2* ed2 = (EXTENT_DATA2*)ext->extent_data.data;
563 
564  if (ext->extent_data.compression == BTRFS_COMPRESSION_NONE)
565  len = (ULONG)ed2->num_bytes;
566  else
567  len = (ULONG)ed2->size;
568 
569  len = (len * sizeof(uint32_t)) >> Vcb->sector_shift;
570 
572  if (!ext2->csum) {
573  ERR("out of memory\n");
574  free_fcb(fcb);
576  }
577 
578  RtlCopyMemory(ext2->csum, ext->csum, len);
579  } else
580  ext2->csum = NULL;
581 
582  InsertTailList(&fcb->extents, &ext2->list_entry);
583  }
584 
585  le = le->Flink;
586  }
587 
588  le = oldfcb->hardlinks.Flink;
589  while (le != &oldfcb->hardlinks) {
590  hardlink *hl = CONTAINING_RECORD(le, hardlink, list_entry), *hl2;
591 
593 
594  if (!hl2) {
595  ERR("out of memory\n");
596  free_fcb(fcb);
598  }
599 
600  hl2->parent = hl->parent;
601  hl2->index = hl->index;
602 
603  hl2->name.Length = hl2->name.MaximumLength = hl->name.Length;
604  hl2->name.Buffer = ExAllocatePoolWithTag(PagedPool, hl2->name.MaximumLength, ALLOC_TAG);
605 
606  if (!hl2->name.Buffer) {
607  ERR("out of memory\n");
608  ExFreePool(hl2);
609  free_fcb(fcb);
611  }
612 
613  RtlCopyMemory(hl2->name.Buffer, hl->name.Buffer, hl->name.Length);
614 
615  hl2->utf8.Length = hl2->utf8.MaximumLength = hl->utf8.Length;
616  hl2->utf8.Buffer = ExAllocatePoolWithTag(PagedPool, hl2->utf8.MaximumLength, ALLOC_TAG);
617 
618  if (!hl2->utf8.Buffer) {
619  ERR("out of memory\n");
620  ExFreePool(hl2->name.Buffer);
621  ExFreePool(hl2);
622  free_fcb(fcb);
624  }
625 
626  RtlCopyMemory(hl2->utf8.Buffer, hl->utf8.Buffer, hl->utf8.Length);
627 
628  InsertTailList(&fcb->hardlinks, &hl2->list_entry);
629 
630  le = le->Flink;
631  }
632 
633  if (oldfcb->reparse_xattr.Buffer && oldfcb->reparse_xattr.Length > 0) {
635 
637  if (!fcb->reparse_xattr.Buffer) {
638  ERR("out of memory\n");
639  free_fcb(fcb);
641  }
642 
644  }
645 
646  if (oldfcb->ea_xattr.Buffer && oldfcb->ea_xattr.Length > 0) {
648 
650  if (!fcb->ea_xattr.Buffer) {
651  ERR("out of memory\n");
652  free_fcb(fcb);
654  }
655 
657  }
658 
660 
661  le = oldfcb->xattrs.Flink;
662  while (le != &oldfcb->xattrs) {
664 
665  if (xa->valuelen > 0) {
666  xattr* xa2;
667 
669 
670  if (!xa2) {
671  ERR("out of memory\n");
672  free_fcb(fcb);
674  }
675 
676  xa2->namelen = xa->namelen;
677  xa2->valuelen = xa->valuelen;
678  xa2->dirty = xa->dirty;
679  memcpy(xa2->data, xa->data, xa->namelen + xa->valuelen);
680 
682  }
683 
684  le = le->Flink;
685  }
686 
687 end:
688  *pfcb = fcb;
689 
690  return STATUS_SUCCESS;
691 }
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
uint32_t adshash
Definition: btrfs_drv.h:331
void free_fcb(_Inout_ fcb *fcb)
Definition: btrfs.c:1734
#define BTRFS_COMPRESSION_NONE
Definition: btrfs.h:65
fcb * create_fcb(device_extension *Vcb, POOL_TYPE pool_type)
Definition: create.c:91
enum prop_compression_type prop_compression
Definition: btrfs_drv.h:307
ANSI_STRING ea_xattr
Definition: btrfs_drv.h:302
ANSI_STRING reparse_xattr
Definition: btrfs_drv.h:301
#define InsertTailList(ListHead, Entry)
if(dx==0 &&dy==0)
Definition: linetemp.h:174
NTSYSAPI ULONG WINAPI RtlLengthSecurityDescriptor(PSECURITY_DESCRIPTOR)
#define ALLOC_TAG
Definition: btrfs_drv.h:87
SECURITY_DESCRIPTOR * sd
Definition: btrfs_drv.h:293
#define offsetof(TYPE, MEMBER)
char ext[3]
Definition: mkdosfs.c:358
uint64_t size
Definition: btrfs.h:369
uint8_t type
Definition: btrfs_drv.h:291
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
FSRTL_ADVANCED_FCB_HEADER Header
Definition: btrfs_drv.h:283
USHORT MaximumLength
Definition: env_spec_w32.h:377
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
struct _fcb fcb
Definition: btrfs_drv.h:1364
LIST_ENTRY xattrs
Definition: btrfs_drv.h:308
#define Vcb
Definition: cdprocs.h:1415
LIST_ENTRY hardlinks
Definition: btrfs_drv.h:304
LIST_ENTRY extents
Definition: btrfs_drv.h:300
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLuint GLuint end
Definition: gl.h:1545
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
static const BYTE ext2[]
Definition: encode.c:2699
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
Definition: typedefs.h:119
static __inline FAST_IO_POSSIBLE fast_io_possible(fcb *fcb)
Definition: btrfs_drv.h:1684
INODE_ITEM inode_item
Definition: btrfs_drv.h:292
USHORT valuelen
Definition: btrfs_drv.h:277
uint64_t num_bytes
Definition: btrfs.h:371
#define ERR(fmt,...)
Definition: debug.h:110
ULONG atts
Definition: btrfs_drv.h:297
bool dirty
Definition: btrfs_drv.h:278
Definition: list.h:27
ULONG adsmaxlen
Definition: btrfs_drv.h:332
#define NULL
Definition: types.h:112
ANSI_STRING adsdata
Definition: btrfs_drv.h:334
LIST_ENTRY list_entry
Definition: btrfs_drv.h:275
bool ads
Definition: btrfs_drv.h:330
USHORT namelen
Definition: btrfs_drv.h:276
unsigned int ULONG
Definition: retypes.h:1
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define STATUS_SUCCESS
Definition: shellext.h:65
#define uint32_t
Definition: nsiface.idl:61
char data[1]
Definition: btrfs_drv.h:279
bool inode_item_changed
Definition: btrfs_drv.h:306
struct _device_extension * Vcb
Definition: btrfs_drv.h:287
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
ANSI_STRING adsxattr
Definition: btrfs_drv.h:333

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.

4245  {
4246  file_ref* fr;
4247  NTSTATUS Status;
4248  ULONG reqlen = 0;
4249  USHORT offset;
4250  bool overflow = false;
4251 
4252  // FIXME - we need a lock on filerefs' filepart
4253 
4254  if (fileref == fileref->fcb->Vcb->root_fileref) {
4255  if (fn->MaximumLength >= sizeof(WCHAR)) {
4256  fn->Buffer[0] = '\\';
4257  fn->Length = sizeof(WCHAR);
4258 
4259  if (name_offset)
4260  *name_offset = 0;
4261 
4262  return STATUS_SUCCESS;
4263  } else {
4264  if (preqlen)
4265  *preqlen = sizeof(WCHAR);
4266  fn->Length = 0;
4267 
4268  return STATUS_BUFFER_OVERFLOW;
4269  }
4270  }
4271 
4272  fr = fileref;
4273  offset = 0;
4274 
4275  while (fr->parent) {
4276  USHORT movelen;
4277 
4278  if (!fr->dc)
4279  return STATUS_INTERNAL_ERROR;
4280 
4281  if (!overflow) {
4282  if (fr->dc->name.Length + sizeof(WCHAR) + fn->Length > fn->MaximumLength)
4283  overflow = true;
4284  }
4285 
4286  if (overflow)
4287  movelen = fn->MaximumLength - fr->dc->name.Length - sizeof(WCHAR);
4288  else
4289  movelen = fn->Length;
4290 
4291  if ((!overflow || fn->MaximumLength > fr->dc->name.Length + sizeof(WCHAR)) && movelen > 0) {
4292  RtlMoveMemory(&fn->Buffer[(fr->dc->name.Length / sizeof(WCHAR)) + 1], fn->Buffer, movelen);
4293  offset += fr->dc->name.Length + sizeof(WCHAR);
4294  }
4295 
4296  if (fn->MaximumLength >= sizeof(WCHAR)) {
4297  fn->Buffer[0] = fr->fcb->ads ? ':' : '\\';
4298  fn->Length += sizeof(WCHAR);
4299 
4300  if (fn->MaximumLength > sizeof(WCHAR)) {
4301  RtlCopyMemory(&fn->Buffer[1], fr->dc->name.Buffer, min(fr->dc->name.Length, fn->MaximumLength - sizeof(WCHAR)));
4302  fn->Length += fr->dc->name.Length;
4303  }
4304 
4305  if (fn->Length > fn->MaximumLength) {
4306  fn->Length = fn->MaximumLength;
4307  overflow = true;
4308  }
4309  }
4310 
4311  reqlen += sizeof(WCHAR) + fr->dc->name.Length;
4312 
4313  fr = fr->parent;
4314  }
4315 
4316  offset += sizeof(WCHAR);
4317 
4318  if (overflow) {
4319  if (preqlen)
4320  *preqlen = reqlen;
4322  } else {
4323  if (name_offset)
4324  *name_offset = offset;
4325 
4327  }
4328 
4329  return Status;
4330 }
struct _file_ref * parent
Definition: btrfs_drv.h:352
static GLenum _GLUfuncptr fn
Definition: wgl_font.c:159
LONG NTSTATUS
Definition: precomp.h:26
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264
#define STATUS_INTERNAL_ERROR
Definition: ntstatus.h:465
Status
Definition: gdiplustypes.h:24
__wchar_t WCHAR
Definition: xmlstorage.h:180
GLintptr offset
Definition: glext.h:5920
struct _file_ref * fileref
Definition: btrfs_drv.h:305
dir_child * dc
Definition: btrfs_drv.h:353
fcb * fcb
Definition: btrfs_drv.h:342
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
unsigned short USHORT
Definition: pedump.c:61
#define min(a, b)
Definition: monoChain.cc:55
bool ads
Definition: btrfs_drv.h:330
unsigned int ULONG
Definition: retypes.h:1
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define STATUS_SUCCESS
Definition: shellext.h:65
UNICODE_STRING name
Definition: btrfs_drv.h:256

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.

4389  {
4391 
4392  if (fcb->ads) {
4393  if (!ccb->fileref || !ccb->fileref->parent) {
4394  ERR("no fileref for stream\n");
4395  return STATUS_INTERNAL_ERROR;
4396  }
4397 
4398  ati->FileAttributes = ccb->fileref->parent->fcb->atts;
4399  } else
4400  ati->FileAttributes = fcb->atts;
4401 
4403  ati->ReparseTag = 0;
4404  else
4406 
4407  return STATUS_SUCCESS;
4408 }
struct _file_ref * parent
Definition: btrfs_drv.h:352
#define STATUS_INTERNAL_ERROR
Definition: ntstatus.h:465
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
#define FILE_ATTRIBUTE_REPARSE_POINT
Definition: ntifs_ex.h:381
struct _FILE_ATTRIBUTE_TAG_INFORMATION FILE_ATTRIBUTE_TAG_INFORMATION
#define ERR(fmt,...)
Definition: debug.h:110
ULONG get_reparse_tag_fcb(fcb *fcb)
Definition: dirctrl.c:83
ULONG atts
Definition: btrfs_drv.h:297
bool ads
Definition: btrfs_drv.h:330
#define STATUS_SUCCESS
Definition: shellext.h:65
file_ref * fileref
Definition: btrfs_drv.h:383

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.

4111  {
4112  RtlZeroMemory(fbi, sizeof(FILE_BASIC_INFORMATION));
4113 
4114  *length -= sizeof(FILE_BASIC_INFORMATION);
4115 
4116  if (fcb == fcb->Vcb->dummy_fcb) {
4118 
4120  fbi->CreationTime = fbi->LastAccessTime = fbi->LastWriteTime = fbi->ChangeTime = time;
4121  } else {
4126  }
4127 
4128  if (fcb->ads) {
4129  if (!fileref || !fileref->parent) {
4130  ERR("no fileref for stream\n");
4131  return STATUS_INTERNAL_ERROR;
4132  } else
4133  fbi->FileAttributes = fileref->parent->fcb->atts == 0 ? FILE_ATTRIBUTE_NORMAL : fileref->parent->fcb->atts;
4134  } else
4136 
4137  return STATUS_SUCCESS;
4138 }
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
BTRFS_TIME otime
Definition: btrfs.h:304
LARGE_INTEGER LastAccessTime
Definition: nt_native.h:940
__u16 time
Definition: mkdosfs.c:366
BTRFS_TIME st_ctime
Definition: btrfs.h:302
#define STATUS_INTERNAL_ERROR
Definition: ntstatus.h:465
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
BTRFS_TIME st_mtime
Definition: btrfs.h:303
static __inline uint64_t unix_time_to_win(BTRFS_TIME *t)
Definition: recv.cpp:1067
LARGE_INTEGER LastWriteTime
Definition: nt_native.h:941
struct _file_ref * fileref
Definition: btrfs_drv.h:305
BTRFS_TIME st_atime
Definition: btrfs.h:301
LARGE_INTEGER CreationTime
Definition: nt_native.h:939
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
LARGE_INTEGER ChangeTime
Definition: nt_native.h:942
#define ERR(fmt,...)
Definition: debug.h:110
ULONG atts
Definition: btrfs_drv.h:297
bool ads
Definition: btrfs_drv.h:330
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define STATUS_SUCCESS
Definition: shellext.h:65
struct _device_extension * Vcb
Definition: btrfs_drv.h:287
LONGLONG QuadPart
Definition: typedefs.h:114
#define FILE_BASIC_INFORMATION
Definition: disk.h:53

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.

5019  {
5021 
5023 
5024  return STATUS_SUCCESS;
5025 }
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
struct _FILE_CASE_SENSITIVE_INFORMATION FILE_CASE_SENSITIVE_INFORMATION
#define FILE_CS_FLAG_CASE_SENSITIVE_DIR
Definition: btrfs_drv.h:165
bool case_sensitive
Definition: btrfs_drv.h:310
#define STATUS_SUCCESS
Definition: shellext.h:65

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.

5029  {
5031 
5032  memset(fci, 0, sizeof(FILE_COMPRESSION_INFORMATION));
5033 
5034  if (fcb->ads)
5036  else if (!S_ISDIR(fcb->inode_item.st_mode))
5038 
5039  return STATUS_SUCCESS;
5040 }
struct _FILE_COMPRESSION_INFORMATION FILE_COMPRESSION_INFORMATION
LARGE_INTEGER CompressedFileSize
Definition: iotypes.h:5849
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
uint64_t st_size
Definition: btrfs.h:289
#define S_ISDIR(mode)
Definition: various.h:18
INODE_ITEM inode_item
Definition: btrfs_drv.h:292
ANSI_STRING adsdata
Definition: btrfs_drv.h:334
bool ads
Definition: btrfs_drv.h:330
#define STATUS_SUCCESS
Definition: shellext.h:65
#define memset(x, y, z)
Definition: compat.h:39
LONGLONG QuadPart
Definition: typedefs.h:114
uint32_t st_mode
Definition: btrfs.h:295

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.

4222  {
4223  *length -= sizeof(FILE_EA_INFORMATION);
4224 
4225  /* This value appears to be the size of the structure NTFS stores on disk, and not,
4226  * as might be expected, the size of FILE_FULL_EA_INFORMATION (which is what we store).
4227  * The formula is 4 bytes as a header, followed by 5 + NameLength + ValueLength for each
4228  * item. */
4229 
4230  eai->EaSize = fcb->ealen;
4231 
4232  return STATUS_SUCCESS;
4233 }
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
ULONG ealen
Definition: btrfs_drv.h:303
struct _FILE_EA_INFORMATION FILE_EA_INFORMATION
#define STATUS_SUCCESS
Definition: shellext.h:65

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.

4875  {
4876  RtlCopyMemory(&fii->VolumeSerialNumber, &fcb->Vcb->superblock.uuid.uuid[8], sizeof(uint64_t));
4877  RtlCopyMemory(&fii->FileId.Identifier[0], &fcb->inode, sizeof(uint64_t));
4878  RtlCopyMemory(&fii->FileId.Identifier[sizeof(uint64_t)], &fcb->subvol->id, sizeof(uint64_t));
4879 
4880  *length -= sizeof(FILE_ID_INFORMATION);
4881 
4882  return STATUS_SUCCESS;
4883 }
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
uint64_t inode
Definition: btrfs_drv.h:289
ULONGLONG VolumeSerialNumber
Definition: fileinfo.c:35
struct _FILE_ID_INFORMATION FILE_ID_INFORMATION
UCHAR Identifier[16]
Definition: btrfs_drv.h:162
UINT64 uint64_t
Definition: types.h:77
struct _root * subvol
Definition: btrfs_drv.h:288
FILE_ID_128 FileId
Definition: fileinfo.c:36
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define STATUS_SUCCESS
Definition: shellext.h:65
struct _device_extension * Vcb
Definition: btrfs_drv.h:287

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.

4214  {
4215  *length -= sizeof(FILE_INTERNAL_INFORMATION);
4216 
4218 
4219  return STATUS_SUCCESS;
4220 }
struct _FILE_INTERNAL_INFORMATION FILE_INTERNAL_INFORMATION
static __inline uint64_t make_file_id(root *r, uint64_t inode)
Definition: btrfs_drv.h:1012
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
uint64_t inode
Definition: btrfs_drv.h:289
struct _root * subvol
Definition: btrfs_drv.h:288
#define STATUS_SUCCESS
Definition: shellext.h:65
LONGLONG QuadPart
Definition: typedefs.h:114

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.

4332  {
4333  ULONG reqlen;
4335  NTSTATUS Status;
4336  static const WCHAR datasuf[] = {':','$','D','A','T','A',0};
4337  uint16_t datasuflen = sizeof(datasuf) - sizeof(WCHAR);
4338 
4339  if (!fileref) {
4340  ERR("called without fileref\n");
4341  return STATUS_INVALID_PARAMETER;
4342  }
4343 
4345 
4346  TRACE("maximum length is %li\n", *length);
4347  fni->FileNameLength = 0;
4348 
4349  fni->FileName[0] = 0;
4350 
4351  fn.Buffer = fni->FileName;
4352  fn.Length = 0;
4353  fn.MaximumLength = (uint16_t)*length;
4354 
4355  Status = fileref_get_filename(fileref, &fn, NULL, &reqlen);
4357  ERR("fileref_get_filename returned %08lx\n", Status);
4358  return Status;
4359  }
4360 
4361  if (fcb->ads) {
4363  reqlen += datasuflen;
4364  else {
4365  if (fn.Length + datasuflen > fn.MaximumLength) {
4366  RtlCopyMemory(&fn.Buffer[fn.Length / sizeof(WCHAR)], datasuf, fn.MaximumLength - fn.Length);
4367  reqlen += datasuflen;
4369  } else {
4370  RtlCopyMemory(&fn.Buffer[fn.Length / sizeof(WCHAR)], datasuf, datasuflen);
4371  fn.Length += datasuflen;
4372  }
4373  }
4374  }
4375 
4376  if (Status == STATUS_BUFFER_OVERFLOW) {
4377  *length = -1;
4378  fni->FileNameLength = reqlen;
4379  TRACE("%.*S (truncated)\n", (int)(fn.Length / sizeof(WCHAR)), fn.Buffer);
4380  } else {
4381  *length -= fn.Length;
4382  fni->FileNameLength = fn.Length;
4383  TRACE("%.*S\n", (int)(fn.Length / sizeof(WCHAR)), fn.Buffer);
4384  }
4385 
4386  return Status;
4387 }
static GLenum _GLUfuncptr fn
Definition: wgl_font.c:159
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
LONG NTSTATUS
Definition: precomp.h:26
unsigned short int uint16_t
Definition: acefiex.h:54
#define uint16_t
Definition: nsiface.idl:60
long LONG
Definition: pedump.c:60
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
#define offsetof(TYPE, MEMBER)
Status
Definition: gdiplustypes.h:24
#define TRACE(s)
Definition: solgame.cpp:4
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
struct _file_ref * fileref
Definition: btrfs_drv.h:305
NTSTATUS fileref_get_filename(file_ref *fileref, PUNICODE_STRING fn, USHORT *name_offset, ULONG *preqlen)
Definition: fileinfo.c:4245
#define ERR(fmt,...)
Definition: debug.h:110
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
#define NULL
Definition: types.h:112
bool ads
Definition: btrfs_drv.h:330
unsigned int ULONG
Definition: retypes.h:1
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263

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.

4140  {
4141  INODE_ITEM* ii;
4142 
4143  if (*length < (LONG)sizeof(FILE_NETWORK_OPEN_INFORMATION)) {
4144  WARN("overflow\n");
4145  return STATUS_BUFFER_OVERFLOW;
4146  }
4147 
4149 
4151 
4152  if (fcb->ads) {
4153  if (!fileref || !fileref->parent) {
4154  ERR("no fileref for stream\n");
4155  return STATUS_INTERNAL_ERROR;
4156  }
4157 
4158  ii = &fileref->parent->fcb->inode_item;
4159  } else
4160  ii = &fcb->inode_item;
4161 
4162  if (fcb == fcb->Vcb->dummy_fcb) {
4164 
4166  fnoi->CreationTime = fnoi->LastAccessTime = fnoi->LastWriteTime = fnoi->ChangeTime = time;
4167  } else {
4172  }
4173 
4174  if (fcb->ads) {
4176  fnoi->FileAttributes = fileref->parent->fcb->atts == 0 ? FILE_ATTRIBUTE_NORMAL : fileref->parent->fcb->atts;
4177  } else {
4180  fnoi->FileAttributes = fcb->atts == 0 ? FILE_ATTRIBUTE_NORMAL : fcb->atts;
4181  }
4182 
4183  return STATUS_SUCCESS;
4184 }
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
BTRFS_TIME otime
Definition: btrfs.h:304
#define WARN(fmt,...)
Definition: debug.h:112
__u16 time
Definition: mkdosfs.c:366
BTRFS_TIME st_ctime
Definition: btrfs.h:302
struct _FILE_NETWORK_OPEN_INFORMATION FILE_NETWORK_OPEN_INFORMATION
#define STATUS_INTERNAL_ERROR
Definition: ntstatus.h:465
long LONG
Definition: pedump.c:60
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
BTRFS_TIME st_mtime
Definition: btrfs.h:303
static __inline uint64_t unix_time_to_win(BTRFS_TIME *t)
Definition: recv.cpp:1067
uint64_t st_size
Definition: btrfs.h:289
#define S_ISDIR(mode)
Definition: various.h:18
struct _file_ref * fileref
Definition: btrfs_drv.h:305
BTRFS_TIME st_atime
Definition: btrfs.h:301
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
INODE_ITEM inode_item
Definition: btrfs_drv.h:292
#define ERR(fmt,...)
Definition: debug.h:110
ULONG atts
Definition: btrfs_drv.h:297
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
static __inline uint64_t fcb_alloc_size(fcb *fcb)
Definition: btrfs_drv.h:1824
ANSI_STRING adsdata
Definition: btrfs_drv.h:334
bool ads
Definition: btrfs_drv.h:330
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define STATUS_SUCCESS
Definition: shellext.h:65
struct _device_extension * Vcb
Definition: btrfs_drv.h:287
LONGLONG QuadPart
Definition: typedefs.h:114
uint32_t st_mode
Definition: btrfs.h:295

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.

4235  {
4237 
4238  *length -= sizeof(FILE_POSITION_INFORMATION);
4239 
4240  fpi->CurrentByteOffset = FileObject->CurrentByteOffset;
4241 
4242  return STATUS_SUCCESS;
4243 }
struct _FILE_POSITION_INFORMATION FILE_POSITION_INFORMATION
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
LARGE_INTEGER CurrentByteOffset
Definition: nt_native.h:955
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:547
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define STATUS_SUCCESS
Definition: shellext.h:65

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.

4186  {
4188 
4189  *length -= sizeof(FILE_STANDARD_INFORMATION);
4190 
4191  if (fcb->ads) {
4192  if (!fileref || !fileref->parent) {
4193  ERR("no fileref for stream\n");
4194  return STATUS_INTERNAL_ERROR;
4195  }
4196 
4198  fsi->NumberOfLinks = fileref->parent->fcb->inode_item.st_nlink;
4199  fsi->Directory = false;
4200  } else {
4205  }
4206 
4207  TRACE("length = %I64u\n", fsi->EndOfFile.QuadPart);
4208 
4209  fsi->DeletePending = fileref ? fileref->delete_on_close : false;
4210 
4211  return STATUS_SUCCESS;
4212 }
#define STATUS_INTERNAL_ERROR
Definition: ntstatus.h:465
uint32_t st_nlink
Definition: btrfs.h:292
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
uint64_t st_size
Definition: btrfs.h:289
#define TRACE(s)
Definition: solgame.cpp:4
#define S_ISDIR(mode)
Definition: various.h:18
struct _file_ref * fileref
Definition: btrfs_drv.h:305
LARGE_INTEGER AllocationSize
Definition: propsheet.cpp:54
#define FILE_STANDARD_INFORMATION
Definition: disk.h:54
INODE_ITEM inode_item
Definition: btrfs_drv.h:292
#define ERR(fmt,...)
Definition: debug.h:110
static __inline uint64_t fcb_alloc_size(fcb *fcb)
Definition: btrfs_drv.h:1824
ANSI_STRING adsdata
Definition: btrfs_drv.h:334
bool ads
Definition: btrfs_drv.h:330
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define STATUS_SUCCESS
Definition: shellext.h:65
LONGLONG QuadPart
Definition: typedefs.h:114
uint32_t st_mode
Definition: btrfs.h:295

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.

4520  {
4521  TRACE("FileStandardLinkInformation\n");
4522 
4523  // FIXME - NumberOfAccessibleLinks should subtract open links which have been marked as delete_on_close
4524 
4527  fsli->DeletePending = fileref ? fileref->delete_on_close : false;
4528  fsli->Directory = (!fcb->ads && fcb->type == BTRFS_TYPE_DIRECTORY) ? true : false;
4529 
4531 
4532  return STATUS_SUCCESS;
4533 }
uint32_t st_nlink
Definition: btrfs.h:292
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
#define BTRFS_TYPE_DIRECTORY
Definition: shellext.h:86
uint8_t type
Definition: btrfs_drv.h:291
#define TRACE(s)
Definition: solgame.cpp:4
struct _file_ref * fileref
Definition: btrfs_drv.h:305
INODE_ITEM inode_item
Definition: btrfs_drv.h:292
bool ads
Definition: btrfs_drv.h:330
#define STATUS_SUCCESS
Definition: shellext.h:65
struct _FILE_STANDARD_LINK_INFORMATION FILE_STANDARD_LINK_INFORMATION

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.

4885  {
4886  INODE_ITEM* ii;
4887 
4889 
4890  if (fcb->ads)
4891  ii = &ccb->fileref->parent->fcb->inode_item;
4892  else
4893  ii = &fcb->inode_item;
4894 
4895  if (fcb == fcb->Vcb->dummy_fcb) {
4897 
4899  fsi->CreationTime = fsi->LastAccessTime = fsi->LastWriteTime = fsi->ChangeTime = time;
4900  } else {
4905  }
4906 
4907  if (fcb->ads) {
4909  fsi->FileAttributes = ccb->fileref->parent->fcb->atts == 0 ? FILE_ATTRIBUTE_NORMAL : ccb->fileref->parent->fcb->atts;
4910  } else {
4914  }
4915 
4916  if (fcb->type == BTRFS_TYPE_SOCKET)
4918  else if (fcb->type == BTRFS_TYPE_FIFO)
4920  else if (fcb->type == BTRFS_TYPE_CHARDEV)
4922  else if (fcb->type == BTRFS_TYPE_BLOCKDEV)
4924  else if (!(fsi->FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT))
4925  fsi->ReparseTag = 0;
4926  else
4928 
4931 
4932  if (fcb->ads)
4933  fsi->NumberOfLinks = ccb->fileref->parent->fcb->inode_item.st_nlink;
4934  else
4936 
4937  fsi->EffectiveAccess = ccb->access;
4938 
4939  *length -= sizeof(FILE_STAT_INFORMATION);
4940 
4941  return STATUS_SUCCESS;
4942 }
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
LARGE_INTEGER EndOfFile
Definition: fileinfo.c:46
struct _file_ref * parent
Definition: btrfs_drv.h:352
#define BTRFS_TYPE_SOCKET
Definition: shellext.h:90
BTRFS_TIME otime
Definition: btrfs.h:304
#define IO_REPARSE_TAG_LX_FIFO
Definition: btrfs_drv.h:121
#define BTRFS_TYPE_BLOCKDEV
Definition: shellext.h:88
#define BTRFS_TYPE_FIFO
Definition: shellext.h:89
LARGE_INTEGER ChangeTime
Definition: fileinfo.c:44
__u16 time
Definition: mkdosfs.c:366
ACCESS_MASK access
Definition: btrfs_drv.h:382
#define BTRFS_TYPE_CHARDEV
Definition: shellext.h:87
LARGE_INTEGER LastAccessTime
Definition: fileinfo.c:42
BTRFS_TIME st_ctime
Definition: btrfs.h:302
static __inline uint64_t make_file_id(root *r, uint64_t inode)
Definition: btrfs_drv.h:1012
struct _FILE_STAT_INFORMATION FILE_STAT_INFORMATION
uint32_t st_nlink
Definition: btrfs.h:292
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
LARGE_INTEGER FileId
Definition: fileinfo.c:40
uint8_t type
Definition: btrfs_drv.h:291
LARGE_INTEGER CreationTime
Definition: fileinfo.c:41
#define FILE_ATTRIBUTE_REPARSE_POINT
Definition: ntifs_ex.h:381
BTRFS_TIME st_mtime
Definition: btrfs.h:303
static __inline uint64_t unix_time_to_win(BTRFS_TIME *t)
Definition: recv.cpp:1067
uint64_t st_size
Definition: btrfs.h:289
uint64_t inode
Definition: btrfs_drv.h:289
#define S_ISDIR(mode)
Definition: various.h:18
#define IO_REPARSE_TAG_LX_BLK
Definition: btrfs_drv.h:123
BTRFS_TIME st_atime
Definition: btrfs.h:301
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
LARGE_INTEGER AllocationSize
Definition: fileinfo.c:45
INODE_ITEM inode_item
Definition: btrfs_drv.h:292
ULONG get_reparse_tag_fcb(fcb *fcb)
Definition: dirctrl.c:83
ULONG atts
Definition: btrfs_drv.h:297
#define IO_REPARSE_TAG_AF_UNIX
Definition: btrfs_drv.h:120
static __inline uint64_t fcb_alloc_size(fcb *fcb)
Definition: btrfs_drv.h:1824
struct _root * subvol
Definition: btrfs_drv.h:288
ANSI_STRING adsdata
Definition: btrfs_drv.h:334
#define IO_REPARSE_TAG_LX_CHR
Definition: btrfs_drv.h:122
bool ads
Definition: btrfs_drv.h:330
LARGE_INTEGER LastWriteTime
Definition: fileinfo.c:43
#define STATUS_SUCCESS
Definition: shellext.h:65
file_ref * fileref
Definition: btrfs_drv.h:383
ACCESS_MASK EffectiveAccess
Definition: fileinfo.c:50
struct _device_extension * Vcb
Definition: btrfs_drv.h:287
LONGLONG QuadPart
Definition: typedefs.h:114
uint32_t st_mode
Definition: btrfs.h:295

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.

4944  {
4945  INODE_ITEM* ii;
4946 
4948 
4949  if (fcb->ads)
4950  ii = &ccb->fileref->parent->fcb->inode_item;
4951  else
4952  ii = &fcb->inode_item;
4953 
4954  if (fcb == fcb->Vcb->dummy_fcb) {
4956 
4958  fsli->CreationTime = fsli->LastAccessTime = fsli->LastWriteTime = fsli->ChangeTime = time;
4959  } else {
4964  }
4965 
4966  if (fcb->ads) {
4968  fsli->FileAttributes = ccb->fileref->parent->fcb->atts == 0 ? FILE_ATTRIBUTE_NORMAL : ccb->fileref->parent->fcb->atts;
4969  } else {
4972  fsli->FileAttributes = fcb->atts == 0 ? FILE_ATTRIBUTE_NORMAL : fcb->atts;
4973  }
4974 
4975  if (fcb->type == BTRFS_TYPE_SOCKET)
4977  else if (fcb->type == BTRFS_TYPE_FIFO)
4979  else if (fcb->type == BTRFS_TYPE_CHARDEV)
4981  else if (fcb->type == BTRFS_TYPE_BLOCKDEV)
4983  else if (!(fsli->FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT))
4984  fsli->ReparseTag = 0;
4985  else
4987 
4990 
4991  if (fcb->ads)
4992  fsli->NumberOfLinks = ccb->fileref->parent->fcb->inode_item.st_nlink;
4993  else
4995 
4996  fsli->EffectiveAccess = ccb->access;
4998 
4999  if (fcb->case_sensitive)
5001 
5002  fsli->LxUid = ii->st_uid;
5003  fsli->LxGid = ii->st_gid;
5004  fsli->LxMode = ii->st_mode;
5005 
5006  if (ii->st_mode & __S_IFBLK || ii->st_mode & __S_IFCHR) {
5007  fsli->LxDeviceIdMajor = (ii->st_rdev & 0xFFFFFFFFFFF00000) >> 20;
5008  fsli->LxDeviceIdMinor = (ii->st_rdev & 0xFFFFF);
5009  } else {
5010  fsli->LxDeviceIdMajor = 0;
5011  fsli->LxDeviceIdMinor = 0;
5012  }
5013 
5014  *length -= sizeof(FILE_STAT_LX_INFORMATION);
5015 
5016  return STATUS_SUCCESS;
5017 }
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
struct _file_ref * parent
Definition: btrfs_drv.h:352
#define LX_FILE_METADATA_HAS_DEVICE_ID
Definition: fileinfo.c:76
#define BTRFS_TYPE_SOCKET
Definition: shellext.h:90
BTRFS_TIME otime
Definition: btrfs.h:304
#define IO_REPARSE_TAG_LX_FIFO
Definition: btrfs_drv.h:121
#define BTRFS_TYPE_BLOCKDEV
Definition: shellext.h:88
LARGE_INTEGER CreationTime
Definition: fileinfo.c:55
#define BTRFS_TYPE_FIFO
Definition: shellext.h:89
__u16 time
Definition: mkdosfs.c:366
ACCESS_MASK access
Definition: btrfs_drv.h:382
#define BTRFS_TYPE_CHARDEV
Definition: shellext.h:87
BTRFS_TIME st_ctime
Definition: btrfs.h:302
#define LX_FILE_METADATA_HAS_MODE
Definition: fileinfo.c:75
static __inline uint64_t make_file_id(root *r, uint64_t inode)
Definition: btrfs_drv.h:1012
uint32_t st_gid
Definition: btrfs.h:294
uint32_t st_nlink
Definition: btrfs.h:292
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
LARGE_INTEGER LastAccessTime
Definition: fileinfo.c:56
uint8_t type
Definition: btrfs_drv.h:291
#define FILE_ATTRIBUTE_REPARSE_POINT
Definition: ntifs_ex.h:381
BTRFS_TIME st_mtime
Definition: btrfs.h:303
static __inline uint64_t unix_time_to_win(BTRFS_TIME *t)
Definition: recv.cpp:1067
uint64_t st_size
Definition: btrfs.h:289
#define LX_FILE_CASE_SENSITIVE_DIR
Definition: fileinfo.c:77
uint64_t inode
Definition: btrfs_drv.h:289
uint64_t st_rdev
Definition: btrfs.h:296
#define S_ISDIR(mode)
Definition: various.h:18
#define IO_REPARSE_TAG_LX_BLK
Definition: btrfs_drv.h:123
bool case_sensitive
Definition: btrfs_drv.h:310
#define __S_IFCHR
Definition: btrfs_drv.h:1755
BTRFS_TIME st_atime
Definition: btrfs.h:301
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
#define LX_FILE_METADATA_HAS_GID
Definition: fileinfo.c:74
INODE_ITEM inode_item
Definition: btrfs_drv.h:292
LARGE_INTEGER EndOfFile
Definition: fileinfo.c:60
ULONG get_reparse_tag_fcb(fcb *fcb)
Definition: dirctrl.c:83
ULONG atts
Definition: btrfs_drv.h:297
#define IO_REPARSE_TAG_AF_UNIX
Definition: btrfs_drv.h:120
static __inline uint64_t fcb_alloc_size(fcb *fcb)
Definition: btrfs_drv.h:1824
struct _root * subvol
Definition: btrfs_drv.h:288
ANSI_STRING adsdata
Definition: btrfs_drv.h:334
#define IO_REPARSE_TAG_LX_CHR
Definition: btrfs_drv.h:122
struct _FILE_STAT_LX_INFORMATION FILE_STAT_LX_INFORMATION
LARGE_INTEGER ChangeTime
Definition: fileinfo.c:58
bool ads
Definition: btrfs_drv.h:330
#define LX_FILE_METADATA_HAS_UID
Definition: fileinfo.c:73
LARGE_INTEGER AllocationSize
Definition: fileinfo.c:59
LARGE_INTEGER LastWriteTime
Definition: fileinfo.c:57
#define __S_IFBLK
Definition: btrfs_drv.h:1756
#define STATUS_SUCCESS
Definition: shellext.h:65
file_ref * fileref
Definition: btrfs_drv.h:383
uint32_t st_uid
Definition: btrfs.h:293
struct _device_extension * Vcb
Definition: btrfs_drv.h:287
ACCESS_MASK EffectiveAccess
Definition: fileinfo.c:64
LONGLONG QuadPart
Definition: typedefs.h:114
LARGE_INTEGER FileId
Definition: fileinfo.c:54
uint32_t st_mode
Definition: btrfs.h:295

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.

4410  {
4411  LONG reqsize;
4412  LIST_ENTRY* le;
4413  FILE_STREAM_INFORMATION *entry, *lastentry;
4414  NTSTATUS Status;
4415 
4416  static const WCHAR datasuf[] = L":$DATA";
4417  UNICODE_STRING suf;
4418 
4419  if (!fileref) {
4420  ERR("fileref was NULL\n");
4421  return STATUS_INVALID_PARAMETER;
4422  }
4423 
4424  suf.Buffer = (WCHAR*)datasuf;
4425  suf.Length = suf.MaximumLength = sizeof(datasuf) - sizeof(WCHAR);
4426 
4427  if (fileref->fcb->type != BTRFS_TYPE_DIRECTORY)
4428  reqsize = sizeof(FILE_STREAM_INFORMATION) - sizeof(WCHAR) + suf.Length + sizeof(WCHAR);
4429  else
4430  reqsize = 0;
4431 
4432  ExAcquireResourceSharedLite(&fileref->fcb->nonpaged->dir_children_lock, true);
4433 
4434  le = fileref->fcb->dir_children_index.Flink;
4435  while (le != &fileref->fcb->dir_children_index) {
4436  dir_child* dc = CONTAINING_RECORD(le, dir_child, list_entry_index);
4437 
4438  if (dc->index == 0) {
4439  reqsize = (ULONG)sector_align(reqsize, sizeof(LONGLONG));
4440  reqsize += sizeof(FILE_STREAM_INFORMATION) - sizeof(WCHAR) + suf.Length + sizeof(WCHAR) + dc->name.Length;
4441  } else
4442  break;
4443 
4444  le = le->Flink;
4445  }
4446 
4447  TRACE("length = %li, reqsize = %lu\n", *length, reqsize);
4448 
4449  if (reqsize > *length) {
4451  goto end;
4452  }
4453 
4454  entry = fsi;
4455  lastentry = NULL;
4456 
4457  if (fileref->fcb->type != BTRFS_TYPE_DIRECTORY) {
4458  ULONG off;
4459 
4460  entry->NextEntryOffset = 0;
4461  entry->StreamNameLength = suf.Length + sizeof(WCHAR);
4462  entry->StreamSize.QuadPart = fileref->fcb->inode_item.st_size;
4463  entry->StreamAllocationSize.QuadPart = fcb_alloc_size(fileref->fcb);
4464 
4465  entry->StreamName[0] = ':';
4466  RtlCopyMemory(&entry->StreamName[1], suf.Buffer, suf.Length);
4467 
4468  off = (ULONG)sector_align(sizeof(FILE_STREAM_INFORMATION) - sizeof(WCHAR) + suf.Length + sizeof(WCHAR), sizeof(LONGLONG));
4469 
4470  lastentry = entry;
4472  }
4473 
4474  le = fileref->fcb->dir_children_index.Flink;
4475  while (le != &fileref->fcb->dir_children_index) {
4476  dir_child* dc = CONTAINING_RECORD(le, dir_child, list_entry_index);
4477 
4478  if (dc->index == 0) {
4479  ULONG off;
4480 
4481  entry->NextEntryOffset = 0;
4482  entry->StreamNameLength = dc->name.Length + suf.Length + sizeof(WCHAR);
4483 
4484  if (dc->fileref)
4485  entry->StreamSize.QuadPart = dc->fileref->fcb->adsdata.Length;
4486  else
4487  entry->StreamSize.QuadPart = dc->size;
4488 
4489  entry->StreamAllocationSize.QuadPart = entry->StreamSize.QuadPart;
4490 
4491  entry->StreamName[0] = ':';
4492 
4493  RtlCopyMemory(&entry->StreamName[1], dc->name.Buffer, dc->name.Length);
4494  RtlCopyMemory(&entry->StreamName[1 + (dc->name.Length / sizeof(WCHAR))], suf.Buffer, suf.Length);
4495 
4496  if (lastentry)
4497  lastentry->NextEntryOffset = (uint32_t)((uint8_t*)entry - (uint8_t*)lastentry);
4498 
4499  off = (ULONG)sector_align(sizeof(FILE_STREAM_INFORMATION) - sizeof(WCHAR) + suf.Length + sizeof(WCHAR) + dc->name.Length, sizeof(LONGLONG));
4500 
4501  lastentry = entry;
4503  } else
4504  break;
4505 
4506  le = le->Flink;
4507  }
4508 
4509  *length -= reqsize;
4510 
4512 
4513 end:
4514  ExReleaseResourceLite(&fileref->fcb->nonpaged->dir_children_lock);
4515 
4516  return Status;
4517 }
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
LONG NTSTATUS
Definition: precomp.h:26
struct _FILE_STREAM_INFORMATION FILE_STREAM_INFORMATION
#define L(x)
Definition: ntvdm.h:50
long LONG
Definition: pedump.c:60
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
#define BTRFS_TYPE_DIRECTORY
Definition: shellext.h:86
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
Status
Definition: gdiplustypes.h:24
int64_t LONGLONG
Definition: typedefs.h:68
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
#define TRACE(s)
Definition: solgame.cpp:4
__wchar_t WCHAR
Definition: xmlstorage.h:180
struct _file_ref * fileref
Definition: btrfs_drv.h:305
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817
GLuint GLuint end
Definition: gl.h:1545
uint32_t entry
Definition: isohybrid.c:63
Definition: typedefs.h:119
BYTE uint8_t
Definition: msvideo1.c:66
#define ERR(fmt,...)
Definition: debug.h:110
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
static __inline uint64_t fcb_alloc_size(fcb *fcb)
Definition: btrfs_drv.h:1824
#define NULL
Definition: types.h:112
BOOLEAN NTAPI ExAcquireResourceSharedLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:885
unsigned int ULONG
Definition: retypes.h:1
static const WCHAR dc[]
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define STATUS_SUCCESS
Definition: shellext.h:65
#define uint32_t
Definition: nsiface.idl:61
static uint64_t __inline sector_align(uint64_t n, uint64_t a)

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.

4704  {
4705  NTSTATUS Status;
4706  LIST_ENTRY* le;
4707  LONG bytes_needed;
4709  bool overflow = false;
4710  fcb* fcb = fileref->fcb;
4711  ULONG len;
4712 
4713  if (fcb->ads)
4714  return STATUS_INVALID_PARAMETER;
4715 
4717  return STATUS_INVALID_PARAMETER;
4718 
4719  RtlZeroMemory(flfii, *length);
4720 
4722  len = bytes_needed;
4723  flefii = NULL;
4724 
4725  ExAcquireResourceSharedLite(fcb->Header.Resource, true);
4726 
4727  if (fcb->inode == SUBVOL_ROOT_INODE) {
4728  ULONG namelen;
4729 
4730  if (fcb == fcb->Vcb->root_fileref->fcb)
4731  namelen = sizeof(WCHAR);
4732  else
4733  namelen = fileref->dc->name.Length;
4734 
4736 
4737  if (bytes_needed > *length)
4738  overflow = true;
4739 
4740  if (!overflow) {
4741  flefii = &flfii->Entry;
4742 
4743  flefii->NextEntryOffset = 0;
4744 
4745  if (fcb == fcb->Vcb->root_fileref->fcb) {
4746  RtlZeroMemory(&flefii->ParentFileId.Identifier[0], sizeof(FILE_ID_128));
4747  flefii->FileNameLength = 1;
4748  flefii->FileName[0] = '.';
4749  } else {
4750  RtlCopyMemory(&flefii->ParentFileId.Identifier[0], &fileref->parent->fcb->inode, sizeof(uint64_t));
4751  RtlCopyMemory(&flefii->ParentFileId.Identifier[sizeof(uint64_t)], &fileref->parent->fcb->subvol->id, sizeof(uint64_t));
4752 
4753  flefii->FileNameLength = fileref->dc->name.Length / sizeof(WCHAR);
4754  RtlCopyMemory(flefii->FileName, fileref->dc->name.Buffer, fileref->dc->name.Length);
4755  }
4756 
4757  flfii->EntriesReturned++;
4758 
4759  len = bytes_needed;
4760  }
4761  } else {
4762  ExAcquireResourceExclusiveLite(&fcb->Vcb->fileref_lock, true);
4763 
4764  if (IsListEmpty(&fcb->hardlinks)) {
4765  bytes_needed += offsetof(FILE_LINK_ENTRY_FULL_ID_INFORMATION, FileName[0]) + fileref->dc->name.Length;
4766 
4767  if (bytes_needed > *length)
4768  overflow = true;
4769 
4770  if (!overflow) {
4771  flefii = &flfii->Entry;
4772 
4773  flefii->NextEntryOffset = 0;
4774 
4775  RtlCopyMemory(&flefii->ParentFileId.Identifier[0], &fileref->parent->fcb->inode, sizeof(uint64_t));
4776  RtlCopyMemory(&flefii->ParentFileId.Identifier[sizeof(uint64_t)], &fileref->parent->fcb->subvol->id, sizeof(uint64_t));
4777 
4778  flefii->FileNameLength = fileref->dc->name.Length / sizeof(WCHAR);
4779  RtlCopyMemory(flefii->FileName, fileref->dc->name.Buffer, fileref->dc->name.Length);
4780 
4781  flfii->EntriesReturned++;
4782 
4783  len = bytes_needed;
4784  }
4785  } else {