drivers/filesystems/btrfs/reparse.c

   1 /* Copyright (c) Mark Harmstone 2016-17
   2  *
   3  * This file is part of WinBtrfs.
   4  *
   5  * WinBtrfs is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU Lesser General Public Licence as published by
   7  * the Free Software Foundation, either version 3 of the Licence, or
   8  * (at your option) any later version.
   9  *
  10  * WinBtrfs is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU Lesser General Public Licence for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public Licence
  16  * along with WinBtrfs.  If not, see <http://www.gnu.org/licenses/>. */
  17
  18 #include "btrfs_drv.h"
  19
  20 NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject, void* buffer, DWORD buflen, ULONG_PTR* retlen) {
  21     USHORT subnamelen, printnamelen, i;
  22     ULONG stringlen;
  23     DWORD reqlen;
  24     REPARSE_DATA_BUFFER* rdb = buffer;
  25     fcb* fcb = FileObject->FsContext;
  26     ccb* ccb = FileObject->FsContext2;
  27     NTSTATUS Status;
  28
  29     TRACE("(%p, %p, %p, %x, %p)\n", DeviceObject, FileObject, buffer, buflen, retlen);
  30
  31     if (!ccb)
  32         return STATUS_INVALID_PARAMETER;
  33
  34     ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, TRUE);
  35     ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
  36
  37     if (fcb->type == BTRFS_TYPE_SYMLINK) {
  38         if (ccb->lxss) {
  39             reqlen = offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) + sizeof(UINT32);
  40
  41             if (buflen < reqlen) {
  42                 Status = STATUS_BUFFER_OVERFLOW;
  43                 goto end;
  44             }
  45
  46             rdb->ReparseTag = IO_REPARSE_TAG_LXSS_SYMLINK;
  47             rdb->ReparseDataLength = offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) + sizeof(UINT32);
  48             rdb->Reserved = 0;
  49
  50             *((UINT32*)rdb->GenericReparseBuffer.DataBuffer) = 1;
  51
  52             *retlen = reqlen;
  53         } else {
  54             char* data;
  55
  56             if (fcb->inode_item.st_size == 0 || fcb->inode_item.st_size > 0xffff) {
  57                 Status = STATUS_INVALID_PARAMETER;
  58                 goto end;
  59             }
  60
  61             data = ExAllocatePoolWithTag(PagedPool, (ULONG)fcb->inode_item.st_size, ALLOC_TAG);
  62             if (!data) {
  63                 ERR("out of memory\n");
  64                 Status = STATUS_INSUFFICIENT_RESOURCES;
  65                 goto end;
  66             }
  67
  68             TRACE("data = %p, size = %x\n", data, fcb->inode_item.st_size);
  69             Status = read_file(fcb, (UINT8*)data, 0, fcb->inode_item.st_size, NULL, NULL);
  70
  71             if (!NT_SUCCESS(Status)) {
  72                 ERR("read_file returned %08x\n", Status);
  73                 ExFreePool(data);
  74                 goto end;
  75             }
  76
  77             Status = RtlUTF8ToUnicodeN(NULL, 0, &stringlen, data, (ULONG)fcb->inode_item.st_size);
  78             if (!NT_SUCCESS(Status)) {
  79                 ERR("RtlUTF8ToUnicodeN 1 returned %08x\n", Status);
  80                 ExFreePool(data);
  81                 goto end;
  82             }
  83
  84             subnamelen = (UINT16)stringlen;
  85             printnamelen = (UINT16)stringlen;
  86
  87             reqlen = offsetof(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer) + subnamelen + printnamelen;
  88
  89             if (buflen >= offsetof(REPARSE_DATA_BUFFER, ReparseDataLength))
  90                 rdb->ReparseTag = IO_REPARSE_TAG_SYMLINK;
  91
  92             if (buflen >= offsetof(REPARSE_DATA_BUFFER, Reserved))
  93                 rdb->ReparseDataLength = (USHORT)(reqlen - offsetof(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer));
  94
  95             if (buflen >= offsetof(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.SubstituteNameOffset))
  96                 rdb->Reserved = 0;
  97
  98             if (buflen < reqlen) {
  99                 ExFreePool(data);
 100                 Status = STATUS_BUFFER_OVERFLOW;
 101                 *retlen = min(buflen, offsetof(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.SubstituteNameOffset));
 102                 goto end;
 103             }
 104
 105             rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset = 0;
 106             rdb->SymbolicLinkReparseBuffer.SubstituteNameLength = subnamelen;
 107             rdb->SymbolicLinkReparseBuffer.PrintNameOffset = subnamelen;
 108             rdb->SymbolicLinkReparseBuffer.PrintNameLength = printnamelen;
 109             rdb->SymbolicLinkReparseBuffer.Flags = SYMLINK_FLAG_RELATIVE;
 110
 111             Status = RtlUTF8ToUnicodeN(&rdb->SymbolicLinkReparseBuffer.PathBuffer[rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)],
 112                                        stringlen, &stringlen, data, (ULONG)fcb->inode_item.st_size);
 113
 114             if (!NT_SUCCESS(Status)) {
 115                 ERR("RtlUTF8ToUnicodeN 2 returned %08x\n", Status);
 116                 ExFreePool(data);
 117                 goto end;
 118             }
 119
 120             for (i = 0; i < stringlen / sizeof(WCHAR); i++) {
 121                 if (rdb->SymbolicLinkReparseBuffer.PathBuffer[(rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)) + i] == '/')
 122                     rdb->SymbolicLinkReparseBuffer.PathBuffer[(rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)) + i] = '\\';
 123             }
 124
 125             RtlCopyMemory(&rdb->SymbolicLinkReparseBuffer.PathBuffer[rdb->SymbolicLinkReparseBuffer.PrintNameOffset / sizeof(WCHAR)],
 126                         &rdb->SymbolicLinkReparseBuffer.PathBuffer[rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)],
 127                         rdb->SymbolicLinkReparseBuffer.SubstituteNameLength);
 128
 129             *retlen = reqlen;
 130
 131             ExFreePool(data);
 132         }
 133
 134         Status = STATUS_SUCCESS;
 135     } else if (fcb->atts & FILE_ATTRIBUTE_REPARSE_POINT) {
 136         if (fcb->type == BTRFS_TYPE_FILE) {
 137             ULONG len;
 138
 139             Status = read_file(fcb, buffer, 0, buflen, &len, NULL);
 140
 141             if (!NT_SUCCESS(Status)) {
 142                 ERR("read_file returned %08x\n", Status);
 143             }
 144
 145             *retlen = len;
 146         } else if (fcb->type == BTRFS_TYPE_DIRECTORY) {
 147             if (!fcb->reparse_xattr.Buffer || fcb->reparse_xattr.Length < sizeof(ULONG)) {
 148                 Status = STATUS_NOT_A_REPARSE_POINT;
 149                 goto end;
 150             }
 151
 152             if (buflen > 0) {
 153                 *retlen = min(buflen, fcb->reparse_xattr.Length);
 154                 RtlCopyMemory(buffer, fcb->reparse_xattr.Buffer, *retlen);
 155             } else
 156                 *retlen = 0;
 157
 158             Status = *retlen == fcb->reparse_xattr.Length ? STATUS_SUCCESS : STATUS_BUFFER_OVERFLOW;
 159         } else
 160             Status = STATUS_NOT_A_REPARSE_POINT;
 161     } else {
 162         Status = STATUS_NOT_A_REPARSE_POINT;
 163     }
 164
 165 end:
 166     ExReleaseResourceLite(fcb->Header.Resource);
 167     ExReleaseResourceLite(&fcb->Vcb->tree_lock);
 168
 169     return Status;
 170 }
 171
 172 static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, ccb* ccb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, BOOL write, LIST_ENTRY* rollback) {
 173     NTSTATUS Status;
 174     ULONG minlen;
 175     ULONG tlength;
 176     UNICODE_STRING subname;
 177     ANSI_STRING target;
 178     LARGE_INTEGER offset, time;
 179     BTRFS_TIME now;
 180     USHORT i;
 181
 182     if (write) {
 183         minlen = offsetof(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer) + sizeof(WCHAR);
 184         if (buflen < minlen) {
 185             WARN("buffer was less than minimum length (%u < %u)\n", buflen, minlen);
 186             return STATUS_INVALID_PARAMETER;
 187         }
 188
 189         if (rdb->SymbolicLinkReparseBuffer.SubstituteNameLength < sizeof(WCHAR)) {
 190             WARN("rdb->SymbolicLinkReparseBuffer.SubstituteNameLength was too short\n");
 191             return STATUS_INVALID_PARAMETER;
 192         }
 193
 194         subname.Buffer = &rdb->SymbolicLinkReparseBuffer.PathBuffer[rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)];
 195         subname.MaximumLength = subname.Length = rdb->SymbolicLinkReparseBuffer.SubstituteNameLength;
 196
 197         TRACE("substitute name = %.*S\n", subname.Length / sizeof(WCHAR), subname.Buffer);
 198     }
 199
 200     fileref->fcb->type = BTRFS_TYPE_SYMLINK;
 201     fileref->fcb->inode_item.st_mode |= __S_IFLNK;
 202     fileref->fcb->inode_item.generation = fileref->fcb->Vcb->superblock.generation; // so we don't confuse btrfs send on Linux
 203
 204     if (fileref->dc)
 205         fileref->dc->type = fileref->fcb->type;
 206
 207     if (write) {
 208         Status = truncate_file(fileref->fcb, 0, Irp, rollback);
 209         if (!NT_SUCCESS(Status)) {
 210             ERR("truncate_file returned %08x\n", Status);
 211             return Status;
 212         }
 213
 214         Status = RtlUnicodeToUTF8N(NULL, 0, (PULONG)&target.Length, subname.Buffer, subname.Length);
 215         if (!NT_SUCCESS(Status)) {
 216             ERR("RtlUnicodeToUTF8N 1 failed with error %08x\n", Status);
 217             return Status;
 218         }
 219
 220         target.MaximumLength = target.Length;
 221         target.Buffer = ExAllocatePoolWithTag(PagedPool, target.MaximumLength, ALLOC_TAG);
 222         if (!target.Buffer) {
 223             ERR("out of memory\n");
 224             return STATUS_INSUFFICIENT_RESOURCES;
 225         }
 226
 227         Status = RtlUnicodeToUTF8N(target.Buffer, target.Length, (PULONG)&target.Length, subname.Buffer, subname.Length);
 228         if (!NT_SUCCESS(Status)) {
 229             ERR("RtlUnicodeToUTF8N 2 failed with error %08x\n", Status);
 230             ExFreePool(target.Buffer);
 231             return Status;
 232         }
 233
 234         for (i = 0; i < target.MaximumLength; i++) {
 235             if (target.Buffer[i] == '\\')
 236                 target.Buffer[i] = '/';
 237         }
 238
 239         offset.QuadPart = 0;
 240         tlength = target.Length;
 241         Status = write_file2(fileref->fcb->Vcb, Irp, offset, target.Buffer, &tlength, FALSE, TRUE,
 242                              TRUE, FALSE, FALSE, rollback);
 243         ExFreePool(target.Buffer);
 244     } else
 245         Status = STATUS_SUCCESS;
 246
 247     KeQuerySystemTime(&time);
 248     win_time_to_unix(time, &now);
 249
 250     fileref->fcb->inode_item.transid = fileref->fcb->Vcb->superblock.generation;
 251     fileref->fcb->inode_item.sequence++;
 252
 253     if (!ccb->user_set_change_time)
 254         fileref->fcb->inode_item.st_ctime = now;
 255
 256     if (!ccb->user_set_write_time)
 257         fileref->fcb->inode_item.st_mtime = now;
 258
 259     fileref->fcb->subvol->root_item.ctransid = fileref->fcb->Vcb->superblock.generation;
 260     fileref->fcb->subvol->root_item.ctime = now;
 261
 262     fileref->fcb->inode_item_changed = TRUE;
 263     mark_fcb_dirty(fileref->fcb);
 264
 265     mark_fileref_dirty(fileref);
 266
 267     return Status;
 268 }
 269
 270 NTSTATUS set_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
 271     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
 272     PFILE_OBJECT FileObject = IrpSp->FileObject;
 273     void* buffer = Irp->AssociatedIrp.SystemBuffer;
 274     REPARSE_DATA_BUFFER* rdb = buffer;
 275     DWORD buflen = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
 276     NTSTATUS Status = STATUS_SUCCESS;
 277     fcb* fcb;
 278     ccb* ccb;
 279     file_ref* fileref;
 280     ULONG tag;
 281     LIST_ENTRY rollback;
 282
 283     TRACE("(%p, %p)\n", DeviceObject, Irp);
 284
 285     InitializeListHead(&rollback);
 286
 287     if (!FileObject) {
 288         ERR("FileObject was NULL\n");
 289         return STATUS_INVALID_PARAMETER;
 290     }
 291
 292     // IFSTest insists on this, for some reason...
 293     if (Irp->UserBuffer)
 294         return STATUS_INVALID_PARAMETER;
 295
 296     fcb = FileObject->FsContext;
 297     ccb = FileObject->FsContext2;
 298
 299     if (!ccb) {
 300         ERR("ccb was NULL\n");
 301         return STATUS_INVALID_PARAMETER;
 302     }
 303
 304     if (Irp->RequestorMode == UserMode && !(ccb->access & (FILE_WRITE_ATTRIBUTES | FILE_WRITE_DATA))) {
 305         WARN("insufficient privileges\n");
 306         return STATUS_ACCESS_DENIED;
 307     }
 308
 309     fileref = ccb->fileref;
 310
 311     if (!fileref) {
 312         ERR("fileref was NULL\n");
 313         return STATUS_INVALID_PARAMETER;
 314     }
 315
 316     if (fcb->ads) {
 317         fileref = fileref->parent;
 318         fcb = fileref->fcb;
 319     }
 320
 321     TRACE("%S\n", file_desc(FileObject));
 322
 323     ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, TRUE);
 324     ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
 325
 326     if (fcb->type == BTRFS_TYPE_SYMLINK) {
 327         WARN("tried to set a reparse point on an existing symlink\n");
 328         Status = STATUS_INVALID_PARAMETER;
 329         goto end;
 330     }
 331
 332     // FIXME - fail if we already have the attribute FILE_ATTRIBUTE_REPARSE_POINT
 333
 334     // FIXME - die if not file or directory
 335
 336     if (buflen < sizeof(ULONG)) {
 337         WARN("buffer was not long enough to hold tag\n");
 338         Status = STATUS_INVALID_BUFFER_SIZE;
 339         goto end;
 340     }
 341
 342     Status = FsRtlValidateReparsePointBuffer(buflen, rdb);
 343     if (!NT_SUCCESS(Status)) {
 344         ERR("FsRtlValidateReparsePointBuffer returned %08x\n", Status);
 345         goto end;
 346     }
 347
 348     RtlCopyMemory(&tag, buffer, sizeof(ULONG));
 349
 350     if (fcb->type == BTRFS_TYPE_FILE &&
 351         ((tag == IO_REPARSE_TAG_SYMLINK && rdb->SymbolicLinkReparseBuffer.Flags & SYMLINK_FLAG_RELATIVE) || tag == IO_REPARSE_TAG_LXSS_SYMLINK)) {
 352         Status = set_symlink(Irp, fileref, ccb, rdb, buflen, tag == IO_REPARSE_TAG_SYMLINK, &rollback);
 353         fcb->atts |= FILE_ATTRIBUTE_REPARSE_POINT;
 354     } else {
 355         LARGE_INTEGER offset, time;
 356         BTRFS_TIME now;
 357
 358         if (fcb->type == BTRFS_TYPE_DIRECTORY) { // for directories, store as xattr
 359             ANSI_STRING buf;
 360
 361             buf.Buffer = ExAllocatePoolWithTag(PagedPool, buflen, ALLOC_TAG);
 362             if (!buf.Buffer) {
 363                 ERR("out of memory\n");
 364                 Status = STATUS_INSUFFICIENT_RESOURCES;
 365                 goto end;
 366             }
 367             buf.Length = buf.MaximumLength = (UINT16)buflen;
 368
 369             if (fcb->reparse_xattr.Buffer)
 370                 ExFreePool(fcb->reparse_xattr.Buffer);
 371
 372             fcb->reparse_xattr = buf;
 373             RtlCopyMemory(buf.Buffer, buffer, buflen);
 374
 375             fcb->reparse_xattr_changed = TRUE;
 376
 377             Status = STATUS_SUCCESS;
 378         } else { // otherwise, store as file data
 379             Status = truncate_file(fcb, 0, Irp, &rollback);
 380             if (!NT_SUCCESS(Status)) {
 381                 ERR("truncate_file returned %08x\n", Status);
 382                 goto end;
 383             }
 384
 385             offset.QuadPart = 0;
 386
 387             Status = write_file2(fcb->Vcb, Irp, offset, buffer, &buflen, FALSE, TRUE, TRUE, FALSE, FALSE, &rollback);
 388             if (!NT_SUCCESS(Status)) {
 389                 ERR("write_file2 returned %08x\n", Status);
 390                 goto end;
 391             }
 392         }
 393
 394         KeQuerySystemTime(&time);
 395         win_time_to_unix(time, &now);
 396
 397         fcb->inode_item.transid = fcb->Vcb->superblock.generation;
 398         fcb->inode_item.sequence++;
 399
 400         if (!ccb->user_set_change_time)
 401             fcb->inode_item.st_ctime = now;
 402
 403         if (!ccb->user_set_write_time)
 404             fcb->inode_item.st_mtime = now;
 405
 406         fcb->atts |= FILE_ATTRIBUTE_REPARSE_POINT;
 407         fcb->atts_changed = TRUE;
 408
 409         fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
 410         fcb->subvol->root_item.ctime = now;
 411
 412         fcb->inode_item_changed = TRUE;
 413         mark_fcb_dirty(fcb);
 414     }
 415
 416     send_notification_fcb(fileref, FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_ATTRIBUTES, FILE_ACTION_MODIFIED, NULL);
 417
 418 end:
 419     if (NT_SUCCESS(Status))
 420         clear_rollback(&rollback);
 421     else
 422         do_rollback(fcb->Vcb, &rollback);
 423
 424     ExReleaseResourceLite(fcb->Header.Resource);
 425     ExReleaseResourceLite(&fcb->Vcb->tree_lock);
 426
 427     return Status;
 428 }
 429
 430 NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
 431     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
 432     PFILE_OBJECT FileObject = IrpSp->FileObject;
 433     REPARSE_DATA_BUFFER* rdb = Irp->AssociatedIrp.SystemBuffer;
 434     DWORD buflen = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
 435     NTSTATUS Status;
 436     fcb* fcb;
 437     ccb* ccb;
 438     file_ref* fileref;
 439     LIST_ENTRY rollback;
 440
 441     TRACE("(%p, %p)\n", DeviceObject, Irp);
 442
 443     InitializeListHead(&rollback);
 444
 445     if (!FileObject) {
 446         ERR("FileObject was NULL\n");
 447         return STATUS_INVALID_PARAMETER;
 448     }
 449
 450     fcb = FileObject->FsContext;
 451
 452     if (!fcb) {
 453         ERR("fcb was NULL\n");
 454         return STATUS_INVALID_PARAMETER;
 455     }
 456
 457     ccb = FileObject->FsContext2;
 458
 459     if (!ccb) {
 460         ERR("ccb was NULL\n");
 461         return STATUS_INVALID_PARAMETER;
 462     }
 463
 464     if (Irp->RequestorMode == UserMode && !(ccb->access & FILE_WRITE_ATTRIBUTES)) {
 465         WARN("insufficient privileges\n");
 466         return STATUS_ACCESS_DENIED;
 467     }
 468
 469     fileref = ccb->fileref;
 470
 471     if (!fileref) {
 472         ERR("fileref was NULL\n");
 473         return STATUS_INVALID_PARAMETER;
 474     }
 475
 476     ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, TRUE);
 477     ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
 478
 479     TRACE("%S\n", file_desc(FileObject));
 480
 481     if (buflen < offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer)) {
 482         ERR("buffer was too short\n");
 483         Status = STATUS_INVALID_PARAMETER;
 484         goto end;
 485     }
 486
 487     if (rdb->ReparseDataLength > 0) {
 488         WARN("rdb->ReparseDataLength was not zero\n");
 489         Status = STATUS_INVALID_PARAMETER;
 490         goto end;
 491     }
 492
 493     if (fcb->ads) {
 494         WARN("tried to delete reparse point on ADS\n");
 495         Status = STATUS_INVALID_PARAMETER;
 496         goto end;
 497     }
 498
 499     if (fcb->type == BTRFS_TYPE_SYMLINK) {
 500         LARGE_INTEGER time;
 501         BTRFS_TIME now;
 502
 503         if (rdb->ReparseTag != IO_REPARSE_TAG_SYMLINK) {
 504             WARN("reparse tag was not IO_REPARSE_TAG_SYMLINK\n");
 505             Status = STATUS_INVALID_PARAMETER;
 506             goto end;
 507         }
 508
 509         KeQuerySystemTime(&time);
 510         win_time_to_unix(time, &now);
 511
 512         fileref->fcb->type = BTRFS_TYPE_FILE;
 513         fileref->fcb->inode_item.st_mode &= ~__S_IFLNK;
 514         fileref->fcb->inode_item.st_mode |= __S_IFREG;
 515         fileref->fcb->inode_item.generation = fileref->fcb->Vcb->superblock.generation; // so we don't confuse btrfs send on Linux
 516         fileref->fcb->inode_item.transid = fileref->fcb->Vcb->superblock.generation;
 517         fileref->fcb->inode_item.sequence++;
 518
 519         if (!ccb->user_set_change_time)
 520             fileref->fcb->inode_item.st_ctime = now;
 521
 522         if (!ccb->user_set_write_time)
 523             fileref->fcb->inode_item.st_mtime = now;
 524
 525         fileref->fcb->atts &= ~FILE_ATTRIBUTE_REPARSE_POINT;
 526
 527         if (fileref->dc)
 528             fileref->dc->type = fileref->fcb->type;
 529
 530         mark_fileref_dirty(fileref);
 531
 532         fileref->fcb->inode_item_changed = TRUE;
 533         mark_fcb_dirty(fileref->fcb);
 534
 535         fileref->fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
 536         fileref->fcb->subvol->root_item.ctime = now;
 537     } else if (fcb->type == BTRFS_TYPE_FILE) {
 538         LARGE_INTEGER time;
 539         BTRFS_TIME now;
 540
 541         // FIXME - do we need to check that the reparse tags match?
 542
 543         Status = truncate_file(fcb, 0, Irp, &rollback);
 544         if (!NT_SUCCESS(Status)) {
 545             ERR("truncate_file returned %08x\n", Status);
 546             goto end;
 547         }
 548
 549         fcb->atts &= ~FILE_ATTRIBUTE_REPARSE_POINT;
 550         fcb->atts_changed = TRUE;
 551
 552         KeQuerySystemTime(&time);
 553         win_time_to_unix(time, &now);
 554
 555         fcb->inode_item.transid = fcb->Vcb->superblock.generation;
 556         fcb->inode_item.sequence++;
 557
 558         if (!ccb->user_set_change_time)
 559             fcb->inode_item.st_ctime = now;
 560
 561         if (!ccb->user_set_write_time)
 562             fcb->inode_item.st_mtime = now;
 563
 564         fcb->inode_item_changed = TRUE;
 565         mark_fcb_dirty(fcb);
 566
 567         fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
 568         fcb->subvol->root_item.ctime = now;
 569     } else if (fcb->type == BTRFS_TYPE_DIRECTORY) {
 570         LARGE_INTEGER time;
 571         BTRFS_TIME now;
 572
 573         // FIXME - do we need to check that the reparse tags match?
 574
 575         fcb->atts &= ~FILE_ATTRIBUTE_REPARSE_POINT;
 576         fcb->atts_changed = TRUE;
 577
 578         if (fcb->reparse_xattr.Buffer) {
 579             ExFreePool(fcb->reparse_xattr.Buffer);
 580             fcb->reparse_xattr.Buffer = NULL;
 581         }
 582
 583         fcb->reparse_xattr_changed = TRUE;
 584
 585         KeQuerySystemTime(&time);
 586         win_time_to_unix(time, &now);
 587
 588         fcb->inode_item.transid = fcb->Vcb->superblock.generation;
 589         fcb->inode_item.sequence++;
 590
 591         if (!ccb->user_set_change_time)
 592             fcb->inode_item.st_ctime = now;
 593
 594         if (!ccb->user_set_write_time)
 595             fcb->inode_item.st_mtime = now;
 596
 597         fcb->inode_item_changed = TRUE;
 598         mark_fcb_dirty(fcb);
 599
 600         fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
 601         fcb->subvol->root_item.ctime = now;
 602     } else {
 603         ERR("unsupported file type %u\n", fcb->type);
 604         Status = STATUS_INVALID_PARAMETER;
 605         goto end;
 606     }
 607
 608     Status = STATUS_SUCCESS;
 609
 610     send_notification_fcb(fileref, FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_ATTRIBUTES, FILE_ACTION_MODIFIED, NULL);
 611
 612 end:
 613     if (NT_SUCCESS(Status))
 614         clear_rollback(&rollback);
 615     else
 616         do_rollback(fcb->Vcb, &rollback);
 617
 618     ExReleaseResourceLite(fcb->Header.Resource);
 619     ExReleaseResourceLite(&fcb->Vcb->tree_lock);
 620
 621     return Status;
 622 }