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