drivers/filesystems/btrfs/pnp.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 struct pnp_context;
  21
  22 typedef struct {
  23     struct pnp_context* context;
  24     PIRP Irp;
  25     IO_STATUS_BLOCK iosb;
  26     NTSTATUS Status;
  27     device* dev;
  28 } pnp_stripe;
  29
  30 typedef struct {
  31     KEVENT Event;
  32     NTSTATUS Status;
  33     LONG left;
  34     pnp_stripe* stripes;
  35 } pnp_context;
  36
  37 extern ERESOURCE pdo_list_lock;
  38 extern LIST_ENTRY pdo_list;
  39
  40 _Function_class_(IO_COMPLETION_ROUTINE)
  41 #ifdef __REACTOS__
  42 static NTSTATUS NTAPI pnp_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
  43 #else
  44 static NTSTATUS pnp_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
  45 #endif
  46     pnp_stripe* stripe = conptr;
  47     pnp_context* context = (pnp_context*)stripe->context;
  48
  49     UNUSED(DeviceObject);
  50
  51     stripe->Status = Irp->IoStatus.Status;
  52
  53     InterlockedDecrement(&context->left);
  54
  55     if (context->left == 0)
  56         KeSetEvent(&context->Event, 0, FALSE);
  57
  58     return STATUS_MORE_PROCESSING_REQUIRED;
  59 }
  60
  61 static NTSTATUS send_disks_pnp_message(device_extension* Vcb, UCHAR minor) {
  62     pnp_context context;
  63     ULONG num_devices, i;
  64     NTSTATUS Status;
  65     LIST_ENTRY* le;
  66
  67     RtlZeroMemory(&context, sizeof(pnp_context));
  68     KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
  69
  70     num_devices = (ULONG)min(0xffffffff, Vcb->superblock.num_devices);
  71
  72     context.stripes = ExAllocatePoolWithTag(NonPagedPool, sizeof(pnp_stripe) * num_devices, ALLOC_TAG);
  73     if (!context.stripes) {
  74         ERR("out of memory\n");
  75         return STATUS_INSUFFICIENT_RESOURCES;
  76     }
  77
  78     RtlZeroMemory(context.stripes, sizeof(pnp_stripe) * num_devices);
  79
  80     i = 0;
  81     le = Vcb->devices.Flink;
  82
  83     while (le != &Vcb->devices) {
  84         PIO_STACK_LOCATION IrpSp;
  85         device* dev = CONTAINING_RECORD(le, device, list_entry);
  86
  87         if (dev->devobj) {
  88             context.stripes[i].context = (struct pnp_context*)&context;
  89
  90             context.stripes[i].Irp = IoAllocateIrp(dev->devobj->StackSize, FALSE);
  91
  92             if (!context.stripes[i].Irp) {
  93                 UINT64 j;
  94
  95                 ERR("IoAllocateIrp failed\n");
  96
  97                 for (j = 0; j < i; j++) {
  98                     if (context.stripes[j].dev->devobj) {
  99                         IoFreeIrp(context.stripes[j].Irp);
 100                     }
 101                 }
 102                 ExFreePool(context.stripes);
 103
 104                 return STATUS_INSUFFICIENT_RESOURCES;
 105             }
 106
 107             IrpSp = IoGetNextIrpStackLocation(context.stripes[i].Irp);
 108             IrpSp->MajorFunction = IRP_MJ_PNP;
 109             IrpSp->MinorFunction = minor;
 110
 111             context.stripes[i].Irp->UserIosb = &context.stripes[i].iosb;
 112
 113             IoSetCompletionRoutine(context.stripes[i].Irp, pnp_completion, &context.stripes[i], TRUE, TRUE, TRUE);
 114
 115             context.stripes[i].Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 116             context.stripes[i].dev = dev;
 117
 118             context.left++;
 119         }
 120
 121         le = le->Flink;
 122     }
 123
 124     if (context.left == 0) {
 125         Status = STATUS_SUCCESS;
 126         goto end;
 127     }
 128
 129     for (i = 0; i < num_devices; i++) {
 130         if (context.stripes[i].Irp) {
 131             IoCallDriver(context.stripes[i].dev->devobj, context.stripes[i].Irp);
 132         }
 133     }
 134
 135     KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);
 136
 137     Status = STATUS_SUCCESS;
 138
 139     for (i = 0; i < num_devices; i++) {
 140         if (context.stripes[i].Irp) {
 141             if (context.stripes[i].Status != STATUS_SUCCESS)
 142                 Status = context.stripes[i].Status;
 143         }
 144     }
 145
 146 end:
 147     for (i = 0; i < num_devices; i++) {
 148         if (context.stripes[i].Irp) {
 149             IoFreeIrp(context.stripes[i].Irp);
 150         }
 151     }
 152
 153     ExFreePool(context.stripes);
 154
 155     return Status;
 156 }
 157
 158 static NTSTATUS pnp_cancel_remove_device(PDEVICE_OBJECT DeviceObject) {
 159     device_extension* Vcb = DeviceObject->DeviceExtension;
 160     NTSTATUS Status;
 161
 162     ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
 163
 164     acquire_fcb_lock_exclusive(Vcb);
 165
 166     if (Vcb->root_fileref && Vcb->root_fileref->fcb && (Vcb->root_fileref->open_count > 0 || has_open_children(Vcb->root_fileref))) {
 167         Status = STATUS_ACCESS_DENIED;
 168         goto end;
 169     }
 170
 171     Status = send_disks_pnp_message(Vcb, IRP_MN_CANCEL_REMOVE_DEVICE);
 172     if (!NT_SUCCESS(Status)) {
 173         WARN("send_disks_pnp_message returned %08x\n", Status);
 174         goto end;
 175     }
 176
 177 end:
 178     release_fcb_lock(Vcb);
 179     ExReleaseResourceLite(&Vcb->tree_lock);
 180
 181     return STATUS_SUCCESS;
 182 }
 183
 184 NTSTATUS pnp_query_remove_device(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
 185     device_extension* Vcb = DeviceObject->DeviceExtension;
 186     NTSTATUS Status;
 187
 188     ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
 189
 190     acquire_fcb_lock_exclusive(Vcb);
 191
 192     if (Vcb->root_fileref && Vcb->root_fileref->fcb && (Vcb->root_fileref->open_count > 0 || has_open_children(Vcb->root_fileref))) {
 193         Status = STATUS_ACCESS_DENIED;
 194         goto end;
 195     }
 196
 197     Status = send_disks_pnp_message(Vcb, IRP_MN_QUERY_REMOVE_DEVICE);
 198     if (!NT_SUCCESS(Status)) {
 199         WARN("send_disks_pnp_message returned %08x\n", Status);
 200         goto end;
 201     }
 202
 203     Vcb->removing = TRUE;
 204
 205     if (Vcb->need_write && !Vcb->readonly) {
 206         Status = do_write(Vcb, Irp);
 207
 208         free_trees(Vcb);
 209
 210         if (!NT_SUCCESS(Status)) {
 211             ERR("do_write returned %08x\n", Status);
 212             goto end;
 213         }
 214     }
 215
 216
 217     Status = STATUS_SUCCESS;
 218 end:
 219     release_fcb_lock(Vcb);
 220
 221     ExReleaseResourceLite(&Vcb->tree_lock);
 222
 223     return Status;
 224 }
 225
 226 static NTSTATUS pnp_remove_device(PDEVICE_OBJECT DeviceObject) {
 227     device_extension* Vcb = DeviceObject->DeviceExtension;
 228     NTSTATUS Status;
 229
 230     ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
 231
 232     Status = send_disks_pnp_message(Vcb, IRP_MN_REMOVE_DEVICE);
 233
 234     if (!NT_SUCCESS(Status))
 235         WARN("send_disks_pnp_message returned %08x\n", Status);
 236
 237     ExReleaseResourceLite(&Vcb->tree_lock);
 238
 239     if (DeviceObject->Vpb->Flags & VPB_MOUNTED) {
 240         Status = FsRtlNotifyVolumeEvent(Vcb->root_file, FSRTL_VOLUME_DISMOUNT);
 241         if (!NT_SUCCESS(Status)) {
 242             WARN("FsRtlNotifyVolumeEvent returned %08x\n", Status);
 243         }
 244
 245         if (Vcb->vde)
 246             Vcb->vde->mounted_device = NULL;
 247
 248         ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
 249         Vcb->removing = TRUE;
 250         Vcb->Vpb->Flags &= ~VPB_MOUNTED;
 251         Vcb->Vpb->Flags |= VPB_DIRECT_WRITES_ALLOWED;
 252         ExReleaseResourceLite(&Vcb->tree_lock);
 253
 254         if (Vcb->open_files == 0)
 255             uninit(Vcb, FALSE);
 256     }
 257
 258     return STATUS_SUCCESS;
 259 }
 260
 261 NTSTATUS pnp_surprise_removal(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
 262     device_extension* Vcb = DeviceObject->DeviceExtension;
 263
 264     TRACE("(%p, %p)\n", DeviceObject, Irp);
 265
 266     if (DeviceObject->Vpb->Flags & VPB_MOUNTED) {
 267         ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
 268
 269         if (Vcb->vde)
 270             Vcb->vde->mounted_device = NULL;
 271
 272         Vcb->removing = TRUE;
 273         Vcb->Vpb->Flags &= ~VPB_MOUNTED;
 274         Vcb->Vpb->Flags |= VPB_DIRECT_WRITES_ALLOWED;
 275
 276         ExReleaseResourceLite(&Vcb->tree_lock);
 277
 278         if (Vcb->open_files == 0)
 279             uninit(Vcb, FALSE);
 280     }
 281
 282     return STATUS_SUCCESS;
 283 }
 284
 285 static void bus_query_capabilities(PIRP Irp) {
 286     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
 287     PDEVICE_CAPABILITIES dc = IrpSp->Parameters.DeviceCapabilities.Capabilities;
 288
 289     dc->UniqueID = TRUE;
 290     dc->SilentInstall = TRUE;
 291
 292     Irp->IoStatus.Status = STATUS_SUCCESS;
 293 }
 294
 295 static NTSTATUS bus_query_device_relations(PIRP Irp) {
 296     NTSTATUS Status;
 297     ULONG num_children;
 298     LIST_ENTRY* le;
 299     ULONG drsize, i;
 300     DEVICE_RELATIONS* dr;
 301
 302     ExAcquireResourceSharedLite(&pdo_list_lock, TRUE);
 303
 304     num_children = 0;
 305
 306     le = pdo_list.Flink;
 307     while (le != &pdo_list) {
 308         num_children++;
 309
 310         le = le->Flink;
 311     }
 312
 313     drsize = offsetof(DEVICE_RELATIONS, Objects[0]) + (num_children * sizeof(PDEVICE_OBJECT));
 314     dr = ExAllocatePoolWithTag(PagedPool, drsize, ALLOC_TAG);
 315
 316     if (!dr) {
 317         ERR("out of memory\n");
 318         Status = STATUS_INSUFFICIENT_RESOURCES;
 319         goto end;
 320     }
 321
 322     dr->Count = num_children;
 323
 324     i = 0;
 325     le = pdo_list.Flink;
 326     while (le != &pdo_list) {
 327         pdo_device_extension* pdode = CONTAINING_RECORD(le, pdo_device_extension, list_entry);
 328
 329         ObReferenceObject(pdode->pdo);
 330         dr->Objects[i] = pdode->pdo;
 331         i++;
 332
 333         le = le->Flink;
 334     }
 335
 336     Irp->IoStatus.Information = (ULONG_PTR)dr;
 337
 338     Status = STATUS_SUCCESS;
 339
 340 end:
 341     ExReleaseResourceLite(&pdo_list_lock);
 342
 343     Irp->IoStatus.Status = Status;
 344     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 345
 346     return Status;
 347 }
 348
 349 static NTSTATUS bus_query_hardware_ids(PIRP Irp) {
 350     WCHAR* out;
 351
 352     static WCHAR ids[] = L"ROOT\\btrfs\0";
 353
 354     out = ExAllocatePoolWithTag(PagedPool, sizeof(ids), ALLOC_TAG);
 355     if (!out) {
 356         ERR("out of memory\n");
 357         return STATUS_INSUFFICIENT_RESOURCES;
 358     }
 359
 360     RtlCopyMemory(out, ids, sizeof(ids));
 361
 362     Irp->IoStatus.Information = (ULONG_PTR)out;
 363
 364     return STATUS_SUCCESS;
 365 }
 366
 367 static NTSTATUS bus_pnp(control_device_extension* cde, PIRP Irp) {
 368     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
 369
 370     switch (IrpSp->MinorFunction) {
 371         case IRP_MN_QUERY_CAPABILITIES:
 372             bus_query_capabilities(Irp);
 373             break;
 374
 375         case IRP_MN_QUERY_DEVICE_RELATIONS:
 376             if (IrpSp->Parameters.QueryDeviceRelations.Type != BusRelations || no_pnp)
 377                 break;
 378
 379             return bus_query_device_relations(Irp);
 380
 381         case IRP_MN_QUERY_ID:
 382         {
 383             NTSTATUS Status;
 384
 385             if (IrpSp->Parameters.QueryId.IdType != BusQueryHardwareIDs)
 386                 break;
 387
 388             Status = bus_query_hardware_ids(Irp);
 389
 390             Irp->IoStatus.Status = Status;
 391             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 392
 393             return Status;
 394         }
 395     }
 396
 397     IoSkipCurrentIrpStackLocation(Irp);
 398     return IoCallDriver(cde->attached_device, Irp);
 399 }
 400
 401 static NTSTATUS pdo_query_device_id(pdo_device_extension* pdode, PIRP Irp) {
 402     WCHAR name[100], *noff, *out;
 403     int i;
 404
 405     static WCHAR pref[] = L"Btrfs\\";
 406
 407     RtlCopyMemory(name, pref, wcslen(pref) * sizeof(WCHAR));
 408
 409     noff = &name[wcslen(pref)];
 410     for (i = 0; i < 16; i++) {
 411         *noff = hex_digit(pdode->uuid.uuid[i] >> 4); noff++;
 412         *noff = hex_digit(pdode->uuid.uuid[i] & 0xf); noff++;
 413
 414         if (i == 3 || i == 5 || i == 7 || i == 9) {
 415             *noff = '-';
 416             noff++;
 417         }
 418     }
 419     *noff = 0;
 420
 421     out = ExAllocatePoolWithTag(PagedPool, (wcslen(name) + 1) * sizeof(WCHAR), ALLOC_TAG);
 422     if (!out) {
 423         ERR("out of memory\n");
 424         return STATUS_INSUFFICIENT_RESOURCES;
 425     }
 426
 427     RtlCopyMemory(out, name, (wcslen(name) + 1) * sizeof(WCHAR));
 428
 429     Irp->IoStatus.Information = (ULONG_PTR)out;
 430
 431     return STATUS_SUCCESS;
 432 }
 433
 434 static NTSTATUS pdo_query_hardware_ids(PIRP Irp) {
 435     WCHAR* out;
 436
 437     static WCHAR ids[] = L"BtrfsVolume\0";
 438
 439     out = ExAllocatePoolWithTag(PagedPool, sizeof(ids), ALLOC_TAG);
 440     if (!out) {
 441         ERR("out of memory\n");
 442         return STATUS_INSUFFICIENT_RESOURCES;
 443     }
 444
 445     RtlCopyMemory(out, ids, sizeof(ids));
 446
 447     Irp->IoStatus.Information = (ULONG_PTR)out;
 448
 449     return STATUS_SUCCESS;
 450 }
 451
 452 static NTSTATUS pdo_query_id(pdo_device_extension* pdode, PIRP Irp) {
 453     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
 454
 455     switch (IrpSp->Parameters.QueryId.IdType) {
 456         case BusQueryDeviceID:
 457             TRACE("BusQueryDeviceID\n");
 458             return pdo_query_device_id(pdode, Irp);
 459
 460         case BusQueryHardwareIDs:
 461             TRACE("BusQueryHardwareIDs\n");
 462             return pdo_query_hardware_ids(Irp);
 463
 464         default:
 465             break;
 466     }
 467
 468     return Irp->IoStatus.Status;
 469 }
 470
 471 static NTSTATUS pdo_pnp(PDEVICE_OBJECT pdo, PIRP Irp) {
 472     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
 473     pdo_device_extension* pdode = pdo->DeviceExtension;
 474
 475     switch (IrpSp->MinorFunction) {
 476         case IRP_MN_QUERY_ID:
 477             return pdo_query_id(pdode, Irp);
 478
 479         case IRP_MN_START_DEVICE:
 480         case IRP_MN_CANCEL_REMOVE_DEVICE:
 481         case IRP_MN_SURPRISE_REMOVAL:
 482         case IRP_MN_REMOVE_DEVICE:
 483             return STATUS_SUCCESS;
 484
 485         case IRP_MN_QUERY_REMOVE_DEVICE:
 486             return STATUS_UNSUCCESSFUL;
 487     }
 488
 489     return Irp->IoStatus.Status;
 490 }
 491
 492 _Dispatch_type_(IRP_MJ_PNP)
 493 _Function_class_(DRIVER_DISPATCH)
 494 NTSTATUS drv_pnp(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
 495     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
 496     device_extension* Vcb = DeviceObject->DeviceExtension;
 497     NTSTATUS Status;
 498     BOOL top_level;
 499
 500     FsRtlEnterFileSystem();
 501
 502     top_level = is_top_level(Irp);
 503
 504     if (Vcb && Vcb->type == VCB_TYPE_CONTROL) {
 505         Status = bus_pnp(DeviceObject->DeviceExtension, Irp);
 506         goto exit;
 507     } else if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
 508         volume_device_extension* vde = DeviceObject->DeviceExtension;
 509         IoSkipCurrentIrpStackLocation(Irp);
 510         Status = IoCallDriver(vde->pdo, Irp);
 511         goto exit;
 512     } else if (Vcb && Vcb->type == VCB_TYPE_PDO) {
 513         Status = pdo_pnp(DeviceObject, Irp);
 514         goto end;
 515     } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
 516         Status = STATUS_INVALID_PARAMETER;
 517         goto end;
 518     }
 519
 520     Status = STATUS_NOT_IMPLEMENTED;
 521
 522     switch (IrpSp->MinorFunction) {
 523         case IRP_MN_CANCEL_REMOVE_DEVICE:
 524             Status = pnp_cancel_remove_device(DeviceObject);
 525             break;
 526
 527         case IRP_MN_QUERY_REMOVE_DEVICE:
 528             Status = pnp_query_remove_device(DeviceObject, Irp);
 529             break;
 530
 531         case IRP_MN_REMOVE_DEVICE:
 532             Status = pnp_remove_device(DeviceObject);
 533             break;
 534
 535         case IRP_MN_SURPRISE_REMOVAL:
 536             Status = pnp_surprise_removal(DeviceObject, Irp);
 537             break;
 538
 539         default:
 540             TRACE("passing minor function 0x%x on\n", IrpSp->MinorFunction);
 541
 542             IoSkipCurrentIrpStackLocation(Irp);
 543             Status = IoCallDriver(Vcb->Vpb->RealDevice, Irp);
 544             goto exit;
 545     }
 546
 547 end:
 548     Irp->IoStatus.Status = Status;
 549
 550     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 551
 552 exit:
 553     TRACE("returning %08x\n", Status);
 554
 555     if (top_level)
 556         IoSetTopLevelIrp(NULL);
 557
 558     FsRtlExitFileSystem();
 559
 560     return Status;
 561 }