drivers/filesystems/btrfs/fsctl.c

   1 /* Copyright (c) Mark Harmstone 2016-17
   2  *
   3  * This file is part of WinBtrfs.
   4  *
   5  * WinBtrfs is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU Lesser General Public Licence as published by
   7  * the Free Software Foundation, either version 3 of the Licence, or
   8  * (at your option) any later version.
   9  *
  10  * WinBtrfs is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU Lesser General Public Licence for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public Licence
  16  * along with WinBtrfs.  If not, see <http://www.gnu.org/licenses/>. */
  17
  18 #include "btrfs_drv.h"
  19 #include "btrfsioctl.h"
  20 #include <ntddstor.h>
  21 #include <ntdddisk.h>
  22 #ifndef __REACTOS__
  23 #include <sys/stat.h>
  24 #endif
  25
  26 #ifndef FSCTL_CSV_CONTROL
  27 #define FSCTL_CSV_CONTROL CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 181, METHOD_BUFFERED, FILE_ANY_ACCESS)
  28 #endif
  29
  30 #ifndef FSCTL_QUERY_VOLUME_CONTAINER_STATE
  31 #define FSCTL_QUERY_VOLUME_CONTAINER_STATE CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 228, METHOD_BUFFERED, FILE_ANY_ACCESS)
  32 #endif
  33
  34 #define DOTDOT ".."
  35
  36 #define SEF_AVOID_PRIVILEGE_CHECK 0x08 // on MSDN but not in any header files(?)
  37
  38 #ifndef _MSC_VER // not in mingw yet
  39 #define DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED 0x80000000
  40 #endif
  41
  42 #define SEF_SACL_AUTO_INHERIT 0x02
  43
  44 extern LIST_ENTRY VcbList;
  45 extern ERESOURCE global_loading_lock;
  46 extern PDRIVER_OBJECT drvobj;
  47
  48 static void mark_subvol_dirty(device_extension* Vcb, root* r);
  49
  50 static NTSTATUS get_file_ids(PFILE_OBJECT FileObject, void* data, ULONG length) {
  51     btrfs_get_file_ids* bgfi;
  52     fcb* fcb;
  53
  54     if (length < sizeof(btrfs_get_file_ids))
  55         return STATUS_BUFFER_OVERFLOW;
  56
  57     if (!FileObject)
  58         return STATUS_INVALID_PARAMETER;
  59
  60     fcb = FileObject->FsContext;
  61
  62     if (!fcb)
  63         return STATUS_INVALID_PARAMETER;
  64
  65     bgfi = data;
  66
  67     bgfi->subvol = fcb->subvol->id;
  68     bgfi->inode = fcb->inode;
  69     bgfi->top = fcb->Vcb->root_fileref->fcb == fcb ? TRUE : FALSE;
  70
  71     return STATUS_SUCCESS;
  72 }
  73
  74 static void get_uuid(BTRFS_UUID* uuid) {
  75     LARGE_INTEGER seed;
  76     UINT8 i;
  77
  78     seed = KeQueryPerformanceCounter(NULL);
  79
  80     for (i = 0; i < 16; i+=2) {
  81         ULONG rand = RtlRandomEx(&seed.LowPart);
  82
  83         uuid->uuid[i] = (rand & 0xff00) >> 8;
  84         uuid->uuid[i+1] = rand & 0xff;
  85     }
  86 }
  87
  88 static NTSTATUS snapshot_tree_copy(device_extension* Vcb, UINT64 addr, root* subvol, UINT64* newaddr, PIRP Irp, LIST_ENTRY* rollback) {
  89     UINT8* buf;
  90     NTSTATUS Status;
  91     write_data_context wtc;
  92     LIST_ENTRY* le;
  93     tree t;
  94     tree_header* th;
  95     chunk* c;
  96
  97     buf = ExAllocatePoolWithTag(NonPagedPool, Vcb->superblock.node_size, ALLOC_TAG);
  98     if (!buf) {
  99         ERR("out of memory\n");
 100         return STATUS_INSUFFICIENT_RESOURCES;
 101     }
 102
 103     wtc.parity1 = wtc.parity2 = wtc.scratch = NULL;
 104     wtc.mdl = wtc.parity1_mdl = wtc.parity2_mdl = NULL;
 105
 106     Status = read_data(Vcb, addr, Vcb->superblock.node_size, NULL, TRUE, buf, NULL, NULL, Irp, 0, FALSE, NormalPagePriority);
 107     if (!NT_SUCCESS(Status)) {
 108         ERR("read_data returned %08x\n", Status);
 109         goto end;
 110     }
 111
 112     th = (tree_header*)buf;
 113
 114     RtlZeroMemory(&t, sizeof(tree));
 115     t.root = subvol;
 116     t.header.level = th->level;
 117     t.header.tree_id = t.root->id;
 118
 119     Status = get_tree_new_address(Vcb, &t, Irp, rollback);
 120     if (!NT_SUCCESS(Status)) {
 121         ERR("get_tree_new_address returned %08x\n", Status);
 122         goto end;
 123     }
 124
 125     if (!t.has_new_address) {
 126         ERR("tree new address not set\n");
 127         Status = STATUS_INTERNAL_ERROR;
 128         goto end;
 129     }
 130
 131     c = get_chunk_from_address(Vcb, t.new_address);
 132
 133     if (c)
 134         c->used += Vcb->superblock.node_size;
 135     else {
 136         ERR("could not find chunk for address %llx\n", t.new_address);
 137         Status = STATUS_INTERNAL_ERROR;
 138         goto end;
 139     }
 140
 141     th->address = t.new_address;
 142     th->tree_id = subvol->id;
 143     th->generation = Vcb->superblock.generation;
 144     th->fs_uuid = Vcb->superblock.uuid;
 145
 146     if (th->level == 0) {
 147         UINT32 i;
 148         leaf_node* ln = (leaf_node*)&th[1];
 149
 150         for (i = 0; i < th->num_items; i++) {
 151             if (ln[i].key.obj_type == TYPE_EXTENT_DATA && ln[i].size >= sizeof(EXTENT_DATA) && ln[i].offset + ln[i].size <= Vcb->superblock.node_size - sizeof(tree_header)) {
 152                 EXTENT_DATA* ed = (EXTENT_DATA*)(((UINT8*)&th[1]) + ln[i].offset);
 153
 154                 if ((ed->type == EXTENT_TYPE_REGULAR || ed->type == EXTENT_TYPE_PREALLOC) && ln[i].size >= sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2)) {
 155                     EXTENT_DATA2* ed2 = (EXTENT_DATA2*)&ed->data[0];
 156
 157                     if (ed2->size != 0) { // not sparse
 158                         Status = increase_extent_refcount_data(Vcb, ed2->address, ed2->size, subvol->id, ln[i].key.obj_id, ln[i].key.offset - ed2->offset, 1, Irp);
 159
 160                         if (!NT_SUCCESS(Status)) {
 161                             ERR("increase_extent_refcount_data returned %08x\n", Status);
 162                             goto end;
 163                         }
 164                     }
 165                 }
 166             }
 167         }
 168     } else {
 169         UINT32 i;
 170         internal_node* in = (internal_node*)&th[1];
 171
 172         for (i = 0; i < th->num_items; i++) {
 173             TREE_BLOCK_REF tbr;
 174
 175             tbr.offset = subvol->id;
 176
 177             Status = increase_extent_refcount(Vcb, in[i].address, Vcb->superblock.node_size, TYPE_TREE_BLOCK_REF, &tbr, NULL, th->level - 1, Irp);
 178             if (!NT_SUCCESS(Status)) {
 179                 ERR("increase_extent_refcount returned %08x\n", Status);
 180                 goto end;
 181             }
 182         }
 183     }
 184
 185     *((UINT32*)buf) = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 186
 187     KeInitializeEvent(&wtc.Event, NotificationEvent, FALSE);
 188     InitializeListHead(&wtc.stripes);
 189     wtc.stripes_left = 0;
 190
 191     Status = write_data(Vcb, t.new_address, buf, Vcb->superblock.node_size, &wtc, NULL, NULL, FALSE, 0, NormalPagePriority);
 192     if (!NT_SUCCESS(Status)) {
 193         ERR("write_data returned %08x\n", Status);
 194         goto end;
 195     }
 196
 197     if (wtc.stripes.Flink != &wtc.stripes) {
 198         BOOL need_wait = FALSE;
 199
 200         // launch writes and wait
 201         le = wtc.stripes.Flink;
 202         while (le != &wtc.stripes) {
 203             write_data_stripe* stripe = CONTAINING_RECORD(le, write_data_stripe, list_entry);
 204
 205             if (stripe->status != WriteDataStatus_Ignore) {
 206                 need_wait = TRUE;
 207                 IoCallDriver(stripe->device->devobj, stripe->Irp);
 208             }
 209
 210             le = le->Flink;
 211         }
 212
 213         if (need_wait)
 214             KeWaitForSingleObject(&wtc.Event, Executive, KernelMode, FALSE, NULL);
 215
 216         le = wtc.stripes.Flink;
 217         while (le != &wtc.stripes) {
 218             write_data_stripe* stripe = CONTAINING_RECORD(le, write_data_stripe, list_entry);
 219
 220             if (stripe->status != WriteDataStatus_Ignore && !NT_SUCCESS(stripe->iosb.Status)) {
 221                 Status = stripe->iosb.Status;
 222                 log_device_error(Vcb, stripe->device, BTRFS_DEV_STAT_WRITE_ERRORS);
 223                 break;
 224             }
 225
 226             le = le->Flink;
 227         }
 228
 229         free_write_data_stripes(&wtc);
 230         buf = NULL;
 231     }
 232
 233     if (NT_SUCCESS(Status))
 234         *newaddr = t.new_address;
 235
 236 end:
 237
 238     if (buf)
 239         ExFreePool(buf);
 240
 241     return Status;
 242 }
 243
 244 void flush_subvol_fcbs(root* subvol) {
 245     LIST_ENTRY* le = subvol->fcbs.Flink;
 246
 247     if (IsListEmpty(&subvol->fcbs))
 248         return;
 249
 250     while (le != &subvol->fcbs) {
 251         struct _fcb* fcb = CONTAINING_RECORD(le, struct _fcb, list_entry);
 252         IO_STATUS_BLOCK iosb;
 253
 254         if (fcb->type != BTRFS_TYPE_DIRECTORY && !fcb->deleted)
 255             CcFlushCache(&fcb->nonpaged->segment_object, NULL, 0, &iosb);
 256
 257         le = le->Flink;
 258     }
 259 }
 260
 261 static NTSTATUS do_create_snapshot(device_extension* Vcb, PFILE_OBJECT parent, fcb* subvol_fcb, PANSI_STRING utf8, PUNICODE_STRING name, BOOL readonly, PIRP Irp) {
 262     LIST_ENTRY rollback;
 263     UINT64 id;
 264     NTSTATUS Status;
 265     root *r, *subvol = subvol_fcb->subvol;
 266     KEY searchkey;
 267     traverse_ptr tp;
 268     UINT64 address, *root_num;
 269     LARGE_INTEGER time;
 270     BTRFS_TIME now;
 271     fcb* fcb = parent->FsContext;
 272     ccb* ccb = parent->FsContext2;
 273     LIST_ENTRY* le;
 274     file_ref *fileref, *fr;
 275     dir_child* dc = NULL;
 276
 277     if (!ccb) {
 278         ERR("error - ccb was NULL\n");
 279         return STATUS_INTERNAL_ERROR;
 280     }
 281
 282     if (!(ccb->access & FILE_ADD_SUBDIRECTORY)) {
 283         WARN("insufficient privileges\n");
 284         return STATUS_ACCESS_DENIED;
 285     }
 286
 287     fileref = ccb->fileref;
 288
 289     if (fileref->fcb == Vcb->dummy_fcb)
 290         return STATUS_ACCESS_DENIED;
 291
 292     // flush open files on this subvol
 293
 294     flush_subvol_fcbs(subvol);
 295
 296     // flush metadata
 297
 298     if (Vcb->need_write)
 299         Status = do_write(Vcb, Irp);
 300     else
 301         Status = STATUS_SUCCESS;
 302
 303     free_trees(Vcb);
 304
 305     if (!NT_SUCCESS(Status)) {
 306         ERR("do_write returned %08x\n", Status);
 307         return Status;
 308     }
 309
 310     InitializeListHead(&rollback);
 311
 312     // create new root
 313
 314     id = InterlockedIncrement64(&Vcb->root_root->lastinode);
 315     Status = create_root(Vcb, id, &r, TRUE, Vcb->superblock.generation, Irp);
 316
 317     if (!NT_SUCCESS(Status)) {
 318         ERR("create_root returned %08x\n", Status);
 319         goto end;
 320     }
 321
 322     r->lastinode = subvol->lastinode;
 323
 324     if (!Vcb->uuid_root) {
 325         root* uuid_root;
 326
 327         TRACE("uuid root doesn't exist, creating it\n");
 328
 329         Status = create_root(Vcb, BTRFS_ROOT_UUID, &uuid_root, FALSE, 0, Irp);
 330
 331         if (!NT_SUCCESS(Status)) {
 332             ERR("create_root returned %08x\n", Status);
 333             goto end;
 334         }
 335
 336         Vcb->uuid_root = uuid_root;
 337     }
 338
 339     root_num = ExAllocatePoolWithTag(PagedPool, sizeof(UINT64), ALLOC_TAG);
 340     if (!root_num) {
 341         ERR("out of memory\n");
 342         Status = STATUS_INSUFFICIENT_RESOURCES;
 343         goto end;
 344     }
 345
 346     tp.tree = NULL;
 347
 348     do {
 349         get_uuid(&r->root_item.uuid);
 350
 351         RtlCopyMemory(&searchkey.obj_id, &r->root_item.uuid, sizeof(UINT64));
 352         searchkey.obj_type = TYPE_SUBVOL_UUID;
 353         RtlCopyMemory(&searchkey.offset, &r->root_item.uuid.uuid[sizeof(UINT64)], sizeof(UINT64));
 354
 355         Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, FALSE, Irp);
 356     } while (NT_SUCCESS(Status) && !keycmp(searchkey, tp.item->key));
 357
 358     *root_num = r->id;
 359
 360     Status = insert_tree_item(Vcb, Vcb->uuid_root, searchkey.obj_id, searchkey.obj_type, searchkey.offset, root_num, sizeof(UINT64), NULL, Irp);
 361     if (!NT_SUCCESS(Status)) {
 362         ERR("insert_tree_item returned %08x\n", Status);
 363         ExFreePool(root_num);
 364         goto end;
 365     }
 366
 367     searchkey.obj_id = r->id;
 368     searchkey.obj_type = TYPE_ROOT_ITEM;
 369     searchkey.offset = 0xffffffffffffffff;
 370
 371     Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
 372     if (!NT_SUCCESS(Status)) {
 373         ERR("error - find_item returned %08x\n", Status);
 374         goto end;
 375     }
 376
 377     Status = snapshot_tree_copy(Vcb, subvol->root_item.block_number, r, &address, Irp, &rollback);
 378     if (!NT_SUCCESS(Status)) {
 379         ERR("snapshot_tree_copy returned %08x\n", Status);
 380         goto end;
 381     }
 382
 383     KeQuerySystemTime(&time);
 384     win_time_to_unix(time, &now);
 385
 386     r->root_item.inode.generation = 1;
 387     r->root_item.inode.st_size = 3;
 388     r->root_item.inode.st_blocks = subvol->root_item.inode.st_blocks;
 389     r->root_item.inode.st_nlink = 1;
 390     r->root_item.inode.st_mode = __S_IFDIR | S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH; // 40755
 391     r->root_item.inode.flags = 0xffffffff80000000; // FIXME - find out what these mean
 392     r->root_item.generation = Vcb->superblock.generation;
 393     r->root_item.objid = subvol->root_item.objid;
 394     r->root_item.block_number = address;
 395     r->root_item.bytes_used = subvol->root_item.bytes_used;
 396     r->root_item.last_snapshot_generation = Vcb->superblock.generation;
 397     r->root_item.root_level = subvol->root_item.root_level;
 398     r->root_item.generation2 = Vcb->superblock.generation;
 399     r->root_item.parent_uuid = subvol->root_item.uuid;
 400     r->root_item.ctransid = subvol->root_item.ctransid;
 401     r->root_item.otransid = Vcb->superblock.generation;
 402     r->root_item.ctime = subvol->root_item.ctime;
 403     r->root_item.otime = now;
 404
 405     if (readonly)
 406         r->root_item.flags |= BTRFS_SUBVOL_READONLY;
 407
 408     r->treeholder.address = address;
 409
 410     // FIXME - do we need to copy over the send and receive fields too?
 411
 412     if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
 413         ERR("error - could not find ROOT_ITEM for subvol %llx\n", r->id);
 414         Status = STATUS_INTERNAL_ERROR;
 415         goto end;
 416     }
 417
 418     RtlCopyMemory(tp.item->data, &r->root_item, sizeof(ROOT_ITEM));
 419
 420     // update ROOT_ITEM of original subvol
 421
 422     subvol->root_item.last_snapshot_generation = Vcb->superblock.generation;
 423
 424     mark_subvol_dirty(Vcb, subvol);
 425
 426     // create fileref for entry in other subvolume
 427
 428     fr = create_fileref(Vcb);
 429     if (!fr) {
 430         ERR("out of memory\n");
 431         Status = STATUS_INSUFFICIENT_RESOURCES;
 432         goto end;
 433     }
 434
 435     Status = open_fcb(Vcb, r, r->root_item.objid, BTRFS_TYPE_DIRECTORY, utf8, fcb, &fr->fcb, PagedPool, Irp);
 436     if (!NT_SUCCESS(Status)) {
 437         ERR("open_fcb returned %08x\n", Status);
 438         free_fileref(Vcb, fr);
 439         goto end;
 440     }
 441
 442     fr->parent = fileref;
 443
 444     Status = add_dir_child(fileref->fcb, r->id, TRUE, utf8, name, BTRFS_TYPE_DIRECTORY, &dc);
 445     if (!NT_SUCCESS(Status))
 446         WARN("add_dir_child returned %08x\n", Status);
 447
 448     fr->dc = dc;
 449     dc->fileref = fr;
 450
 451     ExAcquireResourceExclusiveLite(&fileref->nonpaged->children_lock, TRUE);
 452     InsertTailList(&fileref->children, &fr->list_entry);
 453     ExReleaseResourceLite(&fileref->nonpaged->children_lock);
 454
 455     increase_fileref_refcount(fileref);
 456
 457     fr->created = TRUE;
 458     mark_fileref_dirty(fr);
 459
 460     if (fr->fcb->type == BTRFS_TYPE_DIRECTORY)
 461         fr->fcb->fileref = fr;
 462
 463     fr->fcb->subvol->parent = fileref->fcb->subvol->id;
 464
 465     free_fileref(Vcb, fr);
 466
 467     // change fcb's INODE_ITEM
 468
 469     fcb->inode_item.transid = Vcb->superblock.generation;
 470     fcb->inode_item.sequence++;
 471     fcb->inode_item.st_size += utf8->Length * 2;
 472
 473     if (!ccb->user_set_change_time)
 474         fcb->inode_item.st_ctime = now;
 475
 476     if (!ccb->user_set_write_time)
 477         fcb->inode_item.st_mtime = now;
 478
 479     fcb->inode_item_changed = TRUE;
 480     mark_fcb_dirty(fcb);
 481
 482     fcb->subvol->root_item.ctime = now;
 483     fcb->subvol->root_item.ctransid = Vcb->superblock.generation;
 484
 485     send_notification_fileref(fr, FILE_NOTIFY_CHANGE_DIR_NAME, FILE_ACTION_ADDED, NULL);
 486     send_notification_fileref(fr->parent, FILE_NOTIFY_CHANGE_LAST_WRITE, FILE_ACTION_MODIFIED, NULL);
 487
 488     le = subvol->fcbs.Flink;
 489     while (le != &subvol->fcbs) {
 490         struct _fcb* fcb2 = CONTAINING_RECORD(le, struct _fcb, list_entry);
 491         LIST_ENTRY* le2 = fcb2->extents.Flink;
 492
 493         while (le2 != &fcb2->extents) {
 494             extent* ext = CONTAINING_RECORD(le2, extent, list_entry);
 495
 496             if (!ext->ignore)
 497                 ext->unique = FALSE;
 498
 499             le2 = le2->Flink;
 500         }
 501
 502         le = le->Flink;
 503     }
 504
 505     Status = do_write(Vcb, Irp);
 506
 507     free_trees(Vcb);
 508
 509     if (!NT_SUCCESS(Status))
 510         ERR("do_write returned %08x\n", Status);
 511
 512 end:
 513     if (NT_SUCCESS(Status))
 514         clear_rollback(&rollback);
 515     else
 516         do_rollback(Vcb, &rollback);
 517
 518     return Status;
 519 }
 520
 521 static NTSTATUS create_snapshot(device_extension* Vcb, PFILE_OBJECT FileObject, void* data, ULONG length, PIRP Irp) {
 522     PFILE_OBJECT subvol_obj;
 523     NTSTATUS Status;
 524     btrfs_create_snapshot* bcs = data;
 525     fcb* subvol_fcb;
 526     HANDLE subvolh;
 527     BOOL readonly, posix;
 528     ANSI_STRING utf8;
 529     UNICODE_STRING nameus;
 530     ULONG len;
 531     fcb* fcb;
 532     ccb* ccb;
 533     file_ref *fileref, *fr2;
 534
 535 #if defined(_WIN64)
 536     if (IoIs32bitProcess(Irp)) {
 537         btrfs_create_snapshot32* bcs32 = data;
 538
 539         if (length < offsetof(btrfs_create_snapshot32, name))
 540             return STATUS_INVALID_PARAMETER;
 541
 542         if (length < offsetof(btrfs_create_snapshot32, name) + bcs32->namelen)
 543             return STATUS_INVALID_PARAMETER;
 544
 545         subvolh = Handle32ToHandle(bcs32->subvol);
 546
 547         nameus.Buffer = bcs32->name;
 548         nameus.Length = nameus.MaximumLength = bcs32->namelen;
 549
 550         readonly = bcs32->readonly;
 551         posix = bcs32->posix;
 552     } else {
 553 #endif
 554         if (length < offsetof(btrfs_create_snapshot, name))
 555             return STATUS_INVALID_PARAMETER;
 556
 557         if (length < offsetof(btrfs_create_snapshot, name) + bcs->namelen)
 558             return STATUS_INVALID_PARAMETER;
 559
 560         subvolh = bcs->subvol;
 561
 562         nameus.Buffer = bcs->name;
 563         nameus.Length = nameus.MaximumLength = bcs->namelen;
 564
 565         readonly = bcs->readonly;
 566         posix = bcs->posix;
 567 #if defined(_WIN64)
 568     }
 569 #endif
 570
 571     if (!subvolh)
 572         return STATUS_INVALID_PARAMETER;
 573
 574     if (!FileObject || !FileObject->FsContext)
 575         return STATUS_INVALID_PARAMETER;
 576
 577     fcb = FileObject->FsContext;
 578     ccb = FileObject->FsContext2;
 579
 580     if (!fcb || !ccb || fcb->type != BTRFS_TYPE_DIRECTORY)
 581         return STATUS_INVALID_PARAMETER;
 582
 583     fileref = ccb->fileref;
 584
 585     if (!fileref) {
 586         ERR("fileref was NULL\n");
 587         return STATUS_INVALID_PARAMETER;
 588     }
 589
 590     if (!(ccb->access & FILE_ADD_SUBDIRECTORY)) {
 591         WARN("insufficient privileges\n");
 592         return STATUS_ACCESS_DENIED;
 593     }
 594
 595     if (Vcb->readonly)
 596         return STATUS_MEDIA_WRITE_PROTECTED;
 597
 598     if (is_subvol_readonly(fcb->subvol, Irp))
 599         return STATUS_ACCESS_DENIED;
 600
 601     if (!is_file_name_valid(&nameus, posix))
 602         return STATUS_OBJECT_NAME_INVALID;
 603
 604     utf8.Buffer = NULL;
 605
 606     Status = RtlUnicodeToUTF8N(NULL, 0, &len, nameus.Buffer, nameus.Length);
 607     if (!NT_SUCCESS(Status)) {
 608         ERR("RtlUnicodeToUTF8N failed with error %08x\n", Status);
 609         return Status;
 610     }
 611
 612     if (len == 0) {
 613         ERR("RtlUnicodeToUTF8N returned a length of 0\n");
 614         return STATUS_INTERNAL_ERROR;
 615     }
 616
 617     if (len > 0xffff) {
 618         ERR("len was too long\n");
 619         return STATUS_INVALID_PARAMETER;
 620     }
 621
 622     utf8.MaximumLength = utf8.Length = (USHORT)len;
 623     utf8.Buffer = ExAllocatePoolWithTag(PagedPool, utf8.Length, ALLOC_TAG);
 624
 625     if (!utf8.Buffer) {
 626         ERR("out of memory\n");
 627         return STATUS_INSUFFICIENT_RESOURCES;
 628     }
 629
 630     Status = RtlUnicodeToUTF8N(utf8.Buffer, len, &len, nameus.Buffer, nameus.Length);
 631     if (!NT_SUCCESS(Status)) {
 632         ERR("RtlUnicodeToUTF8N failed with error %08x\n", Status);
 633         goto end2;
 634     }
 635
 636     ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
 637
 638     // no need for fcb_lock as we have tree_lock exclusively
 639     Status = open_fileref(fcb->Vcb, &fr2, &nameus, fileref, FALSE, NULL, NULL, PagedPool, ccb->case_sensitive || posix, Irp);
 640
 641     if (NT_SUCCESS(Status)) {
 642         if (!fr2->deleted) {
 643             WARN("file already exists\n");
 644             free_fileref(Vcb, fr2);
 645             Status = STATUS_OBJECT_NAME_COLLISION;
 646             goto end3;
 647         } else
 648             free_fileref(Vcb, fr2);
 649     } else if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND) {
 650         ERR("open_fileref returned %08x\n", Status);
 651         goto end3;
 652     }
 653
 654     Status = ObReferenceObjectByHandle(subvolh, 0, *IoFileObjectType, Irp->RequestorMode, (void**)&subvol_obj, NULL);
 655     if (!NT_SUCCESS(Status)) {
 656         ERR("ObReferenceObjectByHandle returned %08x\n", Status);
 657         goto end3;
 658     }
 659
 660     if (subvol_obj->DeviceObject != FileObject->DeviceObject) {
 661         Status = STATUS_INVALID_PARAMETER;
 662         goto end;
 663     }
 664
 665     subvol_fcb = subvol_obj->FsContext;
 666     if (!subvol_fcb) {
 667         Status = STATUS_INVALID_PARAMETER;
 668         goto end;
 669     }
 670
 671     if (subvol_fcb->inode != subvol_fcb->subvol->root_item.objid) {
 672         WARN("handle inode was %llx, expected %llx\n", subvol_fcb->inode, subvol_fcb->subvol->root_item.objid);
 673         Status = STATUS_INVALID_PARAMETER;
 674         goto end;
 675     }
 676
 677     ccb = subvol_obj->FsContext2;
 678
 679     if (!ccb) {
 680         Status = STATUS_INVALID_PARAMETER;
 681         goto end;
 682     }
 683
 684     if (!(ccb->access & FILE_TRAVERSE)) {
 685         WARN("insufficient privileges\n");
 686         Status = STATUS_ACCESS_DENIED;
 687         goto end;
 688     }
 689
 690     if (fcb == Vcb->dummy_fcb) {
 691         Status = STATUS_ACCESS_DENIED;
 692         goto end;
 693     }
 694
 695     // clear unique flag on extents of open files in subvol
 696     if (!IsListEmpty(&subvol_fcb->subvol->fcbs)) {
 697         LIST_ENTRY* le = subvol_fcb->subvol->fcbs.Flink;
 698
 699         while (le != &subvol_fcb->subvol->fcbs) {
 700             struct _fcb* openfcb = CONTAINING_RECORD(le, struct _fcb, list_entry);
 701             LIST_ENTRY* le2;
 702
 703             le2 = openfcb->extents.Flink;
 704
 705             while (le2 != &openfcb->extents) {
 706                 extent* ext = CONTAINING_RECORD(le2, extent, list_entry);
 707
 708                 ext->unique = FALSE;
 709
 710                 le2 = le2->Flink;
 711             }
 712
 713             le = le->Flink;
 714         }
 715     }
 716
 717     Status = do_create_snapshot(Vcb, FileObject, subvol_fcb, &utf8, &nameus, readonly, Irp);
 718
 719     if (NT_SUCCESS(Status)) {
 720         file_ref* fr;
 721
 722         Status = open_fileref(Vcb, &fr, &nameus, fileref, FALSE, NULL, NULL, PagedPool, FALSE, Irp);
 723
 724         if (!NT_SUCCESS(Status)) {
 725             ERR("open_fileref returned %08x\n", Status);
 726             Status = STATUS_SUCCESS;
 727         } else {
 728             send_notification_fileref(fr, FILE_NOTIFY_CHANGE_DIR_NAME, FILE_ACTION_ADDED, NULL);
 729             free_fileref(Vcb, fr);
 730         }
 731     }
 732
 733 end:
 734     ObDereferenceObject(subvol_obj);
 735
 736 end3:
 737     ExReleaseResourceLite(&Vcb->tree_lock);
 738
 739 end2:
 740     ExFreePool(utf8.Buffer);
 741
 742     return Status;
 743 }
 744
 745 static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, void* data, ULONG datalen, PIRP Irp) {
 746     btrfs_create_subvol* bcs;
 747     fcb *fcb, *rootfcb = NULL;
 748     ccb* ccb;
 749     file_ref* fileref;
 750     NTSTATUS Status;
 751     UINT64 id;
 752     root* r = NULL;
 753     LARGE_INTEGER time;
 754     BTRFS_TIME now;
 755     ULONG len;
 756     UINT16 irsize;
 757     UNICODE_STRING nameus;
 758     ANSI_STRING utf8;
 759     INODE_REF* ir;
 760     KEY searchkey;
 761     traverse_ptr tp;
 762     SECURITY_SUBJECT_CONTEXT subjcont;
 763     PSID owner;
 764     BOOLEAN defaulted;
 765     UINT64* root_num;
 766     file_ref *fr = NULL, *fr2;
 767     dir_child* dc = NULL;
 768
 769     fcb = FileObject->FsContext;
 770     if (!fcb) {
 771         ERR("error - fcb was NULL\n");
 772         return STATUS_INTERNAL_ERROR;
 773     }
 774
 775     ccb = FileObject->FsContext2;
 776     if (!ccb) {
 777         ERR("error - ccb was NULL\n");
 778         return STATUS_INTERNAL_ERROR;
 779     }
 780
 781     fileref = ccb->fileref;
 782
 783     if (fcb->type != BTRFS_TYPE_DIRECTORY) {
 784         ERR("parent FCB was not a directory\n");
 785         return STATUS_NOT_A_DIRECTORY;
 786     }
 787
 788     if (!fileref) {
 789         ERR("fileref was NULL\n");
 790         return STATUS_INVALID_PARAMETER;
 791     }
 792
 793     if (fileref->deleted || fcb->deleted) {
 794         ERR("parent has been deleted\n");
 795         return STATUS_FILE_DELETED;
 796     }
 797
 798     if (!(ccb->access & FILE_ADD_SUBDIRECTORY)) {
 799         WARN("insufficient privileges\n");
 800         return STATUS_ACCESS_DENIED;
 801     }
 802
 803     if (Vcb->readonly)
 804         return STATUS_MEDIA_WRITE_PROTECTED;
 805
 806     if (is_subvol_readonly(fcb->subvol, Irp))
 807         return STATUS_ACCESS_DENIED;
 808
 809     if (fcb == Vcb->dummy_fcb)
 810         return STATUS_ACCESS_DENIED;
 811
 812     if (!data || datalen < sizeof(btrfs_create_subvol))
 813         return STATUS_INVALID_PARAMETER;
 814
 815     bcs = (btrfs_create_subvol*)data;
 816
 817     if (offsetof(btrfs_create_subvol, name[0]) + bcs->namelen > datalen)
 818         return STATUS_INVALID_PARAMETER;
 819
 820     nameus.Length = nameus.MaximumLength = bcs->namelen;
 821     nameus.Buffer = bcs->name;
 822
 823     if (!is_file_name_valid(&nameus, bcs->posix))
 824         return STATUS_OBJECT_NAME_INVALID;
 825
 826     utf8.Buffer = NULL;
 827
 828     Status = RtlUnicodeToUTF8N(NULL, 0, &len, nameus.Buffer, nameus.Length);
 829     if (!NT_SUCCESS(Status)) {
 830         ERR("RtlUnicodeToUTF8N failed with error %08x\n", Status);
 831         return Status;
 832     }
 833
 834     if (len == 0) {
 835         ERR("RtlUnicodeToUTF8N returned a length of 0\n");
 836         return STATUS_INTERNAL_ERROR;
 837     }
 838
 839     if (len > 0xffff) {
 840         ERR("len was too long\n");
 841         return STATUS_INVALID_PARAMETER;
 842     }
 843
 844     utf8.MaximumLength = utf8.Length = (USHORT)len;
 845     utf8.Buffer = ExAllocatePoolWithTag(PagedPool, utf8.Length, ALLOC_TAG);
 846
 847     if (!utf8.Buffer) {
 848         ERR("out of memory\n");
 849         return STATUS_INSUFFICIENT_RESOURCES;
 850     }
 851
 852     Status = RtlUnicodeToUTF8N(utf8.Buffer, len, &len, nameus.Buffer, nameus.Length);
 853     if (!NT_SUCCESS(Status)) {
 854         ERR("RtlUnicodeToUTF8N failed with error %08x\n", Status);
 855         goto end2;
 856     }
 857
 858     ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
 859
 860     KeQuerySystemTime(&time);
 861     win_time_to_unix(time, &now);
 862
 863     // no need for fcb_lock as we have tree_lock exclusively
 864     Status = open_fileref(fcb->Vcb, &fr2, &nameus, fileref, FALSE, NULL, NULL, PagedPool, ccb->case_sensitive || bcs->posix, Irp);
 865
 866     if (NT_SUCCESS(Status)) {
 867         if (!fr2->deleted) {
 868             WARN("file already exists\n");
 869             free_fileref(Vcb, fr2);
 870             Status = STATUS_OBJECT_NAME_COLLISION;
 871             goto end;
 872         } else
 873             free_fileref(Vcb, fr2);
 874     } else if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND) {
 875         ERR("open_fileref returned %08x\n", Status);
 876         goto end;
 877     }
 878
 879     id = InterlockedIncrement64(&Vcb->root_root->lastinode);
 880     Status = create_root(Vcb, id, &r, FALSE, 0, Irp);
 881
 882     if (!NT_SUCCESS(Status)) {
 883         ERR("create_root returned %08x\n", Status);
 884         goto end;
 885     }
 886
 887     TRACE("created root %llx\n", id);
 888
 889     if (!Vcb->uuid_root) {
 890         root* uuid_root;
 891
 892         TRACE("uuid root doesn't exist, creating it\n");
 893
 894         Status = create_root(Vcb, BTRFS_ROOT_UUID, &uuid_root, FALSE, 0, Irp);
 895
 896         if (!NT_SUCCESS(Status)) {
 897             ERR("create_root returned %08x\n", Status);
 898             goto end;
 899         }
 900
 901         Vcb->uuid_root = uuid_root;
 902     }
 903
 904     root_num = ExAllocatePoolWithTag(PagedPool, sizeof(UINT64), ALLOC_TAG);
 905     if (!root_num) {
 906         ERR("out of memory\n");
 907         Status = STATUS_INSUFFICIENT_RESOURCES;
 908         goto end;
 909     }
 910
 911     tp.tree = NULL;
 912
 913     do {
 914         get_uuid(&r->root_item.uuid);
 915
 916         RtlCopyMemory(&searchkey.obj_id, &r->root_item.uuid, sizeof(UINT64));
 917         searchkey.obj_type = TYPE_SUBVOL_UUID;
 918         RtlCopyMemory(&searchkey.offset, &r->root_item.uuid.uuid[sizeof(UINT64)], sizeof(UINT64));
 919
 920         Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, FALSE, Irp);
 921     } while (NT_SUCCESS(Status) && !keycmp(searchkey, tp.item->key));
 922
 923     *root_num = r->id;
 924
 925     Status = insert_tree_item(Vcb, Vcb->uuid_root, searchkey.obj_id, searchkey.obj_type, searchkey.offset, root_num, sizeof(UINT64), NULL, Irp);
 926     if (!NT_SUCCESS(Status)) {
 927         ERR("insert_tree_item returned %08x\n", Status);
 928         ExFreePool(root_num);
 929         goto end;
 930     }
 931
 932     r->root_item.inode.generation = 1;
 933     r->root_item.inode.st_size = 3;
 934     r->root_item.inode.st_blocks = Vcb->superblock.node_size;
 935     r->root_item.inode.st_nlink = 1;
 936     r->root_item.inode.st_mode = __S_IFDIR | S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH; // 40755
 937     r->root_item.inode.flags = 0xffffffff80000000; // FIXME - find out what these mean
 938
 939     if (bcs->readonly)
 940         r->root_item.flags |= BTRFS_SUBVOL_READONLY;
 941
 942     r->root_item.objid = SUBVOL_ROOT_INODE;
 943     r->root_item.bytes_used = Vcb->superblock.node_size;
 944     r->root_item.ctransid = Vcb->superblock.generation;
 945     r->root_item.otransid = Vcb->superblock.generation;
 946     r->root_item.ctime = now;
 947     r->root_item.otime = now;
 948
 949     // add .. inode to new subvol
 950
 951     rootfcb = create_fcb(Vcb, PagedPool);
 952     if (!rootfcb) {
 953         ERR("out of memory\n");
 954         Status = STATUS_INSUFFICIENT_RESOURCES;
 955         goto end;
 956     }
 957
 958     rootfcb->Vcb = Vcb;
 959
 960     rootfcb->subvol = r;
 961     rootfcb->inode = SUBVOL_ROOT_INODE;
 962     rootfcb->type = BTRFS_TYPE_DIRECTORY;
 963
 964     rootfcb->inode_item.generation = Vcb->superblock.generation;
 965     rootfcb->inode_item.transid = Vcb->superblock.generation;
 966     rootfcb->inode_item.st_nlink = 1;
 967     rootfcb->inode_item.st_mode = __S_IFDIR | inherit_mode(fileref->fcb, TRUE);
 968     rootfcb->inode_item.st_atime = rootfcb->inode_item.st_ctime = rootfcb->inode_item.st_mtime = rootfcb->inode_item.otime = now;
 969     rootfcb->inode_item.st_gid = GID_NOBODY;
 970
 971     rootfcb->atts = get_file_attributes(Vcb, rootfcb->subvol, rootfcb->inode, rootfcb->type, FALSE, TRUE, Irp);
 972
 973     if (r->root_item.flags & BTRFS_SUBVOL_READONLY)
 974         rootfcb->atts |= FILE_ATTRIBUTE_READONLY;
 975
 976     SeCaptureSubjectContext(&subjcont);
 977
 978     Status = SeAssignSecurity(fcb->sd, NULL, (void**)&rootfcb->sd, TRUE, &subjcont, IoGetFileObjectGenericMapping(), PagedPool);
 979
 980     if (!NT_SUCCESS(Status)) {
 981         ERR("SeAssignSecurity returned %08x\n", Status);
 982         goto end;
 983     }
 984
 985     if (!rootfcb->sd) {
 986         ERR("SeAssignSecurity returned NULL security descriptor\n");
 987         Status = STATUS_INTERNAL_ERROR;
 988         goto end;
 989     }
 990
 991     Status = RtlGetOwnerSecurityDescriptor(rootfcb->sd, &owner, &defaulted);
 992     if (!NT_SUCCESS(Status)) {
 993         ERR("RtlGetOwnerSecurityDescriptor returned %08x\n", Status);
 994         rootfcb->inode_item.st_uid = UID_NOBODY;
 995         rootfcb->sd_dirty = TRUE;
 996     } else {
 997         rootfcb->inode_item.st_uid = sid_to_uid(owner);
 998         rootfcb->sd_dirty = rootfcb->inode_item.st_uid == UID_NOBODY;
 999     }
1000
1001     find_gid(rootfcb, fileref->fcb, &subjcont);
1002
1003     rootfcb->inode_item_changed = TRUE;
1004
1005     acquire_fcb_lock_exclusive(Vcb);
1006     InsertTailList(&r->fcbs, &rootfcb->list_entry);
1007     InsertTailList(&Vcb->all_fcbs, &rootfcb->list_entry_all);
1008     release_fcb_lock(Vcb);
1009
1010     rootfcb->Header.IsFastIoPossible = fast_io_possible(rootfcb);
1011     rootfcb->Header.AllocationSize.QuadPart = 0;
1012     rootfcb->Header.FileSize.QuadPart = 0;
1013     rootfcb->Header.ValidDataLength.QuadPart = 0;
1014
1015     rootfcb->created = TRUE;
1016
1017     if (fileref->fcb->inode_item.flags & BTRFS_INODE_COMPRESS)
1018         rootfcb->inode_item.flags |= BTRFS_INODE_COMPRESS;
1019
1020     rootfcb->prop_compression = fileref->fcb->prop_compression;
1021     rootfcb->prop_compression_changed = rootfcb->prop_compression != PropCompression_None;
1022
1023     r->lastinode = rootfcb->inode;
1024
1025     // add INODE_REF
1026
1027     irsize = (UINT16)(offsetof(INODE_REF, name[0]) + strlen(DOTDOT));
1028     ir = ExAllocatePoolWithTag(PagedPool, irsize, ALLOC_TAG);
1029     if (!ir) {
1030         ERR("out of memory\n");
1031         Status = STATUS_INSUFFICIENT_RESOURCES;
1032         goto end;
1033     }
1034
1035     ir->index = 0;
1036     ir->n = (USHORT)strlen(DOTDOT);
1037     RtlCopyMemory(ir->name, DOTDOT, ir->n);
1038
1039     Status = insert_tree_item(Vcb, r, r->root_item.objid, TYPE_INODE_REF, r->root_item.objid, ir, irsize, NULL, Irp);
1040     if (!NT_SUCCESS(Status)) {
1041         ERR("insert_tree_item returned %08x\n", Status);
1042         ExFreePool(ir);
1043         goto end;
1044     }
1045
1046     // create fileref for entry in other subvolume
1047
1048     fr = create_fileref(Vcb);
1049     if (!fr) {
1050         ERR("out of memory\n");
1051
1052         acquire_fcb_lock_exclusive(Vcb);
1053         free_fcb(Vcb, rootfcb);
1054         release_fcb_lock(Vcb);
1055
1056         Status = STATUS_INSUFFICIENT_RESOURCES;
1057         goto end;
1058     }
1059
1060     fr->fcb = rootfcb;
1061
1062     mark_fcb_dirty(rootfcb);
1063
1064     fr->parent = fileref;
1065
1066     Status = add_dir_child(fileref->fcb, r->id, TRUE, &utf8, &nameus, BTRFS_TYPE_DIRECTORY, &dc);
1067     if (!NT_SUCCESS(Status))
1068         WARN("add_dir_child returned %08x\n", Status);
1069
1070     fr->dc = dc;
1071     dc->fileref = fr;
1072
1073     fr->fcb->hash_ptrs = ExAllocatePoolWithTag(PagedPool, sizeof(LIST_ENTRY*) * 256, ALLOC_TAG);
1074     if (!fr->fcb->hash_ptrs) {
1075         ERR("out of memory\n");
1076         acquire_fcb_lock_exclusive(Vcb);
1077         free_fileref(Vcb, fr);
1078         release_fcb_lock(Vcb);
1079         Status = STATUS_INSUFFICIENT_RESOURCES;
1080         goto end;
1081     }
1082
1083     RtlZeroMemory(fr->fcb->hash_ptrs, sizeof(LIST_ENTRY*) * 256);
1084
1085     fr->fcb->hash_ptrs_uc = ExAllocatePoolWithTag(PagedPool, sizeof(LIST_ENTRY*) * 256, ALLOC_TAG);
1086     if (!fr->fcb->hash_ptrs_uc) {
1087         ERR("out of memory\n");
1088         acquire_fcb_lock_exclusive(Vcb);
1089         free_fileref(Vcb, fr);
1090         release_fcb_lock(Vcb);
1091         Status = STATUS_INSUFFICIENT_RESOURCES;
1092         goto end;
1093     }
1094
1095     RtlZeroMemory(fr->fcb->hash_ptrs_uc, sizeof(LIST_ENTRY*) * 256);
1096
1097     ExAcquireResourceExclusiveLite(&fileref->nonpaged->children_lock, TRUE);
1098     InsertTailList(&fileref->children, &fr->list_entry);
1099     ExReleaseResourceLite(&fileref->nonpaged->children_lock);
1100
1101     increase_fileref_refcount(fileref);
1102
1103     if (fr->fcb->type == BTRFS_TYPE_DIRECTORY)
1104         fr->fcb->fileref = fr;
1105
1106     fr->created = TRUE;
1107     mark_fileref_dirty(fr);
1108
1109     // change fcb->subvol's ROOT_ITEM
1110
1111     fcb->subvol->root_item.ctransid = Vcb->superblock.generation;
1112     fcb->subvol->root_item.ctime = now;
1113
1114     // change fcb's INODE_ITEM
1115
1116     fcb->inode_item.transid = Vcb->superblock.generation;
1117     fcb->inode_item.st_size += utf8.Length * 2;
1118     fcb->inode_item.sequence++;
1119
1120     if (!ccb->user_set_change_time)
1121         fcb->inode_item.st_ctime = now;
1122
1123     if (!ccb->user_set_write_time)
1124         fcb->inode_item.st_mtime = now;
1125
1126     fcb->inode_item_changed = TRUE;
1127     mark_fcb_dirty(fcb);
1128
1129     fr->fcb->subvol->parent = fcb->subvol->id;
1130
1131     Status = STATUS_SUCCESS;
1132
1133 end:
1134     if (!NT_SUCCESS(Status)) {
1135         if (fr) {
1136             fr->deleted = TRUE;
1137             mark_fileref_dirty(fr);
1138         } else if (rootfcb) {
1139             rootfcb->deleted = TRUE;
1140             mark_fcb_dirty(rootfcb);
1141         }
1142
1143         if (r) {
1144             RemoveEntryList(&r->list_entry);
1145             InsertTailList(&Vcb->drop_roots, &r->list_entry);
1146         }
1147     }
1148
1149     ExReleaseResourceLite(&Vcb->tree_lock);
1150
1151     if (NT_SUCCESS(Status)) {
1152         send_notification_fileref(fr, FILE_NOTIFY_CHANGE_DIR_NAME, FILE_ACTION_ADDED, NULL);
1153         send_notification_fileref(fr->parent, FILE_NOTIFY_CHANGE_LAST_WRITE, FILE_ACTION_MODIFIED, NULL);
1154     }
1155
1156 end2:
1157     if (fr) {
1158         acquire_fcb_lock_exclusive(Vcb);
1159         free_fileref(Vcb, fr);
1160         release_fcb_lock(Vcb);
1161     }
1162
1163     return Status;
1164 }
1165
1166 static NTSTATUS get_inode_info(PFILE_OBJECT FileObject, void* data, ULONG length) {
1167     btrfs_inode_info* bii = data;
1168     fcb* fcb;
1169     ccb* ccb;
1170
1171     if (length < sizeof(btrfs_inode_info))
1172         return STATUS_BUFFER_OVERFLOW;
1173
1174     if (!FileObject)
1175         return STATUS_INVALID_PARAMETER;
1176
1177     fcb = FileObject->FsContext;
1178
1179     if (!fcb)
1180         return STATUS_INVALID_PARAMETER;
1181
1182     ccb = FileObject->FsContext2;
1183
1184     if (!ccb)
1185         return STATUS_INVALID_PARAMETER;
1186
1187     if (!(ccb->access & FILE_READ_ATTRIBUTES)) {
1188         WARN("insufficient privileges\n");
1189         return STATUS_ACCESS_DENIED;
1190     }
1191
1192     if (fcb->ads)
1193         fcb = ccb->fileref->parent->fcb;
1194
1195     ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
1196
1197     bii->subvol = fcb->subvol->id;
1198     bii->inode = fcb->inode;
1199     bii->top = fcb->Vcb->root_fileref->fcb == fcb ? TRUE : FALSE;
1200     bii->type = fcb->type;
1201     bii->st_uid = fcb->inode_item.st_uid;
1202     bii->st_gid = fcb->inode_item.st_gid;
1203     bii->st_mode = fcb->inode_item.st_mode;
1204
1205     if (fcb->inode_item.st_rdev == 0)
1206         bii->st_rdev = 0;
1207     else
1208         bii->st_rdev = makedev((fcb->inode_item.st_rdev & 0xFFFFFFFFFFF) >> 20, fcb->inode_item.st_rdev & 0xFFFFF);
1209
1210     bii->flags = fcb->inode_item.flags;
1211
1212     bii->inline_length = 0;
1213     bii->disk_size[0] = 0;
1214     bii->disk_size[1] = 0;
1215     bii->disk_size[2] = 0;
1216
1217     if (fcb->type != BTRFS_TYPE_DIRECTORY) {
1218         LIST_ENTRY* le;
1219
1220         le = fcb->extents.Flink;
1221         while (le != &fcb->extents) {
1222             extent* ext = CONTAINING_RECORD(le, extent, list_entry);
1223
1224             if (!ext->ignore) {
1225                 if (ext->extent_data.type == EXTENT_TYPE_INLINE) {
1226                     bii->inline_length += ext->datalen - (UINT16)offsetof(EXTENT_DATA, data[0]);
1227                 } else {
1228                     EXTENT_DATA2* ed2 = (EXTENT_DATA2*)ext->extent_data.data;
1229
1230                     // FIXME - compressed extents with a hole in them are counted more than once
1231                     if (ed2->size != 0) {
1232                         if (ext->extent_data.compression == BTRFS_COMPRESSION_NONE) {
1233                             bii->disk_size[0] += ed2->num_bytes;
1234                         } else if (ext->extent_data.compression == BTRFS_COMPRESSION_ZLIB) {
1235                             bii->disk_size[1] += ed2->size;
1236                         } else if (ext->extent_data.compression == BTRFS_COMPRESSION_LZO) {
1237                             bii->disk_size[2] += ed2->size;
1238                         }
1239                     }
1240                 }
1241             }
1242
1243             le = le->Flink;
1244         }
1245     }
1246
1247     switch (fcb->prop_compression) {
1248         case PropCompression_Zlib:
1249             bii->compression_type = BTRFS_COMPRESSION_ZLIB;
1250         break;
1251
1252         case PropCompression_LZO:
1253             bii->compression_type = BTRFS_COMPRESSION_LZO;
1254         break;
1255
1256         default:
1257             bii->compression_type = BTRFS_COMPRESSION_ANY;
1258         break;
1259     }
1260
1261     ExReleaseResourceLite(fcb->Header.Resource);
1262
1263     return STATUS_SUCCESS;
1264 }
1265
1266 static NTSTATUS set_inode_info(PFILE_OBJECT FileObject, void* data, ULONG length, PIRP Irp) {
1267     btrfs_set_inode_info* bsii = data;
1268     NTSTATUS Status;
1269     fcb* fcb;
1270     ccb* ccb;
1271
1272     if (length < sizeof(btrfs_set_inode_info))
1273         return STATUS_INVALID_PARAMETER;
1274
1275     if (!FileObject)
1276         return STATUS_INVALID_PARAMETER;
1277
1278     fcb = FileObject->FsContext;
1279
1280     if (!fcb)
1281         return STATUS_INVALID_PARAMETER;
1282
1283     ccb = FileObject->FsContext2;
1284
1285     if (!ccb)
1286         return STATUS_INVALID_PARAMETER;
1287
1288     if (bsii->flags_changed && !(ccb->access & FILE_WRITE_ATTRIBUTES)) {
1289         WARN("insufficient privileges\n");
1290         return STATUS_ACCESS_DENIED;
1291     }
1292
1293     if ((bsii->mode_changed || bsii->uid_changed || bsii->gid_changed) && !(ccb->access & WRITE_DAC)) {
1294         WARN("insufficient privileges\n");
1295         return STATUS_ACCESS_DENIED;
1296     }
1297
1298     if (bsii->compression_type_changed && bsii->compression_type > BTRFS_COMPRESSION_LZO)
1299         return STATUS_INVALID_PARAMETER;
1300
1301     if (fcb->ads)
1302         fcb = ccb->fileref->parent->fcb;
1303
1304     if (is_subvol_readonly(fcb->subvol, Irp)) {
1305         WARN("trying to change inode on readonly subvolume\n");
1306         return STATUS_ACCESS_DENIED;
1307     }
1308
1309     ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
1310
1311     if (bsii->flags_changed) {
1312         if (fcb->type != BTRFS_TYPE_DIRECTORY && fcb->inode_item.st_size > 0 &&
1313             (bsii->flags & BTRFS_INODE_NODATACOW) != (fcb->inode_item.flags & BTRFS_INODE_NODATACOW)) {
1314             WARN("trying to change nocow flag on non-empty file\n");
1315             Status = STATUS_INVALID_PARAMETER;
1316             goto end;
1317         }
1318
1319         fcb->inode_item.flags = bsii->flags;
1320
1321         if (fcb->inode_item.flags & BTRFS_INODE_NODATACOW)
1322             fcb->inode_item.flags |= BTRFS_INODE_NODATASUM;
1323         else
1324             fcb->inode_item.flags &= ~(UINT64)BTRFS_INODE_NODATASUM;
1325     }
1326
1327     if (bsii->mode_changed) {
1328         UINT32 allowed = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH |
1329                          S_ISGID | S_ISVTX;
1330
1331         if (ccb->access & WRITE_OWNER)
1332             allowed |= S_ISUID;
1333
1334         fcb->inode_item.st_mode &= ~allowed;
1335         fcb->inode_item.st_mode |= bsii->st_mode & allowed;
1336     }
1337
1338     if (bsii->uid_changed && fcb->inode_item.st_uid != bsii->st_uid) {
1339         fcb->inode_item.st_uid = bsii->st_uid;
1340
1341         fcb->sd_dirty = TRUE;
1342         fcb->sd_deleted = FALSE;
1343     }
1344
1345     if (bsii->gid_changed)
1346         fcb->inode_item.st_gid = bsii->st_gid;
1347
1348     if (bsii->compression_type_changed) {
1349         switch (bsii->compression_type) {
1350             case BTRFS_COMPRESSION_ANY:
1351                 fcb->prop_compression = PropCompression_None;
1352             break;
1353
1354             case BTRFS_COMPRESSION_ZLIB:
1355                 fcb->prop_compression = PropCompression_Zlib;
1356             break;
1357
1358             case BTRFS_COMPRESSION_LZO:
1359                 fcb->prop_compression = PropCompression_LZO;
1360             break;
1361         }
1362
1363         fcb->prop_compression_changed = TRUE;
1364     }
1365
1366     if (bsii->flags_changed || bsii->mode_changed || bsii->uid_changed || bsii->gid_changed || bsii->compression_type_changed) {
1367         fcb->inode_item_changed = TRUE;
1368         mark_fcb_dirty(fcb);
1369     }
1370
1371     Status = STATUS_SUCCESS;
1372
1373 end:
1374     ExReleaseResourceLite(fcb->Header.Resource);
1375
1376     return Status;
1377 }
1378
1379 static NTSTATUS get_devices(device_extension* Vcb, void* data, ULONG length) {
1380     btrfs_device* dev = NULL;
1381     NTSTATUS Status;
1382     LIST_ENTRY* le;
1383
1384     ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
1385
1386     le = Vcb->devices.Flink;
1387     while (le != &Vcb->devices) {
1388         device* dev2 = CONTAINING_RECORD(le, device, list_entry);
1389         ULONG structlen;
1390
1391         if (length < sizeof(btrfs_device) - sizeof(WCHAR)) {
1392             Status = STATUS_BUFFER_OVERFLOW;
1393             goto end;
1394         }
1395
1396         if (!dev)
1397             dev = data;
1398         else {
1399             dev->next_entry = sizeof(btrfs_device) - sizeof(WCHAR) + dev->namelen;
1400             dev = (btrfs_device*)((UINT8*)dev + dev->next_entry);
1401         }
1402
1403         structlen = length - offsetof(btrfs_device, namelen);
1404
1405         if (dev2->devobj) {
1406             Status = dev_ioctl(dev2->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &dev->namelen, structlen, TRUE, NULL);
1407             if (!NT_SUCCESS(Status))
1408                 goto end;
1409
1410             dev->missing = FALSE;
1411         } else {
1412             dev->namelen = 0;
1413             dev->missing = TRUE;
1414         }
1415
1416         dev->next_entry = 0;
1417         dev->dev_id = dev2->devitem.dev_id;
1418         dev->readonly = (Vcb->readonly || dev2->readonly) ? TRUE : FALSE;
1419         dev->device_number = dev2->disk_num;
1420         dev->partition_number = dev2->part_num;
1421         dev->size = dev2->devitem.num_bytes;
1422
1423         if (dev2->devobj) {
1424             GET_LENGTH_INFORMATION gli;
1425
1426             Status = dev_ioctl(dev2->devobj, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &gli, sizeof(gli), TRUE, NULL);
1427             if (!NT_SUCCESS(Status))
1428                 goto end;
1429
1430             dev->max_size = gli.Length.QuadPart;
1431         } else
1432             dev->max_size = dev->size;
1433
1434         RtlCopyMemory(dev->stats, dev2->stats, sizeof(UINT64) * 5);
1435
1436         length -= sizeof(btrfs_device) - sizeof(WCHAR) + dev->namelen;
1437
1438         le = le->Flink;
1439     }
1440
1441 end:
1442     ExReleaseResourceLite(&Vcb->tree_lock);
1443
1444     return Status;
1445 }
1446
1447 static NTSTATUS get_usage(device_extension* Vcb, void* data, ULONG length, PIRP Irp) {
1448     btrfs_usage* usage = (btrfs_usage*)data;
1449     btrfs_usage* lastbue = NULL;
1450     NTSTATUS Status;
1451     LIST_ENTRY* le;
1452
1453     if (length < sizeof(btrfs_usage))
1454         return STATUS_BUFFER_OVERFLOW;
1455
1456     if (!Vcb->chunk_usage_found) {
1457         ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
1458
1459         if (!Vcb->chunk_usage_found)
1460             Status = find_chunk_usage(Vcb, Irp);
1461         else
1462             Status = STATUS_SUCCESS;
1463
1464         ExReleaseResourceLite(&Vcb->tree_lock);
1465
1466         if (!NT_SUCCESS(Status)) {
1467             ERR("find_chunk_usage returned %08x\n", Status);
1468             return Status;
1469         }
1470     }
1471
1472     length -= offsetof(btrfs_usage, devices);
1473
1474     ExAcquireResourceSharedLite(&Vcb->chunk_lock, TRUE);
1475
1476     le = Vcb->chunks.Flink;
1477     while (le != &Vcb->chunks) {
1478         BOOL addnew = FALSE;
1479
1480         chunk* c = CONTAINING_RECORD(le, chunk, list_entry);
1481
1482         if (!lastbue) // first entry
1483             addnew = TRUE;
1484         else {
1485             btrfs_usage* bue = usage;
1486
1487             addnew = TRUE;
1488
1489             while (TRUE) {
1490                 if (bue->type == c->chunk_item->type) {
1491                     addnew = FALSE;
1492                     break;
1493                 }
1494
1495                 if (bue->next_entry == 0)
1496                     break;
1497                 else
1498                     bue = (btrfs_usage*)((UINT8*)bue + bue->next_entry);
1499             }
1500         }
1501
1502         if (addnew) {
1503             btrfs_usage* bue;
1504             LIST_ENTRY* le2;
1505             UINT64 factor;
1506
1507             if (!lastbue) {
1508                 bue = usage;
1509             } else {
1510                 if (length < offsetof(btrfs_usage, devices)) {
1511                     Status = STATUS_BUFFER_OVERFLOW;
1512                     goto end;
1513                 }
1514
1515                 length -= offsetof(btrfs_usage, devices);
1516
1517                 lastbue->next_entry = offsetof(btrfs_usage, devices) + (ULONG)(lastbue->num_devices * sizeof(btrfs_usage_device));
1518
1519                 bue = (btrfs_usage*)((UINT8*)lastbue + lastbue->next_entry);
1520             }
1521
1522             bue->next_entry = 0;
1523             bue->type = c->chunk_item->type;
1524             bue->size = 0;
1525             bue->used = 0;
1526             bue->num_devices = 0;
1527
1528             if (c->chunk_item->type & BLOCK_FLAG_RAID0)
1529                 factor = c->chunk_item->num_stripes;
1530             else if (c->chunk_item->type & BLOCK_FLAG_RAID10)
1531                 factor = c->chunk_item->num_stripes / c->chunk_item->sub_stripes;
1532             else if (c->chunk_item->type & BLOCK_FLAG_RAID5)
1533                 factor = c->chunk_item->num_stripes - 1;
1534             else if (c->chunk_item->type & BLOCK_FLAG_RAID6)
1535                 factor = c->chunk_item->num_stripes - 2;
1536             else
1537                 factor = 1;
1538
1539             le2 = le;
1540             while (le2 != &Vcb->chunks) {
1541                 chunk* c2 = CONTAINING_RECORD(le2, chunk, list_entry);
1542
1543                 if (c2->chunk_item->type == c->chunk_item->type) {
1544                     UINT16 i;
1545                     CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c2->chunk_item[1];
1546                     UINT64 stripesize;
1547
1548                     bue->size += c2->chunk_item->size;
1549                     bue->used += c2->used;
1550
1551                     stripesize = c2->chunk_item->size / factor;
1552
1553                     for (i = 0; i < c2->chunk_item->num_stripes; i++) {
1554                         UINT64 j;
1555                         BOOL found = FALSE;
1556
1557                         for (j = 0; j < bue->num_devices; j++) {
1558                             if (bue->devices[j].dev_id == cis[i].dev_id) {
1559                                 bue->devices[j].alloc += stripesize;
1560                                 found = TRUE;
1561                                 break;
1562                             }
1563                         }
1564
1565                         if (!found) {
1566                             if (length < sizeof(btrfs_usage_device)) {
1567                                 Status = STATUS_BUFFER_OVERFLOW;
1568                                 goto end;
1569                             }
1570
1571                             length -= sizeof(btrfs_usage_device);
1572
1573                             bue->devices[bue->num_devices].dev_id = cis[i].dev_id;
1574                             bue->devices[bue->num_devices].alloc = stripesize;
1575                             bue->num_devices++;
1576                         }
1577                     }
1578                 }
1579
1580                 le2 = le2->Flink;
1581             }
1582
1583             lastbue = bue;
1584         }
1585
1586         le = le->Flink;
1587     }
1588
1589     Status = STATUS_SUCCESS;
1590
1591 end:
1592     ExReleaseResourceLite(&Vcb->chunk_lock);
1593
1594     return Status;
1595 }
1596
1597 static NTSTATUS is_volume_mounted(device_extension* Vcb, PIRP Irp) {
1598     NTSTATUS Status;
1599     ULONG cc;
1600     IO_STATUS_BLOCK iosb;
1601     BOOL verify = FALSE;
1602     LIST_ENTRY* le;
1603
1604     ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
1605
1606     le = Vcb->devices.Flink;
1607     while (le != &Vcb->devices) {
1608         device* dev = CONTAINING_RECORD(le, device, list_entry);
1609
1610         if (dev->devobj && dev->removable) {
1611             Status = dev_ioctl(dev->devobj, IOCTL_STORAGE_CHECK_VERIFY, NULL, 0, &cc, sizeof(ULONG), FALSE, &iosb);
1612
1613             if (iosb.Information != sizeof(ULONG))
1614                 cc = 0;
1615
1616             if (Status == STATUS_VERIFY_REQUIRED || (NT_SUCCESS(Status) && cc != dev->change_count)) {
1617                 dev->devobj->Flags |= DO_VERIFY_VOLUME;
1618                 verify = TRUE;
1619             }
1620
1621             if (NT_SUCCESS(Status) && iosb.Information == sizeof(ULONG))
1622                 dev->change_count = cc;
1623
1624             if (!NT_SUCCESS(Status) || verify) {
1625                 IoSetHardErrorOrVerifyDevice(Irp, dev->devobj);
1626                 ExReleaseResourceLite(&Vcb->tree_lock);
1627
1628                 return verify ? STATUS_VERIFY_REQUIRED : Status;
1629             }
1630         }
1631
1632         le = le->Flink;
1633     }
1634
1635     ExReleaseResourceLite(&Vcb->tree_lock);
1636
1637     return STATUS_SUCCESS;
1638 }
1639
1640 static NTSTATUS fs_get_statistics(void* buffer, DWORD buflen, ULONG_PTR* retlen) {
1641     FILESYSTEM_STATISTICS* fss;
1642
1643     WARN("STUB: FSCTL_FILESYSTEM_GET_STATISTICS\n");
1644
1645     // This is hideously wrong, but at least it stops SMB from breaking
1646
1647     if (buflen < sizeof(FILESYSTEM_STATISTICS))
1648         return STATUS_BUFFER_TOO_SMALL;
1649
1650     fss = buffer;
1651     RtlZeroMemory(fss, sizeof(FILESYSTEM_STATISTICS));
1652
1653     fss->Version = 1;
1654     fss->FileSystemType = FILESYSTEM_STATISTICS_TYPE_NTFS;
1655     fss->SizeOfCompleteStructure = sizeof(FILESYSTEM_STATISTICS);
1656
1657     *retlen = sizeof(FILESYSTEM_STATISTICS);
1658
1659     return STATUS_SUCCESS;
1660 }
1661
1662 static NTSTATUS set_sparse(device_extension* Vcb, PFILE_OBJECT FileObject, void* data, ULONG length, PIRP Irp) {
1663     FILE_SET_SPARSE_BUFFER* fssb = data;
1664     NTSTATUS Status;
1665     BOOL set;
1666     fcb* fcb;
1667     ccb* ccb = FileObject->FsContext2;
1668     file_ref* fileref = ccb ? ccb->fileref : NULL;
1669
1670     if (data && length < sizeof(FILE_SET_SPARSE_BUFFER))
1671         return STATUS_INVALID_PARAMETER;
1672
1673     if (!FileObject) {
1674         ERR("FileObject was NULL\n");
1675         return STATUS_INVALID_PARAMETER;
1676     }
1677
1678     fcb = FileObject->FsContext;
1679
1680     if (!fcb) {
1681         ERR("FCB was NULL\n");
1682         return STATUS_INVALID_PARAMETER;
1683     }
1684
1685     if (!ccb) {
1686         ERR("CCB was NULL\n");
1687         return STATUS_INVALID_PARAMETER;
1688     }
1689
1690     if (Irp->RequestorMode == UserMode && !(ccb->access & FILE_WRITE_ATTRIBUTES)) {
1691         WARN("insufficient privileges\n");
1692         return STATUS_ACCESS_DENIED;
1693     }
1694
1695     if (!fileref) {
1696         ERR("no fileref\n");
1697         return STATUS_INVALID_PARAMETER;
1698     }
1699
1700     if (fcb->ads) {
1701         fileref = fileref->parent;
1702         fcb = fileref->fcb;
1703     }
1704
1705     ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
1706     ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
1707
1708     if (fcb->type != BTRFS_TYPE_FILE) {
1709         WARN("FileObject did not point to a file\n");
1710         Status = STATUS_INVALID_PARAMETER;
1711         goto end;
1712     }
1713
1714     if (fssb)
1715         set = fssb->SetSparse;
1716     else
1717         set = TRUE;
1718
1719     if (set) {
1720         fcb->atts |= FILE_ATTRIBUTE_SPARSE_FILE;
1721         fcb->atts_changed = TRUE;
1722     } else {
1723         ULONG defda;
1724
1725         fcb->atts &= ~FILE_ATTRIBUTE_SPARSE_FILE;
1726         fcb->atts_changed = TRUE;
1727
1728         defda = get_file_attributes(Vcb, fcb->subvol, fcb->inode, fcb->type,
1729                                     fileref && fileref->dc && fileref->dc->name.Length >= sizeof(WCHAR) && fileref->dc->name.Buffer[0] == '.', TRUE, Irp);
1730
1731         fcb->atts_deleted = defda == fcb->atts;
1732     }
1733
1734     mark_fcb_dirty(fcb);
1735     send_notification_fcb(fileref, FILE_NOTIFY_CHANGE_ATTRIBUTES, FILE_ACTION_MODIFIED, NULL);
1736
1737     Status = STATUS_SUCCESS;
1738
1739 end:
1740     ExReleaseResourceLite(fcb->Header.Resource);
1741     ExReleaseResourceLite(&Vcb->tree_lock);
1742
1743     return Status;
1744 }
1745
1746 static NTSTATUS zero_data(device_extension* Vcb, fcb* fcb, UINT64 start, UINT64 length, PIRP Irp, LIST_ENTRY* rollback) {
1747     NTSTATUS Status;
1748     BOOL make_inline, compress;
1749     UINT64 start_data, end_data;
1750     ULONG buf_head;
1751     UINT8* data;
1752
1753     make_inline = fcb->inode_item.st_size <= Vcb->options.max_inline || fcb_is_inline(fcb);
1754
1755     if (!make_inline)
1756         compress = write_fcb_compressed(fcb);
1757
1758     if (make_inline) {
1759         start_data = 0;
1760         end_data = fcb->inode_item.st_size;
1761         buf_head = (ULONG)offsetof(EXTENT_DATA, data[0]);
1762     } else if (compress) {
1763         start_data = start & ~(UINT64)(COMPRESSED_EXTENT_SIZE - 1);
1764         end_data = min(sector_align(start + length, COMPRESSED_EXTENT_SIZE),
1765                        sector_align(fcb->inode_item.st_size, Vcb->superblock.sector_size));
1766         buf_head = 0;
1767     } else {
1768         start_data = start & ~(UINT64)(Vcb->superblock.sector_size - 1);
1769         end_data = sector_align(start + length, Vcb->superblock.sector_size);
1770         buf_head = 0;
1771     }
1772
1773     data = ExAllocatePoolWithTag(PagedPool, (ULONG)(buf_head + end_data - start_data), ALLOC_TAG);
1774     if (!data) {
1775         ERR("out of memory\n");
1776         return STATUS_INSUFFICIENT_RESOURCES;
1777     }
1778
1779     RtlZeroMemory(data + buf_head, (ULONG)(end_data - start_data));
1780
1781     if (start > start_data || start + length < end_data) {
1782         Status = read_file(fcb, data + buf_head, start_data, end_data - start_data, NULL, Irp);
1783
1784         if (!NT_SUCCESS(Status)) {
1785             ERR("read_file returned %08x\n", Status);
1786             ExFreePool(data);
1787             return Status;
1788         }
1789     }
1790
1791     RtlZeroMemory(data + buf_head + start - start_data, (ULONG)length);
1792
1793     if (make_inline) {
1794         UINT16 edsize;
1795         EXTENT_DATA* ed = (EXTENT_DATA*)data;
1796
1797         Status = excise_extents(Vcb, fcb, 0, sector_align(end_data, Vcb->superblock.sector_size), Irp, rollback);
1798         if (!NT_SUCCESS(Status)) {
1799             ERR("excise_extents returned %08x\n", Status);
1800             ExFreePool(data);
1801             return Status;
1802         }
1803
1804         edsize = (UINT16)(offsetof(EXTENT_DATA, data[0]) + end_data);
1805
1806         ed->generation = Vcb->superblock.generation;
1807         ed->decoded_size = end_data;
1808         ed->compression = BTRFS_COMPRESSION_NONE;
1809         ed->encryption = BTRFS_ENCRYPTION_NONE;
1810         ed->encoding = BTRFS_ENCODING_NONE;
1811         ed->type = EXTENT_TYPE_INLINE;
1812
1813         Status = add_extent_to_fcb(fcb, 0, ed, edsize, FALSE, NULL, rollback);
1814         if (!NT_SUCCESS(Status)) {
1815             ERR("add_extent_to_fcb returned %08x\n", Status);
1816             ExFreePool(data);
1817             return Status;
1818         }
1819
1820         ExFreePool(data);
1821
1822         fcb->inode_item.st_blocks += end_data;
1823     } else if (compress) {
1824         Status = write_compressed(fcb, start_data, end_data, data, Irp, rollback);
1825
1826         ExFreePool(data);
1827
1828         if (!NT_SUCCESS(Status)) {
1829             ERR("write_compressed returned %08x\n", Status);
1830             return Status;
1831         }
1832     } else {
1833         Status = do_write_file(fcb, start_data, end_data, data, Irp, FALSE, 0, rollback);
1834
1835         ExFreePool(data);
1836
1837         if (!NT_SUCCESS(Status)) {
1838             ERR("do_write_file returned %08x\n", Status);
1839             return Status;
1840         }
1841     }
1842
1843     return STATUS_SUCCESS;
1844 }
1845
1846 static NTSTATUS set_zero_data(device_extension* Vcb, PFILE_OBJECT FileObject, void* data, ULONG length, PIRP Irp) {
1847     FILE_ZERO_DATA_INFORMATION* fzdi = data;
1848     NTSTATUS Status;
1849     fcb* fcb;
1850     ccb* ccb;
1851     file_ref* fileref;
1852     LIST_ENTRY rollback, *le;
1853     LARGE_INTEGER time;
1854     BTRFS_TIME now;
1855     UINT64 start, end;
1856     extent* ext;
1857     IO_STATUS_BLOCK iosb;
1858
1859     if (!data || length < sizeof(FILE_ZERO_DATA_INFORMATION))
1860         return STATUS_INVALID_PARAMETER;
1861
1862     if (!FileObject) {
1863         ERR("FileObject was NULL\n");
1864         return STATUS_INVALID_PARAMETER;
1865     }
1866
1867     if (fzdi->BeyondFinalZero.QuadPart <= fzdi->FileOffset.QuadPart) {
1868         WARN("BeyondFinalZero was less than or equal to FileOffset (%llx <= %llx)\n", fzdi->BeyondFinalZero.QuadPart, fzdi->FileOffset.QuadPart);
1869         return STATUS_INVALID_PARAMETER;
1870     }
1871
1872     fcb = FileObject->FsContext;
1873
1874     if (!fcb) {
1875         ERR("FCB was NULL\n");
1876         return STATUS_INVALID_PARAMETER;
1877     }
1878
1879     ccb = FileObject->FsContext2;
1880
1881     if (!ccb) {
1882         ERR("ccb was NULL\n");
1883         return STATUS_INVALID_PARAMETER;
1884     }
1885
1886     if (Irp->RequestorMode == UserMode && !(ccb->access & FILE_WRITE_DATA)) {
1887         WARN("insufficient privileges\n");
1888         return STATUS_ACCESS_DENIED;
1889     }
1890
1891     fileref = ccb->fileref;
1892
1893     if (!fileref) {
1894         ERR("fileref was NULL\n");
1895         return STATUS_INVALID_PARAMETER;
1896     }
1897
1898     InitializeListHead(&rollback);
1899
1900     ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
1901     ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
1902
1903     CcFlushCache(&fcb->nonpaged->segment_object, NULL, 0, &iosb);
1904
1905     if (fcb->type != BTRFS_TYPE_FILE) {
1906         WARN("FileObject did not point to a file\n");
1907         Status = STATUS_INVALID_PARAMETER;
1908         goto end;
1909     }
1910
1911     if (fcb->ads) {
1912         ERR("FileObject is stream\n");
1913         Status = STATUS_INVALID_PARAMETER;
1914         goto end;
1915     }
1916
1917     if ((UINT64)fzdi->FileOffset.QuadPart >= fcb->inode_item.st_size) {
1918         Status = STATUS_SUCCESS;
1919         goto end;
1920     }
1921
1922     ext = NULL;
1923     le = fcb->extents.Flink;
1924     while (le != &fcb->extents) {
1925         extent* ext2 = CONTAINING_RECORD(le, extent, list_entry);
1926
1927         if (!ext2->ignore) {
1928             ext = ext2;
1929             break;
1930         }
1931
1932         le = le->Flink;
1933     }
1934
1935     if (!ext) {
1936         Status = STATUS_SUCCESS;
1937         goto end;
1938     }
1939
1940     if (ext->extent_data.type == EXTENT_TYPE_INLINE) {
1941         Status = zero_data(Vcb, fcb, fzdi->FileOffset.QuadPart, fzdi->BeyondFinalZero.QuadPart - fzdi->FileOffset.QuadPart, Irp, &rollback);
1942         if (!NT_SUCCESS(Status)) {
1943             ERR("zero_data returned %08x\n", Status);
1944             goto end;
1945         }
1946     } else {
1947         start = sector_align(fzdi->FileOffset.QuadPart, Vcb->superblock.sector_size);
1948
1949         if ((UINT64)fzdi->BeyondFinalZero.QuadPart > fcb->inode_item.st_size)
1950             end = sector_align(fcb->inode_item.st_size, Vcb->superblock.sector_size);
1951         else
1952             end = (fzdi->BeyondFinalZero.QuadPart / Vcb->superblock.sector_size) * Vcb->superblock.sector_size;
1953
1954         if (end <= start) {
1955             Status = zero_data(Vcb, fcb, fzdi->FileOffset.QuadPart, fzdi->BeyondFinalZero.QuadPart - fzdi->FileOffset.QuadPart, Irp, &rollback);
1956             if (!NT_SUCCESS(Status)) {
1957                 ERR("zero_data returned %08x\n", Status);
1958                 goto end;
1959             }
1960         } else {
1961             if (start > (UINT64)fzdi->FileOffset.QuadPart) {
1962                 Status = zero_data(Vcb, fcb, fzdi->FileOffset.QuadPart, start - fzdi->FileOffset.QuadPart, Irp, &rollback);
1963                 if (!NT_SUCCESS(Status)) {
1964                     ERR("zero_data returned %08x\n", Status);
1965                     goto end;
1966                 }
1967             }
1968
1969             if (end < (UINT64)fzdi->BeyondFinalZero.QuadPart) {
1970                 Status = zero_data(Vcb, fcb, end, fzdi->BeyondFinalZero.QuadPart - end, Irp, &rollback);
1971                 if (!NT_SUCCESS(Status)) {
1972                     ERR("zero_data returned %08x\n", Status);
1973                     goto end;
1974                 }
1975             }
1976
1977             if (end > start) {
1978                 Status = excise_extents(Vcb, fcb, start, end, Irp, &rollback);
1979                 if (!NT_SUCCESS(Status)) {
1980                     ERR("excise_extents returned %08x\n", Status);
1981                     goto end;
1982                 }
1983             }
1984         }
1985     }
1986
1987     CcPurgeCacheSection(&fcb->nonpaged->segment_object, &fzdi->FileOffset, (ULONG)(fzdi->BeyondFinalZero.QuadPart - fzdi->FileOffset.QuadPart), FALSE);
1988
1989     KeQuerySystemTime(&time);
1990     win_time_to_unix(time, &now);
1991
1992     fcb->inode_item.transid = Vcb->superblock.generation;
1993     fcb->inode_item.sequence++;
1994
1995     if (!ccb->user_set_change_time)
1996         fcb->inode_item.st_ctime = now;
1997
1998     if (!ccb->user_set_write_time)
1999         fcb->inode_item.st_mtime = now;
2000
2001     fcb->extents_changed = TRUE;
2002     fcb->inode_item_changed = TRUE;
2003     mark_fcb_dirty(fcb);
2004
2005     send_notification_fcb(fileref, FILE_NOTIFY_CHANGE_LAST_WRITE, FILE_ACTION_MODIFIED, NULL);
2006
2007     fcb->subvol->root_item.ctransid = Vcb->superblock.generation;
2008     fcb->subvol->root_item.ctime = now;
2009
2010     Status = STATUS_SUCCESS;
2011
2012 end:
2013     if (!NT_SUCCESS(Status))
2014         do_rollback(Vcb, &rollback);
2015     else
2016         clear_rollback(&rollback);
2017
2018     ExReleaseResourceLite(fcb->Header.Resource);
2019     ExReleaseResourceLite(&Vcb->tree_lock);
2020
2021     return Status;
2022 }
2023
2024 static NTSTATUS query_ranges(PFILE_OBJECT FileObject, FILE_ALLOCATED_RANGE_BUFFER* inbuf, ULONG inbuflen, void* outbuf, ULONG outbuflen, ULONG_PTR* retlen) {
2025     NTSTATUS Status;
2026     fcb* fcb;
2027     LIST_ENTRY* le;
2028     FILE_ALLOCATED_RANGE_BUFFER* ranges = outbuf;
2029     ULONG i = 0;
2030     UINT64 last_start, last_end;
2031
2032     TRACE("FSCTL_QUERY_ALLOCATED_RANGES\n");
2033
2034     if (!FileObject) {
2035         ERR("FileObject was NULL\n");
2036         return STATUS_INVALID_PARAMETER;
2037     }
2038
2039     if (!inbuf || inbuflen < sizeof(FILE_ALLOCATED_RANGE_BUFFER) || !outbuf)
2040         return STATUS_INVALID_PARAMETER;
2041
2042     fcb = FileObject->FsContext;
2043
2044     if (!fcb) {
2045         ERR("FCB was NULL\n");
2046         return STATUS_INVALID_PARAMETER;
2047     }
2048
2049     ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
2050
2051     // If file is not marked as sparse, claim the whole thing as an allocated range
2052
2053     if (!(fcb->atts & FILE_ATTRIBUTE_SPARSE_FILE)) {
2054         if (fcb->inode_item.st_size == 0)
2055             Status = STATUS_SUCCESS;
2056         else if (outbuflen < sizeof(FILE_ALLOCATED_RANGE_BUFFER))
2057             Status = STATUS_BUFFER_TOO_SMALL;
2058         else {
2059             ranges[i].FileOffset.QuadPart = 0;
2060             ranges[i].Length.QuadPart = fcb->inode_item.st_size;
2061             i++;
2062             Status = STATUS_SUCCESS;
2063         }
2064
2065         goto end;
2066
2067     }
2068
2069     le = fcb->extents.Flink;
2070
2071     last_start = 0;
2072     last_end = 0;
2073
2074     while (le != &fcb->extents) {
2075         extent* ext = CONTAINING_RECORD(le, extent, list_entry);
2076
2077         if (!ext->ignore) {
2078             EXTENT_DATA2* ed2 = (ext->extent_data.type == EXTENT_TYPE_REGULAR || ext->extent_data.type == EXTENT_TYPE_PREALLOC) ? (EXTENT_DATA2*)ext->extent_data.data : NULL;
2079             UINT64 len = ed2 ? ed2->num_bytes : ext->extent_data.decoded_size;
2080
2081             if (ext->offset > last_end) { // first extent after a hole
2082                 if (last_end > last_start) {
2083                     if ((i + 1) * sizeof(FILE_ALLOCATED_RANGE_BUFFER) <= outbuflen) {
2084                         ranges[i].FileOffset.QuadPart = last_start;
2085                         ranges[i].Length.QuadPart = min(fcb->inode_item.st_size, last_end) - last_start;
2086                         i++;
2087                     } else {
2088                         Status = STATUS_BUFFER_TOO_SMALL;
2089                         goto end;
2090                     }
2091                 }
2092
2093                 last_start = ext->offset;
2094             }
2095
2096             last_end = ext->offset + len;
2097         }
2098
2099         le = le->Flink;
2100     }
2101
2102     if (last_end > last_start) {
2103         if ((i + 1) * sizeof(FILE_ALLOCATED_RANGE_BUFFER) <= outbuflen) {
2104             ranges[i].FileOffset.QuadPart = last_start;
2105             ranges[i].Length.QuadPart = min(fcb->inode_item.st_size, last_end) - last_start;
2106             i++;
2107         } else {
2108             Status = STATUS_BUFFER_TOO_SMALL;
2109             goto end;
2110         }
2111     }
2112
2113     Status = STATUS_SUCCESS;
2114
2115 end:
2116     *retlen = i * sizeof(FILE_ALLOCATED_RANGE_BUFFER);
2117
2118     ExReleaseResourceLite(fcb->Header.Resource);
2119
2120     return Status;
2121 }
2122
2123 static NTSTATUS get_object_id(device_extension* Vcb, PFILE_OBJECT FileObject, FILE_OBJECTID_BUFFER* buf, ULONG buflen, ULONG_PTR* retlen) {
2124     fcb* fcb;
2125
2126     TRACE("(%p, %p, %p, %x, %p)\n", Vcb, FileObject, buf, buflen, retlen);
2127
2128     if (!FileObject) {
2129         ERR("FileObject was NULL\n");
2130         return STATUS_INVALID_PARAMETER;
2131     }
2132
2133     if (!buf || buflen < sizeof(FILE_OBJECTID_BUFFER))
2134         return STATUS_INVALID_PARAMETER;
2135
2136     fcb = FileObject->FsContext;
2137
2138     if (!fcb) {
2139         ERR("FCB was NULL\n");
2140         return STATUS_INVALID_PARAMETER;
2141     }
2142
2143     ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
2144
2145     RtlCopyMemory(&buf->ObjectId[0], &fcb->inode, sizeof(UINT64));
2146     RtlCopyMemory(&buf->ObjectId[sizeof(UINT64)], &fcb->subvol->id, sizeof(UINT64));
2147
2148     ExReleaseResourceLite(fcb->Header.Resource);
2149
2150     RtlZeroMemory(&buf->ExtendedInfo, sizeof(buf->ExtendedInfo));
2151
2152     *retlen = sizeof(FILE_OBJECTID_BUFFER);
2153
2154     return STATUS_SUCCESS;
2155 }
2156
2157 static void flush_fcb_caches(device_extension* Vcb) {
2158     LIST_ENTRY* le;
2159
2160     le = Vcb->all_fcbs.Flink;
2161     while (le != &Vcb->all_fcbs) {
2162         struct _fcb* fcb = CONTAINING_RECORD(le, struct _fcb, list_entry_all);
2163         IO_STATUS_BLOCK iosb;
2164
2165         if (fcb->type != BTRFS_TYPE_DIRECTORY && !fcb->deleted)
2166             CcFlushCache(&fcb->nonpaged->segment_object, NULL, 0, &iosb);
2167
2168         le = le->Flink;
2169     }
2170 }
2171
2172 static NTSTATUS lock_volume(device_extension* Vcb, PIRP Irp) {
2173     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
2174     NTSTATUS Status;
2175     KIRQL irql;
2176     BOOL lock_paused_balance = FALSE;
2177
2178     TRACE("FSCTL_LOCK_VOLUME\n");
2179
2180     if (Vcb->scrub.thread) {
2181         WARN("cannot lock while scrub running\n");
2182         return STATUS_DEVICE_NOT_READY;
2183     }
2184
2185     if (Vcb->balance.thread) {
2186         WARN("cannot lock while balance running\n");
2187         return STATUS_DEVICE_NOT_READY;
2188     }
2189
2190     TRACE("locking volume\n");
2191
2192     FsRtlNotifyVolumeEvent(IrpSp->FileObject, FSRTL_VOLUME_LOCK);
2193
2194     if (Vcb->locked)
2195         return STATUS_SUCCESS;
2196
2197     acquire_fcb_lock_exclusive(Vcb);
2198
2199     if (Vcb->root_fileref && Vcb->root_fileref->fcb && (Vcb->root_fileref->open_count > 0 || has_open_children(Vcb->root_fileref))) {
2200         Status = STATUS_ACCESS_DENIED;
2201         release_fcb_lock(Vcb);
2202         goto end;
2203     }
2204
2205     release_fcb_lock(Vcb);
2206
2207     if (Vcb->balance.thread && KeReadStateEvent(&Vcb->balance.event)) {
2208         ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
2209         KeClearEvent(&Vcb->balance.event);
2210         ExReleaseResourceLite(&Vcb->tree_lock);
2211
2212         lock_paused_balance = TRUE;
2213     }
2214
2215     ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
2216
2217     flush_fcb_caches(Vcb);
2218
2219     if (Vcb->need_write && !Vcb->readonly)
2220         Status = do_write(Vcb, Irp);
2221     else
2222         Status = STATUS_SUCCESS;
2223
2224     free_trees(Vcb);
2225
2226     ExReleaseResourceLite(&Vcb->tree_lock);
2227
2228     if (!NT_SUCCESS(Status)) {
2229         ERR("do_write returned %08x\n", Status);
2230         goto end;
2231     }
2232
2233     IoAcquireVpbSpinLock(&irql);
2234
2235     if (!(Vcb->Vpb->Flags & VPB_LOCKED)) {
2236         Vcb->Vpb->Flags |= VPB_LOCKED;
2237         Vcb->locked = TRUE;
2238         Vcb->locked_fileobj = IrpSp->FileObject;
2239         Vcb->lock_paused_balance = lock_paused_balance;
2240     } else {
2241         Status = STATUS_ACCESS_DENIED;
2242         IoReleaseVpbSpinLock(irql);
2243
2244         if (lock_paused_balance)
2245             KeSetEvent(&Vcb->balance.event, 0, FALSE);
2246
2247         goto end;
2248     }
2249
2250     IoReleaseVpbSpinLock(irql);
2251
2252     Status = STATUS_SUCCESS;
2253
2254 end:
2255     if (!NT_SUCCESS(Status))
2256         FsRtlNotifyVolumeEvent(IrpSp->FileObject, FSRTL_VOLUME_LOCK_FAILED);
2257
2258     return Status;
2259 }
2260
2261 void do_unlock_volume(device_extension* Vcb) {
2262     KIRQL irql;
2263
2264     IoAcquireVpbSpinLock(&irql);
2265
2266     Vcb->locked = FALSE;
2267     Vcb->Vpb->Flags &= ~VPB_LOCKED;
2268     Vcb->locked_fileobj = NULL;
2269
2270     IoReleaseVpbSpinLock(irql);
2271
2272     if (Vcb->lock_paused_balance)
2273         KeSetEvent(&Vcb->balance.event, 0, FALSE);
2274 }
2275
2276 static NTSTATUS unlock_volume(device_extension* Vcb, PIRP Irp) {
2277     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
2278
2279     TRACE("FSCTL_UNLOCK_VOLUME\n");
2280
2281     if (!Vcb->locked || IrpSp->FileObject != Vcb->locked_fileobj)
2282         return STATUS_NOT_LOCKED;
2283
2284     TRACE("unlocking volume\n");
2285
2286     do_unlock_volume(Vcb);
2287
2288     FsRtlNotifyVolumeEvent(IrpSp->FileObject, FSRTL_VOLUME_UNLOCK);
2289
2290     return STATUS_SUCCESS;
2291 }
2292
2293 static NTSTATUS invalidate_volumes(PIRP Irp) {
2294     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
2295     LUID TcbPrivilege = {SE_TCB_PRIVILEGE, 0};
2296     NTSTATUS Status;
2297     HANDLE h;
2298     PFILE_OBJECT fileobj;
2299     PDEVICE_OBJECT devobj;
2300     LIST_ENTRY* le;
2301
2302     TRACE("FSCTL_INVALIDATE_VOLUMES\n");
2303
2304     if (!SeSinglePrivilegeCheck(TcbPrivilege, Irp->RequestorMode))
2305         return STATUS_PRIVILEGE_NOT_HELD;
2306
2307 #if defined(_WIN64)
2308     if (IoIs32bitProcess(Irp)) {
2309         if (IrpSp->Parameters.FileSystemControl.InputBufferLength != sizeof(UINT32))
2310             return STATUS_INVALID_PARAMETER;
2311
2312         h = (HANDLE)LongToHandle((*(PUINT32)Irp->AssociatedIrp.SystemBuffer));
2313     } else {
2314 #endif
2315         if (IrpSp->Parameters.FileSystemControl.InputBufferLength != sizeof(HANDLE))
2316             return STATUS_INVALID_PARAMETER;
2317
2318         h = *(PHANDLE)Irp->AssociatedIrp.SystemBuffer;
2319 #if defined(_WIN64)
2320     }
2321 #endif
2322
2323     Status = ObReferenceObjectByHandle(h, 0, *IoFileObjectType, Irp->RequestorMode, (void**)&fileobj, NULL);
2324
2325     if (!NT_SUCCESS(Status)) {
2326         ERR("ObReferenceObjectByHandle returned %08x\n", Status);
2327         return Status;
2328     }
2329
2330     devobj = fileobj->DeviceObject;
2331
2332     ExAcquireResourceSharedLite(&global_loading_lock, TRUE);
2333
2334     le = VcbList.Flink;
2335
2336     while (le != &VcbList) {
2337         device_extension* Vcb = CONTAINING_RECORD(le, device_extension, list_entry);
2338
2339         if (Vcb->Vpb && Vcb->Vpb->RealDevice == devobj) {
2340             if (Vcb->Vpb == devobj->Vpb) {
2341                 KIRQL irql;
2342                 PVPB newvpb;
2343                 BOOL free_newvpb = FALSE;
2344
2345                 newvpb = ExAllocatePoolWithTag(NonPagedPool, sizeof(VPB), ALLOC_TAG);
2346                 if (!newvpb) {
2347                     ERR("out of memory\n");
2348                     Status = STATUS_INSUFFICIENT_RESOURCES;
2349                     goto end;
2350                 }
2351
2352                 RtlZeroMemory(newvpb, sizeof(VPB));
2353
2354                 IoAcquireVpbSpinLock(&irql);
2355                 devobj->Vpb->Flags &= ~VPB_MOUNTED;
2356                 IoReleaseVpbSpinLock(irql);
2357
2358                 ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
2359
2360                 Vcb->removing = TRUE;
2361
2362                 ExReleaseResourceLite(&Vcb->tree_lock);
2363
2364                 CcWaitForCurrentLazyWriterActivity();
2365
2366                 ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
2367
2368                 flush_fcb_caches(Vcb);
2369
2370                 if (Vcb->need_write && !Vcb->readonly)
2371                     Status = do_write(Vcb, Irp);
2372                 else
2373                     Status = STATUS_SUCCESS;
2374
2375                 free_trees(Vcb);
2376
2377                 if (!NT_SUCCESS(Status)) {
2378                     ERR("do_write returned %08x\n", Status);
2379                     ExReleaseResourceLite(&Vcb->tree_lock);
2380                     ExFreePool(newvpb);
2381                     goto end;
2382                 }
2383
2384                 flush_fcb_caches(Vcb);
2385
2386                 ExReleaseResourceLite(&Vcb->tree_lock);
2387
2388                 IoAcquireVpbSpinLock(&irql);
2389
2390                 if (devobj->Vpb->Flags & VPB_MOUNTED) {
2391                     newvpb->Type = IO_TYPE_VPB;
2392                     newvpb->Size = sizeof(VPB);
2393                     newvpb->RealDevice = devobj;
2394                     newvpb->Flags = devobj->Vpb->Flags & VPB_REMOVE_PENDING;
2395
2396                     devobj->Vpb = newvpb;
2397                 } else
2398                     free_newvpb = TRUE;
2399
2400                 IoReleaseVpbSpinLock(irql);
2401
2402                 if (free_newvpb)
2403                     ExFreePool(newvpb);
2404
2405                 if (Vcb->open_files == 0)
2406                     uninit(Vcb, FALSE);
2407             }
2408
2409             break;
2410         }
2411
2412         le = le->Flink;
2413     }
2414
2415     Status = STATUS_SUCCESS;
2416
2417 end:
2418     ExReleaseResourceLite(&global_loading_lock);
2419
2420     ObDereferenceObject(fileobj);
2421
2422     return Status;
2423 }
2424
2425 static NTSTATUS is_volume_dirty(device_extension* Vcb, PIRP Irp) {
2426     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
2427     ULONG* volstate;
2428
2429     if (Irp->AssociatedIrp.SystemBuffer) {
2430         volstate = Irp->AssociatedIrp.SystemBuffer;
2431     } else if (Irp->MdlAddress != NULL) {
2432         volstate = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, LowPagePriority);
2433
2434         if (!volstate)
2435             return STATUS_INSUFFICIENT_RESOURCES;
2436     } else
2437         return STATUS_INVALID_USER_BUFFER;
2438
2439     if (IrpSp->Parameters.FileSystemControl.OutputBufferLength < sizeof(ULONG))
2440         return STATUS_INVALID_PARAMETER;
2441
2442     *volstate = 0;
2443
2444     if (IrpSp->FileObject->FsContext != Vcb->volume_fcb)
2445         return STATUS_INVALID_PARAMETER;
2446
2447     Irp->IoStatus.Information = sizeof(ULONG);
2448
2449     return STATUS_SUCCESS;
2450 }
2451
2452 static NTSTATUS get_compression(PIRP Irp) {
2453     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
2454     USHORT* compression;
2455
2456     TRACE("FSCTL_GET_COMPRESSION\n");
2457
2458     if (Irp->AssociatedIrp.SystemBuffer) {
2459         compression = Irp->AssociatedIrp.SystemBuffer;
2460     } else if (Irp->MdlAddress != NULL) {
2461         compression = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, LowPagePriority);
2462
2463         if (!compression)
2464             return STATUS_INSUFFICIENT_RESOURCES;
2465     } else
2466         return STATUS_INVALID_USER_BUFFER;
2467
2468     if (IrpSp->Parameters.FileSystemControl.OutputBufferLength < sizeof(USHORT))
2469         return STATUS_INVALID_PARAMETER;
2470
2471     *compression = COMPRESSION_FORMAT_NONE;
2472
2473     Irp->IoStatus.Information = sizeof(USHORT);
2474
2475     return STATUS_SUCCESS;
2476 }
2477
2478 static NTSTATUS set_compression(PIRP Irp) {
2479     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
2480     USHORT* compression;
2481
2482     TRACE("FSCTL_SET_COMPRESSION\n");
2483
2484     if (IrpSp->Parameters.FileSystemControl.InputBufferLength < sizeof(USHORT))
2485         return STATUS_INVALID_PARAMETER;
2486
2487     compression = Irp->AssociatedIrp.SystemBuffer;
2488
2489     if (*compression != COMPRESSION_FORMAT_NONE)
2490         return STATUS_INVALID_PARAMETER;
2491
2492     return STATUS_SUCCESS;
2493 }
2494
2495 static void update_volumes(device_extension* Vcb) {
2496     LIST_ENTRY* le;
2497     volume_device_extension* vde = Vcb->vde;
2498     pdo_device_extension* pdode = vde->pdode;
2499
2500     ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
2501
2502     ExAcquireResourceExclusiveLite(&pdode->child_lock, TRUE);
2503
2504     le = pdode->children.Flink;
2505     while (le != &pdode->children) {
2506         volume_child* vc = CONTAINING_RECORD(le, volume_child, list_entry);
2507
2508         vc->generation = Vcb->superblock.generation - 1;
2509
2510         le = le->Flink;
2511     }
2512
2513     ExReleaseResourceLite(&pdode->child_lock);
2514
2515     ExReleaseResourceLite(&Vcb->tree_lock);
2516 }
2517
2518 static NTSTATUS dismount_volume(device_extension* Vcb, PIRP Irp) {
2519     NTSTATUS Status;
2520     KIRQL irql;
2521
2522     TRACE("FSCTL_DISMOUNT_VOLUME\n");
2523
2524     if (!(Vcb->Vpb->Flags & VPB_MOUNTED))
2525         return STATUS_SUCCESS;
2526
2527     if (Vcb->disallow_dismount) {
2528         WARN("attempting to dismount boot volume or one containing a pagefile\n");
2529         return STATUS_ACCESS_DENIED;
2530     }
2531
2532     Status = FsRtlNotifyVolumeEvent(Vcb->root_file, FSRTL_VOLUME_DISMOUNT);
2533     if (!NT_SUCCESS(Status)) {
2534         WARN("FsRtlNotifyVolumeEvent returned %08x\n", Status);
2535     }
2536
2537     ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
2538
2539     if (!Vcb->locked) {
2540         flush_fcb_caches(Vcb);
2541
2542         if (Vcb->need_write && !Vcb->readonly) {
2543             Status = do_write(Vcb, Irp);
2544
2545             if (!NT_SUCCESS(Status))
2546                 ERR("do_write returned %08x\n", Status);
2547         }
2548     }
2549
2550     free_trees(Vcb);
2551
2552     Vcb->removing = TRUE;
2553
2554     if (Vcb->vde) {
2555         update_volumes(Vcb);
2556         Vcb->vde->mounted_device = NULL;
2557     }
2558
2559     ExReleaseResourceLite(&Vcb->tree_lock);
2560
2561     IoAcquireVpbSpinLock(&irql);
2562     Vcb->Vpb->Flags &= ~VPB_MOUNTED;
2563     Vcb->Vpb->Flags |= VPB_DIRECT_WRITES_ALLOWED;
2564     IoReleaseVpbSpinLock(irql);
2565
2566     return STATUS_SUCCESS;
2567 }
2568
2569 static NTSTATUS is_device_part_of_mounted_btrfs_raid(PDEVICE_OBJECT devobj) {
2570     NTSTATUS Status;
2571     ULONG to_read;
2572     superblock* sb;
2573     UINT32 crc32;
2574     BTRFS_UUID fsuuid, devuuid;
2575     LIST_ENTRY* le;
2576
2577     to_read = devobj->SectorSize == 0 ? sizeof(superblock) : (ULONG)sector_align(sizeof(superblock), devobj->SectorSize);
2578
2579     sb = ExAllocatePoolWithTag(PagedPool, to_read, ALLOC_TAG);
2580     if (!sb) {
2581         ERR("out of memory\n");
2582         return STATUS_INSUFFICIENT_RESOURCES;
2583     }
2584
2585     Status = sync_read_phys(devobj, superblock_addrs[0], to_read, (UINT8*)sb, TRUE);
2586     if (!NT_SUCCESS(Status)) {
2587         ERR("sync_read_phys returned %08x\n", Status);
2588         ExFreePool(sb);
2589         return Status;
2590     }
2591
2592     if (sb->magic != BTRFS_MAGIC) {
2593         TRACE("device is not Btrfs\n");
2594         ExFreePool(sb);
2595         return STATUS_SUCCESS;
2596     }
2597
2598     crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
2599
2600     if (crc32 != *((UINT32*)sb->checksum)) {
2601         TRACE("device has Btrfs magic, but invalid superblock checksum\n");
2602         ExFreePool(sb);
2603         return STATUS_SUCCESS;
2604     }
2605
2606     fsuuid = sb->uuid;
2607     devuuid = sb->dev_item.device_uuid;
2608
2609     ExFreePool(sb);
2610
2611     ExAcquireResourceSharedLite(&global_loading_lock, TRUE);
2612
2613     le = VcbList.Flink;
2614
2615     while (le != &VcbList) {
2616         device_extension* Vcb = CONTAINING_RECORD(le, device_extension, list_entry);
2617
2618         if (RtlCompareMemory(&Vcb->superblock.uuid, &fsuuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID)) {
2619             LIST_ENTRY* le2;
2620
2621             ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
2622
2623             if (Vcb->superblock.num_devices > 1) {
2624                 le2 = Vcb->devices.Flink;
2625                 while (le2 != &Vcb->devices) {
2626                     device* dev = CONTAINING_RECORD(le2, device, list_entry);
2627
2628                     if (RtlCompareMemory(&dev->devitem.device_uuid, &devuuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID)) {
2629                         ExReleaseResourceLite(&Vcb->tree_lock);
2630                         ExReleaseResourceLite(&global_loading_lock);
2631                         return STATUS_DEVICE_NOT_READY;
2632                     }
2633
2634                     le2 = le2->Flink;
2635                 }
2636             }
2637
2638             ExReleaseResourceLite(&Vcb->tree_lock);
2639             ExReleaseResourceLite(&global_loading_lock);
2640             return STATUS_SUCCESS;
2641         }
2642
2643         le = le->Flink;
2644     }
2645
2646     ExReleaseResourceLite(&global_loading_lock);
2647
2648     return STATUS_SUCCESS;
2649 }
2650
2651 void trim_whole_device(device* dev) {
2652     DEVICE_MANAGE_DATA_SET_ATTRIBUTES dmdsa;
2653     NTSTATUS Status;
2654
2655     // FIXME - avoid "bootloader area"??
2656
2657     dmdsa.Size = sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES);
2658     dmdsa.Action = DeviceDsmAction_Trim;
2659     dmdsa.Flags = DEVICE_DSM_FLAG_ENTIRE_DATA_SET_RANGE | DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED;
2660     dmdsa.ParameterBlockOffset = 0;
2661     dmdsa.ParameterBlockLength = 0;
2662     dmdsa.DataSetRangesOffset = 0;
2663     dmdsa.DataSetRangesLength = 0;
2664
2665     Status = dev_ioctl(dev->devobj, IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES, &dmdsa, sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES), NULL, 0, TRUE, NULL);
2666     if (!NT_SUCCESS(Status))
2667         WARN("IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES returned %08x\n", Status);
2668 }
2669
2670 static NTSTATUS add_device(device_extension* Vcb, PIRP Irp, KPROCESSOR_MODE processor_mode) {
2671     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
2672     NTSTATUS Status;
2673     PFILE_OBJECT fileobj, mountmgrfo;
2674     PDEVICE_OBJECT DeviceObject;
2675     HANDLE h;
2676     LIST_ENTRY* le;
2677     device* dev;
2678     DEV_ITEM* di;
2679     UINT64 dev_id, size;
2680     UINT8* mb;
2681     UINT64* stats;
2682     UNICODE_STRING mmdevpath, pnp_name, pnp_name2;
2683     volume_child* vc;
2684     PDEVICE_OBJECT mountmgr;
2685     KEY searchkey;
2686     traverse_ptr tp;
2687     STORAGE_DEVICE_NUMBER sdn;
2688     volume_device_extension* vde;
2689     pdo_device_extension* pdode;
2690     const GUID* pnp_guid;
2691     GET_LENGTH_INFORMATION gli;
2692
2693     pnp_name.Buffer = NULL;
2694
2695     if (!SeSinglePrivilegeCheck(RtlConvertLongToLuid(SE_MANAGE_VOLUME_PRIVILEGE), processor_mode))
2696         return STATUS_PRIVILEGE_NOT_HELD;
2697
2698     if (!Vcb->vde) {
2699         WARN("not allowing second device to be added to non-PNP device\n");
2700         return STATUS_NOT_SUPPORTED;
2701     }
2702
2703     if (Vcb->readonly) // FIXME - handle adding R/W device to seeding device
2704         return STATUS_MEDIA_WRITE_PROTECTED;
2705
2706 #if defined(_WIN64)
2707     if (IoIs32bitProcess(Irp)) {
2708         if (IrpSp->Parameters.FileSystemControl.InputBufferLength != sizeof(UINT32))
2709             return STATUS_INVALID_PARAMETER;
2710
2711         h = (HANDLE)LongToHandle((*(PUINT32)Irp->AssociatedIrp.SystemBuffer));
2712     } else {
2713 #endif
2714         if (IrpSp->Parameters.FileSystemControl.InputBufferLength != sizeof(HANDLE))
2715             return STATUS_INVALID_PARAMETER;
2716
2717         h = *(PHANDLE)Irp->AssociatedIrp.SystemBuffer;
2718 #if defined(_WIN64)
2719     }
2720 #endif
2721
2722     Status = ObReferenceObjectByHandle(h, 0, *IoFileObjectType, Irp->RequestorMode, (void**)&fileobj, NULL);
2723
2724     if (!NT_SUCCESS(Status)) {
2725         ERR("ObReferenceObjectByHandle returned %08x\n", Status);
2726         return Status;
2727     }
2728
2729     DeviceObject = fileobj->DeviceObject;
2730
2731     Status = get_device_pnp_name(DeviceObject, &pnp_name, &pnp_guid);
2732     if (!NT_SUCCESS(Status)) {
2733         ERR("get_device_pnp_name returned %08x\n", Status);
2734         ObDereferenceObject(fileobj);
2735         return Status;
2736     }
2737
2738     // If this is a disk, we have been handed the PDO, so need to go up to find something we can use
2739     if (RtlCompareMemory(pnp_guid, &GUID_DEVINTERFACE_DISK, sizeof(GUID)) == sizeof(GUID) && DeviceObject->AttachedDevice)
2740         DeviceObject = DeviceObject->AttachedDevice;
2741
2742     Status = dev_ioctl(DeviceObject, IOCTL_DISK_IS_WRITABLE, NULL, 0, NULL, 0, TRUE, NULL);
2743     if (!NT_SUCCESS(Status)) {
2744         ERR("IOCTL_DISK_IS_WRITABLE returned %08x\n", Status);
2745         ObDereferenceObject(fileobj);
2746         return Status;
2747     }
2748
2749     Status = is_device_part_of_mounted_btrfs_raid(DeviceObject);
2750     if (!NT_SUCCESS(Status)) {
2751         ERR("is_device_part_of_mounted_btrfs_raid returned %08x\n", Status);
2752         ObDereferenceObject(fileobj);
2753         return Status;
2754     }
2755
2756     // if disk, check it has no partitions
2757     if (RtlCompareMemory(pnp_guid, &GUID_DEVINTERFACE_DISK, sizeof(GUID)) == sizeof(GUID)) {
2758         ULONG dlisize;
2759         DRIVE_LAYOUT_INFORMATION_EX* dli = NULL;
2760
2761         dlisize = 0;
2762
2763         do {
2764             dlisize += 1024;
2765
2766             if (dli)
2767                 ExFreePool(dli);
2768
2769             dli = ExAllocatePoolWithTag(PagedPool, dlisize, ALLOC_TAG);
2770             if (!dli) {
2771                 ERR("out of memory\n");
2772                 Status = STATUS_INSUFFICIENT_RESOURCES;
2773                 goto end2;
2774             }
2775
2776             Status = dev_ioctl(DeviceObject, IOCTL_DISK_GET_DRIVE_LAYOUT_EX, NULL, 0, dli, dlisize, TRUE, NULL);
2777         } while (Status == STATUS_BUFFER_TOO_SMALL);
2778
2779         if (NT_SUCCESS(Status) && dli->PartitionCount > 0) {
2780             ExFreePool(dli);
2781             ERR("not adding disk which has partitions\n");
2782             Status = STATUS_DEVICE_NOT_READY;
2783             goto end2;
2784         }
2785
2786         ExFreePool(dli);
2787     }
2788
2789     Status = dev_ioctl(DeviceObject, IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL, 0,
2790                        &sdn, sizeof(STORAGE_DEVICE_NUMBER), TRUE, NULL);
2791     if (NT_SUCCESS(Status)) {
2792         if (sdn.DeviceType != FILE_DEVICE_DISK) { // FIXME - accept floppies and CDs?
2793             WARN("device was not disk\n");
2794             ObDereferenceObject(fileobj);
2795             return STATUS_INVALID_PARAMETER;
2796         }
2797     } else {
2798         sdn.DeviceNumber = 0xffffffff;
2799         sdn.PartitionNumber = 0xffffffff;
2800     }
2801
2802     Status = dev_ioctl(DeviceObject, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0,
2803                         &gli, sizeof(gli), TRUE, NULL);
2804     if (!NT_SUCCESS(Status)) {
2805         ERR("error reading length information: %08x\n", Status);
2806         ObDereferenceObject(fileobj);
2807         return Status;
2808     }
2809
2810     size = gli.Length.QuadPart;
2811
2812     if (size < 0x100000) {
2813         ERR("device was not large enough to hold FS (%llx bytes, need at least 1 MB)\n", size);
2814         ObDereferenceObject(fileobj);
2815         return STATUS_INTERNAL_ERROR;
2816     }
2817
2818     volume_removal(drvobj, &pnp_name);
2819
2820     ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
2821
2822     if (Vcb->need_write)
2823         Status = do_write(Vcb, Irp);
2824     else
2825         Status = STATUS_SUCCESS;
2826
2827     free_trees(Vcb);
2828
2829     if (!NT_SUCCESS(Status)) {
2830         ERR("do_write returned %08x\n", Status);
2831         goto end;
2832     }
2833
2834     dev = ExAllocatePoolWithTag(NonPagedPool, sizeof(device), ALLOC_TAG);
2835     if (!dev) {
2836         ERR("out of memory\n");
2837         Status = STATUS_INSUFFICIENT_RESOURCES;
2838         goto end;
2839     }
2840
2841     RtlZeroMemory(dev, sizeof(device));
2842
2843     dev->devobj = DeviceObject;
2844     dev->seeding = FALSE;
2845     init_device(Vcb, dev, TRUE);
2846
2847     InitializeListHead(&dev->space);
2848
2849     if (size > 0x100000) { // add disk hole - the first MB is marked as used
2850         Status = add_space_entry(&dev->space, NULL, 0x100000, size - 0x100000);
2851         if (!NT_SUCCESS(Status)) {
2852             ERR("add_space_entry returned %08x\n", Status);
2853             goto end;
2854         }
2855     }
2856
2857     dev_id = 0;
2858
2859     le = Vcb->devices.Flink;
2860     while (le != &Vcb->devices) {
2861         device* dev2 = CONTAINING_RECORD(le, device, list_entry);
2862
2863         if (dev2->devitem.dev_id > dev_id)
2864             dev_id = dev2->devitem.dev_id;
2865
2866         le = le->Flink;
2867     }
2868
2869     dev_id++;
2870
2871     dev->devitem.dev_id = dev_id;
2872     dev->devitem.num_bytes = size;
2873     dev->devitem.bytes_used = 0;
2874     dev->devitem.optimal_io_align = Vcb->superblock.sector_size;
2875     dev->devitem.optimal_io_width = Vcb->superblock.sector_size;
2876     dev->devitem.minimal_io_size = Vcb->superblock.sector_size;
2877     dev->devitem.type = 0;
2878     dev->devitem.generation = 0;
2879     dev->devitem.start_offset = 0;
2880     dev->devitem.dev_group = 0;
2881     dev->devitem.seek_speed = 0;
2882     dev->devitem.bandwidth = 0;
2883     get_uuid(&dev->devitem.device_uuid);
2884     dev->devitem.fs_uuid = Vcb->superblock.uuid;
2885
2886     di = ExAllocatePoolWithTag(PagedPool, sizeof(DEV_ITEM), ALLOC_TAG);
2887     if (!di) {
2888         ERR("out of memory\n");
2889         goto end;
2890     }
2891
2892     RtlCopyMemory(di, &dev->devitem, sizeof(DEV_ITEM));
2893
2894     Status = insert_tree_item(Vcb, Vcb->chunk_root, 1, TYPE_DEV_ITEM, di->dev_id, di, sizeof(DEV_ITEM), NULL, Irp);
2895     if (!NT_SUCCESS(Status)) {
2896         ERR("insert_tree_item returned %08x\n", Status);
2897         ExFreePool(di);
2898         goto end;
2899     }
2900
2901     // add stats entry to dev tree
2902     stats = ExAllocatePoolWithTag(PagedPool, sizeof(UINT64) * 5, ALLOC_TAG);
2903     if (!stats) {
2904         ERR("out of memory\n");
2905         Status = STATUS_INSUFFICIENT_RESOURCES;
2906         goto end;
2907     }
2908
2909     RtlZeroMemory(stats, sizeof(UINT64) * 5);
2910
2911     searchkey.obj_id = 0;
2912     searchkey.obj_type = TYPE_DEV_STATS;
2913     searchkey.offset = di->dev_id;
2914
2915     Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, FALSE, Irp);
2916     if (!NT_SUCCESS(Status)) {
2917         ERR("error - find_item returned %08x\n", Status);
2918         ExFreePool(stats);
2919         goto end;
2920     }
2921
2922     if (!keycmp(tp.item->key, searchkey)) {
2923         Status = delete_tree_item(Vcb, &tp);
2924         if (!NT_SUCCESS(Status)) {
2925             ERR("delete_tree_item returned %08x\n", Status);
2926             ExFreePool(stats);
2927             goto end;
2928         }
2929     }
2930
2931     Status = insert_tree_item(Vcb, Vcb->dev_root, 0, TYPE_DEV_STATS, di->dev_id, stats, sizeof(UINT64) * 5, NULL, Irp);
2932     if (!NT_SUCCESS(Status)) {
2933         ERR("insert_tree_item returned %08x\n", Status);
2934         ExFreePool(stats);
2935         goto end;
2936     }
2937
2938     if (dev->trim && !dev->readonly && !Vcb->options.no_trim)
2939         trim_whole_device(dev);
2940
2941     // We clear the first megabyte of the device, so Windows doesn't identify it as another FS
2942     mb = ExAllocatePoolWithTag(PagedPool, 0x100000, ALLOC_TAG);
2943     if (!mb) {
2944         ERR("out of memory\n");
2945         Status = STATUS_INSUFFICIENT_RESOURCES;
2946         goto end;
2947     }
2948
2949     RtlZeroMemory(mb, 0x100000);
2950
2951     Status = write_data_phys(DeviceObject, 0, mb, 0x100000);
2952     if (!NT_SUCCESS(Status)) {
2953         ERR("write_data_phys returned %08x\n", Status);
2954         ExFreePool(mb);
2955         goto end;
2956     }
2957
2958     ExFreePool(mb);
2959
2960     vde = Vcb->vde;
2961     pdode = vde->pdode;
2962
2963     vc = ExAllocatePoolWithTag(NonPagedPool, sizeof(volume_child), ALLOC_TAG);
2964     if (!vc) {
2965         ERR("out of memory\n");
2966         Status = STATUS_INSUFFICIENT_RESOURCES;
2967         goto end;
2968     }
2969
2970     vc->uuid = dev->devitem.device_uuid;
2971     vc->devid = dev_id;
2972     vc->generation = Vcb->superblock.generation;
2973     vc->devobj = DeviceObject;
2974     vc->fileobj = fileobj;
2975     vc->notification_entry = NULL;
2976
2977     Status = IoRegisterPlugPlayNotification(EventCategoryTargetDeviceChange, 0, fileobj,
2978                                             drvobj, pnp_removal, vde->pdode, &vc->notification_entry);
2979     if (!NT_SUCCESS(Status))
2980         WARN("IoRegisterPlugPlayNotification returned %08x\n", Status);
2981
2982     pnp_name2 = pnp_name;
2983
2984     if (pnp_name.Length > 4 * sizeof(WCHAR) && pnp_name.Buffer[0] == '\\' && (pnp_name.Buffer[1] == '\\' || pnp_name.Buffer[1] == '?') &&
2985         pnp_name.Buffer[2] == '?' && pnp_name.Buffer[3] == '\\') {
2986         pnp_name2.Buffer = &pnp_name2.Buffer[3];
2987         pnp_name2.Length -= 3 * sizeof(WCHAR);
2988         pnp_name2.MaximumLength -= 3 * sizeof(WCHAR);
2989     }
2990
2991     vc->pnp_name.Length = vc->pnp_name.MaximumLength = pnp_name2.Length;
2992
2993     if (pnp_name2.Length == 0)
2994         vc->pnp_name.Buffer = NULL;
2995     else {
2996         vc->pnp_name.Buffer = ExAllocatePoolWithTag(PagedPool, pnp_name2.Length, ALLOC_TAG);
2997         if (!vc->pnp_name.Buffer) {
2998             ERR("out of memory\n");
2999             Status = STATUS_INSUFFICIENT_RESOURCES;
3000             goto end;
3001         }
3002
3003         RtlCopyMemory(vc->pnp_name.Buffer, pnp_name2.Buffer, pnp_name2.Length);
3004     }
3005
3006     vc->size = size;
3007     vc->seeding = FALSE;
3008     vc->disk_num = sdn.DeviceNumber;
3009     vc->part_num = sdn.PartitionNumber;
3010     vc->had_drive_letter = FALSE;
3011
3012     ExAcquireResourceExclusiveLite(&pdode->child_lock, TRUE);
3013     InsertTailList(&pdode->children, &vc->list_entry);
3014     pdode->num_children++;
3015     pdode->children_loaded++;
3016     ExReleaseResourceLite(&pdode->child_lock);
3017
3018     RtlInitUnicodeString(&mmdevpath, MOUNTMGR_DEVICE_NAME);
3019     Status = IoGetDeviceObjectPointer(&mmdevpath, FILE_READ_ATTRIBUTES, &mountmgrfo, &mountmgr);
3020     if (!NT_SUCCESS(Status))
3021         ERR("IoGetDeviceObjectPointer returned %08x\n", Status);
3022     else {
3023         Status = remove_drive_letter(mountmgr, &pnp_name);
3024         if (!NT_SUCCESS(Status) && Status != STATUS_NOT_FOUND)
3025             WARN("remove_drive_letter returned %08x\n", Status);
3026
3027         vc->had_drive_letter = NT_SUCCESS(Status);
3028
3029         ObDereferenceObject(mountmgrfo);
3030     }
3031
3032     Vcb->superblock.num_devices++;
3033     Vcb->superblock.total_bytes += size;
3034     Vcb->devices_loaded++;
3035     InsertTailList(&Vcb->devices, &dev->list_entry);
3036
3037     // FIXME - send notification that volume size has increased
3038
3039     ObReferenceObject(DeviceObject); // for Vcb
3040
3041     Status = do_write(Vcb, Irp);
3042     if (!NT_SUCCESS(Status))
3043         ERR("do_write returned %08x\n", Status);
3044
3045     ObReferenceObject(fileobj);
3046
3047 end:
3048     free_trees(Vcb);
3049
3050     ExReleaseResourceLite(&Vcb->tree_lock);
3051
3052 end2:
3053     ObDereferenceObject(fileobj);
3054
3055     if (pnp_name.Buffer)
3056         ExFreePool(pnp_name.Buffer);
3057
3058     if (NT_SUCCESS(Status))
3059         FsRtlNotifyVolumeEvent(Vcb->root_file, FSRTL_VOLUME_CHANGE_SIZE);
3060
3061     return Status;
3062 }
3063
3064 static NTSTATUS allow_extended_dasd_io(device_extension* Vcb, PFILE_OBJECT FileObject) {
3065     fcb* fcb;
3066     ccb* ccb;
3067
3068     TRACE("FSCTL_ALLOW_EXTENDED_DASD_IO\n");
3069
3070     if (!FileObject)
3071         return STATUS_INVALID_PARAMETER;
3072
3073     fcb = FileObject->FsContext;
3074     ccb = FileObject->FsContext2;
3075
3076     if (!fcb)
3077         return STATUS_INVALID_PARAMETER;
3078
3079     if (fcb != Vcb->volume_fcb)
3080         return STATUS_INVALID_PARAMETER;
3081
3082     if (!ccb)
3083         return STATUS_INVALID_PARAMETER;
3084
3085     ccb->allow_extended_dasd_io = TRUE;
3086
3087     return STATUS_SUCCESS;
3088 }
3089
3090 static NTSTATUS query_uuid(device_extension* Vcb, void* data, ULONG length) {
3091     if (length < sizeof(BTRFS_UUID))
3092         return STATUS_BUFFER_OVERFLOW;
3093
3094     RtlCopyMemory(data, &Vcb->superblock.uuid, sizeof(BTRFS_UUID));
3095
3096     return STATUS_SUCCESS;
3097 }
3098
3099 static NTSTATUS reset_stats(device_extension* Vcb, void* data, ULONG length, KPROCESSOR_MODE processor_mode) {
3100     UINT64 devid;
3101     NTSTATUS Status;
3102     LIST_ENTRY* le;
3103
3104     if (length < sizeof(UINT64))
3105         return STATUS_INVALID_PARAMETER;
3106
3107     if (Vcb->readonly)
3108         return STATUS_MEDIA_WRITE_PROTECTED;
3109
3110     if (!SeSinglePrivilegeCheck(RtlConvertLongToLuid(SE_MANAGE_VOLUME_PRIVILEGE), processor_mode))
3111         return STATUS_PRIVILEGE_NOT_HELD;
3112
3113     devid = *((UINT64*)data);
3114
3115     ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
3116
3117     le = Vcb->devices.Flink;
3118
3119     while (le != &Vcb->devices) {
3120         device* dev = CONTAINING_RECORD(le, device, list_entry);
3121
3122         if (dev->devitem.dev_id == devid) {
3123             RtlZeroMemory(dev->stats, sizeof(UINT64) * 5);
3124             dev->stats_changed = TRUE;
3125             Vcb->stats_changed = TRUE;
3126             Vcb->need_write = TRUE;
3127             Status = STATUS_SUCCESS;
3128             goto end;
3129         }
3130
3131         le = le->Flink;
3132     }
3133
3134     WARN("device %llx not found\n", devid);
3135     Status = STATUS_INVALID_PARAMETER;
3136
3137 end:
3138     ExReleaseResourceLite(&Vcb->tree_lock);
3139
3140     return Status;
3141 }
3142
3143 static NTSTATUS get_integrity_information(device_extension* Vcb, PFILE_OBJECT FileObject, void* data, ULONG datalen) {
3144     FSCTL_GET_INTEGRITY_INFORMATION_BUFFER* fgiib = (FSCTL_GET_INTEGRITY_INFORMATION_BUFFER*)data;
3145
3146     TRACE("FSCTL_GET_INTEGRITY_INFORMATION\n");
3147
3148     // STUB
3149
3150     if (!FileObject)
3151         return STATUS_INVALID_PARAMETER;
3152
3153     if (!data || datalen < sizeof(FSCTL_GET_INTEGRITY_INFORMATION_BUFFER))
3154         return STATUS_INVALID_PARAMETER;
3155
3156     fgiib->ChecksumAlgorithm = 0;
3157     fgiib->Reserved = 0;
3158     fgiib->Flags = 0;
3159     fgiib->ChecksumChunkSizeInBytes = Vcb->superblock.sector_size;
3160     fgiib->ClusterSizeInBytes = Vcb->superblock.sector_size;
3161
3162     return STATUS_SUCCESS;
3163 }
3164
3165 static NTSTATUS set_integrity_information(PFILE_OBJECT FileObject, void* data, ULONG datalen) {
3166     TRACE("FSCTL_SET_INTEGRITY_INFORMATION\n");
3167
3168     // STUB
3169
3170     if (!FileObject)
3171         return STATUS_INVALID_PARAMETER;
3172
3173     if (!data || datalen < sizeof(FSCTL_SET_INTEGRITY_INFORMATION_BUFFER))
3174         return STATUS_INVALID_PARAMETER;
3175
3176     return STATUS_SUCCESS;
3177 }
3178
3179 BOOL fcb_is_inline(fcb* fcb) {
3180     LIST_ENTRY* le;
3181
3182     le = fcb->extents.Flink;
3183     while (le != &fcb->extents) {
3184         extent* ext = CONTAINING_RECORD(le, extent, list_entry);
3185
3186         if (!ext->ignore)
3187             return ext->extent_data.type == EXTENT_TYPE_INLINE;
3188
3189         le = le->Flink;
3190     }
3191
3192     return FALSE;
3193 }
3194
3195 static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject, void* data, ULONG datalen, PIRP Irp) {
3196     DUPLICATE_EXTENTS_DATA* ded = (DUPLICATE_EXTENTS_DATA*)data;
3197     fcb *fcb = FileObject ? FileObject->FsContext : NULL, *sourcefcb;
3198     ccb *ccb = FileObject ? FileObject->FsContext2 : NULL, *sourceccb;
3199     NTSTATUS Status;
3200     PFILE_OBJECT sourcefo;
3201     UINT64 sourcelen, nbytes = 0;
3202     LIST_ENTRY rollback, *le, newexts;
3203     LARGE_INTEGER time;
3204     BTRFS_TIME now;
3205     BOOL make_inline;
3206
3207     if (!ded || datalen < sizeof(DUPLICATE_EXTENTS_DATA))
3208         return STATUS_BUFFER_TOO_SMALL;
3209
3210     if (Vcb->readonly)
3211         return STATUS_MEDIA_WRITE_PROTECTED;
3212
3213     if (ded->ByteCount.QuadPart == 0)
3214         return STATUS_SUCCESS;
3215
3216     if (!fcb || !ccb || fcb == Vcb->volume_fcb)
3217         return STATUS_INVALID_PARAMETER;
3218
3219     if (is_subvol_readonly(fcb->subvol, Irp))
3220         return STATUS_ACCESS_DENIED;
3221
3222     if (Irp->RequestorMode == UserMode && !(ccb->access & FILE_WRITE_DATA)) {
3223         WARN("insufficient privileges\n");
3224         return STATUS_ACCESS_DENIED;
3225     }
3226
3227     if (!fcb->ads && fcb->type != BTRFS_TYPE_FILE && fcb->type != BTRFS_TYPE_SYMLINK)
3228         return STATUS_INVALID_PARAMETER;
3229
3230     Status = ObReferenceObjectByHandle(ded->FileHandle, 0, *IoFileObjectType, Irp->RequestorMode, (void**)&sourcefo, NULL);
3231     if (!NT_SUCCESS(Status)) {
3232         ERR("ObReferenceObjectByHandle returned %08x\n", Status);
3233         return Status;
3234     }
3235
3236     if (sourcefo->DeviceObject != FileObject->DeviceObject) {
3237         WARN("source and destination are on different volumes\n");
3238         ObDereferenceObject(sourcefo);
3239         return STATUS_INVALID_PARAMETER;
3240     }
3241
3242     sourcefcb = sourcefo->FsContext;
3243     sourceccb = sourcefo->FsContext2;
3244
3245     if (!sourcefcb || !sourceccb || sourcefcb == Vcb->volume_fcb) {
3246         ObDereferenceObject(sourcefo);
3247         return STATUS_INVALID_PARAMETER;
3248     }
3249
3250     if (!sourcefcb->ads && !fcb->ads) {
3251         if ((ded->SourceFileOffset.QuadPart & (Vcb->superblock.sector_size - 1)) || (ded->TargetFileOffset.QuadPart & (Vcb->superblock.sector_size - 1))) {
3252             ObDereferenceObject(sourcefo);
3253             return STATUS_INVALID_PARAMETER;
3254         }
3255
3256         if (ded->ByteCount.QuadPart & (Vcb->superblock.sector_size - 1)) {
3257             ObDereferenceObject(sourcefo);
3258             return STATUS_INVALID_PARAMETER;
3259         }
3260     }
3261
3262     if (Irp->RequestorMode == UserMode && (!(sourceccb->access & FILE_READ_DATA) || !(sourceccb->access & FILE_READ_ATTRIBUTES))) {
3263         WARN("insufficient privileges\n");
3264         ObDereferenceObject(sourcefo);
3265         return STATUS_ACCESS_DENIED;
3266     }
3267
3268     if (!sourcefcb->ads && sourcefcb->type != BTRFS_TYPE_FILE && sourcefcb->type != BTRFS_TYPE_SYMLINK) {
3269         ObDereferenceObject(sourcefo);
3270         return STATUS_INVALID_PARAMETER;
3271     }
3272
3273     sourcelen = sourcefcb->ads ? sourcefcb->adsdata.Length : sourcefcb->inode_item.st_size;
3274
3275     if (sector_align(sourcelen, Vcb->superblock.sector_size) < (UINT64)ded->SourceFileOffset.QuadPart + (UINT64)ded->ByteCount.QuadPart) {
3276         ObDereferenceObject(sourcefo);
3277         return STATUS_NOT_SUPPORTED;
3278     }
3279
3280     if (fcb == sourcefcb &&
3281         ((ded->SourceFileOffset.QuadPart >= ded->TargetFileOffset.QuadPart && ded->SourceFileOffset.QuadPart < ded->TargetFileOffset.QuadPart + ded->ByteCount.QuadPart) ||
3282         (ded->TargetFileOffset.QuadPart >= ded->SourceFileOffset.QuadPart && ded->TargetFileOffset.QuadPart < ded->SourceFileOffset.QuadPart + ded->ByteCount.QuadPart))) {
3283         WARN("source and destination are the same, and the ranges overlap\n");
3284         ObDereferenceObject(sourcefo);
3285         return STATUS_INVALID_PARAMETER;
3286     }
3287
3288     // fail if nocsum flag set on one file but not the other
3289     if (!fcb->ads && !sourcefcb->ads && (fcb->inode_item.flags & BTRFS_INODE_NODATASUM) != (sourcefcb->inode_item.flags & BTRFS_INODE_NODATASUM)) {
3290         ObDereferenceObject(sourcefo);
3291         return STATUS_INVALID_PARAMETER;
3292     }
3293
3294     InitializeListHead(&rollback);
3295     InitializeListHead(&newexts);
3296
3297     ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
3298
3299     ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
3300
3301     if (fcb != sourcefcb)
3302         ExAcquireResourceSharedLite(sourcefcb->Header.Resource, TRUE);
3303
3304     if (!FsRtlFastCheckLockForWrite(&fcb->lock, &ded->TargetFileOffset, &ded->ByteCount, 0, FileObject, PsGetCurrentProcess())) {
3305         Status = STATUS_FILE_LOCK_CONFLICT;
3306         goto end;
3307     }
3308
3309     if (!FsRtlFastCheckLockForRead(&sourcefcb->lock, &ded->SourceFileOffset, &ded->ByteCount, 0, FileObject, PsGetCurrentProcess())) {
3310         Status = STATUS_FILE_LOCK_CONFLICT;
3311         goto end;
3312     }
3313
3314     make_inline = fcb->ads ? FALSE : (fcb->inode_item.st_size <= Vcb->options.max_inline || fcb_is_inline(fcb));
3315
3316     if (fcb->ads || sourcefcb->ads || make_inline || fcb_is_inline(sourcefcb)) {
3317         UINT8* data2;
3318         ULONG bytes_read, dataoff, datalen2;
3319
3320         if (make_inline) {
3321             dataoff = (ULONG)ded->TargetFileOffset.QuadPart;
3322             datalen2 = (ULONG)fcb->inode_item.st_size;
3323         } else if (fcb->ads) {
3324             dataoff = 0;
3325             datalen2 = (ULONG)ded->ByteCount.QuadPart;
3326         } else {
3327             dataoff = ded->TargetFileOffset.QuadPart % Vcb->superblock.sector_size;
3328             datalen2 = (ULONG)sector_align(ded->ByteCount.QuadPart + dataoff, Vcb->superblock.sector_size);
3329         }
3330
3331         data2 = ExAllocatePoolWithTag(PagedPool, datalen2, ALLOC_TAG);
3332         if (!data2) {
3333             ERR("out of memory\n");
3334             Status = STATUS_INSUFFICIENT_RESOURCES;
3335             goto end;
3336         }
3337
3338         if (dataoff > 0) {
3339             if (make_inline)
3340                 Status = read_file(fcb, data2, 0, datalen2, NULL, Irp);
3341             else
3342                 Status = read_file(fcb, data2, ded->TargetFileOffset.QuadPart - dataoff, dataoff, NULL, Irp);
3343
3344             if (!NT_SUCCESS(Status)) {
3345                 ERR("read_file returned %08x\n", Status);
3346                 ExFreePool(data2);
3347                 goto end;
3348             }
3349         }
3350
3351         if (sourcefcb->ads) {
3352             Status = read_stream(sourcefcb, data2 + dataoff, ded->SourceFileOffset.QuadPart, (ULONG)ded->ByteCount.QuadPart, &bytes_read);
3353             if (!NT_SUCCESS(Status)) {
3354                 ERR("read_stream returned %08x\n", Status);
3355                 ExFreePool(data2);
3356                 goto end;
3357             }
3358         } else {
3359             Status = read_file(sourcefcb, data2 + dataoff, ded->SourceFileOffset.QuadPart, ded->ByteCount.QuadPart, &bytes_read, Irp);
3360             if (!NT_SUCCESS(Status)) {
3361                 ERR("read_file returned %08x\n", Status);
3362                 ExFreePool(data2);
3363                 goto end;
3364             }
3365         }
3366
3367         if (dataoff + bytes_read < datalen2)
3368             RtlZeroMemory(data2 + dataoff + bytes_read, datalen2 - bytes_read);
3369
3370         if (fcb->ads)
3371             RtlCopyMemory(&fcb->adsdata.Buffer[ded->TargetFileOffset.QuadPart], data2, (USHORT)min(ded->ByteCount.QuadPart, fcb->adsdata.Length - ded->TargetFileOffset.QuadPart));
3372         else if (make_inline) {
3373             UINT16 edsize;
3374             EXTENT_DATA* ed;
3375
3376             Status = excise_extents(Vcb, fcb, 0, sector_align(fcb->inode_item.st_size, Vcb->superblock.sector_size), Irp, &rollback);
3377             if (!NT_SUCCESS(Status)) {
3378                 ERR("excise_extents returned %08x\n", Status);
3379                 ExFreePool(data2);
3380                 goto end;
3381             }
3382
3383             edsize = (UINT16)(offsetof(EXTENT_DATA, data[0]) + datalen2);
3384
3385             ed = ExAllocatePoolWithTag(PagedPool, edsize, ALLOC_TAG);
3386             if (!ed) {
3387                 ERR("out of memory\n");
3388                 ExFreePool(data2);
3389                 Status = STATUS_INSUFFICIENT_RESOURCES;
3390                 goto end;
3391             }
3392
3393             ed->generation = Vcb->superblock.generation;
3394             ed->decoded_size = fcb->inode_item.st_size;
3395             ed->compression = BTRFS_COMPRESSION_NONE;
3396             ed->encryption = BTRFS_ENCRYPTION_NONE;
3397             ed->encoding = BTRFS_ENCODING_NONE;
3398             ed->type = EXTENT_TYPE_INLINE;
3399
3400             RtlCopyMemory(ed->data, data2, datalen2);
3401
3402             Status = add_extent_to_fcb(fcb, 0, ed, edsize, FALSE, NULL, &rollback);
3403             if (!NT_SUCCESS(Status)) {
3404                 ERR("add_extent_to_fcb returned %08x\n", Status);
3405                 ExFreePool(data2);
3406                 goto end;
3407             }
3408
3409             fcb->inode_item.st_blocks += datalen2;
3410         } else {
3411             UINT64 start = ded->TargetFileOffset.QuadPart - (ded->TargetFileOffset.QuadPart % Vcb->superblock.sector_size);
3412
3413             Status = do_write_file(fcb, start, start + datalen2, data2, Irp, FALSE, 0, &rollback);
3414             if (!NT_SUCCESS(Status)) {
3415                 ERR("do_write_file returned %08x\n", Status);
3416                 ExFreePool(data2);
3417                 goto end;
3418             }
3419         }
3420
3421         ExFreePool(data2);
3422     } else {
3423         LIST_ENTRY* lastextle;
3424
3425         le = sourcefcb->extents.Flink;
3426         while (le != &sourcefcb->extents) {
3427             extent* ext = CONTAINING_RECORD(le, extent, list_entry);
3428
3429             if (!ext->ignore) {
3430                 if (ext->offset >= (UINT64)ded->SourceFileOffset.QuadPart + (UINT64)ded->ByteCount.QuadPart)
3431                     break;
3432
3433                 if (ext->extent_data.type != EXTENT_TYPE_INLINE) {
3434                     ULONG extlen = offsetof(extent, extent_data) + sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2);
3435                     extent* ext2;
3436                     EXTENT_DATA2 *ed2s, *ed2d;
3437                     chunk* c;
3438
3439                     ed2s = (EXTENT_DATA2*)ext->extent_data.data;
3440
3441                     if (ext->offset + ed2s->num_bytes <= (UINT64)ded->SourceFileOffset.QuadPart) {
3442                         le = le->Flink;
3443                         continue;
3444                     }
3445
3446                     ext2 = ExAllocatePoolWithTag(PagedPool, extlen, ALLOC_TAG);
3447                     if (!ext2) {
3448                         ERR("out of memory\n");
3449                         Status = STATUS_INSUFFICIENT_RESOURCES;
3450                         goto end;
3451                     }
3452
3453                     if (ext->offset < (UINT64)ded->SourceFileOffset.QuadPart)
3454                         ext2->offset = ded->TargetFileOffset.QuadPart;
3455                     else
3456                         ext2->offset = ext->offset - ded->SourceFileOffset.QuadPart + ded->TargetFileOffset.QuadPart;
3457
3458                     ext2->datalen = sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2);
3459                     ext2->unique = FALSE;
3460                     ext2->ignore = FALSE;
3461                     ext2->inserted = TRUE;
3462
3463                     ext2->extent_data.generation = Vcb->superblock.generation;
3464                     ext2->extent_data.decoded_size = ext->extent_data.decoded_size;
3465                     ext2->extent_data.compression = ext->extent_data.compression;
3466                     ext2->extent_data.encryption = ext->extent_data.encryption;
3467                     ext2->extent_data.encoding = ext->extent_data.encoding;
3468                     ext2->extent_data.type = ext->extent_data.type;
3469
3470                     ed2d = (EXTENT_DATA2*)ext2->extent_data.data;
3471
3472                     ed2d->address = ed2s->address;
3473                     ed2d->size = ed2s->size;
3474
3475                     if (ext->offset < (UINT64)ded->SourceFileOffset.QuadPart) {
3476                         ed2d->offset = ed2s->offset + ded->SourceFileOffset.QuadPart - ext->offset;
3477                         ed2d->num_bytes = min((UINT64)ded->ByteCount.QuadPart, ed2s->num_bytes + ext->offset - ded->SourceFileOffset.QuadPart);
3478                     } else {
3479                         ed2d->offset = ed2s->offset;
3480                         ed2d->num_bytes = min(ded->SourceFileOffset.QuadPart + ded->ByteCount.QuadPart - ext->offset, ed2s->num_bytes);
3481                     }
3482
3483                     if (ext->csum) {
3484                         if (ext->extent_data.compression == BTRFS_COMPRESSION_NONE) {
3485                             ext2->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2d->num_bytes * sizeof(UINT32) / Vcb->superblock.sector_size), ALLOC_TAG);
3486                             if (!ext2->csum) {
3487                                 ERR("out of memory\n");
3488                                 Status = STATUS_INSUFFICIENT_RESOURCES;
3489                                 ExFreePool(ext2);
3490                                 goto end;
3491                             }
3492
3493                             RtlCopyMemory(ext2->csum, &ext->csum[(ed2d->offset - ed2s->offset) / Vcb->superblock.sector_size],
3494                                           (ULONG)(ed2d->num_bytes * sizeof(UINT32) / Vcb->superblock.sector_size));
3495                         } else {
3496                             ext2->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2d->size * sizeof(UINT32) / Vcb->superblock.sector_size), ALLOC_TAG);
3497                             if (!ext2->csum) {
3498                                 ERR("out of memory\n");
3499                                 Status = STATUS_INSUFFICIENT_RESOURCES;
3500                                 ExFreePool(ext2);
3501                                 goto end;
3502                             }
3503
3504                             RtlCopyMemory(ext2->csum, ext->csum, (ULONG)(ed2s->size * sizeof(UINT32) / Vcb->superblock.sector_size));
3505                         }
3506                     } else
3507                         ext2->csum = NULL;
3508
3509                     InsertTailList(&newexts, &ext2->list_entry);
3510
3511                     c = get_chunk_from_address(Vcb, ed2s->address);
3512                     if (!c) {
3513                         ERR("get_chunk_from_address(%llx) failed\n", ed2s->address);
3514                         Status = STATUS_INTERNAL_ERROR;
3515                         goto end;
3516                     }
3517
3518                     Status = update_changed_extent_ref(Vcb, c, ed2s->address, ed2s->size, fcb->subvol->id, fcb->inode, ext2->offset - ed2d->offset,
3519                                                     1, fcb->inode_item.flags & BTRFS_INODE_NODATASUM, FALSE, Irp);
3520                     if (!NT_SUCCESS(Status)) {
3521                         ERR("update_changed_extent_ref returned %08x\n", Status);
3522                         goto end;
3523                     }
3524
3525                     nbytes += ed2d->num_bytes;
3526                 }
3527             }
3528
3529             le = le->Flink;
3530         }
3531
3532         Status = excise_extents(Vcb, fcb, ded->TargetFileOffset.QuadPart, ded->TargetFileOffset.QuadPart + ded->ByteCount.QuadPart, Irp, &rollback);
3533         if (!NT_SUCCESS(Status)) {
3534             ERR("excise_extents returned %08x\n", Status);
3535
3536             while (!IsListEmpty(&newexts)) {
3537                 extent* ext = CONTAINING_RECORD(RemoveHeadList(&newexts), extent, list_entry);
3538                 ExFreePool(ext);
3539             }
3540
3541             goto end;
3542         }
3543
3544         // clear unique flags in source fcb
3545         le = sourcefcb->extents.Flink;
3546         while (le != &sourcefcb->extents) {
3547             extent* ext = CONTAINING_RECORD(le, extent, list_entry);
3548
3549             if (!ext->ignore && ext->unique && (ext->extent_data.type == EXTENT_TYPE_REGULAR || ext->extent_data.type == EXTENT_TYPE_PREALLOC)) {
3550                 EXTENT_DATA2* ed2s = (EXTENT_DATA2*)ext->extent_data.data;
3551                 LIST_ENTRY* le2;
3552
3553                 le2 = newexts.Flink;
3554                 while (le2 != &newexts) {
3555                     extent* ext2 = CONTAINING_RECORD(le2, extent, list_entry);
3556
3557                     if (ext2->extent_data.type == EXTENT_TYPE_REGULAR || ext2->extent_data.type == EXTENT_TYPE_PREALLOC) {
3558                         EXTENT_DATA2* ed2d = (EXTENT_DATA2*)ext2->extent_data.data;
3559
3560                         if (ed2d->address == ed2s->address && ed2d->size == ed2s->size) {
3561                             ext->unique = FALSE;
3562                             break;
3563                         }
3564                     }
3565
3566                     le2 = le2->Flink;
3567                 }
3568             }
3569
3570             le = le->Flink;
3571         }
3572
3573         lastextle = &fcb->extents;
3574         while (!IsListEmpty(&newexts)) {
3575             extent* ext = CONTAINING_RECORD(RemoveHeadList(&newexts), extent, list_entry);
3576
3577             add_extent(fcb, lastextle, ext);
3578             lastextle = &ext->list_entry;
3579         }
3580     }
3581
3582     KeQuerySystemTime(&time);
3583     win_time_to_unix(time, &now);
3584
3585     if (fcb->ads) {
3586         ccb->fileref->parent->fcb->inode_item.sequence++;
3587
3588         if (!ccb->user_set_change_time)
3589             ccb->fileref->parent->fcb->inode_item.st_ctime = now;
3590
3591         ccb->fileref->parent->fcb->inode_item_changed = TRUE;
3592         mark_fcb_dirty(ccb->fileref->parent->fcb);
3593     } else {
3594         fcb->inode_item.st_blocks += nbytes;
3595         fcb->inode_item.sequence++;
3596
3597         if (!ccb->user_set_change_time)
3598             fcb->inode_item.st_ctime = now;
3599
3600         if (!ccb->user_set_write_time) {
3601             fcb->inode_item.st_mtime = now;
3602             send_notification_fcb(ccb->fileref, FILE_NOTIFY_CHANGE_LAST_WRITE, FILE_ACTION_MODIFIED, NULL);
3603         }
3604
3605         fcb->inode_item_changed = TRUE;
3606         fcb->extents_changed = TRUE;
3607     }
3608
3609     mark_fcb_dirty(fcb);
3610
3611     if (fcb->nonpaged->segment_object.DataSectionObject)
3612         CcPurgeCacheSection(&fcb->nonpaged->segment_object, &ded->TargetFileOffset, (ULONG)ded->ByteCount.QuadPart, FALSE);
3613
3614     Status = STATUS_SUCCESS;
3615
3616 end:
3617     ObDereferenceObject(sourcefo);
3618
3619     if (NT_SUCCESS(Status))
3620         clear_rollback(&rollback);
3621     else
3622         do_rollback(Vcb, &rollback);
3623
3624     if (fcb != sourcefcb)
3625         ExReleaseResourceLite(sourcefcb->Header.Resource);
3626
3627     ExReleaseResourceLite(fcb->Header.Resource);
3628
3629     ExReleaseResourceLite(&Vcb->tree_lock);
3630
3631     return Status;
3632 }
3633
3634 // based on functions in sys/sysmacros.h
3635 #define major(rdev) ((((rdev) >> 8) & 0xFFF) | ((UINT32)((rdev) >> 32) & ~0xFFF))
3636 #define minor(rdev) (((rdev) & 0xFF) | ((UINT32)((rdev) >> 12) & ~0xFF))
3637
3638 static NTSTATUS mknod(device_extension* Vcb, PFILE_OBJECT FileObject, void* data, ULONG datalen, PIRP Irp) {
3639     NTSTATUS Status;
3640     btrfs_mknod* bmn;
3641     fcb *parfcb, *fcb;
3642     ccb* parccb;
3643     file_ref *parfileref, *fileref;
3644     UNICODE_STRING name;
3645     root* subvol;
3646     UINT64 inode;
3647     dir_child* dc;
3648     LARGE_INTEGER time;
3649     BTRFS_TIME now;
3650     LIST_ENTRY* lastle;
3651     ANSI_STRING utf8;
3652     ULONG len, i;
3653     SECURITY_SUBJECT_CONTEXT subjcont;
3654     PSID owner;
3655     BOOLEAN defaulted;
3656
3657     TRACE("(%p, %p, %p, %u)\n", Vcb, FileObject, data, datalen);
3658
3659     if (!FileObject || !FileObject->FsContext || !FileObject->FsContext2 || FileObject->FsContext == Vcb->volume_fcb)
3660         return STATUS_INVALID_PARAMETER;
3661
3662     if (Vcb->readonly)
3663         return STATUS_MEDIA_WRITE_PROTECTED;
3664
3665     parfcb = FileObject->FsContext;
3666
3667     if (parfcb->type != BTRFS_TYPE_DIRECTORY) {
3668         WARN("trying to create file in something other than a directory\n");
3669         return STATUS_INVALID_PARAMETER;
3670     }
3671
3672     if (is_subvol_readonly(parfcb->subvol, Irp))
3673         return STATUS_ACCESS_DENIED;
3674
3675     parccb = FileObject->FsContext2;
3676     parfileref = parccb->fileref;
3677
3678     if (!parfileref)
3679         return STATUS_INVALID_PARAMETER;
3680
3681     if (datalen < sizeof(btrfs_mknod))
3682         return STATUS_INVALID_PARAMETER;
3683
3684     bmn = (btrfs_mknod*)data;
3685
3686     if (datalen < offsetof(btrfs_mknod, name[0]) + bmn->namelen || bmn->namelen < sizeof(WCHAR))
3687         return STATUS_INVALID_PARAMETER;
3688
3689     if (bmn->type == BTRFS_TYPE_UNKNOWN || bmn->type > BTRFS_TYPE_SYMLINK)
3690         return STATUS_INVALID_PARAMETER;
3691
3692     if ((bmn->type == BTRFS_TYPE_DIRECTORY && !(parccb->access & FILE_ADD_SUBDIRECTORY)) ||
3693         (bmn->type != BTRFS_TYPE_DIRECTORY && !(parccb->access & FILE_ADD_FILE))) {
3694         WARN("insufficient privileges\n");
3695         return STATUS_ACCESS_DENIED;
3696     }
3697
3698     if (bmn->inode != 0) {
3699         if (!SeSinglePrivilegeCheck(RtlConvertLongToLuid(SE_MANAGE_VOLUME_PRIVILEGE), Irp->RequestorMode))
3700             return STATUS_PRIVILEGE_NOT_HELD;
3701     }
3702
3703     for (i = 0; i < bmn->namelen / sizeof(WCHAR); i++) {
3704         if (bmn->name[i] == 0 || bmn->name[i] == '/')
3705             return STATUS_OBJECT_NAME_INVALID;
3706     }
3707
3708     // don't allow files called . or ..
3709     if (bmn->name[0] == '.' && (bmn->namelen == sizeof(WCHAR) || (bmn->namelen == 2 * sizeof(WCHAR) && bmn->name[1] == '.')))
3710         return STATUS_OBJECT_NAME_INVALID;
3711
3712     Status = RtlUnicodeToUTF8N(NULL, 0, &len, bmn->name, bmn->namelen);
3713     if (!NT_SUCCESS(Status)) {
3714         ERR("RtlUnicodeToUTF8N return %08x\n", Status);
3715         return Status;
3716     }
3717
3718     if (len == 0) {
3719         ERR("RtlUnicodeToUTF8N returned a length of 0\n");
3720         return STATUS_INTERNAL_ERROR;
3721     }
3722
3723     if (len > 0xffff) {
3724         ERR("len was too long (%x)\n", len);
3725         return STATUS_INVALID_PARAMETER;
3726     }
3727
3728     utf8.MaximumLength = utf8.Length = (USHORT)len;
3729     utf8.Buffer = ExAllocatePoolWithTag(PagedPool, utf8.MaximumLength, ALLOC_TAG);
3730
3731     if (!utf8.Buffer) {
3732         ERR("out of memory\n");
3733         return STATUS_INSUFFICIENT_RESOURCES;
3734     }
3735
3736     Status = RtlUnicodeToUTF8N(utf8.Buffer, len, &len, bmn->name, bmn->namelen);
3737     if (!NT_SUCCESS(Status)) {
3738         ERR("RtlUnicodeToUTF8N failed with error %08x\n", Status);
3739         ExFreePool(utf8.Buffer);
3740         return Status;
3741     }
3742
3743     name.Length = name.MaximumLength = bmn->namelen;
3744     name.Buffer = bmn->name;
3745
3746     acquire_fcb_lock_exclusive(Vcb);
3747
3748     Status = find_file_in_dir(&name, parfcb, &subvol, &inode, &dc, TRUE);
3749     if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND) {
3750         ERR("find_file_in_dir returned %08x\n", Status);
3751         goto end;
3752     }
3753
3754     if (NT_SUCCESS(Status)) {
3755         WARN("filename already exists\n");
3756         Status = STATUS_OBJECT_NAME_COLLISION;
3757         goto end;
3758     }
3759
3760     if (bmn->inode == 0) {
3761         inode = InterlockedIncrement64(&parfcb->subvol->lastinode);
3762         lastle = parfcb->subvol->fcbs.Blink;
3763     } else {
3764         if (bmn->inode > (UINT64)parfcb->subvol->lastinode) {
3765             inode = parfcb->subvol->lastinode = bmn->inode;
3766             lastle = parfcb->subvol->fcbs.Blink;
3767         } else {
3768             LIST_ENTRY* le = parfcb->subvol->fcbs.Flink;
3769
3770             lastle = parfcb->subvol->fcbs.Blink;;
3771             while (le != &parfcb->subvol->fcbs) {
3772                 struct _fcb* fcb2 = CONTAINING_RECORD(le, struct _fcb, list_entry);
3773
3774                 if (fcb2->inode == bmn->inode && !fcb2->deleted) {
3775                     WARN("inode collision\n");
3776                     Status = STATUS_INVALID_PARAMETER;
3777                     goto end;
3778                 } else if (fcb2->inode > bmn->inode) {
3779                     lastle = fcb2->list_entry.Blink;
3780                     break;
3781                 }
3782
3783                 le = le->Flink;
3784             }
3785
3786             inode = bmn->inode;
3787         }
3788     }
3789
3790     KeQuerySystemTime(&time);
3791     win_time_to_unix(time, &now);
3792
3793     fcb = create_fcb(Vcb, PagedPool);
3794     if (!fcb) {
3795         ERR("out of memory\n");
3796         Status = STATUS_INSUFFICIENT_RESOURCES;
3797         goto end;
3798     }
3799
3800     fcb->Vcb = Vcb;
3801
3802     fcb->inode_item.generation = Vcb->superblock.generation;
3803     fcb->inode_item.transid = Vcb->superblock.generation;
3804     fcb->inode_item.st_size = 0;
3805     fcb->inode_item.st_blocks = 0;
3806     fcb->inode_item.block_group = 0;
3807     fcb->inode_item.st_nlink = 1;
3808     fcb->inode_item.st_uid = UID_NOBODY;
3809     fcb->inode_item.st_gid = GID_NOBODY;
3810     fcb->inode_item.st_mode = inherit_mode(parfcb, bmn->type == BTRFS_TYPE_DIRECTORY);
3811
3812     if (bmn->type == BTRFS_TYPE_BLOCKDEV || bmn->type == BTRFS_TYPE_CHARDEV)
3813         fcb->inode_item.st_rdev = (minor(bmn->st_rdev) & 0xFFFFF) | ((major(bmn->st_rdev) & 0xFFFFFFFFFFF) << 20);
3814     else
3815         fcb->inode_item.st_rdev = 0;
3816
3817     fcb->inode_item.flags = 0;
3818     fcb->inode_item.sequence = 1;
3819     fcb->inode_item.st_atime = now;
3820     fcb->inode_item.st_ctime = now;
3821     fcb->inode_item.st_mtime = now;
3822     fcb->inode_item.otime = now;
3823
3824     if (bmn->type == BTRFS_TYPE_DIRECTORY)
3825         fcb->inode_item.st_mode |= __S_IFDIR;
3826     else if (bmn->type == BTRFS_TYPE_CHARDEV)
3827         fcb->inode_item.st_mode |= __S_IFCHR;
3828     else if (bmn->type == BTRFS_TYPE_BLOCKDEV)
3829         fcb->inode_item.st_mode |= __S_IFBLK;
3830     else if (bmn->type == BTRFS_TYPE_FIFO)
3831         fcb->inode_item.st_mode |= __S_IFIFO;
3832     else if (bmn->type == BTRFS_TYPE_SOCKET)
3833         fcb->inode_item.st_mode |= __S_IFSOCK;
3834     else if (bmn->type == BTRFS_TYPE_SYMLINK)
3835         fcb->inode_item.st_mode |= __S_IFLNK;
3836     else
3837         fcb->inode_item.st_mode |= __S_IFREG;
3838
3839     if (bmn->type != BTRFS_TYPE_DIRECTORY)
3840         fcb->inode_item.st_mode &= ~(S_IXUSR | S_IXGRP | S_IXOTH); // remove executable bit if not directory
3841
3842     // inherit nodatacow flag from parent directory
3843     if (parfcb->inode_item.flags & BTRFS_INODE_NODATACOW) {
3844         fcb->inode_item.flags |= BTRFS_INODE_NODATACOW;
3845
3846         if (bmn->type != BTRFS_TYPE_DIRECTORY)
3847             fcb->inode_item.flags |= BTRFS_INODE_NODATASUM;
3848     }
3849
3850     if (parfcb->inode_item.flags & BTRFS_INODE_COMPRESS)
3851         fcb->inode_item.flags |= BTRFS_INODE_COMPRESS;
3852
3853     fcb->prop_compression = parfcb->prop_compression;
3854     fcb->prop_compression_changed = fcb->prop_compression != PropCompression_None;
3855
3856     fcb->inode_item_changed = TRUE;
3857
3858     fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
3859     fcb->Header.AllocationSize.QuadPart = 0;
3860     fcb->Header.FileSize.QuadPart = 0;
3861     fcb->Header.ValidDataLength.QuadPart = 0;
3862
3863     fcb->atts = 0;
3864
3865     if (bmn->name[0] == '.')
3866         fcb->atts |= FILE_ATTRIBUTE_HIDDEN;
3867
3868     if (bmn->type == BTRFS_TYPE_DIRECTORY)
3869         fcb->atts |= FILE_ATTRIBUTE_DIRECTORY;
3870
3871     fcb->atts_changed = FALSE;
3872
3873     InterlockedIncrement(&parfcb->refcount);
3874     fcb->subvol = parfcb->subvol;
3875     fcb->inode = inode;
3876     fcb->type = bmn->type;
3877
3878     SeCaptureSubjectContext(&subjcont);
3879
3880     Status = SeAssignSecurityEx(parfileref ? parfileref->fcb->sd : NULL, NULL, (void**)&fcb->sd, NULL, fcb->type == BTRFS_TYPE_DIRECTORY,
3881                                 SEF_SACL_AUTO_INHERIT, &subjcont, IoGetFileObjectGenericMapping(), PagedPool);
3882
3883     if (!NT_SUCCESS(Status)) {
3884         ERR("SeAssignSecurityEx returned %08x\n", Status);
3885         free_fcb(Vcb, fcb);
3886         goto end;
3887     }
3888
3889     Status = RtlGetOwnerSecurityDescriptor(fcb->sd, &owner, &defaulted);
3890     if (!NT_SUCCESS(Status)) {
3891         WARN("RtlGetOwnerSecurityDescriptor returned %08x\n", Status);
3892         fcb->sd_dirty = TRUE;
3893     } else {
3894         fcb->inode_item.st_uid = sid_to_uid(owner);
3895         fcb->sd_dirty = fcb->inode_item.st_uid == UID_NOBODY;
3896     }
3897
3898     find_gid(fcb, parfcb, &subjcont);
3899
3900     fileref = create_fileref(Vcb);
3901     if (!fileref) {
3902         ERR("out of memory\n");
3903         free_fcb(Vcb, fcb);
3904         Status = STATUS_INSUFFICIENT_RESOURCES;
3905         goto end;
3906     }
3907
3908     fileref->fcb = fcb;
3909
3910     fcb->created = TRUE;
3911     mark_fcb_dirty(fcb);
3912
3913     fileref->created = TRUE;
3914     mark_fileref_dirty(fileref);
3915
3916     fcb->subvol->root_item.ctransid = Vcb->superblock.generation;
3917     fcb->subvol->root_item.ctime = now;
3918
3919     fileref->parent = parfileref;
3920
3921     Status = add_dir_child(fileref->parent->fcb, fcb->inode, FALSE, &utf8, &name, fcb->type, &dc);
3922     if (!NT_SUCCESS(Status))
3923         WARN("add_dir_child returned %08x\n", Status);
3924
3925     fileref->dc = dc;
3926     dc->fileref = fileref;
3927
3928     ExAcquireResourceExclusiveLite(&parfileref->nonpaged->children_lock, TRUE);
3929     InsertTailList(&parfileref->children, &fileref->list_entry);
3930     ExReleaseResourceLite(&parfileref->nonpaged->children_lock);
3931
3932     increase_fileref_refcount(parfileref);
3933
3934     if (fcb->type == BTRFS_TYPE_DIRECTORY) {
3935         fcb->hash_ptrs = ExAllocatePoolWithTag(PagedPool, sizeof(LIST_ENTRY*) * 256, ALLOC_TAG);
3936         if (!fcb->hash_ptrs) {
3937             ERR("out of memory\n");
3938             free_fileref(Vcb, fileref);
3939             Status = STATUS_INSUFFICIENT_RESOURCES;
3940             goto end;
3941         }
3942
3943         RtlZeroMemory(fcb->hash_ptrs, sizeof(LIST_ENTRY*) * 256);
3944
3945         fcb->hash_ptrs_uc = ExAllocatePoolWithTag(PagedPool, sizeof(LIST_ENTRY*) * 256, ALLOC_TAG);
3946         if (!fcb->hash_ptrs_uc) {
3947             ERR("out of memory\n");
3948             free_fileref(Vcb, fileref);
3949             Status = STATUS_INSUFFICIENT_RESOURCES;
3950             goto end;
3951         }
3952
3953         RtlZeroMemory(fcb->hash_ptrs_uc, sizeof(LIST_ENTRY*) * 256);
3954     }
3955
3956     InsertHeadList(lastle, &fcb->list_entry);
3957     InsertTailList(&Vcb->all_fcbs, &fcb->list_entry_all);
3958
3959     if (bmn->type == BTRFS_TYPE_DIRECTORY)
3960         fileref->fcb->fileref = fileref;
3961
3962     ExAcquireResourceExclusiveLite(parfcb->Header.Resource, TRUE);
3963     parfcb->inode_item.st_size += utf8.Length * 2;
3964     parfcb->inode_item.transid = Vcb->superblock.generation;
3965     parfcb->inode_item.sequence++;
3966
3967     if (!parccb->user_set_change_time)
3968         parfcb->inode_item.st_ctime = now;
3969
3970     if (!parccb->user_set_write_time)
3971         parfcb->inode_item.st_mtime = now;
3972
3973     ExReleaseResourceLite(parfcb->Header.Resource);
3974
3975     parfcb->inode_item_changed = TRUE;
3976     mark_fcb_dirty(parfcb);
3977
3978     send_notification_fileref(fileref, bmn->type == BTRFS_TYPE_DIRECTORY ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME, FILE_ACTION_ADDED, NULL);
3979
3980     if (!parccb->user_set_write_time)
3981         send_notification_fcb(parfileref, FILE_NOTIFY_CHANGE_LAST_WRITE, FILE_ACTION_MODIFIED, NULL);
3982
3983     Status = STATUS_SUCCESS;
3984
3985 end:
3986     release_fcb_lock(Vcb);
3987
3988     ExFreePool(utf8.Buffer);
3989
3990     return Status;
3991 }
3992
3993 static void mark_subvol_dirty(device_extension* Vcb, root* r) {
3994     if (!r->dirty) {
3995         r->dirty = TRUE;
3996
3997         ExAcquireResourceExclusiveLite(&Vcb->dirty_subvols_lock, TRUE);
3998         InsertTailList(&Vcb->dirty_subvols, &r->list_entry_dirty);
3999         ExReleaseResourceLite(&Vcb->dirty_subvols_lock);
4000     }
4001
4002     Vcb->need_write = TRUE;
4003 }
4004
4005 static NTSTATUS recvd_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, void* data, ULONG datalen, KPROCESSOR_MODE processor_mode) {
4006     btrfs_received_subvol* brs = (btrfs_received_subvol*)data;
4007     fcb* fcb;
4008     NTSTATUS Status;
4009     LARGE_INTEGER time;
4010     BTRFS_TIME now;
4011
4012     TRACE("(%p, %p, %p, %u)\n", Vcb, FileObject, data, datalen);
4013
4014     if (!data || datalen < sizeof(btrfs_received_subvol))
4015         return STATUS_INVALID_PARAMETER;
4016
4017     if (!FileObject || !FileObject->FsContext || FileObject->FsContext == Vcb->volume_fcb)
4018         return STATUS_INVALID_PARAMETER;
4019
4020     fcb = FileObject->FsContext;
4021
4022     if (!fcb->subvol)
4023         return STATUS_INVALID_PARAMETER;
4024
4025     if (!SeSinglePrivilegeCheck(RtlConvertLongToLuid(SE_MANAGE_VOLUME_PRIVILEGE), processor_mode))
4026         return STATUS_PRIVILEGE_NOT_HELD;
4027
4028     ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
4029
4030     if (fcb->subvol->root_item.rtransid != 0) {
4031         WARN("subvol already has received information set\n");
4032         Status = STATUS_INVALID_PARAMETER;
4033         goto end;
4034     }
4035
4036     KeQuerySystemTime(&time);
4037     win_time_to_unix(time, &now);
4038
4039     RtlCopyMemory(&fcb->subvol->root_item.received_uuid, &brs->uuid, sizeof(BTRFS_UUID));
4040     fcb->subvol->root_item.stransid = brs->generation;
4041     fcb->subvol->root_item.rtransid = Vcb->superblock.generation;
4042     fcb->subvol->root_item.rtime = now;
4043
4044     fcb->subvol->received = TRUE;
4045     mark_subvol_dirty(Vcb, fcb->subvol);
4046
4047     Status = STATUS_SUCCESS;
4048
4049 end:
4050     ExReleaseResourceLite(&Vcb->tree_lock);
4051
4052     return Status;
4053 }
4054
4055 static NTSTATUS fsctl_get_xattrs(device_extension* Vcb, PFILE_OBJECT FileObject, void* data, ULONG datalen, KPROCESSOR_MODE processor_mode) {
4056     LIST_ENTRY* le;
4057     btrfs_set_xattr* bsxa;
4058     ULONG reqlen = (ULONG)offsetof(btrfs_set_xattr, data[0]);
4059     fcb* fcb;
4060     ccb* ccb;
4061
4062     if (!data || datalen < reqlen)
4063         return STATUS_INVALID_PARAMETER;
4064
4065     if (!FileObject || !FileObject->FsContext || !FileObject->FsContext2 || FileObject->FsContext == Vcb->volume_fcb)
4066         return STATUS_INVALID_PARAMETER;
4067
4068     fcb = FileObject->FsContext;
4069     ccb = FileObject->FsContext2;
4070
4071     if (!(ccb->access & (FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES)) && processor_mode == UserMode) {
4072         WARN("insufficient privileges\n");
4073         return STATUS_ACCESS_DENIED;
4074     }
4075
4076     ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
4077
4078     le = fcb->xattrs.Flink;
4079     while (le != &fcb->xattrs) {
4080         xattr* xa = CONTAINING_RECORD(le, xattr, list_entry);
4081
4082         if (xa->valuelen > 0)
4083             reqlen += (ULONG)offsetof(btrfs_set_xattr, data[0]) + xa->namelen + xa->valuelen;
4084
4085         le = le->Flink;
4086     }
4087
4088     if (datalen < reqlen) {
4089         ExReleaseResourceLite(fcb->Header.Resource);
4090         return STATUS_BUFFER_OVERFLOW;
4091     }
4092
4093     bsxa = (btrfs_set_xattr*)data;
4094
4095     if (reqlen > 0) {
4096         le = fcb->xattrs.Flink;
4097         while (le != &fcb->xattrs) {
4098             xattr* xa = CONTAINING_RECORD(le, xattr, list_entry);
4099
4100             if (xa->valuelen > 0) {
4101                 bsxa->namelen = xa->namelen;
4102                 bsxa->valuelen = xa->valuelen;
4103                 memcpy(bsxa->data, xa->data, xa->namelen + xa->valuelen);
4104
4105                 bsxa = (btrfs_set_xattr*)&bsxa->data[xa->namelen + xa->valuelen];
4106             }
4107
4108             le = le->Flink;
4109         }
4110     }
4111
4112     bsxa->namelen = 0;
4113     bsxa->valuelen = 0;
4114
4115     ExReleaseResourceLite(fcb->Header.Resource);
4116
4117     return STATUS_SUCCESS;
4118 }
4119
4120 static NTSTATUS fsctl_set_xattr(device_extension* Vcb, PFILE_OBJECT FileObject, void* data, ULONG datalen, PIRP Irp) {
4121     NTSTATUS Status;
4122     btrfs_set_xattr* bsxa;
4123     xattr* xa;
4124     fcb* fcb;
4125     ccb* ccb;
4126     LIST_ENTRY* le;
4127
4128     static const char stream_pref[] = "user.";
4129
4130     TRACE("(%p, %p, %p, %u)\n", Vcb, FileObject, data, datalen);
4131
4132     if (!data || datalen < sizeof(btrfs_set_xattr))
4133         return STATUS_INVALID_PARAMETER;
4134
4135     bsxa = (btrfs_set_xattr*)data;
4136
4137     if (datalen < offsetof(btrfs_set_xattr, data[0]) + bsxa->namelen + bsxa->valuelen)
4138         return STATUS_INVALID_PARAMETER;
4139
4140     if (bsxa->namelen + bsxa->valuelen + sizeof(tree_header) + sizeof(leaf_node) + offsetof(DIR_ITEM, name[0]) > Vcb->superblock.node_size)
4141         return STATUS_INVALID_PARAMETER;
4142
4143     if (!FileObject || !FileObject->FsContext || !FileObject->FsContext2 || FileObject->FsContext == Vcb->volume_fcb)
4144         return STATUS_INVALID_PARAMETER;
4145
4146     if (Vcb->readonly)
4147         return STATUS_MEDIA_WRITE_PROTECTED;
4148
4149     fcb = FileObject->FsContext;
4150     ccb = FileObject->FsContext2;
4151
4152     if (is_subvol_readonly(fcb->subvol, Irp))
4153         return STATUS_ACCESS_DENIED;
4154
4155     if (!(ccb->access & FILE_WRITE_ATTRIBUTES) && Irp->RequestorMode == UserMode) {
4156         WARN("insufficient privileges\n");
4157         return STATUS_ACCESS_DENIED;
4158     }
4159
4160     ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
4161
4162     ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
4163
4164     if (bsxa->namelen == strlen(EA_NTACL) && RtlCompareMemory(bsxa->data, EA_NTACL, strlen(EA_NTACL)) == strlen(EA_NTACL)) {
4165         if ((!(ccb->access & WRITE_DAC) || !(ccb->access & WRITE_OWNER)) && Irp->RequestorMode == UserMode) {
4166             WARN("insufficient privileges\n");
4167             Status = STATUS_ACCESS_DENIED;
4168             goto end;
4169         }
4170
4171         if (!SeSinglePrivilegeCheck(RtlConvertLongToLuid(SE_MANAGE_VOLUME_PRIVILEGE), Irp->RequestorMode)) {
4172             Status = STATUS_PRIVILEGE_NOT_HELD;
4173             goto end;
4174         }
4175
4176         if (fcb->sd)
4177             ExFreePool(fcb->sd);
4178
4179         if (bsxa->valuelen > 0 && RtlValidRelativeSecurityDescriptor(bsxa->data + bsxa->namelen, bsxa->valuelen, 0)) {
4180             fcb->sd = ExAllocatePoolWithTag(PagedPool, bsxa->valuelen, ALLOC_TAG);
4181             if (!fcb->sd) {
4182                 ERR("out of memory\n");
4183                 Status = STATUS_INSUFFICIENT_RESOURCES;
4184                 goto end;
4185             }
4186
4187             RtlCopyMemory(fcb->sd, bsxa->data + bsxa->namelen, bsxa->valuelen);
4188         } else if (fcb->sd)
4189             fcb->sd = NULL;
4190
4191         fcb->sd_dirty = TRUE;
4192
4193         if (!fcb->sd) {
4194             fcb_get_sd(fcb, ccb->fileref->parent->fcb, FALSE, Irp);
4195             fcb->sd_deleted = TRUE;
4196         }
4197
4198         mark_fcb_dirty(fcb);
4199
4200         Status = STATUS_SUCCESS;
4201         goto end;
4202     } else if (bsxa->namelen == strlen(EA_DOSATTRIB) && RtlCompareMemory(bsxa->data, EA_DOSATTRIB, strlen(EA_DOSATTRIB)) == strlen(EA_DOSATTRIB)) {
4203         ULONG atts;
4204
4205         if (bsxa->valuelen > 0 && get_file_attributes_from_xattr(bsxa->data + bsxa->namelen, bsxa->valuelen, &atts)) {
4206             fcb->atts = atts;
4207
4208             if (fcb->type == BTRFS_TYPE_DIRECTORY)
4209                 fcb->atts |= FILE_ATTRIBUTE_DIRECTORY;
4210             else if (fcb->type == BTRFS_TYPE_SYMLINK)
4211                 fcb->atts |= FILE_ATTRIBUTE_REPARSE_POINT;
4212
4213             if (fcb->inode == SUBVOL_ROOT_INODE) {
4214                 if (fcb->subvol->root_item.flags & BTRFS_SUBVOL_READONLY)
4215                     fcb->atts |= FILE_ATTRIBUTE_READONLY;
4216                 else
4217                     fcb->atts &= ~FILE_ATTRIBUTE_READONLY;
4218             }
4219
4220             fcb->atts_deleted = FALSE;
4221         } else {
4222             BOOL hidden = ccb->fileref && ccb->fileref->dc && ccb->fileref->dc->utf8.Buffer && ccb->fileref->dc->utf8.Buffer[0] == '.';
4223
4224             fcb->atts = get_file_attributes(Vcb, fcb->subvol, fcb->inode, fcb->type, hidden, TRUE, Irp);
4225             fcb->atts_deleted = TRUE;
4226         }
4227
4228         fcb->atts_changed = TRUE;
4229         mark_fcb_dirty(fcb);
4230
4231         Status = STATUS_SUCCESS;
4232         goto end;
4233     } else if (bsxa->namelen == strlen(EA_REPARSE) && RtlCompareMemory(bsxa->data, EA_REPARSE, strlen(EA_REPARSE)) == strlen(EA_REPARSE)) {
4234         if (fcb->reparse_xattr.Buffer) {
4235             ExFreePool(fcb->reparse_xattr.Buffer);
4236             fcb->reparse_xattr.Buffer = NULL;
4237             fcb->reparse_xattr.Length = fcb->reparse_xattr.MaximumLength = 0;
4238         }
4239
4240         if (bsxa->valuelen > 0) {
4241             fcb->reparse_xattr.Buffer = ExAllocatePoolWithTag(PagedPool, bsxa->valuelen, ALLOC_TAG);
4242             if (!fcb->reparse_xattr.Buffer) {
4243                 ERR("out of memory\n");
4244                 Status = STATUS_INSUFFICIENT_RESOURCES;
4245                 goto end;
4246             }
4247
4248             RtlCopyMemory(fcb->reparse_xattr.Buffer, bsxa->data + bsxa->namelen, bsxa->valuelen);
4249             fcb->reparse_xattr.Length = fcb->reparse_xattr.MaximumLength = bsxa->valuelen;
4250         }
4251
4252         fcb->reparse_xattr_changed = TRUE;
4253         mark_fcb_dirty(fcb);
4254
4255         Status = STATUS_SUCCESS;
4256         goto end;
4257     } else if (bsxa->namelen == strlen(EA_EA) && RtlCompareMemory(bsxa->data, EA_EA, strlen(EA_EA)) == strlen(EA_EA)) {
4258         if (!(ccb->access & FILE_WRITE_EA) && Irp->RequestorMode == UserMode) {
4259             WARN("insufficient privileges\n");
4260             Status = STATUS_ACCESS_DENIED;
4261             goto end;
4262         }
4263
4264         if (fcb->ea_xattr.Buffer) {
4265             ExFreePool(fcb->ea_xattr.Buffer);
4266             fcb->ea_xattr.Length = fcb->ea_xattr.MaximumLength = 0;
4267             fcb->ea_xattr.Buffer = NULL;
4268         }
4269
4270         fcb->ealen = 0;
4271
4272         if (bsxa->valuelen > 0) {
4273             ULONG offset;
4274
4275             Status = IoCheckEaBufferValidity((FILE_FULL_EA_INFORMATION*)(bsxa->data + bsxa->namelen), bsxa->valuelen, &offset);
4276
4277             if (!NT_SUCCESS(Status))
4278                 WARN("IoCheckEaBufferValidity returned %08x (error at offset %u)\n", Status, offset);
4279             else {
4280                 FILE_FULL_EA_INFORMATION* eainfo;
4281
4282                 fcb->ea_xattr.Buffer = ExAllocatePoolWithTag(PagedPool, bsxa->valuelen, ALLOC_TAG);
4283                 if (!fcb->ea_xattr.Buffer) {
4284                     ERR("out of memory\n");
4285                     Status = STATUS_INSUFFICIENT_RESOURCES;
4286                     goto end;
4287                 }
4288
4289                 RtlCopyMemory(fcb->ea_xattr.Buffer, bsxa->data + bsxa->namelen, bsxa->valuelen);
4290
4291                 fcb->ea_xattr.Length = fcb->ea_xattr.MaximumLength = bsxa->valuelen;
4292
4293                 fcb->ealen = 4;
4294
4295                 // calculate ealen
4296                 eainfo = (FILE_FULL_EA_INFORMATION*)(bsxa->data + bsxa->namelen);
4297                 do {
4298                     fcb->ealen += 5 + eainfo->EaNameLength + eainfo->EaValueLength;
4299
4300                     if (eainfo->NextEntryOffset == 0)
4301                         break;
4302
4303                     eainfo = (FILE_FULL_EA_INFORMATION*)(((UINT8*)eainfo) + eainfo->NextEntryOffset);
4304                 } while (TRUE);
4305             }
4306         }
4307
4308         fcb->ea_changed = TRUE;
4309         mark_fcb_dirty(fcb);
4310
4311         Status = STATUS_SUCCESS;
4312         goto end;
4313     } else if (bsxa->namelen == strlen(EA_PROP_COMPRESSION) && RtlCompareMemory(bsxa->data, EA_PROP_COMPRESSION, strlen(EA_PROP_COMPRESSION)) == strlen(EA_PROP_COMPRESSION)) {
4314         const char lzo[] = "lzo";
4315         const char zlib[] = "zlib";
4316
4317         if (bsxa->valuelen == strlen(lzo) && RtlCompareMemory(bsxa->data + bsxa->namelen, lzo, bsxa->valuelen) == bsxa->valuelen)
4318             fcb->prop_compression = PropCompression_LZO;
4319         else if (bsxa->valuelen == strlen(zlib) && RtlCompareMemory(bsxa->data + bsxa->namelen, zlib, bsxa->valuelen) == bsxa->valuelen)
4320             fcb->prop_compression = PropCompression_Zlib;
4321         else
4322             fcb->prop_compression = PropCompression_None;
4323
4324         if (fcb->prop_compression != PropCompression_None) {
4325             fcb->inode_item.flags |= BTRFS_INODE_COMPRESS;
4326             fcb->inode_item_changed = TRUE;
4327         }
4328
4329         fcb->prop_compression_changed = TRUE;
4330         mark_fcb_dirty(fcb);
4331
4332         Status = STATUS_SUCCESS;
4333         goto end;
4334     } else if (bsxa->namelen >= strlen(stream_pref) && RtlCompareMemory(bsxa->data, stream_pref, strlen(stream_pref)) == strlen(stream_pref)) {
4335         // don't allow xattrs beginning with user., as these appear as streams instead
4336         Status = STATUS_OBJECT_NAME_INVALID;
4337         goto end;
4338     }
4339
4340     xa = ExAllocatePoolWithTag(PagedPool, offsetof(xattr, data[0]) + bsxa->namelen + bsxa->valuelen, ALLOC_TAG);
4341     if (!xa) {
4342         ERR("out of memory\n");
4343         Status = STATUS_INSUFFICIENT_RESOURCES;
4344         goto end;
4345     }
4346
4347     le = fcb->xattrs.Flink;
4348     while (le != &fcb->xattrs) {
4349         xattr* xa2 = CONTAINING_RECORD(le, xattr, list_entry);
4350
4351         if (xa2->namelen == bsxa->namelen && RtlCompareMemory(xa2->data, bsxa->data, xa2->namelen) == xa2->namelen) {
4352             RemoveEntryList(&xa2->list_entry);
4353             ExFreePool(xa2);
4354             break;
4355         }
4356
4357         le = le->Flink;
4358     }
4359
4360     xa->namelen = bsxa->namelen;
4361     xa->valuelen = bsxa->valuelen;
4362     xa->dirty = TRUE;
4363     RtlCopyMemory(xa->data, bsxa->data, bsxa->namelen + bsxa->valuelen);
4364
4365     InsertTailList(&fcb->xattrs, &xa->list_entry);
4366
4367     fcb->xattrs_changed = TRUE;
4368     mark_fcb_dirty(fcb);
4369
4370     Status = STATUS_SUCCESS;
4371
4372 end:
4373     ExReleaseResourceLite(fcb->Header.Resource);
4374
4375     ExReleaseResourceLite(&Vcb->tree_lock);
4376
4377     return Status;
4378 }
4379
4380 static NTSTATUS reserve_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, PIRP Irp) {
4381     fcb* fcb;
4382     ccb* ccb;
4383
4384     TRACE("(%p, %p)\n", Vcb, FileObject);
4385
4386     // "Reserving" a readonly subvol allows the calling process to write into it until the handle is closed.
4387
4388     if (!SeSinglePrivilegeCheck(RtlConvertLongToLuid(SE_MANAGE_VOLUME_PRIVILEGE), Irp->RequestorMode))
4389         return STATUS_PRIVILEGE_NOT_HELD;
4390
4391     if (!FileObject || !FileObject->FsContext || !FileObject->FsContext2 || FileObject->FsContext == Vcb->volume_fcb)
4392         return STATUS_INVALID_PARAMETER;
4393
4394     fcb = FileObject->FsContext;
4395     ccb = FileObject->FsContext2;
4396
4397     if (!(fcb->subvol->root_item.flags & BTRFS_SUBVOL_READONLY))
4398         return STATUS_INVALID_PARAMETER;
4399
4400     if (fcb->subvol->reserved)
4401         return STATUS_INVALID_PARAMETER;
4402
4403     fcb->subvol->reserved = PsGetCurrentProcess();
4404     ccb->reserving = TRUE;
4405
4406     return STATUS_SUCCESS;
4407 }
4408
4409 static NTSTATUS get_subvol_path(device_extension* Vcb, UINT64 id, WCHAR* out, ULONG outlen, PIRP Irp) {
4410     LIST_ENTRY* le;
4411     root* r = NULL;
4412     NTSTATUS Status;
4413     file_ref* fr;
4414     UNICODE_STRING us;
4415
4416     le = Vcb->roots.Flink;
4417     while (le != &Vcb->roots) {
4418         root* r2 = CONTAINING_RECORD(le, root, list_entry);
4419
4420         if (r2->id == id) {
4421             r = r2;
4422             break;
4423         }
4424
4425         le = le->Flink;
4426     }
4427
4428     if (!r) {
4429         ERR("couldn't find subvol %llx\n", id);
4430         return STATUS_INTERNAL_ERROR;
4431     }
4432
4433     acquire_fcb_lock_shared(Vcb);
4434
4435     Status = open_fileref_by_inode(Vcb, r, r->root_item.objid, &fr, Irp);
4436     if (!NT_SUCCESS(Status)) {
4437         release_fcb_lock(Vcb);
4438         ERR("open_fileref_by_inode returned %08x\n", Status);
4439         return Status;
4440     }
4441
4442     us.Buffer = out;
4443     us.Length = 0;
4444     us.MaximumLength = (USHORT)min(0xffff, outlen) - sizeof(WCHAR);
4445
4446     Status = fileref_get_filename(fr, &us, NULL, NULL);
4447
4448     if (NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW)
4449         out[us.Length / sizeof(WCHAR)] = 0;
4450     else
4451         ERR("fileref_get_filename returned %08x\n", Status);
4452
4453     free_fileref(Vcb, fr);
4454
4455     release_fcb_lock(Vcb);
4456
4457     return Status;
4458 }
4459
4460 static NTSTATUS find_subvol(device_extension* Vcb, void* in, ULONG inlen, void* out, ULONG outlen, PIRP Irp) {
4461     btrfs_find_subvol* bfs;
4462     NTSTATUS Status;
4463     traverse_ptr tp;
4464     KEY searchkey;
4465
4466     if (!in || inlen < sizeof(btrfs_find_subvol))
4467         return STATUS_INVALID_PARAMETER;
4468
4469     if (!out || outlen < sizeof(WCHAR))
4470         return STATUS_INVALID_PARAMETER;
4471
4472     if (!SeSinglePrivilegeCheck(RtlConvertLongToLuid(SE_MANAGE_VOLUME_PRIVILEGE), Irp->RequestorMode))
4473         return STATUS_PRIVILEGE_NOT_HELD;
4474
4475     bfs = (btrfs_find_subvol*)in;
4476
4477     ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
4478
4479     if (!Vcb->uuid_root) {
4480         ERR("couldn't find uuid root\n");
4481         Status = STATUS_NOT_FOUND;
4482         goto end;
4483     }
4484
4485     RtlCopyMemory(&searchkey.obj_id, &bfs->uuid, sizeof(UINT64));
4486     searchkey.obj_type = TYPE_SUBVOL_UUID;
4487     RtlCopyMemory(&searchkey.offset, &bfs->uuid.uuid[sizeof(UINT64)], sizeof(UINT64));
4488
4489     Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, FALSE, Irp);
4490
4491     if (!NT_SUCCESS(Status)) {
4492         ERR("find_item returned %08x\n", Status);
4493         goto end;
4494     }
4495
4496     if (!keycmp(searchkey, tp.item->key) && tp.item->size >= sizeof(UINT64)) {
4497         UINT64* id = (UINT64*)tp.item->data;
4498
4499         if (bfs->ctransid != 0) {
4500             KEY searchkey2;
4501             traverse_ptr tp2;
4502
4503             searchkey2.obj_id = *id;
4504             searchkey2.obj_type = TYPE_ROOT_ITEM;
4505             searchkey2.offset = 0xffffffffffffffff;
4506
4507             Status = find_item(Vcb, Vcb->root_root, &tp2, &searchkey2, FALSE, Irp);
4508             if (!NT_SUCCESS(Status)) {
4509                 ERR("find_item returned %08x\n", Status);
4510                 goto end;
4511             }
4512
4513             if (tp2.item->key.obj_id == searchkey2.obj_id && tp2.item->key.obj_type == searchkey2.obj_type &&
4514                 tp2.item->size >= offsetof(ROOT_ITEM, otransid)) {
4515                 ROOT_ITEM* ri = (ROOT_ITEM*)tp2.item->data;
4516
4517                 if (ri->ctransid == bfs->ctransid) {
4518                     TRACE("found subvol %llx\n", *id);
4519                     Status = get_subvol_path(Vcb, *id, out, outlen, Irp);
4520                     goto end;
4521                 }
4522             }
4523         } else {
4524             TRACE("found subvol %llx\n", *id);
4525             Status = get_subvol_path(Vcb, *id, out, outlen, Irp);
4526             goto end;
4527         }
4528     }
4529
4530     searchkey.obj_type = TYPE_SUBVOL_REC_UUID;
4531
4532     Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, FALSE, Irp);
4533
4534     if (!NT_SUCCESS(Status)) {
4535         ERR("find_item returned %08x\n", Status);
4536         goto end;
4537     }
4538
4539     if (!keycmp(searchkey, tp.item->key) && tp.item->size >= sizeof(UINT64)) {
4540         UINT64* ids = (UINT64*)tp.item->data;
4541         ULONG i;
4542
4543         for (i = 0; i < tp.item->size / sizeof(UINT64); i++) {
4544             if (bfs->ctransid != 0) {
4545                 KEY searchkey2;
4546                 traverse_ptr tp2;
4547
4548                 searchkey2.obj_id = ids[i];
4549                 searchkey2.obj_type = TYPE_ROOT_ITEM;
4550                 searchkey2.offset = 0xffffffffffffffff;
4551
4552                 Status = find_item(Vcb, Vcb->root_root, &tp2, &searchkey2, FALSE, Irp);
4553                 if (!NT_SUCCESS(Status)) {
4554                     ERR("find_item returned %08x\n", Status);
4555                     goto end;
4556                 }
4557
4558                 if (tp2.item->key.obj_id == searchkey2.obj_id && tp2.item->key.obj_type == searchkey2.obj_type &&
4559                     tp2.item->size >= offsetof(ROOT_ITEM, otransid)) {
4560                     ROOT_ITEM* ri = (ROOT_ITEM*)tp2.item->data;
4561
4562                     if (ri->ctransid == bfs->ctransid) {
4563                         TRACE("found subvol %llx\n", ids[i]);
4564                         Status = get_subvol_path(Vcb, ids[i], out, outlen, Irp);
4565                         goto end;
4566                     }
4567                 }
4568             } else {
4569                 TRACE("found subvol %llx\n", ids[i]);
4570                 Status = get_subvol_path(Vcb, ids[i], out, outlen, Irp);
4571                 goto end;
4572             }
4573         }
4574     }
4575
4576     Status = STATUS_NOT_FOUND;
4577
4578 end:
4579     ExReleaseResourceLite(&Vcb->tree_lock);
4580
4581     return Status;
4582 }
4583
4584 static NTSTATUS resize_device(device_extension* Vcb, void* data, ULONG len, PIRP Irp) {
4585     btrfs_resize* br = (btrfs_resize*)data;
4586     NTSTATUS Status;
4587     LIST_ENTRY* le;
4588     device* dev = NULL;
4589
4590     TRACE("(%p, %p, %u)\n", Vcb, data, len);
4591
4592     if (!data || len < sizeof(btrfs_resize) || (br->size % Vcb->superblock.sector_size) != 0)
4593         return STATUS_INVALID_PARAMETER;
4594
4595     if (!SeSinglePrivilegeCheck(RtlConvertLongToLuid(SE_MANAGE_VOLUME_PRIVILEGE), Irp->RequestorMode))
4596         return STATUS_PRIVILEGE_NOT_HELD;
4597
4598     if (Vcb->readonly)
4599         return STATUS_MEDIA_WRITE_PROTECTED;
4600
4601     ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
4602
4603     le = Vcb->devices.Flink;
4604     while (le != &Vcb->devices) {
4605         device* dev2 = CONTAINING_RECORD(le, device, list_entry);
4606
4607         if (dev2->devitem.dev_id == br->device) {
4608             dev = dev2;
4609             break;
4610         }
4611
4612         le = le->Flink;
4613     }
4614
4615     if (!dev) {
4616         ERR("could not find device %llx\n", br->device);
4617         Status = STATUS_INVALID_PARAMETER;
4618         goto end;
4619     }
4620
4621     if (!dev->devobj) {
4622         ERR("trying to resize missing device\n");
4623         Status = STATUS_INVALID_PARAMETER;
4624         goto end;
4625     }
4626
4627     if (dev->readonly) {
4628         ERR("trying to resize readonly device\n");
4629         Status = STATUS_INVALID_PARAMETER;
4630         goto end;
4631     }
4632
4633     if (br->size > 0 && dev->devitem.num_bytes == br->size) {
4634         TRACE("size unchanged, returning STATUS_SUCCESS\n");
4635         Status = STATUS_SUCCESS;
4636         goto end;
4637     }
4638
4639     if (br->size > 0 && dev->devitem.num_bytes > br->size) { // shrink device
4640         BOOL need_balance = TRUE;
4641         UINT64 old_size, delta;
4642
4643         le = dev->space.Flink;
4644         while (le != &dev->space) {
4645             space* s = CONTAINING_RECORD(le, space, list_entry);
4646
4647             if (s->address <= br->size && s->address + s->size >= dev->devitem.num_bytes) {
4648                 need_balance = FALSE;
4649                 break;
4650             }
4651
4652             le = le->Flink;
4653         }
4654
4655         delta = dev->devitem.num_bytes - br->size;
4656
4657         if (need_balance) {
4658             int i;
4659
4660             if (Vcb->balance.thread) {
4661                 WARN("balance already running\n");
4662                 Status = STATUS_DEVICE_NOT_READY;
4663                 goto end;
4664             }
4665
4666             RtlZeroMemory(Vcb->balance.opts, sizeof(btrfs_balance_opts) * 3);
4667
4668             for (i = 0; i < 3; i++) {
4669                 Vcb->balance.opts[i].flags = BTRFS_BALANCE_OPTS_ENABLED | BTRFS_BALANCE_OPTS_DEVID | BTRFS_BALANCE_OPTS_DRANGE;
4670                 Vcb->balance.opts[i].devid = dev->devitem.dev_id;
4671                 Vcb->balance.opts[i].drange_start = br->size;
4672                 Vcb->balance.opts[i].drange_end = dev->devitem.num_bytes;
4673             }
4674
4675             Vcb->balance.paused = FALSE;
4676             Vcb->balance.shrinking = TRUE;
4677             Vcb->balance.status = STATUS_SUCCESS;
4678             KeInitializeEvent(&Vcb->balance.event, NotificationEvent, !Vcb->balance.paused);
4679
4680             space_list_subtract2(&dev->space, NULL, br->size, delta, NULL, NULL);
4681
4682             Status = PsCreateSystemThread(&Vcb->balance.thread, 0, NULL, NULL, NULL, balance_thread, Vcb);
4683             if (!NT_SUCCESS(Status)) {
4684                 ERR("PsCreateSystemThread returned %08x\n", Status);
4685                 goto end;
4686             }
4687
4688             Status = STATUS_MORE_PROCESSING_REQUIRED;
4689
4690             goto end;
4691         }
4692
4693         old_size = dev->devitem.num_bytes;
4694         dev->devitem.num_bytes = br->size;
4695
4696         Status = update_dev_item(Vcb, dev, Irp);
4697         if (!NT_SUCCESS(Status)) {
4698             ERR("update_dev_item returned %08x\n", Status);
4699             dev->devitem.num_bytes = old_size;
4700             goto end;
4701         }
4702
4703         space_list_subtract2(&dev->space, NULL, br->size, delta, NULL, NULL);
4704
4705         Vcb->superblock.total_bytes -= delta;
4706     } else { // extend device
4707         GET_LENGTH_INFORMATION gli;
4708         UINT64 old_size, delta;
4709
4710         Status = dev_ioctl(dev->devobj, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0,
4711                            &gli, sizeof(gli), TRUE, NULL);
4712         if (!NT_SUCCESS(Status)) {
4713             ERR("IOCTL_DISK_GET_LENGTH_INFO returned %08x\n", Status);
4714             goto end;
4715         }
4716
4717         if (br->size == 0) {
4718             br->size = gli.Length.QuadPart;
4719
4720             if (dev->devitem.num_bytes == br->size) {
4721                 TRACE("size unchanged, returning STATUS_SUCCESS\n");
4722                 Status = STATUS_SUCCESS;
4723                 goto end;
4724             }
4725
4726             if (br->size == 0) {
4727                 ERR("IOCTL_DISK_GET_LENGTH_INFO returned 0 length\n");
4728                 Status = STATUS_INTERNAL_ERROR;
4729                 goto end;
4730             }
4731         } else if ((UINT64)gli.Length.QuadPart < br->size) {
4732             ERR("device was %llx bytes, trying to extend to %llx\n", gli.Length.QuadPart, br->size);
4733             Status = STATUS_INVALID_PARAMETER;
4734             goto end;
4735         }
4736
4737         delta = br->size - dev->devitem.num_bytes;
4738
4739         old_size = dev->devitem.num_bytes;
4740         dev->devitem.num_bytes = br->size;
4741
4742         Status = update_dev_item(Vcb, dev, Irp);
4743         if (!NT_SUCCESS(Status)) {
4744             ERR("update_dev_item returned %08x\n", Status);
4745             dev->devitem.num_bytes = old_size;
4746             goto end;
4747         }
4748
4749         space_list_add2(&dev->space, NULL, dev->devitem.num_bytes, delta, NULL, NULL);
4750
4751         Vcb->superblock.total_bytes += delta;
4752     }
4753
4754     Status = STATUS_SUCCESS;
4755     Vcb->need_write = TRUE;
4756
4757 end:
4758     ExReleaseResourceLite(&Vcb->tree_lock);
4759
4760     if (NT_SUCCESS(Status))
4761         FsRtlNotifyVolumeEvent(Vcb->root_file, FSRTL_VOLUME_CHANGE_SIZE);
4762
4763     return Status;
4764 }
4765
4766 NTSTATUS fsctl_request(PDEVICE_OBJECT DeviceObject, PIRP* Pirp, UINT32 type) {
4767     PIRP Irp = *Pirp;
4768     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
4769     NTSTATUS Status;
4770
4771     switch (type) {
4772 #if (NTDDI_VERSION >= NTDDI_WIN7)
4773         case FSCTL_REQUEST_OPLOCK:
4774             WARN("STUB: FSCTL_REQUEST_OPLOCK\n");
4775             Status = STATUS_INVALID_DEVICE_REQUEST;
4776             break;
4777 #endif
4778
4779         case FSCTL_REQUEST_OPLOCK_LEVEL_1:
4780             WARN("STUB: FSCTL_REQUEST_OPLOCK_LEVEL_1\n");
4781             Status = STATUS_INVALID_DEVICE_REQUEST;
4782             break;
4783
4784         case FSCTL_REQUEST_OPLOCK_LEVEL_2:
4785             WARN("STUB: FSCTL_REQUEST_OPLOCK_LEVEL_2\n");
4786             Status = STATUS_INVALID_DEVICE_REQUEST;
4787             break;
4788
4789         case FSCTL_REQUEST_BATCH_OPLOCK:
4790             WARN("STUB: FSCTL_REQUEST_BATCH_OPLOCK\n");
4791             Status = STATUS_INVALID_DEVICE_REQUEST;
4792             break;
4793
4794         case FSCTL_OPLOCK_BREAK_ACKNOWLEDGE:
4795             WARN("STUB: FSCTL_OPLOCK_BREAK_ACKNOWLEDGE\n");
4796             Status = STATUS_INVALID_DEVICE_REQUEST;
4797             break;
4798
4799         case FSCTL_OPLOCK_BREAK_ACK_NO_2:
4800             WARN("STUB: FSCTL_OPLOCK_BREAK_ACK_NO_2\n");
4801             Status = STATUS_INVALID_DEVICE_REQUEST;
4802             break;
4803
4804         case FSCTL_OPBATCH_ACK_CLOSE_PENDING:
4805             WARN("STUB: FSCTL_OPBATCH_ACK_CLOSE_PENDING\n");
4806             Status = STATUS_INVALID_DEVICE_REQUEST;
4807             break;
4808
4809         case FSCTL_OPLOCK_BREAK_NOTIFY:
4810             WARN("STUB: FSCTL_OPLOCK_BREAK_NOTIFY\n");
4811             Status = STATUS_INVALID_DEVICE_REQUEST;
4812             break;
4813
4814         case FSCTL_REQUEST_FILTER_OPLOCK:
4815             WARN("STUB: FSCTL_REQUEST_FILTER_OPLOCK\n");
4816             Status = STATUS_INVALID_DEVICE_REQUEST;
4817             break;
4818
4819         case FSCTL_LOCK_VOLUME:
4820             Status = lock_volume(DeviceObject->DeviceExtension, Irp);
4821             break;
4822
4823         case FSCTL_UNLOCK_VOLUME:
4824             Status = unlock_volume(DeviceObject->DeviceExtension, Irp);
4825             break;
4826
4827         case FSCTL_DISMOUNT_VOLUME:
4828             Status = dismount_volume(DeviceObject->DeviceExtension, Irp);
4829             break;
4830
4831         case FSCTL_IS_VOLUME_MOUNTED:
4832             Status = is_volume_mounted(DeviceObject->DeviceExtension, Irp);
4833             break;
4834
4835         case FSCTL_IS_PATHNAME_VALID:
4836             WARN("STUB: FSCTL_IS_PATHNAME_VALID\n");
4837             Status = STATUS_INVALID_DEVICE_REQUEST;
4838             break;
4839
4840         case FSCTL_MARK_VOLUME_DIRTY:
4841             WARN("STUB: FSCTL_MARK_VOLUME_DIRTY\n");
4842             Status = STATUS_INVALID_DEVICE_REQUEST;
4843             break;
4844
4845         case FSCTL_QUERY_RETRIEVAL_POINTERS:
4846             WARN("STUB: FSCTL_QUERY_RETRIEVAL_POINTERS\n");
4847             Status = STATUS_INVALID_DEVICE_REQUEST;
4848             break;
4849
4850         case FSCTL_GET_COMPRESSION:
4851             Status = get_compression(Irp);
4852             break;
4853
4854         case FSCTL_SET_COMPRESSION:
4855             Status = set_compression(Irp);
4856             break;
4857
4858         case FSCTL_SET_BOOTLOADER_ACCESSED:
4859             WARN("STUB: FSCTL_SET_BOOTLOADER_ACCESSED\n");
4860             Status = STATUS_INVALID_DEVICE_REQUEST;
4861             break;
4862
4863         case FSCTL_INVALIDATE_VOLUMES:
4864             Status = invalidate_volumes(Irp);
4865             break;
4866
4867         case FSCTL_QUERY_FAT_BPB:
4868             WARN("STUB: FSCTL_QUERY_FAT_BPB\n");
4869             Status = STATUS_INVALID_DEVICE_REQUEST;
4870             break;
4871
4872         case FSCTL_FILESYSTEM_GET_STATISTICS:
4873             Status = fs_get_statistics(Irp->AssociatedIrp.SystemBuffer, IrpSp->Parameters.FileSystemControl.OutputBufferLength, &Irp->IoStatus.Information);
4874             break;
4875
4876         case FSCTL_GET_NTFS_VOLUME_DATA:
4877             WARN("STUB: FSCTL_GET_NTFS_VOLUME_DATA\n");
4878             Status = STATUS_INVALID_DEVICE_REQUEST;
4879             break;
4880
4881         case FSCTL_GET_NTFS_FILE_RECORD:
4882             WARN("STUB: FSCTL_GET_NTFS_FILE_RECORD\n");
4883             Status = STATUS_INVALID_DEVICE_REQUEST;
4884             break;
4885
4886         case FSCTL_GET_VOLUME_BITMAP:
4887             WARN("STUB: FSCTL_GET_VOLUME_BITMAP\n");
4888             Status = STATUS_INVALID_DEVICE_REQUEST;
4889             break;
4890
4891         case FSCTL_GET_RETRIEVAL_POINTERS:
4892             WARN("STUB: FSCTL_GET_RETRIEVAL_POINTERS\n");
4893             Status = STATUS_INVALID_DEVICE_REQUEST;
4894             break;
4895
4896         case FSCTL_MOVE_FILE:
4897             WARN("STUB: FSCTL_MOVE_FILE\n");
4898             Status = STATUS_INVALID_DEVICE_REQUEST;
4899             break;
4900
4901         case FSCTL_IS_VOLUME_DIRTY:
4902             Status = is_volume_dirty(DeviceObject->DeviceExtension, Irp);
4903             break;
4904
4905         case FSCTL_ALLOW_EXTENDED_DASD_IO:
4906             Status = allow_extended_dasd_io(DeviceObject->DeviceExtension, IrpSp->FileObject);
4907             break;
4908
4909         case FSCTL_FIND_FILES_BY_SID:
4910             WARN("STUB: FSCTL_FIND_FILES_BY_SID\n");
4911             Status = STATUS_INVALID_DEVICE_REQUEST;
4912             break;
4913
4914         case FSCTL_SET_OBJECT_ID:
4915             WARN("STUB: FSCTL_SET_OBJECT_ID\n");
4916             Status = STATUS_INVALID_DEVICE_REQUEST;
4917             break;
4918
4919         case FSCTL_GET_OBJECT_ID:
4920             Status = get_object_id(DeviceObject->DeviceExtension, IrpSp->FileObject, Irp->UserBuffer,
4921                                    IrpSp->Parameters.FileSystemControl.OutputBufferLength, &Irp->IoStatus.Information);
4922             break;
4923
4924         case FSCTL_DELETE_OBJECT_ID:
4925             WARN("STUB: FSCTL_DELETE_OBJECT_ID\n");
4926             Status = STATUS_INVALID_DEVICE_REQUEST;
4927             break;
4928
4929         case FSCTL_SET_REPARSE_POINT:
4930             Status = set_reparse_point(DeviceObject, Irp);
4931             break;
4932
4933         case FSCTL_GET_REPARSE_POINT:
4934             Status = get_reparse_point(DeviceObject, IrpSp->FileObject, Irp->AssociatedIrp.SystemBuffer,
4935                                        IrpSp->Parameters.FileSystemControl.OutputBufferLength, &Irp->IoStatus.Information);
4936             break;
4937
4938         case FSCTL_DELETE_REPARSE_POINT:
4939             Status = delete_reparse_point(DeviceObject, Irp);
4940             break;
4941
4942         case FSCTL_ENUM_USN_DATA:
4943             WARN("STUB: FSCTL_ENUM_USN_DATA\n");
4944             Status = STATUS_INVALID_DEVICE_REQUEST;
4945             break;
4946
4947         case FSCTL_SECURITY_ID_CHECK:
4948             WARN("STUB: FSCTL_SECURITY_ID_CHECK\n");
4949             Status = STATUS_INVALID_DEVICE_REQUEST;
4950             break;
4951
4952         case FSCTL_READ_USN_JOURNAL:
4953             WARN("STUB: FSCTL_READ_USN_JOURNAL\n");
4954             Status = STATUS_INVALID_DEVICE_REQUEST;
4955             break;
4956
4957         case FSCTL_SET_OBJECT_ID_EXTENDED:
4958             WARN("STUB: FSCTL_SET_OBJECT_ID_EXTENDED\n");
4959             Status = STATUS_INVALID_DEVICE_REQUEST;
4960             break;
4961
4962         case FSCTL_CREATE_OR_GET_OBJECT_ID:
4963             Status = get_object_id(DeviceObject->DeviceExtension, IrpSp->FileObject, Irp->UserBuffer,
4964                                    IrpSp->Parameters.FileSystemControl.OutputBufferLength, &Irp->IoStatus.Information);
4965             break;
4966
4967         case FSCTL_SET_SPARSE:
4968             Status = set_sparse(DeviceObject->DeviceExtension, IrpSp->FileObject, Irp->AssociatedIrp.SystemBuffer,
4969                                 IrpSp->Parameters.FileSystemControl.InputBufferLength, Irp);
4970             break;
4971
4972         case FSCTL_SET_ZERO_DATA:
4973             Status = set_zero_data(DeviceObject->DeviceExtension, IrpSp->FileObject, Irp->AssociatedIrp.SystemBuffer,
4974                                    IrpSp->Parameters.FileSystemControl.InputBufferLength, Irp);
4975             break;
4976
4977         case FSCTL_QUERY_ALLOCATED_RANGES:
4978             Status = query_ranges(IrpSp->FileObject, IrpSp->Parameters.FileSystemControl.Type3InputBuffer,
4979                                   IrpSp->Parameters.FileSystemControl.InputBufferLength, Irp->UserBuffer,
4980                                   IrpSp->Parameters.FileSystemControl.OutputBufferLength, &Irp->IoStatus.Information);
4981             break;
4982
4983         case FSCTL_ENABLE_UPGRADE:
4984             WARN("STUB: FSCTL_ENABLE_UPGRADE\n");
4985             Status = STATUS_INVALID_DEVICE_REQUEST;
4986             break;
4987
4988         case FSCTL_SET_ENCRYPTION:
4989             WARN("STUB: FSCTL_SET_ENCRYPTION\n");
4990             Status = STATUS_INVALID_DEVICE_REQUEST;
4991             break;
4992
4993         case FSCTL_ENCRYPTION_FSCTL_IO:
4994             WARN("STUB: FSCTL_ENCRYPTION_FSCTL_IO\n");
4995             Status = STATUS_INVALID_DEVICE_REQUEST;
4996             break;
4997
4998         case FSCTL_WRITE_RAW_ENCRYPTED:
4999             WARN("STUB: FSCTL_WRITE_RAW_ENCRYPTED\n");
5000             Status = STATUS_INVALID_DEVICE_REQUEST;
5001             break;
5002
5003         case FSCTL_READ_RAW_ENCRYPTED:
5004             WARN("STUB: FSCTL_READ_RAW_ENCRYPTED\n");
5005             Status = STATUS_INVALID_DEVICE_REQUEST;
5006             break;
5007
5008         case FSCTL_CREATE_USN_JOURNAL:
5009             WARN("STUB: FSCTL_CREATE_USN_JOURNAL\n");
5010             Status = STATUS_INVALID_DEVICE_REQUEST;
5011             break;
5012
5013         case FSCTL_READ_FILE_USN_DATA:
5014             WARN("STUB: FSCTL_READ_FILE_USN_DATA\n");
5015             Status = STATUS_INVALID_DEVICE_REQUEST;
5016             break;
5017
5018         case FSCTL_WRITE_USN_CLOSE_RECORD:
5019             WARN("STUB: FSCTL_WRITE_USN_CLOSE_RECORD\n");
5020             Status = STATUS_INVALID_DEVICE_REQUEST;
5021             break;
5022
5023         case FSCTL_EXTEND_VOLUME:
5024             WARN("STUB: FSCTL_EXTEND_VOLUME\n");
5025             Status = STATUS_INVALID_DEVICE_REQUEST;
5026             break;
5027
5028         case FSCTL_QUERY_USN_JOURNAL:
5029             WARN("STUB: FSCTL_QUERY_USN_JOURNAL\n");
5030             Status = STATUS_INVALID_DEVICE_REQUEST;
5031             break;
5032
5033         case FSCTL_DELETE_USN_JOURNAL:
5034             WARN("STUB: FSCTL_DELETE_USN_JOURNAL\n");
5035             Status = STATUS_INVALID_DEVICE_REQUEST;
5036             break;
5037
5038         case FSCTL_MARK_HANDLE:
5039             WARN("STUB: FSCTL_MARK_HANDLE\n");
5040             Status = STATUS_INVALID_DEVICE_REQUEST;
5041             break;
5042
5043         case FSCTL_SIS_COPYFILE:
5044             WARN("STUB: FSCTL_SIS_COPYFILE\n");
5045             Status = STATUS_INVALID_DEVICE_REQUEST;
5046             break;
5047
5048         case FSCTL_SIS_LINK_FILES:
5049             WARN("STUB: FSCTL_SIS_LINK_FILES\n");
5050             Status = STATUS_INVALID_DEVICE_REQUEST;
5051             break;
5052
5053         case FSCTL_RECALL_FILE:
5054             WARN("STUB: FSCTL_RECALL_FILE\n");
5055             Status = STATUS_INVALID_DEVICE_REQUEST;
5056             break;
5057
5058         case FSCTL_READ_FROM_PLEX:
5059             WARN("STUB: FSCTL_READ_FROM_PLEX\n");
5060             Status = STATUS_INVALID_DEVICE_REQUEST;
5061             break;
5062
5063         case FSCTL_FILE_PREFETCH:
5064             WARN("STUB: FSCTL_FILE_PREFETCH\n");
5065             Status = STATUS_INVALID_DEVICE_REQUEST;
5066             break;
5067
5068 #if WIN32_WINNT >= 0x0600
5069         case FSCTL_MAKE_MEDIA_COMPATIBLE:
5070             WARN("STUB: FSCTL_MAKE_MEDIA_COMPATIBLE\n");
5071             Status = STATUS_INVALID_DEVICE_REQUEST;
5072             break;
5073
5074         case FSCTL_SET_DEFECT_MANAGEMENT:
5075             WARN("STUB: FSCTL_SET_DEFECT_MANAGEMENT\n");
5076             Status = STATUS_INVALID_DEVICE_REQUEST;
5077             break;
5078
5079         case FSCTL_QUERY_SPARING_INFO:
5080             WARN("STUB: FSCTL_QUERY_SPARING_INFO\n");
5081             Status = STATUS_INVALID_DEVICE_REQUEST;
5082             break;
5083
5084         case FSCTL_QUERY_ON_DISK_VOLUME_INFO:
5085             WARN("STUB: FSCTL_QUERY_ON_DISK_VOLUME_INFO\n");
5086             Status = STATUS_INVALID_DEVICE_REQUEST;
5087             break;
5088
5089         case FSCTL_SET_VOLUME_COMPRESSION_STATE:
5090             WARN("STUB: FSCTL_SET_VOLUME_COMPRESSION_STATE\n");
5091             Status = STATUS_INVALID_DEVICE_REQUEST;
5092             break;
5093
5094         case FSCTL_TXFS_MODIFY_RM:
5095             WARN("STUB: FSCTL_TXFS_MODIFY_RM\n");
5096             Status = STATUS_INVALID_DEVICE_REQUEST;
5097             break;
5098
5099         case FSCTL_TXFS_QUERY_RM_INFORMATION:
5100             WARN("STUB: FSCTL_TXFS_QUERY_RM_INFORMATION\n");
5101             Status = STATUS_INVALID_DEVICE_REQUEST;
5102             break;
5103
5104         case FSCTL_TXFS_ROLLFORWARD_REDO:
5105             WARN("STUB: FSCTL_TXFS_ROLLFORWARD_REDO\n");
5106             Status = STATUS_INVALID_DEVICE_REQUEST;
5107             break;
5108
5109         case FSCTL_TXFS_ROLLFORWARD_UNDO:
5110             WARN("STUB: FSCTL_TXFS_ROLLFORWARD_UNDO\n");
5111             Status = STATUS_INVALID_DEVICE_REQUEST;
5112             break;
5113
5114         case FSCTL_TXFS_START_RM:
5115             WARN("STUB: FSCTL_TXFS_START_RM\n");
5116             Status = STATUS_INVALID_DEVICE_REQUEST;
5117             break;
5118
5119         case FSCTL_TXFS_SHUTDOWN_RM:
5120             WARN("STUB: FSCTL_TXFS_SHUTDOWN_RM\n");
5121             Status = STATUS_INVALID_DEVICE_REQUEST;
5122             break;
5123
5124         case FSCTL_TXFS_READ_BACKUP_INFORMATION:
5125             WARN("STUB: FSCTL_TXFS_READ_BACKUP_INFORMATION\n");
5126             Status = STATUS_INVALID_DEVICE_REQUEST;
5127             break;
5128
5129         case FSCTL_TXFS_WRITE_BACKUP_INFORMATION:
5130             WARN("STUB: FSCTL_TXFS_WRITE_BACKUP_INFORMATION\n");
5131             Status = STATUS_INVALID_DEVICE_REQUEST;
5132             break;
5133
5134         case FSCTL_TXFS_CREATE_SECONDARY_RM:
5135             WARN("STUB: FSCTL_TXFS_CREATE_SECONDARY_RM\n");
5136             Status = STATUS_INVALID_DEVICE_REQUEST;
5137             break;
5138
5139         case FSCTL_TXFS_GET_METADATA_INFO:
5140             WARN("STUB: FSCTL_TXFS_GET_METADATA_INFO\n");
5141             Status = STATUS_INVALID_DEVICE_REQUEST;
5142             break;
5143
5144         case FSCTL_TXFS_GET_TRANSACTED_VERSION:
5145             WARN("STUB: FSCTL_TXFS_GET_TRANSACTED_VERSION\n");
5146             Status = STATUS_INVALID_DEVICE_REQUEST;
5147             break;
5148
5149         case FSCTL_TXFS_SAVEPOINT_INFORMATION:
5150             WARN("STUB: FSCTL_TXFS_SAVEPOINT_INFORMATION\n");
5151             Status = STATUS_INVALID_DEVICE_REQUEST;
5152             break;
5153
5154         case FSCTL_TXFS_CREATE_MINIVERSION:
5155             WARN("STUB: FSCTL_TXFS_CREATE_MINIVERSION\n");
5156             Status = STATUS_INVALID_DEVICE_REQUEST;
5157             break;
5158
5159         case FSCTL_TXFS_TRANSACTION_ACTIVE:
5160             WARN("STUB: FSCTL_TXFS_TRANSACTION_ACTIVE\n");
5161             Status = STATUS_INVALID_DEVICE_REQUEST;
5162             break;
5163
5164         case FSCTL_SET_ZERO_ON_DEALLOCATION:
5165             WARN("STUB: FSCTL_SET_ZERO_ON_DEALLOCATION\n");
5166             Status = STATUS_INVALID_DEVICE_REQUEST;
5167             break;
5168
5169         case FSCTL_SET_REPAIR:
5170             WARN("STUB: FSCTL_SET_REPAIR\n");
5171             Status = STATUS_INVALID_DEVICE_REQUEST;
5172             break;
5173
5174         case FSCTL_GET_REPAIR:
5175             WARN("STUB: FSCTL_GET_REPAIR\n");
5176             Status = STATUS_INVALID_DEVICE_REQUEST;
5177             break;
5178
5179         case FSCTL_WAIT_FOR_REPAIR:
5180             WARN("STUB: FSCTL_WAIT_FOR_REPAIR\n");
5181             Status = STATUS_INVALID_DEVICE_REQUEST;
5182             break;
5183
5184         case FSCTL_INITIATE_REPAIR:
5185             WARN("STUB: FSCTL_INITIATE_REPAIR\n");
5186             Status = STATUS_INVALID_DEVICE_REQUEST;
5187             break;
5188
5189         case FSCTL_CSC_INTERNAL:
5190             WARN("STUB: FSCTL_CSC_INTERNAL\n");
5191             Status = STATUS_INVALID_DEVICE_REQUEST;
5192             break;
5193
5194         case FSCTL_SHRINK_VOLUME:
5195             WARN("STUB: FSCTL_SHRINK_VOLUME\n");
5196             Status = STATUS_INVALID_DEVICE_REQUEST;
5197             break;
5198
5199         case FSCTL_SET_SHORT_NAME_BEHAVIOR:
5200             WARN("STUB: FSCTL_SET_SHORT_NAME_BEHAVIOR\n");
5201             Status = STATUS_INVALID_DEVICE_REQUEST;
5202             break;
5203
5204         case FSCTL_DFSR_SET_GHOST_HANDLE_STATE:
5205             WARN("STUB: FSCTL_DFSR_SET_GHOST_HANDLE_STATE\n");
5206             Status = STATUS_INVALID_DEVICE_REQUEST;
5207             break;
5208
5209         case FSCTL_TXFS_LIST_TRANSACTION_LOCKED_FILES:
5210             WARN("STUB: FSCTL_TXFS_LIST_TRANSACTION_LOCKED_FILES\n");
5211             Status = STATUS_INVALID_DEVICE_REQUEST;
5212             break;
5213
5214         case FSCTL_TXFS_LIST_TRANSACTIONS:
5215             WARN("STUB: FSCTL_TXFS_LIST_TRANSACTIONS\n");
5216             Status = STATUS_INVALID_DEVICE_REQUEST;
5217             break;
5218
5219         case FSCTL_QUERY_PAGEFILE_ENCRYPTION:
5220             WARN("STUB: FSCTL_QUERY_PAGEFILE_ENCRYPTION\n");
5221             Status = STATUS_INVALID_DEVICE_REQUEST;
5222             break;
5223
5224         case FSCTL_RESET_VOLUME_ALLOCATION_HINTS:
5225             WARN("STUB: FSCTL_RESET_VOLUME_ALLOCATION_HINTS\n");
5226             Status = STATUS_INVALID_DEVICE_REQUEST;
5227             break;
5228
5229         case FSCTL_TXFS_READ_BACKUP_INFORMATION2:
5230             WARN("STUB: FSCTL_TXFS_READ_BACKUP_INFORMATION2\n");
5231             Status = STATUS_INVALID_DEVICE_REQUEST;
5232             break;
5233
5234         case FSCTL_CSV_CONTROL:
5235             WARN("STUB: FSCTL_CSV_CONTROL\n");
5236             Status = STATUS_INVALID_DEVICE_REQUEST;
5237             break;
5238 #endif
5239         // TRACE rather than WARN because Windows 10 spams this undocumented fsctl
5240         case FSCTL_QUERY_VOLUME_CONTAINER_STATE:
5241             TRACE("STUB: FSCTL_QUERY_VOLUME_CONTAINER_STATE\n");
5242             Status = STATUS_INVALID_DEVICE_REQUEST;
5243             break;
5244
5245         case FSCTL_GET_INTEGRITY_INFORMATION:
5246             Status = get_integrity_information(DeviceObject->DeviceExtension, IrpSp->FileObject, map_user_buffer(Irp, NormalPagePriority),
5247                                                IrpSp->Parameters.FileSystemControl.OutputBufferLength);
5248             break;
5249
5250         case FSCTL_SET_INTEGRITY_INFORMATION:
5251             Status = set_integrity_information(IrpSp->FileObject, Irp->AssociatedIrp.SystemBuffer, IrpSp->Parameters.FileSystemControl.InputBufferLength);
5252             break;
5253
5254         case FSCTL_DUPLICATE_EXTENTS_TO_FILE:
5255             Status = duplicate_extents(DeviceObject->DeviceExtension, IrpSp->FileObject, Irp->AssociatedIrp.SystemBuffer,
5256                                        IrpSp->Parameters.FileSystemControl.InputBufferLength, Irp);
5257             break;
5258
5259         case FSCTL_BTRFS_GET_FILE_IDS:
5260             Status = get_file_ids(IrpSp->FileObject, map_user_buffer(Irp, NormalPagePriority), IrpSp->Parameters.FileSystemControl.OutputBufferLength);
5261             break;
5262
5263         case FSCTL_BTRFS_CREATE_SUBVOL:
5264             Status = create_subvol(DeviceObject->DeviceExtension, IrpSp->FileObject, Irp->AssociatedIrp.SystemBuffer, IrpSp->Parameters.FileSystemControl.InputBufferLength, Irp);
5265             break;
5266
5267         case FSCTL_BTRFS_CREATE_SNAPSHOT:
5268             Status = create_snapshot(DeviceObject->DeviceExtension, IrpSp->FileObject, Irp->AssociatedIrp.SystemBuffer, IrpSp->Parameters.FileSystemControl.InputBufferLength, Irp);
5269             break;
5270
5271         case FSCTL_BTRFS_GET_INODE_INFO:
5272             Status = get_inode_info(IrpSp->FileObject, map_user_buffer(Irp, NormalPagePriority), IrpSp->Parameters.FileSystemControl.OutputBufferLength);
5273             break;
5274
5275         case FSCTL_BTRFS_SET_INODE_INFO:
5276             Status = set_inode_info(IrpSp->FileObject, Irp->AssociatedIrp.SystemBuffer, IrpSp->Parameters.FileSystemControl.InputBufferLength, Irp);
5277             break;
5278
5279         case FSCTL_BTRFS_GET_DEVICES:
5280             Status = get_devices(DeviceObject->DeviceExtension, map_user_buffer(Irp, NormalPagePriority), IrpSp->Parameters.FileSystemControl.OutputBufferLength);
5281             break;
5282
5283         case FSCTL_BTRFS_GET_USAGE:
5284             Status = get_usage(DeviceObject->DeviceExtension, map_user_buffer(Irp, NormalPagePriority), IrpSp->Parameters.FileSystemControl.OutputBufferLength, Irp);
5285             break;
5286
5287         case FSCTL_BTRFS_START_BALANCE:
5288             Status = start_balance(DeviceObject->DeviceExtension, Irp->AssociatedIrp.SystemBuffer, IrpSp->Parameters.FileSystemControl.InputBufferLength, Irp->RequestorMode);
5289             break;
5290
5291         case FSCTL_BTRFS_QUERY_BALANCE:
5292             Status = query_balance(DeviceObject->DeviceExtension, map_user_buffer(Irp, NormalPagePriority), IrpSp->Parameters.FileSystemControl.OutputBufferLength);
5293             break;
5294
5295         case FSCTL_BTRFS_PAUSE_BALANCE:
5296             Status = pause_balance(DeviceObject->DeviceExtension, Irp->RequestorMode);
5297             break;
5298
5299         case FSCTL_BTRFS_RESUME_BALANCE:
5300             Status = resume_balance(DeviceObject->DeviceExtension, Irp->RequestorMode);
5301             break;
5302
5303         case FSCTL_BTRFS_STOP_BALANCE:
5304             Status = stop_balance(DeviceObject->DeviceExtension, Irp->RequestorMode);
5305             break;
5306
5307         case FSCTL_BTRFS_ADD_DEVICE:
5308             Status = add_device(DeviceObject->DeviceExtension, Irp, Irp->RequestorMode);
5309             break;
5310
5311         case FSCTL_BTRFS_REMOVE_DEVICE:
5312             Status = remove_device(DeviceObject->DeviceExtension, Irp->AssociatedIrp.SystemBuffer, IrpSp->Parameters.FileSystemControl.InputBufferLength, Irp->RequestorMode);
5313             break;
5314
5315         case FSCTL_BTRFS_GET_UUID:
5316             Status = query_uuid(DeviceObject->DeviceExtension, map_user_buffer(Irp, NormalPagePriority), IrpSp->Parameters.FileSystemControl.OutputBufferLength);
5317             break;
5318
5319         case FSCTL_BTRFS_START_SCRUB:
5320             Status = start_scrub(DeviceObject->DeviceExtension, Irp->RequestorMode);
5321             break;
5322
5323         case FSCTL_BTRFS_QUERY_SCRUB:
5324             Status = query_scrub(DeviceObject->DeviceExtension, Irp->RequestorMode, map_user_buffer(Irp, NormalPagePriority), IrpSp->Parameters.FileSystemControl.OutputBufferLength);
5325             break;
5326
5327         case FSCTL_BTRFS_PAUSE_SCRUB:
5328             Status = pause_scrub(DeviceObject->DeviceExtension, Irp->RequestorMode);
5329             break;
5330
5331         case FSCTL_BTRFS_RESUME_SCRUB:
5332             Status = resume_scrub(DeviceObject->DeviceExtension, Irp->RequestorMode);
5333             break;
5334
5335         case FSCTL_BTRFS_STOP_SCRUB:
5336             Status = stop_scrub(DeviceObject->DeviceExtension, Irp->RequestorMode);
5337             break;
5338
5339         case FSCTL_BTRFS_RESET_STATS:
5340             Status = reset_stats(DeviceObject->DeviceExtension, Irp->AssociatedIrp.SystemBuffer, IrpSp->Parameters.FileSystemControl.InputBufferLength, Irp->RequestorMode);
5341             break;
5342
5343         case FSCTL_BTRFS_MKNOD:
5344             Status = mknod(DeviceObject->DeviceExtension, IrpSp->FileObject, Irp->AssociatedIrp.SystemBuffer, IrpSp->Parameters.FileSystemControl.InputBufferLength, Irp);
5345             break;
5346
5347         case FSCTL_BTRFS_RECEIVED_SUBVOL:
5348             Status = recvd_subvol(DeviceObject->DeviceExtension, IrpSp->FileObject, Irp->AssociatedIrp.SystemBuffer,
5349                                   IrpSp->Parameters.FileSystemControl.InputBufferLength, Irp->RequestorMode);
5350             break;
5351
5352         case FSCTL_BTRFS_GET_XATTRS:
5353             Status = fsctl_get_xattrs(DeviceObject->DeviceExtension, IrpSp->FileObject, Irp->UserBuffer, IrpSp->Parameters.FileSystemControl.OutputBufferLength, Irp->RequestorMode);
5354             break;
5355
5356         case FSCTL_BTRFS_SET_XATTR:
5357             Status = fsctl_set_xattr(DeviceObject->DeviceExtension, IrpSp->FileObject, Irp->AssociatedIrp.SystemBuffer,
5358                                      IrpSp->Parameters.FileSystemControl.InputBufferLength, Irp);
5359             break;
5360
5361         case FSCTL_BTRFS_RESERVE_SUBVOL:
5362             Status = reserve_subvol(DeviceObject->DeviceExtension, IrpSp->FileObject, Irp);
5363             break;
5364
5365         case FSCTL_BTRFS_FIND_SUBVOL:
5366             Status = find_subvol(DeviceObject->DeviceExtension, Irp->AssociatedIrp.SystemBuffer, IrpSp->Parameters.FileSystemControl.InputBufferLength,
5367                                  Irp->UserBuffer, IrpSp->Parameters.FileSystemControl.OutputBufferLength, Irp);
5368             break;
5369
5370         case FSCTL_BTRFS_SEND_SUBVOL:
5371             Status = send_subvol(DeviceObject->DeviceExtension, Irp->AssociatedIrp.SystemBuffer, IrpSp->Parameters.FileSystemControl.InputBufferLength,
5372                                  IrpSp->FileObject, Irp);
5373             break;
5374
5375         case FSCTL_BTRFS_READ_SEND_BUFFER:
5376             Status = read_send_buffer(DeviceObject->DeviceExtension, IrpSp->FileObject, map_user_buffer(Irp, NormalPagePriority), IrpSp->Parameters.FileSystemControl.OutputBufferLength,
5377                                       &Irp->IoStatus.Information, Irp->RequestorMode);
5378             break;
5379
5380         case FSCTL_BTRFS_RESIZE:
5381             Status = resize_device(DeviceObject->DeviceExtension, Irp->AssociatedIrp.SystemBuffer,
5382                                    IrpSp->Parameters.FileSystemControl.InputBufferLength, Irp);
5383             break;
5384
5385         default:
5386             WARN("unknown control code %x (DeviceType = %x, Access = %x, Function = %x, Method = %x)\n",
5387                           IrpSp->Parameters.FileSystemControl.FsControlCode, (IrpSp->Parameters.FileSystemControl.FsControlCode & 0xff0000) >> 16,
5388                           (IrpSp->Parameters.FileSystemControl.FsControlCode & 0xc000) >> 14, (IrpSp->Parameters.FileSystemControl.FsControlCode & 0x3ffc) >> 2,
5389                           IrpSp->Parameters.FileSystemControl.FsControlCode & 0x3);
5390             Status = STATUS_INVALID_DEVICE_REQUEST;
5391             break;
5392     }
5393
5394     return Status;
5395 }