drivers/filesystems/cdfs/lockctrl.c

   1 /*++
   2
   3 Copyright (c) 1989-2000 Microsoft Corporation
   4
   5 Module Name:
   6
   7     LockCtrl.c
   8
   9 Abstract:
  10
  11     This module implements the Lock Control routines for Cdfs called
  12     by the Fsd/Fsp dispatch driver.
  13
  14
  15 --*/
  16
  17 #include "cdprocs.h"
  18
  19 //
  20 //  The Bug check file id for this module
  21 //
  22
  23 #define BugCheckFileId                   (CDFS_BUG_CHECK_LOCKCTRL)
  24
  25 #ifdef ALLOC_PRAGMA
  26 #pragma alloc_text(PAGE, CdCommonLockControl)
  27 #pragma alloc_text(PAGE, CdFastLock)
  28 #pragma alloc_text(PAGE, CdFastUnlockAll)
  29 #pragma alloc_text(PAGE, CdFastUnlockAllByKey)
  30 #pragma alloc_text(PAGE, CdFastUnlockSingle)
  31 #endif
  32
  33 \f
  34 NTSTATUS
  35 CdCommonLockControl (
  36     _Inout_ PIRP_CONTEXT IrpContext,
  37     _Inout_ PIRP Irp
  38     )
  39
  40 /*++
  41
  42 Routine Description:
  43
  44     This is the common routine for Lock Control called by both the fsd and fsp
  45     threads.
  46
  47 Arguments:
  48
  49     Irp - Supplies the Irp to process
  50
  51 Return Value:
  52
  53     NTSTATUS - The return status for the operation
  54
  55 --*/
  56
  57 {
  58     NTSTATUS Status;
  59     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
  60
  61     TYPE_OF_OPEN TypeOfOpen;
  62     PFCB Fcb;
  63     PCCB Ccb;
  64
  65     PAGED_CODE();
  66
  67     //
  68     //  Extract and decode the type of file object we're being asked to process
  69     //
  70
  71     TypeOfOpen = CdDecodeFileObject( IrpContext, IrpSp->FileObject, &Fcb, &Ccb );
  72
  73     //
  74     //  If the file is not a user file open then we reject the request
  75     //  as an invalid parameter
  76     //
  77
  78     if (TypeOfOpen != UserFileOpen) {
  79
  80         CdCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
  81         return STATUS_INVALID_PARAMETER;
  82     }
  83
  84     //
  85     //  We check whether we can proceed based on the state of the file oplocks.
  86     //  This call might post the irp for us.
  87     //
  88
  89     Status = FsRtlCheckOplock( CdGetFcbOplock(Fcb),
  90                                Irp,
  91                                IrpContext,
  92                                (PVOID)CdOplockComplete,/* ReactOS Change: GCC "assignment from incompatible pointer type" */
  93                                NULL );
  94
  95     //
  96     //  If we don't get success then the oplock package completed the request.
  97     //
  98
  99     if (Status != STATUS_SUCCESS) {
 100
 101         return Status;
 102     }
 103
 104     //
 105     //  Verify the Fcb.
 106     //
 107
 108     CdVerifyFcbOperation( IrpContext, Fcb );
 109
 110     //
 111     //  If we don't have a file lock, then get one now.
 112     //
 113
 114     if (Fcb->FileLock == NULL) { CdCreateFileLock( IrpContext, Fcb, TRUE ); }
 115
 116     //
 117     //  Now call the FsRtl routine to do the actual processing of the
 118     //  Lock request
 119     //
 120
 121     Status = FsRtlProcessFileLock( Fcb->FileLock, Irp, NULL );
 122
 123     //
 124     //  Set the flag indicating if Fast I/O is possible
 125     //
 126
 127     CdLockFcb( IrpContext, Fcb );
 128     Fcb->IsFastIoPossible = CdIsFastIoPossible( Fcb );
 129     CdUnlockFcb( IrpContext, Fcb );
 130
 131     //
 132     //  Complete the request.
 133     //
 134
 135     CdCompleteRequest( IrpContext, NULL, Status );
 136     return Status;
 137 }
 138
 139 \f
 140 BOOLEAN
 141 NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
 142 CdFastLock (
 143     _In_ PFILE_OBJECT FileObject,
 144     _In_ PLARGE_INTEGER FileOffset,
 145     _In_ PLARGE_INTEGER Length,
 146     _In_ PEPROCESS ProcessId,
 147     _In_ ULONG Key,
 148     _In_ BOOLEAN FailImmediately,
 149     _In_ BOOLEAN ExclusiveLock,
 150     _Out_ PIO_STATUS_BLOCK IoStatus,
 151     _In_ PDEVICE_OBJECT DeviceObject
 152     )
 153
 154 /*++
 155
 156 Routine Description:
 157
 158     This is a call back routine for doing the fast lock call.
 159
 160 Arguments:
 161
 162     FileObject - Supplies the file object used in this operation
 163
 164     FileOffset - Supplies the file offset used in this operation
 165
 166     Length - Supplies the length used in this operation
 167
 168     ProcessId - Supplies the process ID used in this operation
 169
 170     Key - Supplies the key used in this operation
 171
 172     FailImmediately - Indicates if the request should fail immediately
 173         if the lock cannot be granted.
 174
 175     ExclusiveLock - Indicates if this is a request for an exclusive or
 176         shared lock
 177
 178     IoStatus - Receives the Status if this operation is successful
 179
 180 Return Value:
 181
 182     BOOLEAN - TRUE if this operation completed and FALSE if caller
 183         needs to take the long route.
 184
 185 --*/
 186
 187 {
 188     BOOLEAN Results = FALSE;
 189
 190     PFCB Fcb;
 191     TYPE_OF_OPEN TypeOfOpen;
 192
 193     PAGED_CODE();
 194
 195     UNREFERENCED_PARAMETER( DeviceObject );
 196
 197     ASSERT_FILE_OBJECT( FileObject );
 198
 199     IoStatus->Information = 0;
 200
 201     //
 202     //  Decode the type of file object we're being asked to process and
 203     //  make sure that is is only a user file open.
 204     //
 205
 206     TypeOfOpen = CdFastDecodeFileObject( FileObject, &Fcb );
 207
 208     if (TypeOfOpen != UserFileOpen) {
 209
 210         IoStatus->Status = STATUS_INVALID_PARAMETER;
 211         return TRUE;
 212     }
 213
 214     //
 215     //  Only deal with 'good' Fcb's.
 216     //
 217
 218     if (!CdVerifyFcbOperation( NULL, Fcb )) {
 219
 220         return FALSE;
 221     }
 222
 223     FsRtlEnterFileSystem();
 224
 225     //
 226     //  Use a try-finally to facilitate cleanup.
 227     //
 228
 229     _SEH2_TRY {
 230
 231         //
 232         //  We check whether we can proceed based on the state of the file oplocks.
 233         //
 234
 235         if (!FsRtlOplockIsFastIoPossible( CdGetFcbOplock(Fcb) )) {
 236
 237             try_return( NOTHING );
 238         }
 239
 240         //
 241         //  If we don't have a file lock, then get one now.
 242         //
 243
 244         if ((Fcb->FileLock == NULL) && !CdCreateFileLock( NULL, Fcb, FALSE )) {
 245
 246             try_return( NOTHING );
 247         }
 248
 249         //
 250         //  Now call the FsRtl routine to perform the lock request.
 251         //
 252
 253 #ifdef _MSC_VER
 254 #pragma prefast(suppress: 28159, "prefast thinks this is an obsolete routine, but it is ok for CDFS to use it")
 255 #endif
 256         if ((Results = FsRtlFastLock( Fcb->FileLock,
 257                                       FileObject,
 258                                       FileOffset,
 259                                       Length,
 260                                       ProcessId,
 261                                       Key,
 262                                       FailImmediately,
 263                                       ExclusiveLock,
 264                                       IoStatus,
 265                                       NULL,
 266                                       FALSE )) != FALSE) {
 267
 268             //
 269             //  Set the flag indicating if Fast I/O is questionable.  We
 270             //  only change this flag if the current state is possible.
 271             //  Retest again after synchronizing on the header.
 272             //
 273
 274             if (Fcb->IsFastIoPossible == FastIoIsPossible) {
 275
 276                 CdLockFcb( NULL, Fcb );
 277                 Fcb->IsFastIoPossible = CdIsFastIoPossible( Fcb );
 278                 CdUnlockFcb( NULL, Fcb );
 279             }
 280         }
 281
 282     try_exit:  NOTHING;
 283     } _SEH2_FINALLY {
 284
 285         FsRtlExitFileSystem();
 286     } _SEH2_END;
 287
 288     return Results;
 289 }
 290
 291 \f
 292 BOOLEAN
 293 NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
 294 CdFastUnlockSingle (
 295     _In_ PFILE_OBJECT FileObject,
 296     _In_ PLARGE_INTEGER FileOffset,
 297     _In_ PLARGE_INTEGER Length,
 298     _In_ PEPROCESS ProcessId,
 299     _In_ ULONG Key,
 300     _Out_ PIO_STATUS_BLOCK IoStatus,
 301     _In_ PDEVICE_OBJECT DeviceObject
 302     )
 303
 304 /*++
 305
 306 Routine Description:
 307
 308     This is a call back routine for doing the fast unlock single call.
 309
 310 Arguments:
 311
 312     FileObject - Supplies the file object used in this operation
 313
 314     FileOffset - Supplies the file offset used in this operation
 315
 316     Length - Supplies the length used in this operation
 317
 318     ProcessId - Supplies the process ID used in this operation
 319
 320     Key - Supplies the key used in this operation
 321
 322     Status - Receives the Status if this operation is successful
 323
 324 Return Value:
 325
 326     BOOLEAN - TRUE if this operation completed and FALSE if caller
 327         needs to take the long route.
 328
 329 --*/
 330
 331 {
 332     BOOLEAN Results = FALSE;
 333     TYPE_OF_OPEN TypeOfOpen;
 334     PFCB Fcb;
 335
 336     PAGED_CODE();
 337
 338     UNREFERENCED_PARAMETER( DeviceObject );
 339
 340     IoStatus->Information = 0;
 341
 342     //
 343     //  Decode the type of file object we're being asked to process and
 344     //  make sure that is is only a user file open.
 345     //
 346
 347     TypeOfOpen = CdFastDecodeFileObject( FileObject, &Fcb );
 348
 349     if (TypeOfOpen != UserFileOpen) {
 350
 351         IoStatus->Status = STATUS_INVALID_PARAMETER;
 352         return TRUE;
 353     }
 354
 355     //
 356     //  Only deal with 'good' Fcb's.
 357     //
 358
 359     if (!CdVerifyFcbOperation( NULL, Fcb )) {
 360
 361         return FALSE;
 362     }
 363
 364     //
 365     //  If there is no lock then return immediately.
 366     //
 367
 368     if (Fcb->FileLock == NULL) {
 369
 370         IoStatus->Status = STATUS_RANGE_NOT_LOCKED;
 371         return TRUE;
 372     }
 373
 374     FsRtlEnterFileSystem();
 375
 376     _SEH2_TRY {
 377
 378         //
 379         //  We check whether we can proceed based on the state of the file oplocks.
 380         //
 381
 382         if (!FsRtlOplockIsFastIoPossible( CdGetFcbOplock(Fcb) )) {
 383
 384             try_return( NOTHING );
 385         }
 386
 387         //
 388         //  If we don't have a file lock, then get one now.
 389         //
 390
 391         if ((Fcb->FileLock == NULL) && !CdCreateFileLock( NULL, Fcb, FALSE )) {
 392
 393             try_return( NOTHING );
 394         }
 395
 396         //
 397         //  Now call the FsRtl routine to do the actual processing of the
 398         //  Lock request.  The call will always succeed.
 399         //
 400
 401         Results = TRUE;
 402         IoStatus->Status = FsRtlFastUnlockSingle( Fcb->FileLock,
 403                                                   FileObject,
 404                                                   FileOffset,
 405                                                   Length,
 406                                                   ProcessId,
 407                                                   Key,
 408                                                   NULL,
 409                                                   FALSE );
 410
 411         //
 412         //  Set the flag indicating if Fast I/O is possible.  We are
 413         //  only concerned if there are no longer any filelocks on this
 414         //  file.
 415         //
 416
 417         if (!FsRtlAreThereCurrentFileLocks( Fcb->FileLock ) &&
 418             (Fcb->IsFastIoPossible != FastIoIsPossible)) {
 419
 420             CdLockFcb( IrpContext, Fcb );
 421             Fcb->IsFastIoPossible = CdIsFastIoPossible( Fcb );
 422             CdUnlockFcb( IrpContext, Fcb );
 423         }
 424
 425     try_exit:  NOTHING;
 426     } _SEH2_FINALLY {
 427
 428         FsRtlExitFileSystem();
 429     } _SEH2_END;
 430
 431     return Results;
 432 }
 433
 434 \f
 435 BOOLEAN
 436 NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
 437 CdFastUnlockAll (
 438     _In_ PFILE_OBJECT FileObject,
 439     _In_ PEPROCESS ProcessId,
 440     _Out_ PIO_STATUS_BLOCK IoStatus,
 441     _In_ PDEVICE_OBJECT DeviceObject
 442     )
 443
 444 /*++
 445
 446 Routine Description:
 447
 448     This is a call back routine for doing the fast unlock all call.
 449
 450 Arguments:
 451
 452     FileObject - Supplies the file object used in this operation
 453
 454     ProcessId - Supplies the process ID used in this operation
 455
 456     Status - Receives the Status if this operation is successful
 457
 458 Return Value:
 459
 460     BOOLEAN - TRUE if this operation completed and FALSE if caller
 461         needs to take the long route.
 462
 463 --*/
 464
 465 {
 466     BOOLEAN Results = FALSE;
 467     TYPE_OF_OPEN TypeOfOpen;
 468     PFCB Fcb;
 469
 470     PAGED_CODE();
 471
 472     UNREFERENCED_PARAMETER( DeviceObject );
 473
 474     IoStatus->Information = 0;
 475
 476     //
 477     //  Decode the type of file object we're being asked to process and
 478     //  make sure that is is only a user file open.
 479     //
 480
 481     TypeOfOpen = CdFastDecodeFileObject( FileObject, &Fcb );
 482
 483     if (TypeOfOpen != UserFileOpen) {
 484
 485         IoStatus->Status = STATUS_INVALID_PARAMETER;
 486         return TRUE;
 487     }
 488
 489     //
 490     //  Only deal with 'good' Fcb's.
 491     //
 492
 493     if (!CdVerifyFcbOperation( NULL, Fcb )) {
 494
 495         return FALSE;
 496     }
 497
 498     //
 499     //  If there is no lock then return immediately.
 500     //
 501
 502     if (Fcb->FileLock == NULL) {
 503
 504         IoStatus->Status = STATUS_RANGE_NOT_LOCKED;
 505         return TRUE;
 506     }
 507
 508     FsRtlEnterFileSystem();
 509
 510     _SEH2_TRY {
 511
 512         //
 513         //  We check whether we can proceed based on the state of the file oplocks.
 514         //
 515
 516         if (!FsRtlOplockIsFastIoPossible( CdGetFcbOplock(Fcb) )) {
 517
 518             try_return( NOTHING );
 519         }
 520
 521         //
 522         //  If we don't have a file lock, then get one now.
 523         //
 524
 525         if ((Fcb->FileLock == NULL) && !CdCreateFileLock( NULL, Fcb, FALSE )) {
 526
 527             try_return( NOTHING );
 528         }
 529
 530         //
 531         //  Now call the FsRtl routine to do the actual processing of the
 532         //  Lock request.  The call will always succeed.
 533         //
 534
 535         Results = TRUE;
 536         IoStatus->Status = FsRtlFastUnlockAll( Fcb->FileLock,
 537                                                FileObject,
 538                                                ProcessId,
 539                                                NULL );
 540
 541
 542         //
 543         //  Set the flag indicating if Fast I/O is possible
 544         //
 545
 546         CdLockFcb( IrpContext, Fcb );
 547         Fcb->IsFastIoPossible = CdIsFastIoPossible( Fcb );
 548         CdUnlockFcb( IrpContext, Fcb );
 549
 550     try_exit:  NOTHING;
 551     } _SEH2_FINALLY {
 552
 553         FsRtlExitFileSystem();
 554     } _SEH2_END;
 555
 556     return Results;
 557 }
 558
 559 \f
 560 BOOLEAN
 561 NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
 562 CdFastUnlockAllByKey (
 563     _In_ PFILE_OBJECT FileObject,
 564     _In_ PVOID ProcessId,
 565     _In_ ULONG Key,
 566     _Out_ PIO_STATUS_BLOCK IoStatus,
 567     _In_ PDEVICE_OBJECT DeviceObject
 568     )
 569
 570 /*++
 571
 572 Routine Description:
 573
 574     This is a call back routine for doing the fast unlock all by key call.
 575
 576 Arguments:
 577
 578     FileObject - Supplies the file object used in this operation
 579
 580     ProcessId - Supplies the process ID used in this operation
 581
 582     Key - Supplies the key used in this operation
 583
 584     Status - Receives the Status if this operation is successful
 585
 586 Return Value:
 587
 588     BOOLEAN - TRUE if this operation completed and FALSE if caller
 589         needs to take the long route.
 590
 591 --*/
 592
 593 {
 594     BOOLEAN Results = FALSE;
 595     TYPE_OF_OPEN TypeOfOpen;
 596     PFCB Fcb;
 597
 598     PAGED_CODE();
 599
 600     UNREFERENCED_PARAMETER( DeviceObject );
 601
 602     IoStatus->Information = 0;
 603
 604     //
 605     //  Decode the type of file object we're being asked to process and
 606     //  make sure that is is only a user file open.
 607     //
 608
 609     TypeOfOpen = CdFastDecodeFileObject( FileObject, &Fcb );
 610
 611     if (TypeOfOpen != UserFileOpen) {
 612
 613         IoStatus->Status = STATUS_INVALID_PARAMETER;
 614         return TRUE;
 615     }
 616
 617     //
 618     //  Only deal with 'good' Fcb's.
 619     //
 620
 621     if (!CdVerifyFcbOperation( NULL, Fcb )) {
 622
 623         return FALSE;
 624     }
 625
 626     //
 627     //  If there is no lock then return immediately.
 628     //
 629
 630     if (Fcb->FileLock == NULL) {
 631
 632         IoStatus->Status = STATUS_RANGE_NOT_LOCKED;
 633         return TRUE;
 634     }
 635
 636     FsRtlEnterFileSystem();
 637
 638     _SEH2_TRY {
 639
 640         //
 641         //  We check whether we can proceed based on the state of the file oplocks.
 642         //
 643
 644         if (!FsRtlOplockIsFastIoPossible( CdGetFcbOplock(Fcb) )) {
 645
 646             try_return( NOTHING );
 647         }
 648
 649         //
 650         //  If we don't have a file lock, then get one now.
 651         //
 652
 653         if ((Fcb->FileLock == NULL) && !CdCreateFileLock( NULL, Fcb, FALSE )) {
 654
 655             try_return( NOTHING );
 656         }
 657
 658         //
 659         //  Now call the FsRtl routine to do the actual processing of the
 660         //  Lock request.  The call will always succeed.
 661         //
 662
 663         Results = TRUE;
 664         IoStatus->Status = FsRtlFastUnlockAllByKey( Fcb->FileLock,
 665                                                     FileObject,
 666                                                     ProcessId,
 667                                                     Key,
 668                                                     NULL );
 669
 670
 671         //
 672         //  Set the flag indicating if Fast I/O is possible
 673         //
 674
 675         CdLockFcb( IrpContext, Fcb );
 676         Fcb->IsFastIoPossible = CdIsFastIoPossible( Fcb );
 677         CdUnlockFcb( IrpContext, Fcb );
 678
 679     try_exit:  NOTHING;
 680     } _SEH2_FINALLY {
 681
 682         FsRtlExitFileSystem();
 683     } _SEH2_END;
 684
 685     return Results;
 686 }
 687
 688
 689