ReactOS  0.4.15-dev-4603-gb922b6d
Classes | Macros | Typedefs | Enumerations | Functions | Variables
btrfs_drv.h File Reference
#include <ntifs.h>
#include <ntddk.h>
#include <mountmgr.h>
#include <windef.h>
#include <wdm.h>
#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include "btrfs.h"
#include "btrfsioctl.h"
Include dependency graph for btrfs_drv.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  _FILE_ID_128
 
struct  _DUPLICATE_EXTENTS_DATA
 
struct  _FSCTL_GET_INTEGRITY_INFORMATION_BUFFER
 
struct  _FSCTL_SET_INTEGRITY_INFORMATION_BUFFER
 
struct  _fcb_nonpaged
 
struct  extent
 
struct  hardlink
 
struct  dir_child
 
struct  xattr
 
struct  _fcb
 
struct  _file_ref
 
struct  send_info
 
struct  _ccb
 
struct  tree_holder
 
struct  _tree_data
 
struct  tree_nonpaged
 
struct  _tree
 
struct  root_nonpaged
 
struct  _root
 
struct  batch_item
 
struct  batch_root
 
struct  traverse_ptr
 
struct  _root_cache
 
struct  space
 
struct  device
 
struct  range_lock
 
struct  partial_stripe
 
struct  chunk
 
struct  changed_extent
 
struct  changed_extent_ref
 
struct  sys_chunk
 
struct  calc_job
 
struct  drv_calc_thread
 
struct  drv_calc_threads
 
struct  mount_options
 
struct  balance_info
 
struct  scrub_error
 
struct  scrub_info
 
struct  _device_extension
 
struct  control_device_extension
 
struct  bus_device_extension
 
struct  volume_child
 
struct  _volume_device_extension
 
struct  pdo_device_extension
 
struct  uid_map
 
struct  gid_map
 
struct  write_data_stripe
 
struct  _write_data_context
 
struct  tree_write
 
struct  name_bit
 
struct  rollback_space
 
struct  rollback_extent
 
struct  rollback_item
 
struct  ea_item
 
struct  FSRTL_ADVANCED_FCB_HEADER_NEW
 
struct  _LDR_DATA_TABLE_ENTRY
 
struct  _PEB_LDR_DATA
 
struct  _RTL_USER_PROCESS_PARAMETERS
 
struct  _PEB
 

Macros

#define _WIN32_WINNT   0x0601
 
#define NTDDI_VERSION   0x06020000
 
#define _CRT_SECURE_NO_WARNINGS
 
#define _NO_CRT_STDIO_INLINE
 
#define UNUSED(x)   (void)(x)
 
#define BTRFS_NODE_TYPE_CCB   0x2295
 
#define BTRFS_NODE_TYPE_FCB   0x2296
 
#define ALLOC_TAG   0x7442484D
 
#define ALLOC_TAG_ZLIB   0x7A42484D
 
#define UID_NOBODY   65534
 
#define GID_NOBODY   65534
 
#define EA_NTACL   "security.NTACL"
 
#define EA_NTACL_HASH   0x45922146
 
#define EA_DOSATTRIB   "user.DOSATTRIB"
 
#define EA_DOSATTRIB_HASH   0x914f9939
 
#define EA_REPARSE   "user.reparse"
 
#define EA_REPARSE_HASH   0xfabad1fe
 
#define EA_EA   "user.EA"
 
#define EA_EA_HASH   0x8270dd43
 
#define EA_CASE_SENSITIVE   "user.casesensitive"
 
#define EA_CASE_SENSITIVE_HASH   0x1a9d97d4
 
#define EA_PROP_COMPRESSION   "btrfs.compression"
 
#define EA_PROP_COMPRESSION_HASH   0x20ccdf69
 
#define MAX_EXTENT_SIZE   0x8000000
 
#define COMPRESSED_EXTENT_SIZE   0x20000
 
#define READ_AHEAD_GRANULARITY   COMPRESSED_EXTENT_SIZE
 
#define IO_REPARSE_TAG_LX_SYMLINK   0xa000001d
 
#define IO_REPARSE_TAG_AF_UNIX   0x80000023
 
#define IO_REPARSE_TAG_LX_FIFO   0x80000024
 
#define IO_REPARSE_TAG_LX_CHR   0x80000025
 
#define IO_REPARSE_TAG_LX_BLK   0x80000026
 
#define BTRFS_VOLUME_PREFIX   L"\\Device\\Btrfs{"
 
#define try   if (1)
 
#define except(x)   if (0 && (x))
 
#define finally   if (1)
 
#define leave
 
#define InterlockedIncrement64(a)   __sync_add_and_fetch(a, 1)
 
#define FILE_SUPPORTS_BLOCK_REFCOUNTING   0x08000000
 
#define FILE_SUPPORTS_POSIX_UNLINK_RENAME   0x00000400
 
#define FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL   0x00020000
 
#define FILE_CS_FLAG_CASE_SENSITIVE_DIR   1
 
#define FSCTL_DUPLICATE_EXTENTS_TO_FILE   CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 209, METHOD_BUFFERED, FILE_WRITE_ACCESS)
 
#define FSCTL_GET_INTEGRITY_INFORMATION   CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 159, METHOD_BUFFERED, FILE_ANY_ACCESS)
 
#define FSCTL_SET_INTEGRITY_INFORMATION   CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 160, METHOD_BUFFERED, FILE_READ_DATA | FILE_WRITE_DATA)
 
#define __drv_aliasesMem
 
#define _Dispatch_type_(a)
 
#define _Lock_level_order_(a, b)
 
#define MAX_HASH_SIZE   32
 
#define VCB_TYPE_FS   1
 
#define VCB_TYPE_CONTROL   2
 
#define VCB_TYPE_VOLUME   3
 
#define VCB_TYPE_PDO   4
 
#define VCB_TYPE_BUS   5
 
#define BALANCE_OPTS_DATA   0
 
#define BALANCE_OPTS_METADATA   1
 
#define BALANCE_OPTS_SYSTEM   2
 
#define keycmp(key1, key2)
 
#define acquire_chunk_lock(c, Vcb)   ExAcquireResourceExclusiveLite(&(c)->lock, true)
 
#define release_chunk_lock(c, Vcb)   ExReleaseResourceLite(&(c)->lock)
 
#define funcname   __func__
 
#define __attribute__(x)
 
#define TRACE(s, ...)   do { } while(0)
 
#define WARN(s, ...)   do { } while(0)
 
#define FIXME(s, ...)   DbgPrint("Btrfs FIXME : %s : " s, funcname, ##__VA_ARGS__)
 
#define ERR(s, ...)   DbgPrint("Btrfs ERR : %s : " s, funcname, ##__VA_ARGS__)
 
#define SHA256_HASH_SIZE   32
 
#define BLAKE2_HASH_SIZE   32
 
#define makedev(major, minor)   (((minor) & 0xFF) | (((major) & 0xFFF) << 8) | (((uint64_t)((minor) & ~0xFF)) << 12) | (((uint64_t)((major) & ~0xFFF)) << 32))
 
#define FSRTL_FCB_HEADER_V2   2
 
#define increase_fileref_refcount(fileref)   InterlockedIncrement(&fileref->refcount)
 
#define int3   asm("int3;")
 
#define hex_digit(c)   ((c) <= 9) ? ((c) + '0') : ((c) - 10 + 'a')
 
#define __S_IFMT   0170000 /* These bits determine file type. */
 
#define __S_IFDIR   0040000 /* Directory. */
 
#define __S_IFCHR   0020000 /* Character device. */
 
#define __S_IFBLK   0060000 /* Block device. */
 
#define __S_IFREG   0100000 /* Regular file. */
 
#define __S_IFIFO   0010000 /* FIFO. */
 
#define __S_IFLNK   0120000 /* Symbolic link. */
 
#define __S_IFSOCK   0140000 /* Socket. */
 
#define __S_ISTYPE(mode, mask)   (((mode) & __S_IFMT) == (mask))
 
#define S_ISDIR(mode)   __S_ISTYPE((mode), __S_IFDIR)
 
#define S_IRUSR   0000400
 
#define S_IWUSR   0000200
 
#define S_IXUSR   0000100
 
#define S_IRGRP   (S_IRUSR >> 3)
 
#define S_IWGRP   (S_IWUSR >> 3)
 
#define S_IXGRP   (S_IXUSR >> 3)
 
#define S_IROTH   (S_IRGRP >> 3)
 
#define S_IWOTH   (S_IWGRP >> 3)
 
#define S_IXOTH   (S_IXGRP >> 3)
 
#define S_ISUID   0004000
 
#define S_ISGID   0002000
 
#define S_ISVTX   0001000
 
#define major(rdev)   ((((rdev) >> 8) & 0xFFF) | ((uint32_t)((rdev) >> 32) & ~0xFFF))
 
#define minor(rdev)   (((rdev) & 0xFF) | ((uint32_t)((rdev) >> 12) & ~0xFF))
 
#define CC_ENABLE_DISK_IO_ACCOUNTING   0x00000010
 

Typedefs

typedef struct _FILE_ID_128 FILE_ID_128
 
typedef struct _FILE_ID_128 * PFILE_ID_128
 
typedef struct _DUPLICATE_EXTENTS_DATA DUPLICATE_EXTENTS_DATA
 
typedef struct _DUPLICATE_EXTENTS_DATA * PDUPLICATE_EXTENTS_DATA
 
typedef struct _FSCTL_GET_INTEGRITY_INFORMATION_BUFFER FSCTL_GET_INTEGRITY_INFORMATION_BUFFER
 
typedef struct _FSCTL_GET_INTEGRITY_INFORMATION_BUFFER * PFSCTL_GET_INTEGRITY_INFORMATION_BUFFER
 
typedef struct _FSCTL_SET_INTEGRITY_INFORMATION_BUFFER FSCTL_SET_INTEGRITY_INFORMATION_BUFFER
 
typedef struct _FSCTL_SET_INTEGRITY_INFORMATION_BUFFER * PFSCTL_SET_INTEGRITY_INFORMATION_BUFFER
 
typedef struct _fcb_nonpaged fcb_nonpaged
 
typedef struct _fcb fcb
 
typedef struct _file_ref file_ref
 
typedef struct _ccb ccb
 
typedef struct _tree_data tree_data
 
typedef struct _tree tree
 
typedef struct _root root
 
typedef struct _root_cache root_cache
 
typedef struct _device_extension device_extension
 
typedef struct _volume_device_extension volume_device_extension
 
typedef struct pdo_device_extension pdo_device_extension
 
typedef struct _write_data_context write_data_context
 
typedef void(__stdcall * xor_func) (uint8_t *buf1, uint8_t *buf2, uint32_t len)
 
typedef BOOLEAN(__stdcall * tPsIsDiskCountersEnabled) ()
 
typedef VOID(__stdcall * tPsUpdateDiskCounters) (PEPROCESS Process, ULONG64 BytesRead, ULONG64 BytesWritten, ULONG ReadOperationCount, ULONG WriteOperationCount, ULONG FlushOperationCount)
 
typedef BOOLEAN(__stdcall * tCcCopyWriteEx) (PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID Buffer, PETHREAD IoIssuerThread)
 
typedef BOOLEAN(__stdcall * tCcCopyReadEx) (PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PETHREAD IoIssuerThread)
 
typedef VOID(__stdcall * tCcSetAdditionalCacheAttributesEx) (PFILE_OBJECT FileObject, ULONG Flags)
 
typedef VOID(__stdcall * tFsRtlUpdateDiskCounters) (ULONG64 BytesRead, ULONG64 BytesWritten)
 
typedef NTSTATUS(__stdcall * tIoUnregisterPlugPlayNotificationEx) (PVOID NotificationEntry)
 
typedef NTSTATUS(__stdcall * tFsRtlGetEcpListFromIrp) (PIRP Irp, PECP_LIST *EcpList)
 
typedef NTSTATUS(__stdcall * tFsRtlGetNextExtraCreateParameter) (PECP_LIST EcpList, PVOID CurrentEcpContext, LPGUID NextEcpType, PVOID *NextEcpContext, ULONG *NextEcpContextSize)
 
typedef NTSTATUS(__stdcall * tFsRtlValidateReparsePointBuffer) (ULONG BufferLength, PREPARSE_DATA_BUFFER ReparseBuffer)
 
typedef BOOLEAN(__stdcall * tFsRtlCheckLockForOplockRequest) (PFILE_LOCK FileLock, PLARGE_INTEGER AllocationSize)
 
typedef BOOLEAN(__stdcall * tFsRtlAreThereCurrentOrInProgressFileLocks) (PFILE_LOCK FileLock)
 
typedef struct _LDR_DATA_TABLE_ENTRY LDR_DATA_TABLE_ENTRY
 
typedef struct _LDR_DATA_TABLE_ENTRY * PLDR_DATA_TABLE_ENTRY
 
typedef struct _PEB_LDR_DATA PEB_LDR_DATA
 
typedef struct _PEB_LDR_DATA * PPEB_LDR_DATA
 
typedef struct _RTL_USER_PROCESS_PARAMETERS RTL_USER_PROCESS_PARAMETERS
 
typedef struct _RTL_USER_PROCESS_PARAMETERS * PRTL_USER_PROCESS_PARAMETERS
 
typedef VOID(NTAPI * PPS_POST_PROCESS_INIT_ROUTINE) (VOID)
 
typedef struct _PEB PEB
 
typedef struct _PEB * PPEB
 

Enumerations

enum  prop_compression_type { PropCompression_None, PropCompression_Zlib, PropCompression_LZO, PropCompression_ZSTD }
 
enum  batch_operation {
  Batch_Delete, Batch_DeleteInode, Batch_DeleteDirItem, Batch_DeleteInodeRef,
  Batch_DeleteInodeExtRef, Batch_DeleteXattr, Batch_DeleteExtentData, Batch_DeleteFreeSpace,
  Batch_Insert, Batch_SetXattr, Batch_DirItem, Batch_InodeRef,
  Batch_InodeExtRef
}
 
enum  calc_thread_type {
  calc_thread_crc32c, calc_thread_xxhash, calc_thread_sha256, calc_thread_blake2,
  calc_thread_decomp_zlib, calc_thread_decomp_lzo, calc_thread_decomp_zstd, calc_thread_comp_zlib,
  calc_thread_comp_lzo, calc_thread_comp_zstd
}
 
enum  write_data_status {
  WriteDataStatus_Pending, WriteDataStatus_Success, WriteDataStatus_Error, WriteDataStatus_Cancelling,
  WriteDataStatus_Cancelled, WriteDataStatus_Ignore
}
 
enum  rollback_type { ROLLBACK_INSERT_EXTENT, ROLLBACK_DELETE_EXTENT, ROLLBACK_ADD_SPACE, ROLLBACK_SUBTRACT_SPACE }
 

Functions

 _Create_lock_level_ (tree_lock) _Create_lock_level_(fcb_lock) _Lock_level_order_(tree_lock
 
 _Requires_lock_not_held_ (Vcb->fcb_lock) _Acquires_shared_lock_(Vcb -> fcb_lock) static __inline void acquire_fcb_lock_shared(device_extension *Vcb)
 
 _Requires_lock_held_ (Vcb->fcb_lock) _Releases_lock_(Vcb -> fcb_lock) static __inline void release_fcb_lock(device_extension *Vcb)
 
static __inline void * map_user_buffer (PIRP Irp, ULONG priority)
 
static __inline uint64_t unix_time_to_win (BTRFS_TIME *t)
 
static __inline void win_time_to_unix (LARGE_INTEGER t, BTRFS_TIME *out)
 
_Post_satisfies_ static stripe __inline void get_raid0_offset (_In_ uint64_t off, _In_ uint64_t stripe_length, _In_ uint16_t num_stripes, _Out_ uint64_t *stripeoff, _Out_ uint16_t *stripe)
 
static __inline uint64_t make_file_id (root *r, uint64_t inode)
 
 _Post_satisfies_ (return >=n) __inline static uint64_t sector_align(_In_ uint64_t n
 
static __inline bool is_subvol_readonly (root *r, PIRP Irp)
 
static __inline uint16_t get_extent_data_len (uint8_t type)
 
static __inline uint32_t get_extent_data_refcount (uint8_t type, void *data)
 
_Ret_maybenull_ device * find_device_from_uuid (_In_ device_extension *Vcb, _In_ BTRFS_UUID *uuid)
 
 _Success_ (return) bool get_file_attributes_from_xattr(_In_reads_bytes_(len) char *val
 
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)
 
void free_fcb (_Inout_ fcb *fcb)
 
void free_fileref (_Inout_ file_ref *fr)
 
void protect_superblocks (_Inout_ chunk *c)
 
bool is_top_level (_In_ PIRP Irp)
 
NTSTATUS create_root (_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_ uint64_t id, _Out_ root **rootptr, _In_ bool no_tree, _In_ uint64_t offset, _In_opt_ PIRP Irp)
 
void uninit (_In_ device_extension *Vcb)
 
NTSTATUS dev_ioctl (_In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG ControlCode, _In_reads_bytes_opt_(InputBufferSize) PVOID InputBuffer, _In_ ULONG InputBufferSize, _Out_writes_bytes_opt_(OutputBufferSize) PVOID OutputBuffer, _In_ ULONG OutputBufferSize, _In_ bool Override, _Out_opt_ IO_STATUS_BLOCK *iosb)
 
NTSTATUS check_file_name_valid (_In_ PUNICODE_STRING us, _In_ bool posix, _In_ bool stream)
 
void send_notification_fileref (_In_ file_ref *fileref, _In_ ULONG filter_match, _In_ ULONG action, _In_opt_ PUNICODE_STRING stream)
 
void queue_notification_fcb (_In_ file_ref *fileref, _In_ ULONG filter_match, _In_ ULONG action, _In_opt_ PUNICODE_STRING stream)
 
void mark_fcb_dirty (_In_ fcb *fcb)
 
void mark_fileref_dirty (_In_ file_ref *fileref)
 
NTSTATUS delete_fileref (_In_ file_ref *fileref, _In_opt_ PFILE_OBJECT FileObject, _In_ bool make_orphan, _In_opt_ PIRP Irp, _In_ LIST_ENTRY *rollback)
 
void chunk_lock_range (_In_ device_extension *Vcb, _In_ chunk *c, _In_ uint64_t start, _In_ uint64_t length)
 
void chunk_unlock_range (_In_ device_extension *Vcb, _In_ chunk *c, _In_ uint64_t start, _In_ uint64_t length)
 
void init_device (_In_ device_extension *Vcb, _Inout_ device *dev, _In_ bool get_nums)
 
void init_file_cache (_In_ PFILE_OBJECT FileObject, _In_ CC_FILE_SIZES *ccfs)
 
NTSTATUS sync_read_phys (_In_ PDEVICE_OBJECT DeviceObject, _In_ PFILE_OBJECT FileObject, _In_ uint64_t StartingOffset, _In_ ULONG Length, _Out_writes_bytes_(Length) PUCHAR Buffer, _In_ bool override)
 
NTSTATUS get_device_pnp_name (_In_ PDEVICE_OBJECT DeviceObject, _Out_ PUNICODE_STRING pnp_name, _Out_ const GUID **guid)
 
void log_device_error (_In_ device_extension *Vcb, _Inout_ device *dev, _In_ int error)
 
NTSTATUS find_chunk_usage (_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_opt_ PIRP Irp)
 
 _Function_class_ (DRIVER_ADD_DEVICE) NTSTATUS __stdcall AddDevice(PDRIVER_OBJECT DriverObject
 
void reap_fcb (fcb *fcb)
 
void reap_fcbs (device_extension *Vcb)
 
void reap_fileref (device_extension *Vcb, file_ref *fr)
 
void reap_filerefs (device_extension *Vcb, file_ref *fr)
 
NTSTATUS utf8_to_utf16 (WCHAR *dest, ULONG dest_max, ULONG *dest_len, char *src, ULONG src_len)
 
NTSTATUS utf16_to_utf8 (char *dest, ULONG dest_max, ULONG *dest_len, WCHAR *src, ULONG src_len)
 
uint32_t get_num_of_processors ()
 
_Ret_maybenull_ root * find_default_subvol (_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_opt_ PIRP Irp)
 
void do_shutdown (PIRP Irp)
 
bool check_superblock_checksum (superblock *sb)
 
void init_fast_io_dispatch (FAST_IO_DISPATCH **fiod)
 
void calc_sha256 (uint8_t *hash, const void *input, size_t len)
 
void blake2b (void *out, size_t outlen, const void *in, size_t inlen)
 
NTSTATUS find_item (_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_ root *r, _Out_ traverse_ptr *tp, _In_ const KEY *searchkey, _In_ bool ignore, _In_opt_ PIRP Irp) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS find_item_to_level (device_extension *Vcb, root *r, traverse_ptr *tp, const KEY *searchkey, bool ignore, uint8_t level, PIRP Irp) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS bool find_next_item (_Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, const traverse_ptr *tp, traverse_ptr *next_tp, bool ignore, PIRP Irp) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS bool bool find_prev_item (_Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, const traverse_ptr *tp, traverse_ptr *prev_tp, PIRP Irp) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS bool bool void free_trees (device_extension *Vcb) __attribute__((nonnull(1)))
 
NTSTATUS insert_tree_item (_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_ root *r, _In_ uint64_t obj_id, _In_ uint8_t obj_type, _In_ uint64_t offset, _In_reads_bytes_opt_(size) _When_(return >=0, __drv_aliasesMem) void *data, _In_ uint16_t size, _Out_opt_ traverse_ptr *ptp, _In_opt_ PIRP Irp) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS delete_tree_item (_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _Inout_ traverse_ptr *tp) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS void free_tree (tree *t) __attribute__((nonnull(1)))
 
NTSTATUS load_tree (device_extension *Vcb, uint64_t addr, uint8_t *buf, root *r, tree **pt) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS do_load_tree (device_extension *Vcb, tree_holder *th, root *r, tree *t, tree_data *td, PIRP Irp) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS void clear_rollback (LIST_ENTRY *rollback) __attribute__((nonnull(1)))
 
void do_rollback (device_extension *Vcb, LIST_ENTRY *rollback) __attribute__((nonnull(1
 
void void free_trees_root (device_extension *Vcb, root *r) __attribute__((nonnull(1
 
void void void add_rollback (_In_ LIST_ENTRY *rollback, _In_ enum rollback_type type, _In_ __drv_aliasesMem void *ptr) __attribute__((nonnull(1
 
void void void NTSTATUS commit_batch_list (_Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension *Vcb, LIST_ENTRY *batchlist, PIRP Irp) __attribute__((nonnull(1
 
void void void NTSTATUS void clear_batch_list (device_extension *Vcb, LIST_ENTRY *batchlist) __attribute__((nonnull(1
 
void void void NTSTATUS void NTSTATUS skip_to_difference (device_extension *Vcb, traverse_ptr *tp, traverse_ptr *tp2, bool *ended1, bool *ended2) __attribute__((nonnull(1
 
void void void NTSTATUS void NTSTATUS NTSTATUS remove_drive_letter (PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath)
 
 _Function_class_ (KSTART_ROUTINE) void __stdcall mountmgr_thread(_In_ void *context)
 
 _Function_class_ (DRIVER_NOTIFICATION_CALLBACK_ROUTINE) NTSTATUS __stdcall pnp_notification(PVOID NotificationStructure
 
void disk_arrival (PUNICODE_STRING devpath)
 
bool volume_arrival (PUNICODE_STRING devpath, bool fve_callback)
 
void volume_removal (PUNICODE_STRING devpath)
 
void remove_volume_child (_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lock) _Releases_exclusive_lock_(_Curr_->child_lock) _In_ volume_device_extension *vde, _In_ volume_child *vc, _In_ bool skip_dev)
 
void init_cache ()
 
NTSTATUS write_file (device_extension *Vcb, PIRP Irp, bool wait, bool deferred_write) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS write_file2 (device_extension *Vcb, PIRP Irp, LARGE_INTEGER offset, void *buf, ULONG *length, bool paging_io, bool no_cache, bool wait, bool deferred_write, bool write_irp, LIST_ENTRY *rollback) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS NTSTATUS truncate_file (fcb *fcb, uint64_t end, PIRP Irp, LIST_ENTRY *rollback) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS NTSTATUS NTSTATUS extend_file (fcb *fcb, file_ref *fileref, uint64_t end, bool prealloc, PIRP Irp, LIST_ENTRY *rollback) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS NTSTATUS NTSTATUS NTSTATUS excise_extents (device_extension *Vcb, fcb *fcb, uint64_t start_data, uint64_t end_data, PIRP Irp, LIST_ENTRY *rollback) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS NTSTATUS NTSTATUS NTSTATUS chunk * get_chunk_from_address (device_extension *Vcb, uint64_t address) __attribute__((nonnull(1)))
 
NTSTATUS alloc_chunk (device_extension *Vcb, uint64_t flags, chunk **pc, bool full_size) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS write_data (_In_ device_extension *Vcb, _In_ uint64_t address, _In_reads_bytes_(length) void *data, _In_ uint32_t length, _In_ write_data_context *wtc, _In_opt_ PIRP Irp, _In_opt_ chunk *c, _In_ bool file_write, _In_ uint64_t irp_offset, _In_ ULONG priority) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS NTSTATUS write_data_complete (device_extension *Vcb, uint64_t address, void *data, uint32_t length, PIRP Irp, chunk *c, bool file_write, uint64_t irp_offset, ULONG priority) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS NTSTATUS void free_write_data_stripes (write_data_context *wtc) __attribute__((nonnull(1)))
 
 _Dispatch_type_ (IRP_MJ_WRITE) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_write(IN PDEVICE_OBJECT DeviceObject
 
IN PIRP Irp __attribute__ ((nonnull(1, 2)))
 
 _Requires_lock_held_ (c->lock) _When_(return !=0
 
 _Releases_lock_ (c->lock)) bool insert_extent_chunk(_In_ device_extension *Vcb
 
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t _In_ uint64_t _In_ bool _In_ uint64_t irp_offset __attribute__ ((nonnull(1, 2, 3, 9)))
 
NTSTATUS do_write_file (fcb *fcb, uint64_t start_data, uint64_t end_data, void *data, PIRP Irp, bool file_write, uint32_t irp_offset, LIST_ENTRY *rollback) __attribute__((nonnull(1
 
NTSTATUS bool find_data_address_in_chunk (device_extension *Vcb, chunk *c, uint64_t length, uint64_t *address) __attribute__((nonnull(1
 
NTSTATUS bool void get_raid56_lock_range (chunk *c, uint64_t address, uint64_t length, uint64_t *lockaddr, uint64_t *locklen) __attribute__((nonnull(1
 
NTSTATUS bool void NTSTATUS add_extent_to_fcb (_In_ fcb *fcb, _In_ uint64_t offset, _In_reads_bytes_(edsize) EXTENT_DATA *ed, _In_ uint16_t edsize, _In_ bool unique, _In_opt_ _When_(return >=0, __drv_aliasesMem) void *csum, _In_ LIST_ENTRY *rollback) __attribute__((nonnull(1
 
NTSTATUS bool void NTSTATUS void add_extent (_In_ fcb *fcb, _In_ LIST_ENTRY *prevextle, _In_ __drv_aliasesMem extent *newext) __attribute__((nonnull(1
 
NTSTATUS bool void NTSTATUS void _Dispatch_type_ (IRP_MJ_DIRECTORY_CONTROL) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_directory_control(IN PDEVICE_OBJECT DeviceObject
 
ULONG get_reparse_tag (device_extension *Vcb, root *subvol, uint64_t inode, uint8_t type, ULONG atts, bool lxss, PIRP Irp)
 
ULONG get_reparse_tag_fcb (fcb *fcb)
 
 _Dispatch_type_ (IRP_MJ_QUERY_SECURITY) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_query_security(IN PDEVICE_OBJECT DeviceObject
 
 _Dispatch_type_ (IRP_MJ_SET_SECURITY) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_set_security(IN PDEVICE_OBJECT DeviceObject
 
void fcb_get_sd (fcb *fcb, struct _fcb *parent, bool look_for_xattr, PIRP Irp)
 
void add_user_mapping (WCHAR *sidstring, ULONG sidstringlength, uint32_t uid)
 
void add_group_mapping (WCHAR *sidstring, ULONG sidstringlength, uint32_t gid)
 
uint32_t sid_to_uid (PSID sid)
 
NTSTATUS uid_to_sid (uint32_t uid, PSID *sid)
 
NTSTATUS fcb_get_new_sd (fcb *fcb, file_ref *parfileref, ACCESS_STATE *as)
 
void find_gid (struct _fcb *fcb, struct _fcb *parfcb, PSECURITY_SUBJECT_CONTEXT subjcont)
 
 _Dispatch_type_ (IRP_MJ_SET_INFORMATION) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_set_information(IN PDEVICE_OBJECT DeviceObject
 
 _Dispatch_type_ (IRP_MJ_QUERY_INFORMATION) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_query_information(IN PDEVICE_OBJECT DeviceObject
 
 _Dispatch_type_ (IRP_MJ_QUERY_EA) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_query_ea(IN PDEVICE_OBJECT DeviceObject
 
 _Dispatch_type_ (IRP_MJ_SET_EA) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_set_ea(IN PDEVICE_OBJECT DeviceObject
 
bool has_open_children (file_ref *fileref)
 
NTSTATUS stream_set_end_of_file_information (device_extension *Vcb, uint16_t end, fcb *fcb, file_ref *fileref, bool advance_only)
 
NTSTATUS fileref_get_filename (file_ref *fileref, PUNICODE_STRING fn, USHORT *name_offset, ULONG *preqlen)
 
void insert_dir_child_into_hash_lists (fcb *fcb, dir_child *dc)
 
void remove_dir_child_from_hash_lists (fcb *fcb, dir_child *dc)
 
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)
 
NTSTATUS get_reparse_point (PFILE_OBJECT FileObject, void *buffer, DWORD buflen, ULONG_PTR *retlen)
 
NTSTATUS set_reparse_point2 (fcb *fcb, REPARSE_DATA_BUFFER *rdb, ULONG buflen, ccb *ccb, file_ref *fileref, PIRP Irp, LIST_ENTRY *rollback)
 
NTSTATUS set_reparse_point (PIRP Irp)
 
NTSTATUS delete_reparse_point (PIRP Irp)
 
 _Dispatch_type_ (IRP_MJ_CREATE) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_create(IN PDEVICE_OBJECT DeviceObject
 
NTSTATUS open_fileref (_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lock_held_(_Curr_->fcb_lock) _In_ device_extension *Vcb, _Out_ file_ref **pfr, _In_ PUNICODE_STRING fnus, _In_opt_ file_ref *related, _In_ bool parent, _Out_opt_ USHORT *parsed, _Out_opt_ ULONG *fn_offset, _In_ POOL_TYPE pooltype, _In_ bool case_sensitive, _In_opt_ PIRP Irp)
 
NTSTATUS open_fcb (_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lock_held_(_Curr_->fcb_lock) device_extension *Vcb, root *subvol, uint64_t inode, uint8_t type, PANSI_STRING utf8, bool always_add_hl, fcb *parent, fcb **pfcb, POOL_TYPE pooltype, PIRP Irp)
 
NTSTATUS load_csum (_Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, void *csum, uint64_t start, uint64_t length, PIRP Irp)
 
NTSTATUS load_dir_children (_Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, fcb *fcb, bool ignore_size, PIRP Irp)
 
NTSTATUS add_dir_child (fcb *fcb, uint64_t inode, bool subvol, PANSI_STRING utf8, PUNICODE_STRING name, uint8_t type, dir_child **pdc)
 
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)
 
fcb * create_fcb (device_extension *Vcb, POOL_TYPE pool_type)
 
NTSTATUS find_file_in_dir (PUNICODE_STRING filename, fcb *fcb, root **subvol, uint64_t *inode, dir_child **pdc, bool case_sensitive)
 
uint32_t inherit_mode (fcb *parfcb, bool is_dir)
 
file_ref * create_fileref (device_extension *Vcb)
 
NTSTATUS open_fileref_by_inode (_Requires_exclusive_lock_held_(_Curr_->fcb_lock) device_extension *Vcb, root *subvol, uint64_t inode, file_ref **pfr, PIRP Irp)
 
NTSTATUS fsctl_request (PDEVICE_OBJECT DeviceObject, PIRP *Pirp, uint32_t type)
 
void do_unlock_volume (device_extension *Vcb)
 
void trim_whole_device (device *dev)
 
void flush_subvol_fcbs (root *subvol)
 
bool fcb_is_inline (fcb *fcb)
 
NTSTATUS dismount_volume (device_extension *Vcb, bool shutdown, PIRP Irp)
 
NTSTATUS do_write (device_extension *Vcb, PIRP Irp)
 
NTSTATUS get_tree_new_address (device_extension *Vcb, tree *t, PIRP Irp, LIST_ENTRY *rollback)
 
NTSTATUS flush_fcb (fcb *fcb, bool cache, LIST_ENTRY *batchlist, PIRP Irp)
 
NTSTATUS write_data_phys (_In_ PDEVICE_OBJECT device, _In_ PFILE_OBJECT fileobj, _In_ uint64_t address, _In_reads_bytes_(length) void *data, _In_ uint32_t length)
 
bool is_tree_unique (device_extension *Vcb, tree *t, PIRP Irp)
 
NTSTATUS do_tree_writes (device_extension *Vcb, LIST_ENTRY *tree_writes, bool no_free)
 
void add_checksum_entry (device_extension *Vcb, uint64_t address, ULONG length, void *csum, PIRP Irp)
 
bool find_metadata_address_in_chunk (device_extension *Vcb, chunk *c, uint64_t *address)
 
void add_trim_entry_avoid_sb (device_extension *Vcb, device *dev, uint64_t address, uint64_t size)
 
NTSTATUS insert_tree_item_batch (LIST_ENTRY *batchlist, device_extension *Vcb, root *r, uint64_t objid, uint8_t objtype, uint64_t offset, _In_opt_ _When_(return >=0, __drv_aliasesMem) void *data, uint16_t datalen, enum batch_operation operation)
 
NTSTATUS flush_partial_stripe (device_extension *Vcb, chunk *c, partial_stripe *ps)
 
NTSTATUS update_dev_item (device_extension *Vcb, device *device, PIRP Irp)
 
void calc_tree_checksum (device_extension *Vcb, tree_header *th)
 
 _Dispatch_type_ (IRP_MJ_READ) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_read(PDEVICE_OBJECT DeviceObject
 
NTSTATUS read_data (_In_ device_extension *Vcb, _In_ uint64_t addr, _In_ uint32_t length, _In_reads_bytes_opt_(length *sizeof(uint32_t)/Vcb->superblock.sector_size) void *csum, _In_ bool is_tree, _Out_writes_bytes_(length) uint8_t *buf, _In_opt_ chunk *c, _Out_opt_ chunk **pc, _In_opt_ PIRP Irp, _In_ uint64_t generation, _In_ bool file_read, _In_ ULONG priority)
 
NTSTATUS read_file (fcb *fcb, uint8_t *data, uint64_t start, uint64_t length, ULONG *pbr, PIRP Irp) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS read_stream (fcb *fcb, uint8_t *data, uint64_t start, ULONG length, ULONG *pbr) __attribute__((nonnull(1
 
NTSTATUS NTSTATUS NTSTATUS do_read (PIRP Irp, bool wait, ULONG *bytes_read)
 
NTSTATUS check_csum (device_extension *Vcb, uint8_t *data, uint32_t sectors, void *csum)
 
void raid6_recover2 (uint8_t *sectors, uint16_t num_stripes, ULONG sector_size, uint16_t missing1, uint16_t missing2, uint8_t *out)
 
void get_tree_checksum (device_extension *Vcb, tree_header *th, void *csum)
 
bool check_tree_checksum (device_extension *Vcb, tree_header *th)
 
void get_sector_csum (device_extension *Vcb, void *buf, void *csum)
 
bool check_sector_csum (device_extension *Vcb, void *buf, void *csum)
 
 _Dispatch_type_ (IRP_MJ_PNP) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_pnp(PDEVICE_OBJECT DeviceObject
 
NTSTATUS pnp_surprise_removal (PDEVICE_OBJECT DeviceObject, PIRP Irp)
 
NTSTATUS pnp_query_remove_device (PDEVICE_OBJECT DeviceObject, PIRP Irp)
 
NTSTATUS load_cache_chunk (device_extension *Vcb, chunk *c, PIRP Irp)
 
NTSTATUS clear_free_space_cache (device_extension *Vcb, LIST_ENTRY *batchlist, PIRP Irp)
 
NTSTATUS allocate_cache (device_extension *Vcb, bool *changed, PIRP Irp, LIST_ENTRY *rollback)
 
NTSTATUS update_chunk_caches (device_extension *Vcb, PIRP Irp, LIST_ENTRY *rollback)
 
NTSTATUS update_chunk_caches_tree (device_extension *Vcb, PIRP Irp)
 
NTSTATUS add_space_entry (LIST_ENTRY *list, LIST_ENTRY *list_size, uint64_t offset, uint64_t size)
 
void space_list_add (chunk *c, uint64_t address, uint64_t length, LIST_ENTRY *rollback)
 
void space_list_add2 (LIST_ENTRY *list, LIST_ENTRY *list_size, uint64_t address, uint64_t length, chunk *c, LIST_ENTRY *rollback)
 
void space_list_subtract (chunk *c, uint64_t address, uint64_t length, LIST_ENTRY *rollback)
 
void space_list_subtract2 (LIST_ENTRY *list, LIST_ENTRY *list_size, uint64_t address, uint64_t length, chunk *c, LIST_ENTRY *rollback)
 
void space_list_merge (LIST_ENTRY *spacelist, LIST_ENTRY *spacelist_size, LIST_ENTRY *deleting)
 
NTSTATUS load_stored_free_space_cache (device_extension *Vcb, chunk *c, bool load_only, PIRP Irp)
 
NTSTATUS increase_extent_refcount_data (device_extension *Vcb, uint64_t address, uint64_t size, uint64_t root, uint64_t inode, uint64_t offset, uint32_t refcount, PIRP Irp)
 
NTSTATUS decrease_extent_refcount_data (device_extension *Vcb, uint64_t address, uint64_t size, uint64_t root, uint64_t inode, uint64_t offset, uint32_t refcount, bool superseded, PIRP Irp)
 
NTSTATUS decrease_extent_refcount_tree (device_extension *Vcb, uint64_t address, uint64_t size, uint64_t root, uint8_t level, PIRP Irp)
 
uint64_t get_extent_refcount (device_extension *Vcb, uint64_t address, uint64_t size, PIRP Irp)
 
bool is_extent_unique (device_extension *Vcb, uint64_t address, uint64_t size, PIRP Irp)
 
NTSTATUS increase_extent_refcount (device_extension *Vcb, uint64_t address, uint64_t size, uint8_t type, void *data, KEY *firstitem, uint8_t level, PIRP Irp)
 
uint64_t get_extent_flags (device_extension *Vcb, uint64_t address, PIRP Irp)
 
void update_extent_flags (device_extension *Vcb, uint64_t address, uint64_t flags, PIRP Irp)
 
NTSTATUS update_changed_extent_ref (device_extension *Vcb, chunk *c, uint64_t address, uint64_t size, uint64_t root, uint64_t objid, uint64_t offset, int32_t count, bool no_csum, bool superseded, PIRP Irp)
 
void add_changed_extent_ref (chunk *c, uint64_t address, uint64_t size, uint64_t root, uint64_t objid, uint64_t offset, uint32_t count, bool no_csum)
 
uint64_t find_extent_shared_tree_refcount (device_extension *Vcb, uint64_t address, uint64_t parent, PIRP Irp)
 
uint32_t find_extent_shared_data_refcount (device_extension *Vcb, uint64_t address, uint64_t parent, PIRP Irp)
 
NTSTATUS decrease_extent_refcount (device_extension *Vcb, uint64_t address, uint64_t size, uint8_t type, void *data, KEY *firstitem, uint8_t level, uint64_t parent, bool superseded, PIRP Irp)
 
uint64_t get_extent_data_ref_hash2 (uint64_t root, uint64_t objid, uint64_t offset)
 
NTSTATUS do_read_job (PIRP Irp)
 
NTSTATUS do_write_job (device_extension *Vcb, PIRP Irp)
 
bool add_thread_job (device_extension *Vcb, PIRP Irp)
 
void read_registry (PUNICODE_STRING regpath, bool refresh)
 
NTSTATUS registry_mark_volume_mounted (BTRFS_UUID *uuid)
 
NTSTATUS registry_mark_volume_unmounted (BTRFS_UUID *uuid)
 
NTSTATUS registry_load_volume_options (device_extension *Vcb)
 
void watch_registry (HANDLE regh)
 
NTSTATUS zlib_decompress (uint8_t *inbuf, uint32_t inlen, uint8_t *outbuf, uint32_t outlen)
 
NTSTATUS lzo_decompress (uint8_t *inbuf, uint32_t inlen, uint8_t *outbuf, uint32_t outlen, uint32_t inpageoff)
 
NTSTATUS zstd_decompress (uint8_t *inbuf, uint32_t inlen, uint8_t *outbuf, uint32_t outlen)
 
NTSTATUS write_compressed (fcb *fcb, uint64_t start_data, uint64_t end_data, void *data, PIRP Irp, LIST_ENTRY *rollback)
 
NTSTATUS zlib_compress (uint8_t *inbuf, uint32_t inlen, uint8_t *outbuf, uint32_t outlen, unsigned int level, unsigned int *space_left)
 
NTSTATUS lzo_compress (uint8_t *inbuf, uint32_t inlen, uint8_t *outbuf, uint32_t outlen, unsigned int *space_left)
 
NTSTATUS zstd_compress (uint8_t *inbuf, uint32_t inlen, uint8_t *outbuf, uint32_t outlen, uint32_t level, unsigned int *space_left)
 
void galois_double (uint8_t *data, uint32_t len)
 
void galois_divpower (uint8_t *data, uint8_t div, uint32_t readlen)
 
uint8_t gpow2 (uint8_t e)
 
uint8_t gmul (uint8_t a, uint8_t b)
 
uint8_t gdiv (uint8_t a, uint8_t b)
 
 _Dispatch_type_ (IRP_MJ_DEVICE_CONTROL) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_device_control(IN PDEVICE_OBJECT DeviceObject
 
void do_calc_job (device_extension *Vcb, uint8_t *data, uint32_t sectors, void *csum)
 
NTSTATUS add_calc_job_decomp (device_extension *Vcb, uint8_t compression, void *in, unsigned int inlen, void *out, unsigned int outlen, unsigned int off, calc_job **pcj)
 
NTSTATUS add_calc_job_comp (device_extension *Vcb, uint8_t compression, void *in, unsigned int inlen, void *out, unsigned int outlen, calc_job **pcj)
 
void calc_thread_main (device_extension *Vcb, calc_job *cj)
 
NTSTATUS start_balance (device_extension *Vcb, void *data, ULONG length, KPROCESSOR_MODE processor_mode)
 
NTSTATUS query_balance (device_extension *Vcb, void *data, ULONG length)
 
NTSTATUS pause_balance (device_extension *Vcb, KPROCESSOR_MODE processor_mode)
 
NTSTATUS resume_balance (device_extension *Vcb, KPROCESSOR_MODE processor_mode)
 
NTSTATUS stop_balance (device_extension *Vcb, KPROCESSOR_MODE processor_mode)
 
NTSTATUS look_for_balance_item (_Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb)
 
NTSTATUS remove_device (device_extension *Vcb, void *data, ULONG length, KPROCESSOR_MODE processor_mode)
 
NTSTATUS vol_create (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
NTSTATUS vol_close (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
NTSTATUS vol_read (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
NTSTATUS vol_write (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
NTSTATUS vol_device_control (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
void add_volume_device (superblock *sb, PUNICODE_STRING devpath, uint64_t length, ULONG disk_num, ULONG part_num)
 
NTSTATUS mountmgr_add_drive_letter (PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath)
 
void free_vol (volume_device_extension *vde)
 
NTSTATUS start_scrub (device_extension *Vcb, KPROCESSOR_MODE processor_mode)
 
NTSTATUS query_scrub (device_extension *Vcb, KPROCESSOR_MODE processor_mode, void *data, ULONG length)
 
NTSTATUS pause_scrub (device_extension *Vcb, KPROCESSOR_MODE processor_mode)
 
NTSTATUS resume_scrub (device_extension *Vcb, KPROCESSOR_MODE processor_mode)
 
NTSTATUS stop_scrub (device_extension *Vcb, KPROCESSOR_MODE processor_mode)
 
NTSTATUS send_subvol (device_extension *Vcb, void *data, ULONG datalen, PFILE_OBJECT FileObject, PIRP Irp)
 
NTSTATUS read_send_buffer (device_extension *Vcb, PFILE_OBJECT FileObject, void *data, ULONG datalen, ULONG_PTR *retlen, KPROCESSOR_MODE processor_mode)
 
NTSTATUS __stdcall compat_FsRtlValidateReparsePointBuffer (IN ULONG BufferLength, IN PREPARSE_DATA_BUFFER ReparseBuffer)
 
void check_system_root ()
 
void boot_add_device (DEVICE_OBJECT *pdo)
 
static __inline POPLOCK fcb_oplock (fcb *fcb)
 
static __inline FAST_IO_POSSIBLE fast_io_possible (fcb *fcb)
 
static __inline void print_open_trees (device_extension *Vcb)
 
static __inline bool write_fcb_compressed (fcb *fcb)
 
static __inline uint64_t fcb_alloc_size (fcb *fcb)
 
PEPROCESS __stdcall PsGetThreadProcess (_In_ PETHREAD Thread)
 

Variables

_In_ uint64_t a
 
return n
 
_In_ uint16_t len
 
_In_ uint16_t _Out_ ULONG * atts
 
xor_func do_xor
 
PDEVICE_OBJECT PhysicalDeviceObject
 
uint32_t mount_compress
 
uint32_t mount_compress_force
 
uint32_t mount_compress_type
 
uint32_t mount_zlib_level
 
uint32_t mount_zstd_level
 
uint32_t mount_flush_interval
 
uint32_t mount_max_inline
 
uint32_t mount_skip_balance
 
uint32_t mount_no_barrier
 
uint32_t mount_no_trim
 
uint32_t mount_clear_cache
 
uint32_t mount_allow_degraded
 
uint32_t mount_readonly
 
uint32_t mount_no_root_dir
 
uint32_t no_pnp
 
static const char lxuid [] = "$LXUID"
 
static const char lxgid [] = "$LXGID"
 
static const char lxmod [] = "$LXMOD"
 
static const char lxdev [] = "$LXDEV"
 
PVOID Context
 
KSPIN_LOCK fve_data_lock
 
CACHE_MANAGER_CALLBACKS cache_callbacks
 
_In_ fcb _In_ chunk * c
 
_In_ fcb _In_ chunk _In_ uint64_t start_data
 
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t length
 
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool prealloc
 
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void * data
 
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP Irp
 
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY * rollback
 
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t compression
 
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t _In_ uint64_t decoded_size
 
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t _In_ uint64_t _In_ bool file_write
 
BTRFS_UUID boot_uuid
 

Macro Definition Documentation

◆ __attribute__

#define __attribute__ (   x)

Definition at line 1188 of file btrfs_drv.h.

◆ __drv_aliasesMem

#define __drv_aliasesMem

Definition at line 203 of file btrfs_drv.h.

◆ __S_IFBLK

#define __S_IFBLK   0060000 /* Block device. */

Definition at line 1746 of file btrfs_drv.h.

◆ __S_IFCHR

#define __S_IFCHR   0020000 /* Character device. */

Definition at line 1745 of file btrfs_drv.h.

◆ __S_IFDIR

#define __S_IFDIR   0040000 /* Directory. */

Definition at line 1744 of file btrfs_drv.h.

◆ __S_IFIFO

#define __S_IFIFO   0010000 /* FIFO. */

Definition at line 1748 of file btrfs_drv.h.

◆ __S_IFLNK

#define __S_IFLNK   0120000 /* Symbolic link. */

Definition at line 1749 of file btrfs_drv.h.

◆ __S_IFMT

#define __S_IFMT   0170000 /* These bits determine file type. */

Definition at line 1743 of file btrfs_drv.h.

◆ __S_IFREG

#define __S_IFREG   0100000 /* Regular file. */

Definition at line 1747 of file btrfs_drv.h.

◆ __S_IFSOCK

#define __S_IFSOCK   0140000 /* Socket. */

Definition at line 1750 of file btrfs_drv.h.

◆ __S_ISTYPE

#define __S_ISTYPE (   mode,
  mask 
)    (((mode) & __S_IFMT) == (mask))

Definition at line 1751 of file btrfs_drv.h.

◆ _CRT_SECURE_NO_WARNINGS

#define _CRT_SECURE_NO_WARNINGS

Definition at line 26 of file btrfs_drv.h.

◆ _Dispatch_type_

#define _Dispatch_type_ (   a)

Definition at line 204 of file btrfs_drv.h.

◆ _Lock_level_order_

#define _Lock_level_order_ (   a,
  b 
)

Definition at line 205 of file btrfs_drv.h.

◆ _NO_CRT_STDIO_INLINE

#define _NO_CRT_STDIO_INLINE

Definition at line 27 of file btrfs_drv.h.

◆ _WIN32_WINNT

#define _WIN32_WINNT   0x0601

Definition at line 24 of file btrfs_drv.h.

◆ acquire_chunk_lock

#define acquire_chunk_lock (   c,
  Vcb 
)    ExAcquireResourceExclusiveLite(&(c)->lock, true)

Definition at line 1131 of file btrfs_drv.h.

◆ ALLOC_TAG

#define ALLOC_TAG   0x7442484D

Definition at line 87 of file btrfs_drv.h.

◆ ALLOC_TAG_ZLIB

#define ALLOC_TAG_ZLIB   0x7A42484D

Definition at line 88 of file btrfs_drv.h.

◆ BALANCE_OPTS_DATA

#define BALANCE_OPTS_DATA   0

Definition at line 685 of file btrfs_drv.h.

◆ BALANCE_OPTS_METADATA

#define BALANCE_OPTS_METADATA   1

Definition at line 686 of file btrfs_drv.h.

◆ BALANCE_OPTS_SYSTEM

#define BALANCE_OPTS_SYSTEM   2

Definition at line 687 of file btrfs_drv.h.

◆ BLAKE2_HASH_SIZE

#define BLAKE2_HASH_SIZE   32

Definition at line 1243 of file btrfs_drv.h.

◆ BTRFS_NODE_TYPE_CCB

#define BTRFS_NODE_TYPE_CCB   0x2295

Definition at line 84 of file btrfs_drv.h.

◆ BTRFS_NODE_TYPE_FCB

#define BTRFS_NODE_TYPE_FCB   0x2296

Definition at line 85 of file btrfs_drv.h.

◆ BTRFS_VOLUME_PREFIX

#define BTRFS_VOLUME_PREFIX   L"\\Device\\Btrfs{"

Definition at line 127 of file btrfs_drv.h.

◆ CC_ENABLE_DISK_IO_ACCOUNTING

#define CC_ENABLE_DISK_IO_ACCOUNTING   0x00000010

Definition at line 1835 of file btrfs_drv.h.

◆ COMPRESSED_EXTENT_SIZE

#define COMPRESSED_EXTENT_SIZE   0x20000

Definition at line 112 of file btrfs_drv.h.

◆ EA_CASE_SENSITIVE

#define EA_CASE_SENSITIVE   "user.casesensitive"

Definition at line 105 of file btrfs_drv.h.

◆ EA_CASE_SENSITIVE_HASH

#define EA_CASE_SENSITIVE_HASH   0x1a9d97d4

Definition at line 106 of file btrfs_drv.h.

◆ EA_DOSATTRIB

#define EA_DOSATTRIB   "user.DOSATTRIB"

Definition at line 96 of file btrfs_drv.h.

◆ EA_DOSATTRIB_HASH

#define EA_DOSATTRIB_HASH   0x914f9939

Definition at line 97 of file btrfs_drv.h.

◆ EA_EA

#define EA_EA   "user.EA"

Definition at line 102 of file btrfs_drv.h.

◆ EA_EA_HASH

#define EA_EA_HASH   0x8270dd43

Definition at line 103 of file btrfs_drv.h.

◆ EA_NTACL

#define EA_NTACL   "security.NTACL"

Definition at line 93 of file btrfs_drv.h.

◆ EA_NTACL_HASH

#define EA_NTACL_HASH   0x45922146

Definition at line 94 of file btrfs_drv.h.

◆ EA_PROP_COMPRESSION

#define EA_PROP_COMPRESSION   "btrfs.compression"

Definition at line 108 of file btrfs_drv.h.

◆ EA_PROP_COMPRESSION_HASH

#define EA_PROP_COMPRESSION_HASH   0x20ccdf69

Definition at line 109 of file btrfs_drv.h.

◆ EA_REPARSE

#define EA_REPARSE   "user.reparse"

Definition at line 99 of file btrfs_drv.h.

◆ EA_REPARSE_HASH

#define EA_REPARSE_HASH   0xfabad1fe

Definition at line 100 of file btrfs_drv.h.

◆ ERR

#define ERR (   s,
  ... 
)    DbgPrint("Btrfs ERR : %s : " s, funcname, ##__VA_ARGS__)

Definition at line 1225 of file btrfs_drv.h.

◆ except

#define except (   x)    if (0 && (x))

Definition at line 136 of file btrfs_drv.h.

◆ FILE_CS_FLAG_CASE_SENSITIVE_DIR

#define FILE_CS_FLAG_CASE_SENSITIVE_DIR   1

Definition at line 165 of file btrfs_drv.h.

◆ FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL

#define FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL   0x00020000

Definition at line 156 of file btrfs_drv.h.

◆ FILE_SUPPORTS_BLOCK_REFCOUNTING

#define FILE_SUPPORTS_BLOCK_REFCOUNTING   0x08000000

Definition at line 148 of file btrfs_drv.h.

◆ FILE_SUPPORTS_POSIX_UNLINK_RENAME

#define FILE_SUPPORTS_POSIX_UNLINK_RENAME   0x00000400

Definition at line 152 of file btrfs_drv.h.

◆ finally

#define finally   if (1)

Definition at line 137 of file btrfs_drv.h.

◆ FIXME

#define FIXME (   s,
  ... 
)    DbgPrint("Btrfs FIXME : %s : " s, funcname, ##__VA_ARGS__)

Definition at line 1224 of file btrfs_drv.h.

◆ FSCTL_DUPLICATE_EXTENTS_TO_FILE

#define FSCTL_DUPLICATE_EXTENTS_TO_FILE   CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 209, METHOD_BUFFERED, FILE_WRITE_ACCESS)

Definition at line 182 of file btrfs_drv.h.

◆ FSCTL_GET_INTEGRITY_INFORMATION

#define FSCTL_GET_INTEGRITY_INFORMATION   CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 159, METHOD_BUFFERED, FILE_ANY_ACCESS)

Definition at line 198 of file btrfs_drv.h.

◆ FSCTL_SET_INTEGRITY_INFORMATION

#define FSCTL_SET_INTEGRITY_INFORMATION   CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 160, METHOD_BUFFERED, FILE_READ_DATA | FILE_WRITE_DATA)

Definition at line 199 of file btrfs_drv.h.

◆ FSRTL_FCB_HEADER_V2

#define FSRTL_FCB_HEADER_V2   2

Definition at line 1648 of file btrfs_drv.h.

◆ funcname

#define funcname   __func__

Definition at line 1168 of file btrfs_drv.h.

◆ GID_NOBODY

#define GID_NOBODY   65534

Definition at line 91 of file btrfs_drv.h.

◆ hex_digit

#define hex_digit (   c)    ((c) <= 9) ? ((c) + '0') : ((c) - 10 + 'a')

Definition at line 1738 of file btrfs_drv.h.

◆ increase_fileref_refcount

#define increase_fileref_refcount (   fileref)    InterlockedIncrement(&fileref->refcount)

Definition at line 1729 of file btrfs_drv.h.

◆ int3

#define int3   asm("int3;")

Definition at line 1735 of file btrfs_drv.h.

◆ InterlockedIncrement64

#define InterlockedIncrement64 (   a)    __sync_add_and_fetch(a, 1)

Definition at line 143 of file btrfs_drv.h.

◆ IO_REPARSE_TAG_AF_UNIX

#define IO_REPARSE_TAG_AF_UNIX   0x80000023

Definition at line 120 of file btrfs_drv.h.

◆ IO_REPARSE_TAG_LX_BLK

#define IO_REPARSE_TAG_LX_BLK   0x80000026

Definition at line 123 of file btrfs_drv.h.

◆ IO_REPARSE_TAG_LX_CHR

#define IO_REPARSE_TAG_LX_CHR   0x80000025

Definition at line 122 of file btrfs_drv.h.

◆ IO_REPARSE_TAG_LX_FIFO

#define IO_REPARSE_TAG_LX_FIFO   0x80000024

Definition at line 121 of file btrfs_drv.h.

◆ IO_REPARSE_TAG_LX_SYMLINK

#define IO_REPARSE_TAG_LX_SYMLINK   0xa000001d

Definition at line 118 of file btrfs_drv.h.

◆ keycmp

#define keycmp (   key1,
  key2 
)
Value:
((key1.obj_id < key2.obj_id) ? -1 :\
((key1.obj_id > key2.obj_id) ? 1 :\
((key1.obj_type < key2.obj_type) ? -1 :\
((key1.obj_type > key2.obj_type) ? 1 :\
((key1.offset < key2.offset) ? -1 :\
((key1.offset > key2.offset) ? 1 :\
0))))))
key1
GLuint64EXT GLuint GLuint GLenum GLenum GLuint GLuint GLenum GLuint GLuint key1
Definition: glext.h:10608

Definition at line 1008 of file btrfs_drv.h.

◆ leave

#define leave

Definition at line 138 of file btrfs_drv.h.

◆ major

#define major (   rdev)    ((((rdev) >> 8) & 0xFFF) | ((uint32_t)((rdev) >> 32) & ~0xFFF))

Definition at line 1811 of file btrfs_drv.h.

◆ makedev

#define makedev (   major,
  minor 
)    (((minor) & 0xFF) | (((major) & 0xFFF) << 8) | (((uint64_t)((minor) & ~0xFF)) << 12) | (((uint64_t)((major) & ~0xFFF)) << 32))

Definition at line 1630 of file btrfs_drv.h.

◆ MAX_EXTENT_SIZE

#define MAX_EXTENT_SIZE   0x8000000

Definition at line 111 of file btrfs_drv.h.

◆ MAX_HASH_SIZE

#define MAX_HASH_SIZE   32

Definition at line 213 of file btrfs_drv.h.

◆ minor

#define minor (   rdev)    (((rdev) & 0xFF) | ((uint32_t)((rdev) >> 12) & ~0xFF))

Definition at line 1812 of file btrfs_drv.h.

◆ NTDDI_VERSION

#define NTDDI_VERSION   0x06020000

Definition at line 25 of file btrfs_drv.h.

◆ READ_AHEAD_GRANULARITY

#define READ_AHEAD_GRANULARITY   COMPRESSED_EXTENT_SIZE

Definition at line 114 of file btrfs_drv.h.

◆ release_chunk_lock

#define release_chunk_lock (   c,
  Vcb 
)    ExReleaseResourceLite(&(c)->lock)

Definition at line 1132 of file btrfs_drv.h.

◆ S_IRGRP

#define S_IRGRP   (S_IRUSR >> 3)

Definition at line 1775 of file btrfs_drv.h.

◆ S_IROTH

#define S_IROTH   (S_IRGRP >> 3)

Definition at line 1787 of file btrfs_drv.h.

◆ S_IRUSR

#define S_IRUSR   0000400

Definition at line 1758 of file btrfs_drv.h.

◆ S_ISDIR

#define S_ISDIR (   mode)    __S_ISTYPE((mode), __S_IFDIR)

Definition at line 1754 of file btrfs_drv.h.

◆ S_ISGID

#define S_ISGID   0002000

Definition at line 1803 of file btrfs_drv.h.

◆ S_ISUID

#define S_ISUID   0004000

Definition at line 1799 of file btrfs_drv.h.

◆ S_ISVTX

#define S_ISVTX   0001000

Definition at line 1807 of file btrfs_drv.h.

◆ S_IWGRP

#define S_IWGRP   (S_IWUSR >> 3)

Definition at line 1779 of file btrfs_drv.h.

◆ S_IWOTH

#define S_IWOTH   (S_IWGRP >> 3)

Definition at line 1791 of file btrfs_drv.h.

◆ S_IWUSR

#define S_IWUSR   0000200

Definition at line 1762 of file btrfs_drv.h.

◆ S_IXGRP

#define S_IXGRP   (S_IXUSR >> 3)

Definition at line 1783 of file btrfs_drv.h.

◆ S_IXOTH

#define S_IXOTH   (S_IXGRP >> 3)

Definition at line 1795 of file btrfs_drv.h.

◆ S_IXUSR

#define S_IXUSR   0000100

Definition at line 1766 of file btrfs_drv.h.

◆ SHA256_HASH_SIZE

#define SHA256_HASH_SIZE   32

Definition at line 1239 of file btrfs_drv.h.

◆ TRACE

#define TRACE (   s,
  ... 
)    do { } while(0)

Definition at line 1222 of file btrfs_drv.h.

◆ try

#define try   if (1)

Definition at line 135 of file btrfs_drv.h.

◆ UID_NOBODY

#define UID_NOBODY   65534

Definition at line 90 of file btrfs_drv.h.

◆ UNUSED

#define UNUSED (   x)    (void)(x)

Definition at line 82 of file btrfs_drv.h.

◆ VCB_TYPE_BUS

#define VCB_TYPE_BUS   5

Definition at line 683 of file btrfs_drv.h.

◆ VCB_TYPE_CONTROL

#define VCB_TYPE_CONTROL   2

Definition at line 680 of file btrfs_drv.h.

◆ VCB_TYPE_FS

#define VCB_TYPE_FS   1

Definition at line 679 of file btrfs_drv.h.

◆ VCB_TYPE_PDO

#define VCB_TYPE_PDO   4

Definition at line 682 of file btrfs_drv.h.

◆ VCB_TYPE_VOLUME

#define VCB_TYPE_VOLUME   3

Definition at line 681 of file btrfs_drv.h.

◆ WARN

#define WARN (   s,
  ... 
)    do { } while(0)

Definition at line 1223 of file btrfs_drv.h.

Typedef Documentation

◆ ccb

typedef struct _ccb ccb

◆ device_extension

typedef struct _device_extension device_extension

◆ DUPLICATE_EXTENTS_DATA

typedef struct _DUPLICATE_EXTENTS_DATA DUPLICATE_EXTENTS_DATA

◆ fcb

_In_ fcb * fcb

Definition at line 1355 of file btrfs_drv.h.

◆ fcb_nonpaged

typedef struct _fcb_nonpaged fcb_nonpaged

◆ FILE_ID_128

typedef struct _FILE_ID_128 FILE_ID_128

◆ file_ref

typedef struct _file_ref file_ref

◆ FSCTL_GET_INTEGRITY_INFORMATION_BUFFER

typedef struct _FSCTL_GET_INTEGRITY_INFORMATION_BUFFER FSCTL_GET_INTEGRITY_INFORMATION_BUFFER

◆ FSCTL_SET_INTEGRITY_INFORMATION_BUFFER

typedef struct _FSCTL_SET_INTEGRITY_INFORMATION_BUFFER FSCTL_SET_INTEGRITY_INFORMATION_BUFFER

◆ LDR_DATA_TABLE_ENTRY

typedef struct _LDR_DATA_TABLE_ENTRY LDR_DATA_TABLE_ENTRY

◆ pdo_device_extension

typedef struct pdo_device_extension pdo_device_extension

◆ PDUPLICATE_EXTENTS_DATA

typedef struct _DUPLICATE_EXTENTS_DATA * PDUPLICATE_EXTENTS_DATA

◆ PEB

typedef struct _PEB PEB

◆ PEB_LDR_DATA

typedef struct _PEB_LDR_DATA PEB_LDR_DATA

◆ PFILE_ID_128

typedef struct _FILE_ID_128 * PFILE_ID_128

◆ PFSCTL_GET_INTEGRITY_INFORMATION_BUFFER

typedef struct _FSCTL_GET_INTEGRITY_INFORMATION_BUFFER * PFSCTL_GET_INTEGRITY_INFORMATION_BUFFER

◆ PFSCTL_SET_INTEGRITY_INFORMATION_BUFFER

typedef struct _FSCTL_SET_INTEGRITY_INFORMATION_BUFFER * PFSCTL_SET_INTEGRITY_INFORMATION_BUFFER

◆ PLDR_DATA_TABLE_ENTRY

typedef struct _LDR_DATA_TABLE_ENTRY* PLDR_DATA_TABLE_ENTRY

◆ PPEB

typedef struct _PEB* PPEB

◆ PPEB_LDR_DATA

typedef struct _PEB_LDR_DATA* PPEB_LDR_DATA

◆ PPS_POST_PROCESS_INIT_ROUTINE

typedef VOID(NTAPI * PPS_POST_PROCESS_INIT_ROUTINE) (VOID)

Definition at line 1895 of file btrfs_drv.h.

◆ PRTL_USER_PROCESS_PARAMETERS

typedef struct _RTL_USER_PROCESS_PARAMETERS* PRTL_USER_PROCESS_PARAMETERS

◆ root

typedef struct _root root

◆ root_cache

typedef struct _root_cache root_cache

◆ RTL_USER_PROCESS_PARAMETERS

typedef struct _RTL_USER_PROCESS_PARAMETERS RTL_USER_PROCESS_PARAMETERS

◆ tCcCopyReadEx

typedef BOOLEAN(__stdcall * tCcCopyReadEx) (PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PETHREAD IoIssuerThread)

Definition at line 1831 of file btrfs_drv.h.

◆ tCcCopyWriteEx

typedef BOOLEAN(__stdcall * tCcCopyWriteEx) (PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID Buffer, PETHREAD IoIssuerThread)

Definition at line 1828 of file btrfs_drv.h.

◆ tCcSetAdditionalCacheAttributesEx

typedef VOID(__stdcall * tCcSetAdditionalCacheAttributesEx) (PFILE_OBJECT FileObject, ULONG Flags)

Definition at line 1843 of file btrfs_drv.h.

◆ tFsRtlAreThereCurrentOrInProgressFileLocks

typedef BOOLEAN(__stdcall * tFsRtlAreThereCurrentOrInProgressFileLocks) (PFILE_LOCK FileLock)

Definition at line 1858 of file btrfs_drv.h.

◆ tFsRtlCheckLockForOplockRequest

typedef BOOLEAN(__stdcall * tFsRtlCheckLockForOplockRequest) (PFILE_LOCK FileLock, PLARGE_INTEGER AllocationSize)

Definition at line 1856 of file btrfs_drv.h.

◆ tFsRtlGetEcpListFromIrp

typedef NTSTATUS(__stdcall * tFsRtlGetEcpListFromIrp) (PIRP Irp, PECP_LIST *EcpList)

Definition at line 1849 of file btrfs_drv.h.

◆ tFsRtlGetNextExtraCreateParameter

typedef NTSTATUS(__stdcall * tFsRtlGetNextExtraCreateParameter) (PECP_LIST EcpList, PVOID CurrentEcpContext, LPGUID NextEcpType, PVOID *NextEcpContext, ULONG *NextEcpContextSize)

Definition at line 1851 of file btrfs_drv.h.

◆ tFsRtlUpdateDiskCounters

typedef VOID(__stdcall * tFsRtlUpdateDiskCounters) (ULONG64 BytesRead, ULONG64 BytesWritten)

Definition at line 1845 of file btrfs_drv.h.

◆ tFsRtlValidateReparsePointBuffer

typedef NTSTATUS(__stdcall * tFsRtlValidateReparsePointBuffer) (ULONG BufferLength, PREPARSE_DATA_BUFFER ReparseBuffer)

Definition at line 1854 of file btrfs_drv.h.

◆ tIoUnregisterPlugPlayNotificationEx

typedef NTSTATUS(__stdcall * tIoUnregisterPlugPlayNotificationEx) (PVOID NotificationEntry)

Definition at line 1847 of file btrfs_drv.h.

◆ tPsIsDiskCountersEnabled

typedef BOOLEAN(__stdcall * tPsIsDiskCountersEnabled) ()

Definition at line 1823 of file btrfs_drv.h.

◆ tPsUpdateDiskCounters

typedef VOID(__stdcall * tPsUpdateDiskCounters) (PEPROCESS Process, ULONG64 BytesRead, ULONG64 BytesWritten, ULONG ReadOperationCount, ULONG WriteOperationCount, ULONG FlushOperationCount)

Definition at line 1825 of file btrfs_drv.h.

◆ tree

typedef struct _tree tree

◆ tree_data

typedef struct _tree_data tree_data

◆ volume_device_extension

typedef struct _volume_device_extension volume_device_extension

◆ write_data_context

typedef struct _write_data_context write_data_context

◆ xor_func

typedef void(__stdcall * xor_func) (uint8_t *buf1, uint8_t *buf2, uint32_t len)

Definition at line 1123 of file btrfs_drv.h.

Enumeration Type Documentation

◆ batch_operation

enum batch_operation
Enumerator
Batch_Delete 
Batch_DeleteInode 
Batch_DeleteDirItem 
Batch_DeleteInodeRef 
Batch_DeleteInodeExtRef 
Batch_DeleteXattr 
Batch_DeleteExtentData 
Batch_DeleteFreeSpace 
Batch_Insert 
Batch_SetXattr 
Batch_DirItem 
Batch_InodeRef 
Batch_InodeExtRef 

Definition at line 470 of file btrfs_drv.h.

470  {
471  Batch_Delete,
472  Batch_DeleteInode,
473  Batch_DeleteDirItem,
474  Batch_DeleteInodeRef,
475  Batch_DeleteInodeExtRef,
476  Batch_DeleteXattr,
477  Batch_DeleteExtentData,
478  Batch_DeleteFreeSpace,
479  Batch_Insert,
480  Batch_SetXattr,
481  Batch_DirItem,
482  Batch_InodeRef,
483  Batch_InodeExtRef,
484 };
Batch_DeleteInode
Definition: btrfs_drv.h:472
Batch_DeleteExtentData
Definition: btrfs_drv.h:477
Batch_DirItem
Definition: btrfs_drv.h:481
Batch_DeleteXattr
Definition: btrfs_drv.h:476
Batch_Delete
Definition: btrfs_drv.h:471
Batch_DeleteInodeRef
Definition: btrfs_drv.h:474
Batch_Insert
Definition: btrfs_drv.h:479
Batch_DeleteInodeExtRef
Definition: btrfs_drv.h:475
Batch_InodeRef
Definition: btrfs_drv.h:482
Batch_DeleteDirItem
Definition: btrfs_drv.h:473
Batch_InodeExtRef
Definition: btrfs_drv.h:483
Batch_SetXattr
Definition: btrfs_drv.h:480
Batch_DeleteFreeSpace
Definition: btrfs_drv.h:478

◆ calc_thread_type

enum calc_thread_type
Enumerator
calc_thread_crc32c 
calc_thread_xxhash 
calc_thread_sha256 
calc_thread_blake2 
calc_thread_decomp_zlib 
calc_thread_decomp_lzo 
calc_thread_decomp_zstd 
calc_thread_comp_zlib 
calc_thread_comp_lzo 
calc_thread_comp_zstd 

Definition at line 620 of file btrfs_drv.h.

620  {
621  calc_thread_crc32c,
622  calc_thread_xxhash,
623  calc_thread_sha256,
624  calc_thread_blake2,
625  calc_thread_decomp_zlib,
626  calc_thread_decomp_lzo,
627  calc_thread_decomp_zstd,
628  calc_thread_comp_zlib,
629  calc_thread_comp_lzo,
630  calc_thread_comp_zstd,
631 };
calc_thread_decomp_lzo
Definition: btrfs_drv.h:626
calc_thread_decomp_zstd
Definition: btrfs_drv.h:627
calc_thread_crc32c
Definition: btrfs_drv.h:621
calc_thread_decomp_zlib
Definition: btrfs_drv.h:625
calc_thread_xxhash
Definition: btrfs_drv.h:622
calc_thread_sha256
Definition: btrfs_drv.h:623
calc_thread_blake2
Definition: btrfs_drv.h:624
calc_thread_comp_lzo
Definition: btrfs_drv.h:629
calc_thread_comp_zstd
Definition: btrfs_drv.h:630
calc_thread_comp_zlib
Definition: btrfs_drv.h:628

◆ prop_compression_type

enum prop_compression_type
Enumerator
PropCompression_None 
PropCompression_Zlib 
PropCompression_LZO 
PropCompression_ZSTD 

Definition at line 267 of file btrfs_drv.h.

267  {
268  PropCompression_None,
269  PropCompression_Zlib,
270  PropCompression_LZO,
271  PropCompression_ZSTD
272 };
PropCompression_None
Definition: btrfs_drv.h:268
PropCompression_LZO
Definition: btrfs_drv.h:270
PropCompression_ZSTD
Definition: btrfs_drv.h:271
PropCompression_Zlib
Definition: btrfs_drv.h:269

◆ rollback_type

enum rollback_type
Enumerator
ROLLBACK_INSERT_EXTENT 
ROLLBACK_DELETE_EXTENT 
ROLLBACK_ADD_SPACE 
ROLLBACK_SUBTRACT_SPACE 

Definition at line 1258 of file btrfs_drv.h.

1258  {
1259  ROLLBACK_INSERT_EXTENT,
1260  ROLLBACK_DELETE_EXTENT,
1261  ROLLBACK_ADD_SPACE,
1262  ROLLBACK_SUBTRACT_SPACE
1263 };
ROLLBACK_INSERT_EXTENT
Definition: btrfs_drv.h:1259
ROLLBACK_SUBTRACT_SPACE
Definition: btrfs_drv.h:1262
ROLLBACK_DELETE_EXTENT
Definition: btrfs_drv.h:1260
ROLLBACK_ADD_SPACE
Definition: btrfs_drv.h:1261

◆ write_data_status

enum write_data_status
Enumerator
WriteDataStatus_Pending 
WriteDataStatus_Success 
WriteDataStatus_Error 
WriteDataStatus_Cancelling 
WriteDataStatus_Cancelled 
WriteDataStatus_Ignore 

Definition at line 906 of file btrfs_drv.h.

906  {
907  WriteDataStatus_Pending,
908  WriteDataStatus_Success,
909  WriteDataStatus_Error,
910  WriteDataStatus_Cancelling,
911  WriteDataStatus_Cancelled,
912  WriteDataStatus_Ignore
913 };
WriteDataStatus_Success
Definition: btrfs_drv.h:908
WriteDataStatus_Ignore
Definition: btrfs_drv.h:912
WriteDataStatus_Cancelled
Definition: btrfs_drv.h:911
WriteDataStatus_Error
Definition: btrfs_drv.h:909
WriteDataStatus_Pending
Definition: btrfs_drv.h:907
WriteDataStatus_Cancelling
Definition: btrfs_drv.h:910

Function Documentation

◆ __attribute__() [1/2]

IN PIRP Irp __attribute__ ( (nonnull(1, 2))  )

Definition at line 2730 of file read.c.

2731  {
2732  ULONG readlen;
2733 
2734  TRACE("(%p, %p, %I64x, %lx, %p)\n", fcb, data, start, length, pbr);
2735 
2736  if (pbr) *pbr = 0;
2737 
2738  if (start >= fcb->adsdata.Length) {
2739  TRACE("tried to read beyond end of stream\n");
2740  return STATUS_END_OF_FILE;
2741  }
2742 
2743  if (length == 0) {
2744  WARN("tried to read zero bytes\n");
2745  return STATUS_SUCCESS;
2746  }
2747 
2748  if (start + length < fcb->adsdata.Length)
2749  readlen = length;
2750  else
2751  readlen = fcb->adsdata.Length - (ULONG)start;
2752 
2753  if (readlen > 0)
2754  RtlCopyMemory(data, fcb->adsdata.Buffer + start, readlen);
2755 
2756  if (pbr) *pbr = readlen;
2757 
2758  return STATUS_SUCCESS;
2759 }
_ANSI_STRING::Buffer
PSTR Buffer
Definition: env_spec_w32.h:378
WARN
#define WARN(fmt,...)
Definition: debug.h:112
STATUS_END_OF_FILE
#define STATUS_END_OF_FILE
Definition: shellext.h:67
length
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
_ANSI_STRING::Length
USHORT Length
Definition: env_spec_w32.h:376
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
_fcb
Definition: btrfs_drv.h:282
start
GLuint start
Definition: gl.h:1545
_fcb::adsdata
ANSI_STRING adsdata
Definition: btrfs_drv.h:334
ULONG
unsigned int ULONG
Definition: retypes.h:1
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65

◆ __attribute__() [2/2]

_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t _In_ uint64_t _In_ bool _In_ uint64_t irp_offset __attribute__ ( (nonnull(1, 2, 3, 9))  )

◆ _Create_lock_level_()

_Create_lock_level_ ( tree_lock  )

◆ _Dispatch_type_() [1/12]

_Dispatch_type_ ( IRP_MJ_WRITE  )

◆ _Dispatch_type_() [2/12]

NTSTATUS bool void NTSTATUS void _Dispatch_type_ ( IRP_MJ_DIRECTORY_CONTROL  )

◆ _Dispatch_type_() [3/12]

_Dispatch_type_ ( IRP_MJ_QUERY_SECURITY  )

◆ _Dispatch_type_() [4/12]

_Dispatch_type_ ( IRP_MJ_SET_SECURITY  )

◆ _Dispatch_type_() [5/12]

_Dispatch_type_ ( IRP_MJ_SET_INFORMATION  )

◆ _Dispatch_type_() [6/12]

_Dispatch_type_ ( IRP_MJ_QUERY_INFORMATION  )

◆ _Dispatch_type_() [7/12]

_Dispatch_type_ ( IRP_MJ_QUERY_EA  )

◆ _Dispatch_type_() [8/12]

_Dispatch_type_ ( IRP_MJ_SET_EA  )

◆ _Dispatch_type_() [9/12]

_Dispatch_type_ ( IRP_MJ_CREATE  )

Definition at line 984 of file isapnp.c.

995 {
996  PAGED_CODE();
997 
998  Irp->IoStatus.Status = STATUS_SUCCESS;
999 
1000  DPRINT("%s(%p, %p)\n", __FUNCTION__, DeviceObject, Irp);
1001 
1002  IoCompleteRequest(Irp, IO_NO_INCREMENT);
1003 
1004  return STATUS_SUCCESS;
1005 }
DeviceObject
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
Irp
_In_ PIRP Irp
Definition: csq.h:116
IoCompleteRequest
#define IoCompleteRequest
Definition: irp.c:1240
IO_NO_INCREMENT
#define IO_NO_INCREMENT
Definition: iotypes.h:598
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
DPRINT
#define DPRINT
Definition: sndvol32.h:71
__FUNCTION__
#define __FUNCTION__
Definition: types.h:112
PAGED_CODE
#define PAGED_CODE()
Definition: Bus_PDO_QueryResourceRequirements.c:89

◆ _Dispatch_type_() [10/12]

_Dispatch_type_ ( IRP_MJ_READ  )

◆ _Dispatch_type_() [11/12]

_Dispatch_type_ ( IRP_MJ_PNP  )

Definition at line 1581 of file isapnp.c.

1591 {
1592  PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
1593  PISAPNP_COMMON_EXTENSION DevExt = DeviceObject->DeviceExtension;
1594 
1595  PAGED_CODE();
1596 
1597  if (DevExt->Signature == IsaPnpBus)
1598  return IsaFdoPnp((PISAPNP_FDO_EXTENSION)DevExt, Irp, IrpSp);
1599  else
1600  return IsaPdoPnp((PISAPNP_PDO_EXTENSION)DevExt, Irp, IrpSp);
1601 }
_ISAPNP_FDO_EXTENSION
Definition: isapnp.h:155
_IO_STACK_LOCATION
Definition: iotypes.h:3110
_ISAPNP_COMMON_EXTENSION
Definition: isapnp.h:148
DeviceObject
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
Irp
_In_ PIRP Irp
Definition: csq.h:116
IoGetCurrentIrpStackLocation
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
IrpSp
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4137
IsaFdoPnp
NTSTATUS IsaFdoPnp(_In_ PISAPNP_FDO_EXTENSION FdoExt, _Inout_ PIRP Irp, _In_ PIO_STACK_LOCATION IrpSp)
Definition: fdo.c:123
_ISAPNP_COMMON_EXTENSION::Signature
ISAPNP_SIGNATURE Signature
Definition: isapnp.h:150
IsaPdoPnp
NTSTATUS IsaPdoPnp(_In_ PISAPNP_PDO_EXTENSION PdoDeviceExtension, _Inout_ PIRP Irp, _In_ PIO_STACK_LOCATION IrpSp)
Definition: pdo.c:864
_ISAPNP_PDO_EXTENSION
Definition: isapnp.h:176
PAGED_CODE
#define PAGED_CODE()
Definition: Bus_PDO_QueryResourceRequirements.c:89

◆ _Dispatch_type_() [12/12]

_Dispatch_type_ ( IRP_MJ_DEVICE_CONTROL  )

Definition at line 1007 of file isapnp.c.

1018 {
1019  PISAPNP_COMMON_EXTENSION CommonExt = DeviceObject->DeviceExtension;
1020 
1021  PAGED_CODE();
1022 
1023  DPRINT("%s(%p, %p) Minor - %X\n", __FUNCTION__, DeviceObject, Irp,
1024  IoGetCurrentIrpStackLocation(Irp)->MinorFunction);
1025 
1026  if (CommonExt->Signature == IsaPnpBus)
1027  {
1028  IoSkipCurrentIrpStackLocation(Irp);
1029  return IoCallDriver(((PISAPNP_FDO_EXTENSION)CommonExt)->Ldo, Irp);
1030  }
1031  else
1032  {
1033  NTSTATUS Status = Irp->IoStatus.Status;
1034 
1035  IoCompleteRequest(Irp, IO_NO_INCREMENT);
1036  return Status;
1037  }
1038 }
_ISAPNP_FDO_EXTENSION
Definition: isapnp.h:155
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
_ISAPNP_COMMON_EXTENSION
Definition: isapnp.h:148
DeviceObject
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
Irp
_In_ PIRP Irp
Definition: csq.h:116
MinorFunction
_In_ UCHAR _In_ UCHAR MinorFunction
Definition: wdfdevice.h:1697
IoCompleteRequest
#define IoCompleteRequest
Definition: irp.c:1240
Status
Status
Definition: gdiplustypes.h:24
IoGetCurrentIrpStackLocation
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
IoCallDriver
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
IoSkipCurrentIrpStackLocation
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421
_ISAPNP_COMMON_EXTENSION::Signature
ISAPNP_SIGNATURE Signature
Definition: isapnp.h:150
IO_NO_INCREMENT
#define IO_NO_INCREMENT
Definition: iotypes.h:598
DPRINT
#define DPRINT
Definition: sndvol32.h:71
__FUNCTION__
#define __FUNCTION__
Definition: types.h:112
PAGED_CODE
#define PAGED_CODE()
Definition: Bus_PDO_QueryResourceRequirements.c:89

◆ _Function_class_() [1/3]

_Function_class_ ( DRIVER_ADD_DEVICE  )

◆ _Function_class_() [2/3]

_Function_class_ ( KSTART_ROUTINE  )

Definition at line 3047 of file balance.c.

3048  {
3049  device_extension* Vcb = (device_extension*)context;
3050  LIST_ENTRY chunks;
3051  LIST_ENTRY* le;
3052  uint64_t num_chunks[3], okay_metadata_chunks = 0, okay_data_chunks = 0, okay_system_chunks = 0;
3053  uint64_t old_data_flags = 0, old_metadata_flags = 0, old_system_flags = 0;
3054  NTSTATUS Status;
3055 
3056  Vcb->balance.balance_num++;
3057 
3058  Vcb->balance.stopping = false;
3059  KeInitializeEvent(&Vcb->balance.finished, NotificationEvent, false);
3060 
3061  if (Vcb->balance.opts[BALANCE_OPTS_DATA].flags & BTRFS_BALANCE_OPTS_ENABLED && Vcb->balance.opts[BALANCE_OPTS_DATA].flags & BTRFS_BALANCE_OPTS_CONVERT) {
3062  old_data_flags = Vcb->data_flags;
3063  Vcb->data_flags = BLOCK_FLAG_DATA | (Vcb->balance.opts[BALANCE_OPTS_DATA].convert == BLOCK_FLAG_SINGLE ? 0 : Vcb->balance.opts[BALANCE_OPTS_DATA].convert);
3064 
3065  FsRtlNotifyVolumeEvent(Vcb->root_file, FSRTL_VOLUME_CHANGE_SIZE);
3066  }
3067 
3068  if (Vcb->balance.opts[BALANCE_OPTS_METADATA].flags & BTRFS_BALANCE_OPTS_ENABLED && Vcb->balance.opts[BALANCE_OPTS_METADATA].flags & BTRFS_BALANCE_OPTS_CONVERT) {
3069  old_metadata_flags = Vcb->metadata_flags;
3070  Vcb->metadata_flags = BLOCK_FLAG_METADATA | (Vcb->balance.opts[BALANCE_OPTS_METADATA].convert == BLOCK_FLAG_SINGLE ? 0 : Vcb->balance.opts[BALANCE_OPTS_METADATA].convert);
3071  }
3072 
3073  if (Vcb->balance.opts[BALANCE_OPTS_SYSTEM].flags & BTRFS_BALANCE_OPTS_ENABLED && Vcb->balance.opts[BALANCE_OPTS_SYSTEM].flags & BTRFS_BALANCE_OPTS_CONVERT) {
3074  old_system_flags = Vcb->system_flags;
3075  Vcb->system_flags = BLOCK_FLAG_SYSTEM | (Vcb->balance.opts[BALANCE_OPTS_SYSTEM].convert == BLOCK_FLAG_SINGLE ? 0 : Vcb->balance.opts[BALANCE_OPTS_SYSTEM].convert);
3076  }
3077 
3078  if (Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_MIXED_GROUPS) {
3079  if (Vcb->balance.opts[BALANCE_OPTS_DATA].flags & BTRFS_BALANCE_OPTS_ENABLED)
3080  RtlCopyMemory(&Vcb->balance.opts[BALANCE_OPTS_METADATA], &Vcb->balance.opts[BALANCE_OPTS_DATA], sizeof(btrfs_balance_opts));
3081  else if (Vcb->balance.opts[BALANCE_OPTS_METADATA].flags & BTRFS_BALANCE_OPTS_ENABLED)
3082  RtlCopyMemory(&Vcb->balance.opts[BALANCE_OPTS_DATA], &Vcb->balance.opts[BALANCE_OPTS_METADATA], sizeof(btrfs_balance_opts));
3083  }
3084 
3085  num_chunks[0] = num_chunks[1] = num_chunks[2] = 0;
3086  Vcb->balance.total_chunks = Vcb->balance.chunks_left = 0;
3087 
3088  InitializeListHead(&chunks);
3089 
3090  // FIXME - what are we supposed to do with limit_start?
3091 
3092  if (!Vcb->readonly) {
3093  if (!Vcb->balance.removing && !Vcb->balance.shrinking) {
3094  Status = add_balance_item(Vcb);
3095  if (!NT_SUCCESS(Status)) {
3096  ERR("add_balance_item returned %08lx\n", Status);
3097  Vcb->balance.status = Status;
3098  goto end;
3099  }
3100  } else {
3101  if (Vcb->need_write) {
3102  Status = do_write(Vcb, NULL);
3103 
3104  free_trees(Vcb);
3105 
3106  if (!NT_SUCCESS(Status)) {
3107  ERR("do_write returned %08lx\n", Status);
3108  Vcb->balance.status = Status;
3109  goto end;
3110  }
3111  }
3112  }
3113  }
3114 
3115  KeWaitForSingleObject(&Vcb->balance.event, Executive, KernelMode, false, NULL);
3116 
3117  if (Vcb->balance.stopping)
3118  goto end;
3119 
3120  ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
3121 
3122  le = Vcb->chunks.Flink;
3123  while (le != &Vcb->chunks) {
3124  chunk* c = CONTAINING_RECORD(le, chunk, list_entry);
3125  uint8_t sort;
3126 
3127  acquire_chunk_lock(c, Vcb);
3128 
3129  if (c->chunk_item->type & BLOCK_FLAG_DATA)
3130  sort = BALANCE_OPTS_DATA;
3131  else if (c->chunk_item->type & BLOCK_FLAG_METADATA)
3132  sort = BALANCE_OPTS_METADATA;
3133  else if (c->chunk_item->type & BLOCK_FLAG_SYSTEM)
3134  sort = BALANCE_OPTS_SYSTEM;
3135  else {
3136  ERR("unexpected chunk type %I64x\n", c->chunk_item->type);
3137  release_chunk_lock(c, Vcb);
3138  break;
3139  }
3140 
3141  if ((!(Vcb->balance.opts[sort].flags & BTRFS_BALANCE_OPTS_LIMIT) || num_chunks[sort] < Vcb->balance.opts[sort].limit_end) &&
3142  should_balance_chunk(Vcb, sort, c)) {
3143  InsertTailList(&chunks, &c->list_entry_balance);
3144 
3145  num_chunks[sort]++;
3146  Vcb->balance.total_chunks++;
3147  Vcb->balance.chunks_left++;
3148  } else if (sort == BALANCE_OPTS_METADATA)
3149  okay_metadata_chunks++;
3150  else if (sort == BALANCE_OPTS_DATA)
3151  okay_data_chunks++;
3152  else if (sort == BALANCE_OPTS_SYSTEM)
3153  okay_system_chunks++;
3154 
3155  if (!c->cache_loaded) {
3156  Status = load_cache_chunk(Vcb, c, NULL);
3157 
3158  if (!NT_SUCCESS(Status)) {
3159  ERR("load_cache_chunk returned %08lx\n", Status);
3160  Vcb->balance.status = Status;
3161  release_chunk_lock(c, Vcb);
3162  ExReleaseResourceLite(&Vcb->chunk_lock);
3163  goto end;
3164  }
3165  }
3166 
3167  release_chunk_lock(c, Vcb);
3168 
3169  le = le->Flink;
3170  }
3171 
3172  ExReleaseResourceLite(&Vcb->chunk_lock);
3173 
3174  // If we're doing a full balance, try and allocate a new chunk now, before we mess things up
3175  if (okay_metadata_chunks == 0 || okay_data_chunks == 0 || okay_system_chunks == 0) {
3176  bool consolidated = false;
3177  chunk* c;
3178 
3179  if (okay_metadata_chunks == 0) {
3180  ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, true);
3181 
3182  Status = alloc_chunk(Vcb, Vcb->metadata_flags, &c, true);
3183  if (NT_SUCCESS(Status))
3184  c->balance_num = Vcb->balance.balance_num;
3185  else if (Status != STATUS_DISK_FULL || consolidated) {
3186  ERR("alloc_chunk returned %08lx\n", Status);
3187  ExReleaseResourceLite(&Vcb->chunk_lock);
3188  Vcb->balance.status = Status;
3189  goto end;
3190  }
3191 
3192  ExReleaseResourceLite(&Vcb->chunk_lock);
3193 
3194  if (Status == STATUS_DISK_FULL) {
3195  Status = try_consolidation(Vcb, Vcb->metadata_flags, &c);
3196  if (!NT_SUCCESS(Status)) {
3197  ERR("try_consolidation returned %08lx\n", Status);
3198  Vcb->balance.status = Status;
3199  goto end;
3200  } else
3201  c->balance_num = Vcb->balance.balance_num;
3202 
3203  consolidated = true;
3204 
3205  if (Vcb->balance.stopping)
3206  goto end;
3207  }
3208  }
3209 
3210  if (okay_data_chunks == 0) {
3211  ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, true);
3212 
3213  Status = alloc_chunk(Vcb, Vcb->data_flags, &c, true);
3214  if (NT_SUCCESS(Status))
3215  c->balance_num = Vcb->balance.balance_num;
3216  else if (Status != STATUS_DISK_FULL || consolidated) {
3217  ERR("alloc_chunk returned %08lx\n", Status);
3218  ExReleaseResourceLite(&Vcb->chunk_lock);
3219  Vcb->balance.status = Status;
3220  goto end;
3221  }
3222 
3223  ExReleaseResourceLite(&Vcb->chunk_lock);
3224 
3225  if (Status == STATUS_DISK_FULL) {
3226  Status = try_consolidation(Vcb, Vcb->data_flags, &c);
3227  if (!NT_SUCCESS(Status)) {
3228  ERR("try_consolidation returned %08lx\n", Status);
3229  Vcb->balance.status = Status;
3230  goto end;
3231  } else
3232  c->balance_num = Vcb->balance.balance_num;
3233 
3234  consolidated = true;
3235 
3236  if (Vcb->balance.stopping)
3237  goto end;
3238  }
3239  }
3240 
3241  if (okay_system_chunks == 0) {
3242  ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, true);
3243 
3244  Status = alloc_chunk(Vcb, Vcb->system_flags, &c, true);
3245  if (NT_SUCCESS(Status))
3246  c->balance_num = Vcb->balance.balance_num;
3247  else if (Status != STATUS_DISK_FULL || consolidated) {
3248  ERR("alloc_chunk returned %08lx\n", Status);
3249  ExReleaseResourceLite(&Vcb->chunk_lock);
3250  Vcb->balance.status = Status;
3251  goto end;
3252  }
3253 
3254  ExReleaseResourceLite(&Vcb->chunk_lock);
3255 
3256  if (Status == STATUS_DISK_FULL) {
3257  Status = try_consolidation(Vcb, Vcb->system_flags, &c);
3258  if (!NT_SUCCESS(Status)) {
3259  ERR("try_consolidation returned %08lx\n", Status);
3260  Vcb->balance.status = Status;
3261  goto end;
3262  } else
3263  c->balance_num = Vcb->balance.balance_num;
3264 
3265  consolidated = true;
3266 
3267  if (Vcb->balance.stopping)
3268  goto end;
3269  }
3270  }
3271  }
3272 
3273  ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
3274 
3275  le = chunks.Flink;
3276  while (le != &chunks) {
3277  chunk* c = CONTAINING_RECORD(le, chunk, list_entry_balance);
3278 
3279  c->reloc = true;
3280 
3281  le = le->Flink;
3282  }
3283 
3284  ExReleaseResourceLite(&Vcb->chunk_lock);
3285 
3286  // do data chunks before metadata
3287  le = chunks.Flink;
3288  while (le != &chunks) {
3289  chunk* c = CONTAINING_RECORD(le, chunk, list_entry_balance);
3290  LIST_ENTRY* le2 = le->Flink;
3291 
3292  if (c->chunk_item->type & BLOCK_FLAG_DATA) {
3293  bool changed;
3294 
3295  do {
3296  changed = false;
3297 
3298  Status = balance_data_chunk(Vcb, c, &changed);
3299  if (!NT_SUCCESS(Status)) {
3300  ERR("balance_data_chunk returned %08lx\n", Status);
3301  Vcb->balance.status = Status;
3302  goto end;
3303  }
3304 
3305  KeWaitForSingleObject(&Vcb->balance.event, Executive, KernelMode, false, NULL);
3306 
3307  if (Vcb->readonly)
3308  Vcb->balance.stopping = true;
3309 
3310  if (Vcb->balance.stopping)
3311  break;
3312  } while (changed);
3313 
3314  c->changed = true;
3315  c->space_changed = true;
3316  }
3317 
3318  if (Vcb->balance.stopping)
3319  goto end;
3320 
3321  if (c->chunk_item->type & BLOCK_FLAG_DATA &&
3322  (!(Vcb->balance.opts[BALANCE_OPTS_METADATA].flags & BTRFS_BALANCE_OPTS_ENABLED) || !(c->chunk_item->type & BLOCK_FLAG_METADATA))) {
3323  RemoveEntryList(&c->list_entry_balance);
3324  c->list_entry_balance.Flink = NULL;
3325 
3326  Vcb->balance.chunks_left--;
3327  }
3328 
3329  le = le2;
3330  }
3331 
3332  // do metadata chunks
3333  while (!IsListEmpty(&chunks)) {
3334  chunk* c;
3335  bool changed;
3336 
3337  le = RemoveHeadList(&chunks);
3338  c = CONTAINING_RECORD(le, chunk, list_entry_balance);
3339 
3340  if (c->chunk_item->type & BLOCK_FLAG_METADATA || c->chunk_item->type & BLOCK_FLAG_SYSTEM) {
3341  do {
3342  Status = balance_metadata_chunk(Vcb, c, &changed);
3343  if (!NT_SUCCESS(Status)) {
3344  ERR("balance_metadata_chunk returned %08lx\n", Status);
3345  Vcb->balance.status = Status;
3346  goto end;
3347  }
3348 
3349  KeWaitForSingleObject(&Vcb->balance.event, Executive, KernelMode, false, NULL);
3350 
3351  if (Vcb->readonly)
3352  Vcb->balance.stopping = true;
3353 
3354  if (Vcb->balance.stopping)
3355  break;
3356  } while (changed);
3357 
3358  c->changed = true;
3359  c->space_changed = true;
3360  }
3361 
3362  if (Vcb->balance.stopping)
3363  break;
3364 
3365  c->list_entry_balance.Flink = NULL;
3366 
3367  Vcb->balance.chunks_left--;
3368  }
3369 
3370 end:
3371  if (!Vcb->readonly) {
3372  if (Vcb->balance.stopping || !NT_SUCCESS(Vcb->balance.status)) {
3373  le = chunks.Flink;
3374  while (le != &chunks) {
3375  chunk* c = CONTAINING_RECORD(le, chunk, list_entry_balance);
3376  c->reloc = false;
3377 
3378  le = le->Flink;
3379  c->list_entry_balance.Flink = NULL;
3380  }
3381 
3382  if (old_data_flags != 0)
3383  Vcb->data_flags = old_data_flags;
3384 
3385  if (old_metadata_flags != 0)
3386  Vcb->metadata_flags = old_metadata_flags;
3387 
3388  if (old_system_flags != 0)
3389  Vcb->system_flags = old_system_flags;
3390  }
3391 
3392  if (Vcb->balance.removing) {
3393  device* dev = NULL;
3394 
3395  ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
3396 
3397  le = Vcb->devices.Flink;
3398  while (le != &Vcb->devices) {
3399  device* dev2 = CONTAINING_RECORD(le, device, list_entry);
3400 
3401  if (dev2->devitem.dev_id == Vcb->balance.opts[0].devid) {
3402  dev = dev2;
3403  break;
3404  }
3405 
3406  le = le->Flink;
3407  }
3408 
3409  if (dev) {
3410  if (Vcb->balance.chunks_left == 0) {
3411  Status = finish_removing_device(Vcb, dev);
3412 
3413  if (!NT_SUCCESS(Status)) {
3414  ERR("finish_removing_device returned %08lx\n", Status);
3415  dev->reloc = false;
3416  }
3417  } else
3418  dev->reloc = false;
3419  }
3420 
3421  ExReleaseResourceLite(&Vcb->tree_lock);
3422  } else if (Vcb->balance.shrinking) {
3423  device* dev = NULL;
3424 
3425  ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
3426 
3427  le = Vcb->devices.Flink;
3428  while (le != &Vcb->devices) {
3429  device* dev2 = CONTAINING_RECORD(le, device, list_entry);
3430 
3431  if (dev2->devitem.dev_id == Vcb->balance.opts[0].devid) {
3432  dev = dev2;
3433  break;
3434  }
3435 
3436  le = le->Flink;
3437  }
3438 
3439  if (!dev) {
3440  ERR("could not find device %I64x\n", Vcb->balance.opts[0].devid);
3441  Vcb->balance.status = STATUS_INTERNAL_ERROR;
3442  }
3443 
3444  if (Vcb->balance.stopping || !NT_SUCCESS(Vcb->balance.status)) {
3445  if (dev) {
3446  Status = regenerate_space_list(Vcb, dev);
3447  if (!NT_SUCCESS(Status))
3448  WARN("regenerate_space_list returned %08lx\n", Status);
3449  }
3450  } else {
3451  uint64_t old_size;
3452 
3453  old_size = dev->devitem.num_bytes;
3454  dev->devitem.num_bytes = Vcb->balance.opts[0].drange_start;
3455 
3456  Status = update_dev_item(Vcb, dev, NULL);
3457  if (!NT_SUCCESS(Status)) {
3458  ERR("update_dev_item returned %08lx\n", Status);
3459  dev->devitem.num_bytes = old_size;
3460  Vcb->balance.status = Status;
3461 
3462  Status = regenerate_space_list(Vcb, dev);
3463  if (!NT_SUCCESS(Status))
3464  WARN("regenerate_space_list returned %08lx\n", Status);
3465  } else {
3466  Vcb->superblock.total_bytes -= old_size - dev->devitem.num_bytes;
3467 
3468  Status = do_write(Vcb, NULL);
3469  if (!NT_SUCCESS(Status))
3470  ERR("do_write returned %08lx\n", Status);
3471 
3472  free_trees(Vcb);
3473  }
3474  }
3475 
3476  ExReleaseResourceLite(&Vcb->tree_lock);
3477 
3478  if (!Vcb->balance.stopping && NT_SUCCESS(Vcb->balance.status))
3479  FsRtlNotifyVolumeEvent(Vcb->root_file, FSRTL_VOLUME_CHANGE_SIZE);
3480  } else {
3481  Status = remove_balance_item(Vcb);
3482  if (!NT_SUCCESS(Status)) {
3483  ERR("remove_balance_item returned %08lx\n", Status);
3484  goto end;
3485  }
3486  }
3487 
3488  if (Vcb->trim && !Vcb->options.no_trim) {
3489  ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
3490 
3491  le = Vcb->devices.Flink;
3492  while (le != &Vcb->devices) {
3493  device* dev2 = CONTAINING_RECORD(le, device, list_entry);
3494 
3495  if (dev2->devobj && !dev2->readonly && dev2->trim)
3496  trim_unalloc_space(Vcb, dev2);
3497 
3498  le = le->Flink;
3499  }
3500 
3501  ExReleaseResourceLite(&Vcb->tree_lock);
3502  }
3503  }
3504 
3505  ZwClose(Vcb->balance.thread);
3506  Vcb->balance.thread = NULL;
3507 
3508  KeSetEvent(&Vcb->balance.finished, 0, false);
3509 }
should_balance_chunk
static bool should_balance_chunk(device_extension *Vcb, uint8_t sort, chunk *c)
Definition: balance.c:2225
BALANCE_OPTS_SYSTEM
#define BALANCE_OPTS_SYSTEM
Definition: btrfs_drv.h:687
context
Definition: http.c:7251
ZwClose
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
sort
_STLP_MOVE_TO_STD_NAMESPACE void sort(_RandomAccessIter __first, _RandomAccessIter __last)
Definition: _algo.c:993
do_write
NTSTATUS do_write(device_extension *Vcb, PIRP Irp)
Definition: flushthread.c:7759
device::devobj
PDEVICE_OBJECT devobj
Definition: btrfs_drv.h:518
WARN
#define WARN(fmt,...)
Definition: debug.h:112
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
device::readonly
bool readonly
Definition: btrfs_drv.h:523
InsertTailList
#define InsertTailList(ListHead, Entry)
Definition: env_spec_w32.h:1003
balance_metadata_chunk
static NTSTATUS balance_metadata_chunk(device_extension *Vcb, chunk *c, bool *changed)
Definition: balance.c:1100
KeSetEvent
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159
KeWaitForSingleObject
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
IsListEmpty
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
BLOCK_FLAG_SINGLE
#define BLOCK_FLAG_SINGLE
Definition: btrfsioctl.h:141
RemoveEntryList
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
ExAcquireResourceExclusiveLite
BOOLEAN NTAPI ExAcquireResourceExclusiveLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:770
STATUS_INTERNAL_ERROR
#define STATUS_INTERNAL_ERROR
Definition: ntstatus.h:465
try_consolidation
static NTSTATUS try_consolidation(device_extension *Vcb, uint64_t flags, chunk **newchunk)
Definition: balance.c:2902
BTRFS_BALANCE_OPTS_CONVERT
#define BTRFS_BALANCE_OPTS_CONVERT
Definition: btrfsioctl.h:138
device
Definition: devices.h:37
BTRFS_INCOMPAT_FLAGS_MIXED_GROUPS
#define BTRFS_INCOMPAT_FLAGS_MIXED_GROUPS
Definition: btrfs.h:117
BLOCK_FLAG_SYSTEM
#define BLOCK_FLAG_SYSTEM
Definition: shellext.h:76
device::trim
bool trim
Definition: btrfs_drv.h:525
RemoveHeadList
FORCEINLINE PLIST_ENTRY RemoveHeadList(_Inout_ PLIST_ENTRY ListHead)
Definition: rtlfuncs.h:128
release_chunk_lock
#define release_chunk_lock(c, Vcb)
Definition: btrfs_drv.h:1132
alloc_chunk
NTSTATUS alloc_chunk(device_extension *Vcb, uint64_t flags, chunk **pc, bool full_size) __attribute__((nonnull(1
CONTAINING_RECORD
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_VOLUME_CHANGE_SIZE
#define FSRTL_VOLUME_CHANGE_SIZE
Definition: fsrtltypes.h:101
Status
Status
Definition: gdiplustypes.h:24
add_balance_item
static NTSTATUS add_balance_item(device_extension *Vcb)
Definition: balance.c:2378
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
regenerate_space_list
static NTSTATUS regenerate_space_list(device_extension *Vcb, device *dev)
Definition: balance.c:2997
FsRtlNotifyVolumeEvent
NTSTATUS NTAPI FsRtlNotifyVolumeEvent(IN PFILE_OBJECT FileObject, IN ULONG EventCode)
Definition: pnp.c:38
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
Vcb
#define Vcb
Definition: cdprocs.h:1415
BTRFS_BALANCE_OPTS_LIMIT
#define BTRFS_BALANCE_OPTS_LIMIT
Definition: btrfsioctl.h:135
c
const GLubyte * c
Definition: glext.h:8905
ExReleaseResourceLite
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817
end
GLuint GLuint end
Definition: gl.h:1545
update_dev_item
NTSTATUS update_dev_item(device_extension *Vcb, device *device, PIRP Irp)
Definition: flushthread.c:4087
BTRFS_BALANCE_OPTS_ENABLED
#define BTRFS_BALANCE_OPTS_ENABLED
Definition: btrfsioctl.h:130
BLOCK_FLAG_METADATA
#define BLOCK_FLAG_METADATA
Definition: shellext.h:77
DEV_ITEM::dev_id
uint64_t dev_id
Definition: btrfs.h:178
_LIST_ENTRY
Definition: typedefs.h:119
uint8_t
BYTE uint8_t
Definition: msvideo1.c:66
free_trees
NTSTATUS NTSTATUS bool bool void free_trees(device_extension *Vcb) __attribute__((nonnull(1)))
load_cache_chunk
NTSTATUS load_cache_chunk(device_extension *Vcb, chunk *c, PIRP Irp)
Definition: free-space.c:980
ERR
#define ERR(fmt,...)
Definition: debug.h:110
remove_balance_item
static NTSTATUS remove_balance_item(device_extension *Vcb)
Definition: balance.c:2451
balance_data_chunk
static NTSTATUS balance_data_chunk(device_extension *Vcb, chunk *c, bool *changed)
Definition: balance.c:1671
uint64_t
UINT64 uint64_t
Definition: types.h:77
KeInitializeEvent
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
btrfs_balance_opts
Definition: btrfsioctl.h:143
acquire_chunk_lock
#define acquire_chunk_lock(c, Vcb)
Definition: btrfs_drv.h:1131
InitializeListHead
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
list_entry
Definition: list.h:27
device::devitem
DEV_ITEM devitem
Definition: btrfs_drv.h:520
NULL
#define NULL
Definition: types.h:112
ExAcquireResourceSharedLite
BOOLEAN NTAPI ExAcquireResourceSharedLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:885
BLOCK_FLAG_DATA
#define BLOCK_FLAG_DATA
Definition: shellext.h:75
finish_removing_device
static NTSTATUS finish_removing_device(_Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension *Vcb, device *dev)
Definition: balance.c:2586
STATUS_DISK_FULL
#define STATUS_DISK_FULL
Definition: udferr_usr.h:155
trim_unalloc_space
static void trim_unalloc_space(_Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, device *dev)
Definition: balance.c:2802
c
#define c
Definition: ke_i.h:80
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
BALANCE_OPTS_METADATA
#define BALANCE_OPTS_METADATA
Definition: btrfs_drv.h:686
_device_extension
Definition: btrfs_drv.h:750
BALANCE_OPTS_DATA
#define BALANCE_OPTS_DATA
Definition: btrfs_drv.h:685

◆ _Function_class_() [3/3]

_Function_class_ ( DRIVER_NOTIFICATION_CALLBACK_ROUTINE  )

◆ _Post_satisfies_()

_Post_satisfies_ ( return >=  n)

◆ _Releases_lock_()

_Releases_lock_ ( c->  lock)

◆ _Requires_lock_held_() [1/2]

_Requires_lock_held_ ( Vcb->  fcb_lock) -> fcb_lock) static __inline void release_fcb_lock(device_extension* Vcb)

Definition at line 963 of file btrfs_drv.h.

965  {
966  ExReleaseResourceLite(&Vcb->fcb_lock);
967 }
Vcb
#define Vcb
Definition: cdprocs.h:1415
ExReleaseResourceLite
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817

◆ _Requires_lock_held_() [2/2]

_Requires_lock_held_ ( c->  lock)
pure virtual

◆ _Requires_lock_not_held_()

_Requires_lock_not_held_ ( Vcb->  fcb_lock) -> fcb_lock) static __inline void acquire_fcb_lock_shared(device_extension* Vcb)

Definition at line 951 of file btrfs_drv.h.

953  {
954  ExAcquireResourceSharedLite(&Vcb->fcb_lock, true);
955 }
Vcb
#define Vcb
Definition: cdprocs.h:1415
ExAcquireResourceSharedLite
BOOLEAN NTAPI ExAcquireResourceSharedLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:885

◆ _Success_()

_Success_ ( return  )

◆ add_calc_job_comp()

NTSTATUS add_calc_job_comp ( device_extension *  Vcb,
uint8_t  compression,
void *  in,
unsigned int  inlen,
void *  out,
unsigned int  outlen,
calc_job **  pcj 
)

Definition at line 237 of file calcthread.c.

238  {
239  calc_job* cj;
240  KIRQL irql;
241 
242  cj = ExAllocatePoolWithTag(NonPagedPool, sizeof(calc_job), ALLOC_TAG);
243  if (!cj) {
244  ERR("out of memory\n");
245  return STATUS_INSUFFICIENT_RESOURCES;
246  }
247 
248  cj->in = in;
249  cj->inlen = inlen;
250  cj->out = out;
251  cj->outlen = outlen;
252  cj->left = cj->not_started = 1;
253  cj->Status = STATUS_SUCCESS;
254 
255  switch (compression) {
256  case BTRFS_COMPRESSION_ZLIB:
257  cj->type = calc_thread_comp_zlib;
258  break;
259 
260  case BTRFS_COMPRESSION_LZO:
261  cj->type = calc_thread_comp_lzo;
262  break;
263 
264  case BTRFS_COMPRESSION_ZSTD:
265  cj->type = calc_thread_comp_zstd;
266  break;
267 
268  default:
269  ERR("unexpected compression type %x\n", compression);
270  ExFreePool(cj);
271  return STATUS_NOT_SUPPORTED;
272  }
273 
274  KeInitializeEvent(&cj->event, NotificationEvent, false);
275 
276  KeAcquireSpinLock(&Vcb->calcthreads.spinlock, &irql);
277 
278  InsertTailList(&Vcb->calcthreads.job_list, &cj->list_entry);
279 
280  KeSetEvent(&Vcb->calcthreads.event, 0, false);
281  KeClearEvent(&Vcb->calcthreads.event);
282 
283  KeReleaseSpinLock(&Vcb->calcthreads.spinlock, irql);
284 
285  *pcj = cj;
286 
287  return STATUS_SUCCESS;
288 }
STATUS_NOT_SUPPORTED
return STATUS_NOT_SUPPORTED
Definition: fxdriverapi.cpp:376
cj
_In_ ULONG cj
Definition: winddi.h:3540
STATUS_INSUFFICIENT_RESOURCES
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
pcj
_In_ ULONG * pcj
Definition: winddi.h:3642
KeAcquireSpinLock
VOID NTAPI KeAcquireSpinLock(PKSPIN_LOCK SpinLock, PKIRQL OldIrql)
Definition: spinlock.c:50
irql
KIRQL irql
Definition: wave.h:1
BTRFS_COMPRESSION_LZO
#define BTRFS_COMPRESSION_LZO
Definition: btrfs.h:67
BTRFS_COMPRESSION_ZSTD
#define BTRFS_COMPRESSION_ZSTD
Definition: btrfs.h:68
InsertTailList
#define InsertTailList(ListHead, Entry)
Definition: env_spec_w32.h:1003
calc_job
Definition: btrfs_drv.h:633
KeSetEvent
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159
BTRFS_COMPRESSION_ZLIB
#define BTRFS_COMPRESSION_ZLIB
Definition: btrfs.h:66
ALLOC_TAG
#define ALLOC_TAG
Definition: btrfs_drv.h:87
KIRQL
UCHAR KIRQL
Definition: env_spec_w32.h:591
compression
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t compression
Definition: btrfs_drv.h:1355
Vcb
#define Vcb
Definition: cdprocs.h:1415
out
static FILE * out
Definition: regtests2xml.c:44
ExAllocatePoolWithTag
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
ERR
#define ERR(fmt,...)
Definition: debug.h:110
KeInitializeEvent
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
in
GLuint in
Definition: glext.h:9616
KeReleaseSpinLock
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
calc_thread_comp_lzo
Definition: btrfs_drv.h:629
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
KeClearEvent
VOID NTAPI KeClearEvent(IN PKEVENT Event)
Definition: eventobj.c:22
ExFreePool
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
calc_thread_comp_zstd
Definition: btrfs_drv.h:630
calc_thread_comp_zlib
Definition: btrfs_drv.h:628

Referenced by write_compressed().

◆ add_calc_job_decomp()

NTSTATUS add_calc_job_decomp ( device_extension *  Vcb,
uint8_t  compression,
void *  in,
unsigned int  inlen,
void *  out,
unsigned int  outlen,
unsigned int  off,
calc_job **  pcj 
)

Definition at line 183 of file calcthread.c.

184  {
185  calc_job* cj;
186  KIRQL irql;
187 
188  cj = ExAllocatePoolWithTag(NonPagedPool, sizeof(calc_job), ALLOC_TAG);
189  if (!cj) {
190  ERR("out of memory\n");
191  return STATUS_INSUFFICIENT_RESOURCES;
192  }
193 
194  cj->in = in;
195  cj->inlen = inlen;
196  cj->out = out;
197  cj->outlen = outlen;
198  cj->off = off;
199  cj->left = cj->not_started = 1;
200  cj->Status = STATUS_SUCCESS;
201 
202  switch (compression) {
203  case BTRFS_COMPRESSION_ZLIB:
204  cj->type = calc_thread_decomp_zlib;
205  break;
206 
207  case BTRFS_COMPRESSION_LZO:
208  cj->type = calc_thread_decomp_lzo;
209  break;
210 
211  case BTRFS_COMPRESSION_ZSTD:
212  cj->type = calc_thread_decomp_zstd;
213  break;
214 
215  default:
216  ERR("unexpected compression type %x\n", compression);
217  ExFreePool(cj);
218  return STATUS_NOT_SUPPORTED;
219  }
220 
221  KeInitializeEvent(&cj->event, NotificationEvent, false);
222 
223  KeAcquireSpinLock(&Vcb->calcthreads.spinlock, &irql);
224 
225  InsertTailList(&Vcb->calcthreads.job_list, &cj->list_entry);
226 
227  KeSetEvent(&Vcb->calcthreads.event, 0, false);
228  KeClearEvent(&Vcb->calcthreads.event);
229 
230  KeReleaseSpinLock(&Vcb->calcthreads.spinlock, irql);
231 
232  *pcj = cj;
233 
234  return STATUS_SUCCESS;
235 }
calc_thread_decomp_lzo
Definition: btrfs_drv.h:626
calc_thread_decomp_zstd
Definition: btrfs_drv.h:627
STATUS_NOT_SUPPORTED
return STATUS_NOT_SUPPORTED
Definition: fxdriverapi.cpp:376
cj
_In_ ULONG cj
Definition: winddi.h:3540
STATUS_INSUFFICIENT_RESOURCES
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
pcj
_In_ ULONG * pcj
Definition: winddi.h:3642
KeAcquireSpinLock
VOID NTAPI KeAcquireSpinLock(PKSPIN_LOCK SpinLock, PKIRQL OldIrql)
Definition: spinlock.c:50
irql
KIRQL irql
Definition: wave.h:1
BTRFS_COMPRESSION_LZO
#define BTRFS_COMPRESSION_LZO
Definition: btrfs.h:67
BTRFS_COMPRESSION_ZSTD
#define BTRFS_COMPRESSION_ZSTD
Definition: btrfs.h:68
InsertTailList
#define InsertTailList(ListHead, Entry)
Definition: env_spec_w32.h:1003
calc_job
Definition: btrfs_drv.h:633
KeSetEvent
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159
BTRFS_COMPRESSION_ZLIB
#define BTRFS_COMPRESSION_ZLIB
Definition: btrfs.h:66
ALLOC_TAG
#define ALLOC_TAG
Definition: btrfs_drv.h:87
KIRQL
UCHAR KIRQL
Definition: env_spec_w32.h:591
compression
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t compression
Definition: btrfs_drv.h:1355
calc_thread_decomp_zlib
Definition: btrfs_drv.h:625
Vcb
#define Vcb
Definition: cdprocs.h:1415
out
static FILE * out
Definition: regtests2xml.c:44
ExAllocatePoolWithTag
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
ERR
#define ERR(fmt,...)
Definition: debug.h:110
KeInitializeEvent
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
in
GLuint in
Definition: glext.h:9616
KeReleaseSpinLock
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
KeClearEvent
VOID NTAPI KeClearEvent(IN PKEVENT Event)
Definition: eventobj.c:22
ExFreePool
#define ExFreePool(addr)
Definition: env_spec_w32.h:352

◆ add_changed_extent_ref()

void add_changed_extent_ref ( chunk *  c,
uint64_t  address,
uint64_t  size,
uint64_t  root,
uint64_t  objid,
uint64_t  offset,
uint32_t  count,
bool  no_csum 
)

Definition at line 2076 of file extent-tree.c.

2076  {
2077  changed_extent* ce;
2078  changed_extent_ref* cer;
2079  LIST_ENTRY* le;
2080 
2081  ce = get_changed_extent_item(c, address, size, no_csum);
2082 
2083  if (!ce) {
2084  ERR("get_changed_extent_item failed\n");
2085  return;
2086  }
2087 
2088  le = ce->refs.Flink;
2089  while (le != &ce->refs) {
2090  cer = CONTAINING_RECORD(le, changed_extent_ref, list_entry);
2091 
2092  if (cer->type == TYPE_EXTENT_DATA_REF && cer->edr.root == root && cer->edr.objid == objid && cer->edr.offset == offset) {
2093  ce->count += count;
2094  cer->edr.count += count;
2095  return;
2096  }
2097 
2098  le = le->Flink;
2099  }
2100 
2101  cer = ExAllocatePoolWithTag(PagedPool, sizeof(changed_extent_ref), ALLOC_TAG);
2102 
2103  if (!cer) {
2104  ERR("out of memory\n");
2105  return;
2106  }
2107 
2108  cer->type = TYPE_EXTENT_DATA_REF;
2109  cer->edr.root = root;
2110  cer->edr.objid = objid;
2111  cer->edr.offset = offset;
2112  cer->edr.count = count;
2113 
2114  InsertTailList(&ce->refs, &cer->list_entry);
2115 
2116  ce->count += count;
2117 }
EXTENT_DATA_REF::offset
uint64_t offset
Definition: btrfs.h:419
changed_extent_ref::list_entry
LIST_ENTRY list_entry
Definition: btrfs_drv.h:610
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
root
struct _root root
EXTENT_DATA_REF::objid
uint64_t objid
Definition: btrfs.h:418
changed_extent_ref
Definition: btrfs_drv.h:602
changed_extent_ref::type
uint8_t type
Definition: btrfs_drv.h:603
InsertTailList
#define InsertTailList(ListHead, Entry)
Definition: env_spec_w32.h:1003
ALLOC_TAG
#define ALLOC_TAG
Definition: btrfs_drv.h:87
changed_extent
Definition: btrfs_drv.h:589
changed_extent_ref::edr
EXTENT_DATA_REF edr
Definition: btrfs_drv.h:606
EXTENT_DATA_REF::count
uint32_t count
Definition: btrfs.h:420
changed_extent::count
uint64_t count
Definition: btrfs_drv.h:593
EXTENT_DATA_REF::root
uint64_t root
Definition: btrfs.h:417
CONTAINING_RECORD
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
TYPE_EXTENT_DATA_REF
#define TYPE_EXTENT_DATA_REF
Definition: btrfs.h:38
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
size
GLsizeiptr size
Definition: glext.h:5919
offset
GLintptr offset
Definition: glext.h:5920
c
const GLubyte * c
Definition: glext.h:8905
address
GLuint address
Definition: glext.h:9393
ExAllocatePoolWithTag
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
_root
Definition: btrfs_drv.h:450
_LIST_ENTRY
Definition: typedefs.h:119
ERR
#define ERR(fmt,...)
Definition: debug.h:110
changed_extent::refs
LIST_ENTRY refs
Definition: btrfs_drv.h:597
get_changed_extent_item
static changed_extent * get_changed_extent_item(chunk *c, uint64_t address, uint64_t size, bool no_csum)
Definition: extent-tree.c:1916
list_entry
Definition: list.h:27

Referenced by insert_extent_chunk(), rationalize_extents(), and write_compressed().

◆ add_checksum_entry()

void add_checksum_entry ( device_extension *  Vcb,
uint64_t  address,
ULONG  length,
void *  csum,
PIRP  Irp 
)

Definition at line 2596 of file flushthread.c.

2596  {
2597  KEY searchkey;
2598  traverse_ptr tp, next_tp;
2599  NTSTATUS Status;
2600  uint64_t startaddr, endaddr;
2601  ULONG len;
2602  RTL_BITMAP bmp;
2603  ULONG* bmparr;
2604  ULONG runlength, index;
2605 
2606  TRACE("(%p, %I64x, %lx, %p, %p)\n", Vcb, address, length, csum, Irp);
2607 
2608  searchkey.obj_id = EXTENT_CSUM_ID;
2609  searchkey.obj_type = TYPE_EXTENT_CSUM;
2610  searchkey.offset = address;
2611 
2612  // FIXME - create checksum_root if it doesn't exist at all
2613 
2614  Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, false, Irp);
2615  if (Status == STATUS_NOT_FOUND) { // tree is completely empty
2616  if (csum) { // not deleted
2617  ULONG length2 = length;
2618  uint64_t off = address;
2619  void* data = csum;
2620 
2621  do {
2622  uint16_t il = (uint16_t)min(length2, MAX_CSUM_SIZE / Vcb->csum_size);
2623 
2624  void* checksums = ExAllocatePoolWithTag(PagedPool, il * Vcb->csum_size, ALLOC_TAG);
2625  if (!checksums) {
2626  ERR("out of memory\n");
2627  return;
2628  }
2629 
2630  RtlCopyMemory(checksums, data, il * Vcb->csum_size);
2631 
2632  Status = insert_tree_item(Vcb, Vcb->checksum_root, EXTENT_CSUM_ID, TYPE_EXTENT_CSUM, off, checksums,
2633  il * Vcb->csum_size, NULL, Irp);
2634  if (!NT_SUCCESS(Status)) {
2635  ERR("insert_tree_item returned %08lx\n", Status);
2636  ExFreePool(checksums);
2637  return;
2638  }
2639 
2640  length2 -= il;
2641 
2642  if (length2 > 0) {
2643  off += (uint64_t)il << Vcb->sector_shift;
2644  data = (uint8_t*)data + (il * Vcb->csum_size);
2645  }
2646  } while (length2 > 0);
2647  }
2648  } else if (!NT_SUCCESS(Status)) {
2649  ERR("find_item returned %08lx\n", Status);
2650  return;
2651  } else {
2652  uint32_t tplen;
2653  void* checksums;
2654 
2655  // FIXME - check entry is TYPE_EXTENT_CSUM?
2656 
2657  if (tp.item->key.offset < address && tp.item->key.offset + (((uint64_t)tp.item->size << Vcb->sector_shift) / Vcb->csum_size) >= address)
2658  startaddr = tp.item->key.offset;
2659  else
2660  startaddr = address;
2661 
2662  searchkey.obj_id = EXTENT_CSUM_ID;
2663  searchkey.obj_type = TYPE_EXTENT_CSUM;
2664  searchkey.offset = address + (length << Vcb->sector_shift);
2665 
2666  Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, false, Irp);
2667  if (!NT_SUCCESS(Status)) {
2668  ERR("find_item returned %08lx\n", Status);
2669  return;
2670  }
2671 
2672  tplen = tp.item->size / Vcb->csum_size;
2673 
2674  if (tp.item->key.offset + (tplen << Vcb->sector_shift) >= address + (length << Vcb->sector_shift))
2675  endaddr = tp.item->key.offset + (tplen << Vcb->sector_shift);
2676  else
2677  endaddr = address + (length << Vcb->sector_shift);
2678 
2679  TRACE("cs starts at %I64x (%lx sectors)\n", address, length);
2680  TRACE("startaddr = %I64x\n", startaddr);
2681  TRACE("endaddr = %I64x\n", endaddr);
2682 
2683  len = (ULONG)((endaddr - startaddr) >> Vcb->sector_shift);
2684 
2685  checksums = ExAllocatePoolWithTag(PagedPool, Vcb->csum_size * len, ALLOC_TAG);
2686  if (!checksums) {
2687  ERR("out of memory\n");
2688  return;
2689  }
2690 
2691  bmparr = ExAllocatePoolWithTag(PagedPool, sizeof(ULONG) * ((len/8)+1), ALLOC_TAG);
2692  if (!bmparr) {
2693  ERR("out of memory\n");
2694  ExFreePool(checksums);
2695  return;
2696  }
2697 
2698  RtlInitializeBitMap(&bmp, bmparr, len);
2699  RtlSetAllBits(&bmp);
2700 
2701  searchkey.obj_id = EXTENT_CSUM_ID;
2702  searchkey.obj_type = TYPE_EXTENT_CSUM;
2703  searchkey.offset = address;
2704 
2705  Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, false, Irp);
2706  if (!NT_SUCCESS(Status)) {
2707  ERR("find_item returned %08lx\n", Status);
2708  ExFreePool(checksums);
2709  ExFreePool(bmparr);
2710  return;
2711  }
2712 
2713  // set bit = free space, cleared bit = allocated sector
2714 
2715  while (tp.item->key.offset < endaddr) {
2716  if (tp.item->key.offset >= startaddr) {
2717  if (tp.item->size > 0) {
2718  ULONG itemlen = (ULONG)min((len - ((tp.item->key.offset - startaddr) >> Vcb->sector_shift)) * Vcb->csum_size, tp.item->size);
2719 
2720  RtlCopyMemory((uint8_t*)checksums + (((tp.item->key.offset - startaddr) * Vcb->csum_size) >> Vcb->sector_shift),
2721  tp.item->data, itemlen);
2722  RtlClearBits(&bmp, (ULONG)((tp.item->key.offset - startaddr) >> Vcb->sector_shift), itemlen / Vcb->csum_size);
2723  }
2724 
2725  Status = delete_tree_item(Vcb, &tp);
2726  if (!NT_SUCCESS(Status)) {
2727  ERR("delete_tree_item returned %08lx\n", Status);
2728  ExFreePool(checksums);
2729  ExFreePool(bmparr);
2730  return;
2731  }
2732  }
2733 
2734  if (find_next_item(Vcb, &tp, &next_tp, false, Irp)) {
2735  tp = next_tp;
2736  } else
2737  break;
2738  }
2739 
2740  if (!csum) { // deleted
2741  RtlSetBits(&bmp, (ULONG)((address - startaddr) >> Vcb->sector_shift), length);
2742  } else {
2743  RtlCopyMemory((uint8_t*)checksums + (((address - startaddr) * Vcb->csum_size) >> Vcb->sector_shift),
2744  csum, length * Vcb->csum_size);
2745  RtlClearBits(&bmp, (ULONG)((address - startaddr) >> Vcb->sector_shift), length);
2746  }
2747 
2748  runlength = RtlFindFirstRunClear(&bmp, &index);
2749 
2750  while (runlength != 0) {
2751  if (index >= len)
2752  break;
2753 
2754  if (index + runlength >= len) {
2755  runlength = len - index;
2756 
2757  if (runlength == 0)
2758  break;
2759  }
2760 
2761  do {
2762  uint16_t rl;
2763  uint64_t off;
2764  void* data;
2765 
2766  if (runlength * Vcb->csum_size > MAX_CSUM_SIZE)
2767  rl = (uint16_t)(MAX_CSUM_SIZE / Vcb->csum_size);
2768  else
2769  rl = (uint16_t)runlength;
2770 
2771  data = ExAllocatePoolWithTag(PagedPool, Vcb->csum_size * rl, ALLOC_TAG);
2772  if (!data) {
2773  ERR("out of memory\n");
2774  ExFreePool(bmparr);
2775  ExFreePool(checksums);
2776  return;
2777  }
2778 
2779  RtlCopyMemory(data, (uint8_t*)checksums + (Vcb->csum_size * index), Vcb->csum_size * rl);
2780 
2781  off = startaddr + ((uint64_t)index << Vcb->sector_shift);
2782 
2783  Status = insert_tree_item(Vcb, Vcb->checksum_root, EXTENT_CSUM_ID, TYPE_EXTENT_CSUM, off, data, Vcb->csum_size * rl, NULL, Irp);
2784  if (!NT_SUCCESS(Status)) {
2785  ERR("insert_tree_item returned %08lx\n", Status);
2786  ExFreePool(data);
2787  ExFreePool(bmparr);
2788  ExFreePool(checksums);
2789  return;
2790  }
2791 
2792  runlength -= rl;
2793  index += rl;
2794  } while (runlength > 0);
2795 
2796  runlength = RtlFindNextForwardRunClear(&bmp, index, &index);
2797  }
2798 
2799  ExFreePool(bmparr);
2800  ExFreePool(checksums);
2801  }
2802 }
KEY::obj_id
uint64_t obj_id
Definition: btrfs.h:144
MAX_CSUM_SIZE
#define MAX_CSUM_SIZE
Definition: flushthread.c:28
KEY::obj_type
uint8_t obj_type
Definition: btrfs.h:145
RtlInitializeBitMap
NTSYSAPI void WINAPI RtlInitializeBitMap(PRTL_BITMAP, PULONG, ULONG)
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
_tree_data::size
uint16_t size
Definition: btrfs_drv.h:414
uint16_t
unsigned short int uint16_t
Definition: acefiex.h:54
uint16_t
#define uint16_t
Definition: nsiface.idl:60
find_next_item
NTSTATUS NTSTATUS bool find_next_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, const traverse_ptr *tp, traverse_ptr *next_tp, bool ignore, PIRP Irp) __attribute__((nonnull(1
KEY::offset
uint64_t offset
Definition: btrfs.h:146
_tree_data::data
uint8_t * data
Definition: btrfs_drv.h:415
_RTL_BITMAP
Definition: typedefs.h:88
TYPE_EXTENT_CSUM
#define TYPE_EXTENT_CSUM
Definition: btrfs.h:31
ALLOC_TAG
#define ALLOC_TAG
Definition: btrfs_drv.h:87
Irp
_In_ PIRP Irp
Definition: csq.h:116
_tree_data::key
KEY key
Definition: btrfs_drv.h:405
length
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
RtlSetAllBits
NTSYSAPI void WINAPI RtlSetAllBits(PRTL_BITMAP)
insert_tree_item
NTSTATUS insert_tree_item(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_ root *r, _In_ uint64_t obj_id, _In_ uint8_t obj_type, _In_ uint64_t offset, _In_reads_bytes_opt_(size) _When_(return >=0, __drv_aliasesMem) void *data, _In_ uint16_t size, _Out_opt_ traverse_ptr *ptp, _In_opt_ PIRP Irp) __attribute__((nonnull(1
index
GLuint index
Definition: glext.h:6031
traverse_ptr
Definition: btrfs_drv.h:500
tp
_In_ uint64_t _In_ uint64_t _In_ uint64_t _In_opt_ traverse_ptr * tp
Definition: btrfs.c:2965
Status
Status
Definition: gdiplustypes.h:24
STATUS_NOT_FOUND
#define STATUS_NOT_FOUND
Definition: shellext.h:72
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
find_item
NTSTATUS find_item(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_ root *r, _Out_ traverse_ptr *tp, _In_ const KEY *searchkey, _In_ bool ignore, _In_opt_ PIRP Irp) __attribute__((nonnull(1
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
Vcb
#define Vcb
Definition: cdprocs.h:1415
address
GLuint address
Definition: glext.h:9393
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
bmp
BITMAP bmp
Definition: alphablend.c:62
ExAllocatePoolWithTag
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
traverse_ptr::item
tree_data * item
Definition: btrfs_drv.h:502
index
#define index(s, c)
Definition: various.h:29
len
GLenum GLsizei len
Definition: glext.h:6722
startaddr
static void startaddr(void)
Definition: adnsresfilter.c:345
uint8_t
BYTE uint8_t
Definition: msvideo1.c:66
uint64_t
#define uint64_t
Definition: nsiface.idl:62
ERR
#define ERR(fmt,...)
Definition: debug.h:110
RtlClearBits
NTSYSAPI void WINAPI RtlClearBits(PRTL_BITMAP, ULONG, ULONG)
KEY
Definition: btrfs.h:143
EXTENT_CSUM_ID
#define EXTENT_CSUM_ID
Definition: btrfs.h:91
uint64_t
UINT64 uint64_t
Definition: types.h:77
delete_tree_item
NTSTATUS NTSTATUS delete_tree_item(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _Inout_ traverse_ptr *tp) __attribute__((nonnull(1
RtlFindFirstRunClear
NTSYSAPI ULONG NTAPI RtlFindFirstRunClear(_In_ PRTL_BITMAP BitMapHeader, _Out_ PULONG StartingIndex)
RtlSetBits
NTSYSAPI void WINAPI RtlSetBits(PRTL_BITMAP, ULONG, ULONG)
min
#define min(a, b)
Definition: monoChain.cc:55
NULL
#define NULL
Definition: types.h:112
uint32_t
UINT32 uint32_t
Definition: types.h:75
RtlFindNextForwardRunClear
NTSYSAPI ULONG WINAPI RtlFindNextForwardRunClear(PCRTL_BITMAP, ULONG, PULONG)
csum
Definition: ffs.h:52
ULONG
unsigned int ULONG
Definition: retypes.h:1
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
ExFreePool
#define ExFreePool(addr)
Definition: env_spec_w32.h:352

Referenced by balance_data_chunk(), decrease_extent_refcount(), flush_fcb(), and rationalize_extents().

◆ add_dir_child()

NTSTATUS add_dir_child ( fcb *  fcb,
uint64_t  inode,
bool  subvol,
PANSI_STRING  utf8,
PUNICODE_STRING  name,
uint8_t  type,
dir_child **  pdc 
)

Definition at line 1871 of file create.c.

1871  {
1872  NTSTATUS Status;
1873  dir_child* dc;
1874  bool locked;
1875 
1876  dc = ExAllocatePoolWithTag(PagedPool, sizeof(dir_child), ALLOC_TAG);
1877  if (!dc) {
1878  ERR("out of memory\n");
1879  return STATUS_INSUFFICIENT_RESOURCES;
1880  }
1881 
1882  RtlZeroMemory(dc, sizeof(dir_child));
1883 
1884  dc->utf8.Buffer = ExAllocatePoolWithTag(PagedPool, utf8->Length, ALLOC_TAG);
1885  if (!dc->utf8.Buffer) {
1886  ERR("out of memory\n");
1887  ExFreePool(dc);
1888  return STATUS_INSUFFICIENT_RESOURCES;
1889  }
1890 
1891  dc->name.Buffer = ExAllocatePoolWithTag(PagedPool, name->Length, ALLOC_TAG);
1892  if (!dc->name.Buffer) {
1893  ERR("out of memory\n");
1894  ExFreePool(dc->utf8.Buffer);
1895  ExFreePool(dc);
1896  return STATUS_INSUFFICIENT_RESOURCES;
1897  }
1898 
1899  dc->key.obj_id = inode;
1900  dc->key.obj_type = subvol ? TYPE_ROOT_ITEM : TYPE_INODE_ITEM;
1901  dc->key.offset = subvol ? 0xffffffffffffffff : 0;
1902  dc->type = type;
1903  dc->fileref = NULL;
1904 
1905  dc->utf8.Length = dc->utf8.MaximumLength = utf8->Length;
1906  RtlCopyMemory(dc->utf8.Buffer, utf8->Buffer, utf8->Length);
1907 
1908  dc->name.Length = dc->name.MaximumLength = name->Length;
1909  RtlCopyMemory(dc->name.Buffer, name->Buffer, name->Length);
1910 
1911  Status = RtlUpcaseUnicodeString(&dc->name_uc, name, true);
1912  if (!NT_SUCCESS(Status)) {
1913  ERR("RtlUpcaseUnicodeString returned %08lx\n", Status);
1914  ExFreePool(dc->utf8.Buffer);
1915  ExFreePool(dc->name.Buffer);
1916  ExFreePool(dc);
1917  return Status;
1918  }
1919 
1920  dc->hash = calc_crc32c(0xffffffff, (uint8_t*)dc->name.Buffer, dc->name.Length);
1921  dc->hash_uc = calc_crc32c(0xffffffff, (uint8_t*)dc->name_uc.Buffer, dc->name_uc.Length);
1922 
1923  locked = ExIsResourceAcquiredExclusive(&fcb->nonpaged->dir_children_lock);
1924 
1925  if (!locked)
1926  ExAcquireResourceExclusiveLite(&fcb->nonpaged->dir_children_lock, true);
1927 
1928  if (IsListEmpty(&fcb->dir_children_index))
1929  dc->index = 2;
1930  else {
1931  dir_child* dc2 = CONTAINING_RECORD(fcb->dir_children_index.Blink, dir_child, list_entry_index);
1932 
1933  dc->index = max(2, dc2->index + 1);
1934  }
1935 
1936  InsertTailList(&fcb->dir_children_index, &dc->list_entry_index);
1937 
1938  insert_dir_child_into_hash_lists(fcb, dc);
1939 
1940  if (!locked)
1941  ExReleaseResourceLite(&fcb->nonpaged->dir_children_lock);
1942 
1943  *pdc = dc;
1944 
1945  return STATUS_SUCCESS;
1946 }
max
#define max(a, b)
Definition: svc.c:63
STATUS_INSUFFICIENT_RESOURCES
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
RtlUpcaseUnicodeString
NTSTATUS RtlUpcaseUnicodeString(PUNICODE_STRING dst, PUNICODE_STRING src, BOOLEAN Alloc)
Definition: string_lib.cpp:46
_ANSI_STRING::Buffer
PSTR Buffer
Definition: env_spec_w32.h:378
dir_child
Definition: btrfs_drv.h:250
Status
Iosb Status
Definition: create.c:4287
_LIST_ENTRY::Blink
struct _LIST_ENTRY * Blink
Definition: typedefs.h:122
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
InsertTailList
#define InsertTailList(ListHead, Entry)
Definition: env_spec_w32.h:1003
IsListEmpty
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
inode
Definition: fs.h:78
ExAcquireResourceExclusiveLite
BOOLEAN NTAPI ExAcquireResourceExclusiveLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:770
ALLOC_TAG
#define ALLOC_TAG
Definition: btrfs_drv.h:87
CONTAINING_RECORD
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
Status
Definition: gdiplustypes.h:24
_fcb::dir_children_index
LIST_ENTRY dir_children_index
Definition: btrfs_drv.h:314
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
ExReleaseResourceLite
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817
_ANSI_STRING::Length
USHORT Length
Definition: env_spec_w32.h:376
ExAllocatePoolWithTag
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
dir_child::index
uint64_t index
Definition: btrfs_drv.h:252
TYPE_INODE_ITEM
#define TYPE_INODE_ITEM
Definition: btrfs.h:23
calc_crc32c
crc_func calc_crc32c
Definition: crc32c.c:23
uint8_t
BYTE uint8_t
Definition: msvideo1.c:66
_fcb
Definition: btrfs_drv.h:282
ERR
#define ERR(fmt,...)
Definition: debug.h:110
_fcb::nonpaged
struct _fcb_nonpaged * nonpaged
Definition: btrfs_drv.h:284
TYPE_ROOT_ITEM
#define TYPE_ROOT_ITEM
Definition: btrfs.h:32
insert_dir_child_into_hash_lists
void insert_dir_child_into_hash_lists(fcb *fcb, dir_child *dc)
Definition: fileinfo.c:1470
NULL
#define NULL
Definition: types.h:112
name
Definition: name.c:38
RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
dc
static const WCHAR dc[]
Definition: metadataquery.c:790
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
ExIsResourceAcquiredExclusive
#define ExIsResourceAcquiredExclusive
Definition: exfuncs.h:347
ExFreePool
#define ExFreePool(addr)
Definition: env_spec_w32.h:352

Referenced by create_subvol(), do_create_snapshot(), file_create2(), mknod(), and set_link_information().

◆ add_extent()

NTSTATUS bool void NTSTATUS void add_extent ( _In_ fcb *  fcb,
_In_ LIST_ENTRY *  prevextle,
_In_ __drv_aliasesMem extent *  newext 
)

Referenced by __attribute__(), and duplicate_extents().

◆ add_extent_to_fcb()

NTSTATUS bool void NTSTATUS add_extent_to_fcb ( _In_ fcb *  fcb,
_In_ uint64_t  offset,
_In_reads_bytes_(edsize) EXTENT_DATA *  ed,
_In_ uint16_t  edsize,
_In_ bool  unique,
_In_opt_ _When_(return >=0, __drv_aliasesMem) void *  csum,
_In_ LIST_ENTRY *  rollback 
)

Referenced by __attribute__(), duplicate_extents(), insert_extent_chunk(), rename_stream_to_file(), write_compressed(), and zero_data().

◆ 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 }
_LIST_ENTRY::Blink
struct _LIST_ENTRY * Blink
Definition: typedefs.h:122
InsertHeadList
FORCEINLINE VOID InsertHeadList(_Inout_ PLIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
Definition: rtlfuncs.h:201
InsertTailList
#define InsertTailList(ListHead, Entry)
Definition: env_spec_w32.h:1003
_fcb::list_entry
LIST_ENTRY list_entry
Definition: btrfs_drv.h:336
CONTAINING_RECORD
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
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
c
const GLubyte * c
Definition: glext.h:8905
_fcb::hash
uint32_t hash
Definition: