ReactOS 0.4.16-dev-1946-g52006dd
Macros | Functions
lockctrl.c File Reference
#include "cdprocs.h"
Include dependency graph for lockctrl.c:

Go to the source code of this file.

Macros

#define BugCheckFileId   (CDFS_BUG_CHECK_LOCKCTRL)
 

Functions

NTSTATUS CdCommonLockControl (_Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp)
 
BOOLEAN NTAPI CdFastLock (_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ PLARGE_INTEGER Length, _In_ PEPROCESS ProcessId, _In_ ULONG Key, _In_ BOOLEAN FailImmediately, _In_ BOOLEAN ExclusiveLock, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
 
BOOLEAN NTAPI CdFastUnlockSingle (_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ PLARGE_INTEGER Length, _In_ PEPROCESS ProcessId, _In_ ULONG Key, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
 
BOOLEAN NTAPI CdFastUnlockAll (_In_ PFILE_OBJECT FileObject, _In_ PEPROCESS ProcessId, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
 
BOOLEAN NTAPI CdFastUnlockAllByKey (_In_ PFILE_OBJECT FileObject, _In_ PVOID ProcessId, _In_ ULONG Key, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
 

Macro Definition Documentation

◆ BugCheckFileId

#define BugCheckFileId   (CDFS_BUG_CHECK_LOCKCTRL)

Definition at line 23 of file lockctrl.c.

Function Documentation

◆ CdCommonLockControl()

NTSTATUS CdCommonLockControl ( _Inout_ PIRP_CONTEXT  IrpContext,
_Inout_ PIRP  Irp 
)

Definition at line 35 of file lockctrl.c.

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}
IoGetCurrentIrpStackLocation
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
Definition: Bus_PDO_EvalMethod.c:150
PAGED_CODE
#define PAGED_CODE()
Definition: Bus_PDO_EvalMethod.c:87
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
CdCompleteRequest
VOID CdCompleteRequest(_Inout_opt_ PIRP_CONTEXT IrpContext, _Inout_opt_ PIRP Irp, _In_ NTSTATUS Status)
Definition: cddata.c:914
CdLockFcb
#define CdLockFcb(IC, F)
Definition: cdprocs.h:1044
TypeOfOpen
_Inout_ PFILE_OBJECT _In_ TYPE_OF_OPEN TypeOfOpen
Definition: cdprocs.h:589
UserFileOpen
@ UserFileOpen
Definition: cdprocs.h:577
CdGetFcbOplock
#define CdGetFcbOplock(F)
Definition: cdprocs.h:1081
Fcb
_In_ PFCB Fcb
Definition: cdprocs.h:159
Ccb
_Inout_ PFILE_OBJECT _In_ TYPE_OF_OPEN PFCB _In_opt_ PCCB Ccb
Definition: cdprocs.h:592
CdVerifyFcbOperation
BOOLEAN CdVerifyFcbOperation(_In_opt_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb)
Definition: verfysup.c:615
TYPE_OF_OPEN
enum _TYPE_OF_OPEN TYPE_OF_OPEN
CdIsFastIoPossible
#define CdIsFastIoPossible(F)
Definition: cdprocs.h:2015
CdUnlockFcb
#define CdUnlockFcb(IC, F)
Definition: cdprocs.h:1060
Irp
_In_ PIRP Irp
Definition: csq.h:116
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
IrpSp
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4138
FsRtlProcessFileLock
NTSTATUS NTAPI FsRtlProcessFileLock(IN PFILE_LOCK FileLock, IN PIRP Irp, IN PVOID Context OPTIONAL)
Definition: filelock.c:1152
Status
Status
Definition: gdiplustypes.h:25
FsRtlCheckOplock
NTSTATUS NTAPI FsRtlCheckOplock(IN POPLOCK Oplock, IN PIRP Irp, IN PVOID Context, IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine OPTIONAL, IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine OPTIONAL)
Definition: oplock.c:1170
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
_CCB
Definition: cdstruc.h:1067
_FCB
Definition: cdstruc.h:902
_FCB::FileLock
FILE_LOCK FileLock
Definition: fatstruc.h:1071
_IO_STACK_LOCATION
Definition: Bus_PDO_EvalMethod.c:93
_IO_STACK_LOCATION::FileObject
PFILE_OBJECT FileObject
Definition: iotypes.h:3171
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135

Referenced by _IRQL_requires_max_(), and CdFspDispatch().

◆ CdFastLock()

BOOLEAN NTAPI CdFastLock ( _In_ PFILE_OBJECT  FileObject,
_In_ PLARGE_INTEGER  FileOffset,
_In_ PLARGE_INTEGER  Length,
_In_ PEPROCESS  ProcessId,
_In_ ULONG  Key,
_In_ BOOLEAN  FailImmediately,
_In_ BOOLEAN  ExclusiveLock,
_Out_ PIO_STATUS_BLOCK  IoStatus,
_In_ PDEVICE_OBJECT  DeviceObject 
)

Definition at line 142 of file lockctrl.c.

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}
BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185
ASSERT_FILE_OBJECT
#define ASSERT_FILE_OBJECT(FO)
Definition: cddata.h:252
FileOffset
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:160
CdFastDecodeFileObject
TYPE_OF_OPEN CdFastDecodeFileObject(_In_ PFILE_OBJECT FileObject, _Out_ PFCB *Fcb)
Definition: filobsup.c:206
try_return
#define try_return(S)
Definition: cdprocs.h:2179
FALSE
#define FALSE
Definition: types.h:117
ExclusiveLock
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ULONG BOOLEAN BOOLEAN ExclusiveLock
Definition: fatprocs.h:2715
FailImmediately
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ULONG BOOLEAN FailImmediately
Definition: fatprocs.h:2714
ProcessId
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ProcessId
Definition: fatprocs.h:2712
FsRtlEnterFileSystem
#define FsRtlEnterFileSystem
FsRtlExitFileSystem
#define FsRtlExitFileSystem
FsRtlFastLock
#define FsRtlFastLock(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)
Definition: fsrtlfuncs.h:1581
FastIoIsPossible
@ FastIoIsPossible
Definition: fsrtltypes.h:241
NOTHING
#define NOTHING
Definition: input_list.c:10
IoStatus
__in UCHAR __in POWER_STATE __in_opt PVOID __in PIO_STATUS_BLOCK IoStatus
Definition: mxum.h:159
UNREFERENCED_PARAMETER
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:329
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
FsRtlOplockIsFastIoPossible
BOOLEAN NTAPI FsRtlOplockIsFastIoPossible(IN POPLOCK Oplock)
Definition: oplock.c:1564
_SEH2_FINALLY
#define _SEH2_FINALLY
Definition: pseh2_64.h:130
_SEH2_END
#define _SEH2_END
Definition: pseh2_64.h:171
_SEH2_TRY
#define _SEH2_TRY
Definition: pseh2_64.h:71
DeviceObject
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2061
FileObject
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:550

◆ CdFastUnlockAll()

BOOLEAN NTAPI CdFastUnlockAll ( _In_ PFILE_OBJECT  FileObject,
_In_ PEPROCESS  ProcessId,
_Out_ PIO_STATUS_BLOCK  IoStatus,
_In_ PDEVICE_OBJECT  DeviceObject 
)

Definition at line 437 of file lockctrl.c.

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}
FsRtlFastUnlockAll
NTSTATUS NTAPI FsRtlFastUnlockAll(IN PFILE_LOCK FileLock, IN PFILE_OBJECT FileObject, IN PEPROCESS Process, IN PVOID Context OPTIONAL)
Definition: filelock.c:1025
STATUS_RANGE_NOT_LOCKED
#define STATUS_RANGE_NOT_LOCKED
Definition: ntstatus.h:456

◆ CdFastUnlockAllByKey()

BOOLEAN NTAPI CdFastUnlockAllByKey ( _In_ PFILE_OBJECT  FileObject,
_In_ PVOID  ProcessId,
_In_ ULONG  Key,
_Out_ PIO_STATUS_BLOCK  IoStatus,
_In_ PDEVICE_OBJECT  DeviceObject 
)

Definition at line 562 of file lockctrl.c.

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}
FsRtlFastUnlockAllByKey
NTSTATUS NTAPI FsRtlFastUnlockAllByKey(IN PFILE_LOCK FileLock, IN PFILE_OBJECT FileObject, IN PEPROCESS Process, IN ULONG Key, IN PVOID Context OPTIONAL)
Definition: filelock.c:1086

◆ CdFastUnlockSingle()

BOOLEAN NTAPI CdFastUnlockSingle ( _In_ PFILE_OBJECT  FileObject,
_In_ PLARGE_INTEGER  FileOffset,
_In_ PLARGE_INTEGER  Length,
_In_ PEPROCESS  ProcessId,
_In_ ULONG  Key,
_Out_ PIO_STATUS_BLOCK  IoStatus,
_In_ PDEVICE_OBJECT  DeviceObject 
)

Definition at line 294 of file lockctrl.c.

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}
FsRtlFastUnlockSingle
NTSTATUS NTAPI FsRtlFastUnlockSingle(IN PFILE_LOCK FileLock, IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, IN PEPROCESS Process, IN ULONG Key, IN PVOID Context OPTIONAL, IN BOOLEAN AlreadySynchronized)
Definition: filelock.c:825
FsRtlAreThereCurrentFileLocks
#define FsRtlAreThereCurrentFileLocks(FL)
Definition: fsrtlfuncs.h:1584