drivers/filesystems/npfs/datasup.c

   1 /*
   2  * PROJECT:     ReactOS Named Pipe FileSystem
   3  * LICENSE:     BSD - See COPYING.ARM in the top level directory
   4  * FILE:        drivers/filesystems/npfs/datasup.c
   5  * PURPOSE:     Data Queues Support
   6  * PROGRAMMERS: ReactOS Portable Systems Group
   7  */
   8
   9 /* INCLUDES *******************************************************************/
  10
  11 #include "npfs.h"
  12
  13 // File ID number for NPFS bugchecking support
  14 #define NPFS_BUGCHECK_FILE_ID   (NPFS_BUGCHECK_DATASUP)
  15
  16 /* FUNCTIONS ******************************************************************/
  17
  18 NTSTATUS
  19 NTAPI
  20 NpUninitializeDataQueue(IN PNP_DATA_QUEUE DataQueue)
  21 {
  22     PAGED_CODE();
  23
  24     ASSERT(DataQueue->QueueState == Empty);
  25
  26     RtlZeroMemory(DataQueue, sizeof(*DataQueue));
  27     return STATUS_SUCCESS;
  28 }
  29
  30 NTSTATUS
  31 NTAPI
  32 NpInitializeDataQueue(IN PNP_DATA_QUEUE DataQueue,
  33                       IN ULONG Quota)
  34 {
  35     PAGED_CODE();
  36
  37     DataQueue->BytesInQueue = 0;
  38     DataQueue->EntriesInQueue = 0;
  39     DataQueue->QuotaUsed = 0;
  40     DataQueue->ByteOffset = 0;
  41     DataQueue->QueueState = Empty;
  42     DataQueue->Quota = Quota;
  43     InitializeListHead(&DataQueue->Queue);
  44     return STATUS_SUCCESS;
  45 }
  46
  47 VOID
  48 NTAPI
  49 NpCompleteStalledWrites(IN PNP_DATA_QUEUE DataQueue,
  50                         IN PLIST_ENTRY List)
  51 {
  52     ULONG QuotaLeft, ByteOffset, DataLeft, NewQuotaLeft;
  53     PNP_DATA_QUEUE_ENTRY DataQueueEntry;
  54     PIRP Irp;
  55     PLIST_ENTRY NextEntry;
  56
  57     QuotaLeft = DataQueue->Quota - DataQueue->QuotaUsed;
  58     ByteOffset = DataQueue->ByteOffset;
  59
  60     NextEntry = DataQueue->Queue.Flink;
  61     while (NextEntry != &DataQueue->Queue)
  62     {
  63         if (!QuotaLeft) break;
  64
  65         DataQueueEntry = CONTAINING_RECORD(NextEntry,
  66                                            NP_DATA_QUEUE_ENTRY,
  67                                            QueueEntry);
  68
  69         Irp = DataQueueEntry->Irp;
  70
  71         if ((DataQueueEntry->DataEntryType == Buffered) && (Irp))
  72         {
  73             DataLeft = DataQueueEntry->DataSize - ByteOffset;
  74
  75             if (DataQueueEntry->QuotaInEntry < DataLeft)
  76             {
  77                 NewQuotaLeft = DataLeft - DataQueueEntry->QuotaInEntry;
  78                 if (NewQuotaLeft > QuotaLeft) NewQuotaLeft = QuotaLeft;
  79
  80                 QuotaLeft -= NewQuotaLeft;
  81                 DataQueueEntry->QuotaInEntry += NewQuotaLeft;
  82
  83                 if (DataQueueEntry->QuotaInEntry == DataLeft &&
  84                     IoSetCancelRoutine(Irp, NULL))
  85                 {
  86                     DataQueueEntry->Irp = NULL;
  87
  88                     Irp->IoStatus.Status = STATUS_SUCCESS;
  89                     Irp->IoStatus.Information = DataQueueEntry->DataSize;
  90
  91                     InsertTailList(List, &Irp->Tail.Overlay.ListEntry);
  92                 }
  93             }
  94         }
  95
  96         NextEntry = NextEntry->Flink;
  97         ByteOffset = 0;
  98     }
  99
 100     DataQueue->QuotaUsed = DataQueue->Quota - QuotaLeft;
 101 }
 102
 103 PIRP
 104 NTAPI
 105 NpRemoveDataQueueEntry(IN PNP_DATA_QUEUE DataQueue,
 106                        IN BOOLEAN Flag,
 107                        IN PLIST_ENTRY List)
 108 {
 109     PIRP Irp;
 110     PNP_DATA_QUEUE_ENTRY QueueEntry;
 111     BOOLEAN HasWrites;
 112
 113     if (DataQueue->QueueState == Empty)
 114     {
 115         Irp = NULL;
 116         ASSERT(IsListEmpty(&DataQueue->Queue));
 117         ASSERT(DataQueue->EntriesInQueue == 0);
 118         ASSERT(DataQueue->BytesInQueue == 0);
 119         ASSERT(DataQueue->QuotaUsed == 0);
 120     }
 121     else
 122     {
 123         QueueEntry = CONTAINING_RECORD(RemoveHeadList(&DataQueue->Queue),
 124                                        NP_DATA_QUEUE_ENTRY,
 125                                        QueueEntry);
 126
 127         DataQueue->BytesInQueue -= QueueEntry->DataSize;
 128         --DataQueue->EntriesInQueue;
 129
 130         HasWrites = TRUE;
 131         if (DataQueue->QueueState != WriteEntries ||
 132             DataQueue->QuotaUsed < DataQueue->Quota ||
 133             !QueueEntry->QuotaInEntry)
 134         {
 135             HasWrites = FALSE;
 136         }
 137
 138         DataQueue->QuotaUsed -= QueueEntry->QuotaInEntry;
 139
 140         if (IsListEmpty(&DataQueue->Queue))
 141         {
 142             DataQueue->QueueState = Empty;
 143             HasWrites = FALSE;
 144         }
 145
 146         Irp = QueueEntry->Irp;
 147         NpFreeClientSecurityContext(QueueEntry->ClientSecurityContext);
 148
 149         if (Irp && !IoSetCancelRoutine(Irp, NULL))
 150         {
 151             Irp->Tail.Overlay.DriverContext[3] = NULL;
 152             Irp = NULL;
 153         }
 154
 155         ExFreePool(QueueEntry);
 156
 157         if (Flag)
 158         {
 159             NpGetNextRealDataQueueEntry(DataQueue, List);
 160         }
 161
 162         if (HasWrites)
 163         {
 164             NpCompleteStalledWrites(DataQueue, List);
 165         }
 166     }
 167
 168     DataQueue->ByteOffset = 0;
 169     return Irp;
 170 }
 171
 172 PLIST_ENTRY
 173 NTAPI
 174 NpGetNextRealDataQueueEntry(IN PNP_DATA_QUEUE DataQueue,
 175                             IN PLIST_ENTRY List)
 176 {
 177     PNP_DATA_QUEUE_ENTRY DataEntry;
 178     ULONG Type;
 179     PIRP Irp;
 180     PLIST_ENTRY NextEntry;
 181     PAGED_CODE();
 182
 183     for (NextEntry = DataQueue->Queue.Flink;
 184          NextEntry != &DataQueue->Queue;
 185          NextEntry = DataQueue->Queue.Flink)
 186     {
 187         DataEntry = CONTAINING_RECORD(NextEntry,
 188                                       NP_DATA_QUEUE_ENTRY,
 189                                       QueueEntry);
 190
 191         Type = DataEntry->DataEntryType;
 192         if (Type == Buffered || Type == Unbuffered) break;
 193
 194         Irp = NpRemoveDataQueueEntry(DataQueue, FALSE, List);
 195         if (Irp)
 196         {
 197             Irp->IoStatus.Status = STATUS_SUCCESS;
 198             InsertTailList(List, &Irp->Tail.Overlay.ListEntry);
 199         }
 200     }
 201
 202     return NextEntry;
 203 }
 204
 205 VOID
 206 NTAPI
 207 NpCancelDataQueueIrp(IN PDEVICE_OBJECT DeviceObject,
 208                      IN PIRP Irp)
 209 {
 210     PNP_DATA_QUEUE DataQueue;
 211     PNP_DATA_QUEUE_ENTRY DataEntry;
 212     LIST_ENTRY DeferredList;
 213     PSECURITY_CLIENT_CONTEXT ClientSecurityContext;
 214     BOOLEAN CompleteWrites, FirstEntry;
 215
 216     if (DeviceObject) IoReleaseCancelSpinLock(Irp->CancelIrql);
 217
 218     InitializeListHead(&DeferredList);
 219
 220     DataQueue = Irp->Tail.Overlay.DriverContext[2];
 221     ClientSecurityContext = NULL;
 222
 223     if (DeviceObject)
 224     {
 225         FsRtlEnterFileSystem();
 226         NpAcquireExclusiveVcb();
 227     }
 228
 229     DataEntry = Irp->Tail.Overlay.DriverContext[3];
 230     if (DataEntry)
 231     {
 232         if (DataEntry->QueueEntry.Blink == &DataQueue->Queue)
 233         {
 234             DataQueue->ByteOffset = 0;
 235             FirstEntry = TRUE;
 236         }
 237         else
 238         {
 239             FirstEntry = FALSE;
 240         }
 241
 242         RemoveEntryList(&DataEntry->QueueEntry);
 243
 244         ClientSecurityContext = DataEntry->ClientSecurityContext;
 245
 246         CompleteWrites = TRUE;
 247         if (DataQueue->QueueState != WriteEntries ||
 248             DataQueue->QuotaUsed < DataQueue->Quota ||
 249             !DataEntry->QuotaInEntry)
 250         {
 251             CompleteWrites = FALSE;
 252         }
 253
 254         DataQueue->BytesInQueue -= DataEntry->DataSize;
 255         DataQueue->QuotaUsed -= DataEntry->QuotaInEntry;
 256         --DataQueue->EntriesInQueue;
 257
 258         if (IsListEmpty(&DataQueue->Queue))
 259         {
 260             DataQueue->QueueState = Empty;
 261             ASSERT(DataQueue->BytesInQueue == 0);
 262             ASSERT(DataQueue->EntriesInQueue == 0);
 263             ASSERT(DataQueue->QuotaUsed == 0);
 264         }
 265         else
 266         {
 267             if (FirstEntry)
 268             {
 269                 NpGetNextRealDataQueueEntry(DataQueue, &DeferredList);
 270             }
 271             if (CompleteWrites)
 272             {
 273                 NpCompleteStalledWrites(DataQueue, &DeferredList);
 274             }
 275         }
 276     }
 277
 278     if (DeviceObject)
 279     {
 280         NpReleaseVcb();
 281         FsRtlExitFileSystem();
 282     }
 283
 284     if (DataEntry) ExFreePool(DataEntry);
 285
 286     NpFreeClientSecurityContext(ClientSecurityContext);
 287     Irp->IoStatus.Status = STATUS_CANCELLED;
 288     IoCompleteRequest(Irp, IO_NAMED_PIPE_INCREMENT);
 289
 290     NpCompleteDeferredIrps(&DeferredList);
 291 }
 292
 293 NTSTATUS
 294 NTAPI
 295 NpAddDataQueueEntry(IN ULONG NamedPipeEnd,
 296                     IN PNP_CCB Ccb,
 297                     IN PNP_DATA_QUEUE DataQueue,
 298                     IN ULONG Who,
 299                     IN ULONG Type,
 300                     IN ULONG DataSize,
 301                     IN PIRP Irp,
 302                     IN PVOID Buffer,
 303                     IN ULONG ByteOffset)
 304 {
 305     NTSTATUS Status;
 306     PNP_DATA_QUEUE_ENTRY DataEntry;
 307     SIZE_T EntrySize;
 308     ULONG QuotaInEntry;
 309     PSECURITY_CLIENT_CONTEXT ClientContext;
 310     BOOLEAN HasSpace;
 311
 312     ClientContext = NULL;
 313     ASSERT((DataQueue->QueueState == Empty) || (DataQueue->QueueState == Who));
 314
 315     Status = STATUS_SUCCESS;
 316
 317     if ((Type != 2) && (Who == WriteEntries))
 318     {
 319         Status = NpGetClientSecurityContext(NamedPipeEnd,
 320                                             Ccb,
 321                                             Irp ? Irp->Tail.Overlay.Thread :
 322                                             PsGetCurrentThread(),
 323                                             &ClientContext);
 324         if (!NT_SUCCESS(Status))
 325         {
 326             return Status;
 327         }
 328     }
 329
 330     switch (Type)
 331     {
 332         case Unbuffered:
 333         case 2:
 334         case 3:
 335
 336             ASSERT(Irp != NULL);
 337             DataEntry = ExAllocatePoolWithQuotaTag(NonPagedPool | POOL_QUOTA_FAIL_INSTEAD_OF_RAISE,
 338                                                    sizeof(*DataEntry),
 339                                                    NPFS_DATA_ENTRY_TAG);
 340             if (!DataEntry)
 341             {
 342                 NpFreeClientSecurityContext(ClientContext);
 343                 return STATUS_INSUFFICIENT_RESOURCES;
 344             }
 345
 346             DataEntry->DataEntryType = Type;
 347             DataEntry->QuotaInEntry = 0;
 348             DataEntry->Irp = Irp;
 349             DataEntry->DataSize = DataSize;
 350             DataEntry->ClientSecurityContext = ClientContext;
 351             ASSERT((DataQueue->QueueState == Empty) || (DataQueue->QueueState == Who));
 352             Status = STATUS_PENDING;
 353             break;
 354
 355         case Buffered:
 356
 357             EntrySize = sizeof(*DataEntry);
 358             if (Who != ReadEntries)
 359             {
 360                 EntrySize += DataSize;
 361                 if (EntrySize < DataSize)
 362                 {
 363                     NpFreeClientSecurityContext(ClientContext);
 364                     return STATUS_INVALID_PARAMETER;
 365                 }
 366             }
 367
 368             QuotaInEntry = DataSize - ByteOffset;
 369             if (DataQueue->Quota - DataQueue->QuotaUsed < QuotaInEntry)
 370             {
 371                 QuotaInEntry = DataQueue->Quota - DataQueue->QuotaUsed;
 372                 HasSpace = TRUE;
 373             }
 374             else
 375             {
 376                 HasSpace = FALSE;
 377             }
 378
 379             DataEntry = ExAllocatePoolWithQuotaTag(NonPagedPool | POOL_QUOTA_FAIL_INSTEAD_OF_RAISE,
 380                                                    EntrySize,
 381                                                    NPFS_DATA_ENTRY_TAG);
 382             if (!DataEntry)
 383             {
 384                 NpFreeClientSecurityContext(ClientContext);
 385                 return STATUS_INSUFFICIENT_RESOURCES;
 386             }
 387
 388             DataEntry->QuotaInEntry = QuotaInEntry;
 389             DataEntry->Irp = Irp;
 390             DataEntry->DataEntryType = Buffered;
 391             DataEntry->ClientSecurityContext = ClientContext;
 392             DataEntry->DataSize = DataSize;
 393
 394             if (Who == ReadEntries)
 395             {
 396                 ASSERT(Irp);
 397
 398                 Status = STATUS_PENDING;
 399                 ASSERT((DataQueue->QueueState == Empty) ||
 400                        (DataQueue->QueueState == Who));
 401             }
 402             else
 403             {
 404                 _SEH2_TRY
 405                 {
 406                     RtlCopyMemory(DataEntry + 1,
 407                                   Irp ? Irp->UserBuffer: Buffer,
 408                                   DataSize);
 409                 }
 410                 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 411                 {
 412                     NpFreeClientSecurityContext(ClientContext);
 413                     _SEH2_YIELD(return _SEH2_GetExceptionCode());
 414                 }
 415                 _SEH2_END;
 416
 417                 if (HasSpace && Irp)
 418                 {
 419                     Status = STATUS_PENDING;
 420                 }
 421                 else
 422                 {
 423                     DataEntry->Irp = NULL;
 424                     Status = STATUS_SUCCESS;
 425                 }
 426
 427                 ASSERT((DataQueue->QueueState == Empty) ||
 428                        (DataQueue->QueueState == Who));
 429             }
 430             break;
 431
 432         default:
 433             ASSERT(FALSE);
 434             NpFreeClientSecurityContext(ClientContext);
 435             return STATUS_INVALID_PARAMETER;
 436     }
 437
 438     ASSERT((DataQueue->QueueState == Empty) || (DataQueue->QueueState == Who));
 439     if (DataQueue->QueueState == Empty)
 440     {
 441         ASSERT(DataQueue->BytesInQueue == 0);
 442         ASSERT(DataQueue->EntriesInQueue == 0);
 443         ASSERT(IsListEmpty(&DataQueue->Queue));
 444     }
 445     else
 446     {
 447         ASSERT(DataQueue->QueueState == Who);
 448         ASSERT(DataQueue->QueueState != Empty);
 449         ASSERT(DataQueue->EntriesInQueue != 0);
 450     }
 451
 452     DataQueue->QuotaUsed += DataEntry->QuotaInEntry;
 453     DataQueue->QueueState = Who;
 454     DataQueue->BytesInQueue += DataEntry->DataSize;
 455     DataQueue->EntriesInQueue++;
 456
 457     if (ByteOffset)
 458     {
 459         DataQueue->ByteOffset = ByteOffset;
 460         ASSERT(Who == WriteEntries);
 461         ASSERT(ByteOffset < DataEntry->DataSize);
 462         ASSERT(DataQueue->EntriesInQueue == 1);
 463     }
 464
 465     InsertTailList(&DataQueue->Queue, &DataEntry->QueueEntry);
 466
 467     if (Status == STATUS_PENDING)
 468     {
 469         IoMarkIrpPending(Irp);
 470         Irp->Tail.Overlay.DriverContext[2] = DataQueue;
 471         Irp->Tail.Overlay.DriverContext[3] = DataEntry;
 472
 473         IoSetCancelRoutine(Irp, NpCancelDataQueueIrp);
 474
 475         if ((Irp->Cancel) && (IoSetCancelRoutine(Irp, NULL)))
 476         {
 477             NpCancelDataQueueIrp(NULL, Irp);
 478         }
 479     }
 480
 481     return Status;
 482 }
 483
 484 /* EOF */