ReactOS 0.4.15-dev-8339-g4028de8
fspdisp.c File Reference
#include "fatprocs.h"
Include dependency graph for fspdisp.c:

Go to the source code of this file.

Macros

#define Dbg   (DEBUG_TRACE_FSP_DISPATCHER)
 

Functions

PVOID FatRemoveOverflowEntry (IN PVOLUME_DEVICE_OBJECT VolDo)
 
VOID NTAPI FatFspDispatch (_In_ PVOID Context)
 

Macro Definition Documentation

◆ Dbg

#define Dbg   (DEBUG_TRACE_FSP_DISPATCHER)

Definition at line 32 of file fspdisp.c.

Function Documentation

◆ FatFspDispatch()

VOID NTAPI FatFspDispatch ( _In_ PVOID  Context)

Definition at line 41 of file fspdisp.c.

65{
67
68
69 PIRP Irp;
70 PIRP_CONTEXT IrpContext;
72 BOOLEAN VcbDeleted;
73 BOOLEAN ExceptionCompletedIrp = FALSE;
74
76
78
79 PAGED_CODE();
80
81 IrpContext = (PIRP_CONTEXT)Context;
82
83 Irp = IrpContext->OriginatingIrp;
84
86
87 //
88 // Now because we are the Fsp we will force the IrpContext to
89 // indicate true on Wait.
90 //
91
93
94 //
95 // If this request has an associated volume device object, remember it.
96 //
97
98 if ( IrpSp->FileObject != NULL ) {
99
102 DeviceObject );
103 } else {
104
105 VolDo = NULL;
106 }
107
108 //
109 // Now case on the function code. For each major function code,
110 // either call the appropriate FSP routine or case on the minor
111 // function and then call the FSP routine. The FSP routine that
112 // we call is responsible for completing the IRP, and not us.
113 // That way the routine can complete the IRP and then continue
114 // post processing as required. For example, a read can be
115 // satisfied right away and then read can be done.
116 //
117 // We'll do all of the work within an exception handler that
118 // will be invoked if ever some underlying operation gets into
119 // trouble (e.g., if FatReadSectorsSync has trouble).
120 //
121
122 while ( TRUE ) {
123
124 ExceptionCompletedIrp = FALSE;
125
126 DebugTrace(0, Dbg, "FatFspDispatch: Irp = %p\n", Irp);
127
128 //
129 // If this Irp was top level, note it in our thread local storage.
130 //
131
133
134 if ( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL) ) {
135
137
138 } else {
139
141 }
142
143 MajorFunction = IrpContext->MajorFunction;
144
145 _SEH2_TRY {
146
147 switch ( MajorFunction ) {
148
149 //
150 // For Create Operation,
151 //
152
153 case IRP_MJ_CREATE:
154
155 Status = FatCommonCreate( IrpContext, Irp );
156 break;
157
158 //
159 // For close operations. We do a little kludge here in case
160 // this close causes a volume to go away. It will NULL the
161 // VolDo local variable so that we will not try to look at
162 // the overflow queue.
163 //
164
165 case IRP_MJ_CLOSE:
166
167 {
168 PVCB Vcb;
169 PFCB Fcb;
170 PCCB Ccb;
172
173 //
174 // Extract and decode the file object
175 //
176
178
179 //
180 // Do the close. We have a slightly different format
181 // for this call because of the async closes.
182 //
183
184 Status = FatCommonClose( Vcb,
185 Fcb,
186 Ccb,
188 TRUE,
189 TRUE,
190 &VcbDeleted );
191
192 //
193 // If the VCB was deleted, do not try to access it later.
194 //
195
196 if (VcbDeleted) {
197
198 VolDo = NULL;
199 }
200
202
203 FatCompleteRequest( IrpContext, Irp, Status );
204
205 break;
206 }
207
208 //
209 // For read operations
210 //
211
212 case IRP_MJ_READ:
213
214 (VOID) FatCommonRead( IrpContext, Irp );
215 break;
216
217 //
218 // For write operations,
219 //
220
221 case IRP_MJ_WRITE:
222
223 (VOID) FatCommonWrite( IrpContext, Irp );
224 break;
225
226 //
227 // For Query Information operations,
228 //
229
231
232 (VOID) FatCommonQueryInformation( IrpContext, Irp );
233 break;
234
235 //
236 // For Set Information operations,
237 //
238
240
241 (VOID) FatCommonSetInformation( IrpContext, Irp );
242 break;
243
244 //
245 // For Query EA operations,
246 //
247
248 case IRP_MJ_QUERY_EA:
249
250 (VOID) FatCommonQueryEa( IrpContext, Irp );
251 break;
252
253 //
254 // For Set EA operations,
255 //
256
257 case IRP_MJ_SET_EA:
258
259 (VOID) FatCommonSetEa( IrpContext, Irp );
260 break;
261
262 //
263 // For Flush buffers operations,
264 //
265
267
268 (VOID) FatCommonFlushBuffers( IrpContext, Irp );
269 break;
270
271 //
272 // For Query Volume Information operations,
273 //
274
276
277 (VOID) FatCommonQueryVolumeInfo( IrpContext, Irp );
278 break;
279
280 //
281 // For Set Volume Information operations,
282 //
283
285
286 (VOID) FatCommonSetVolumeInfo( IrpContext, Irp );
287 break;
288
289 //
290 // For File Cleanup operations,
291 //
292
293 case IRP_MJ_CLEANUP:
294
295 (VOID) FatCommonCleanup( IrpContext, Irp );
296 break;
297
298 //
299 // For Directory Control operations,
300 //
301
303
304 (VOID) FatCommonDirectoryControl( IrpContext, Irp );
305 break;
306
307 //
308 // For File System Control operations,
309 //
310
312
313 (VOID) FatCommonFileSystemControl( IrpContext, Irp );
314 break;
315
316 //
317 // For Lock Control operations,
318 //
319
321
322 (VOID) FatCommonLockControl( IrpContext, Irp );
323 break;
324
325 //
326 // For Device Control operations,
327 //
328
330
331 (VOID) FatCommonDeviceControl( IrpContext, Irp );
332 break;
333
334 //
335 // For the Shutdown operation,
336 //
337
338 case IRP_MJ_SHUTDOWN:
339
340 (VOID) FatCommonShutdown( IrpContext, Irp );
341 break;
342
343 //
344 // For plug and play operations.
345 //
346
347 case IRP_MJ_PNP:
348
349 //
350 // I don't believe this should ever occur, but allow for the unexpected.
351 //
352
353 (VOID) FatCommonPnp( IrpContext, Irp );
354 break;
355
356 //
357 // For any other major operations, return an invalid
358 // request.
359 //
360
361 default:
362
364 break;
365
366 }
367
369
370 //
371 // We had some trouble trying to perform the requested
372 // operation, so we'll abort the I/O request with
373 // the error status that we get back from the
374 // execption code.
375 //
376
377 (VOID) FatProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
378 ExceptionCompletedIrp = TRUE;
379 } _SEH2_END;
380
382
384
385
386 if (MajorFunction == IRP_MJ_CREATE && !ExceptionCompletedIrp && Status != STATUS_PENDING) {
387
388 //
389 // Creates are completed here. IrpContext is also freed here.
390 //
391
392 FatCompleteRequest( IrpContext, Irp, Status );
393 }
394
395 //
396 // If there are any entries on this volume's overflow queue, service
397 // them.
398 //
399
400 if ( VolDo != NULL ) {
401
402 PVOID Entry;
403
404 //
405 // We have a volume device object so see if there is any work
406 // left to do in its overflow queue.
407 //
408
409 Entry = FatRemoveOverflowEntry( VolDo );
410
411 //
412 // There wasn't an entry, break out of the loop and return to
413 // the Ex Worker thread.
414 //
415
416 if ( Entry == NULL ) {
417
418 break;
419 }
420
421 //
422 // Extract the IrpContext, Irp, and IrpSp, and loop.
423 //
424
425 IrpContext = CONTAINING_RECORD( Entry,
427 WorkQueueItem.List );
428
430
431 Irp = IrpContext->OriginatingIrp;
432
434
435 continue;
436
437 } else {
438
439 break;
440 }
441 }
442
443 return;
444}
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
#define PAGED_CODE()
unsigned char BOOLEAN
#define VOID
Definition: acefi.h:82
LONG NTSTATUS
Definition: precomp.h:26
_Inout_ PFILE_OBJECT _In_ TYPE_OF_OPEN TypeOfOpen
Definition: cdprocs.h:589
_In_ PFCB Fcb
Definition: cdprocs.h:159
_Inout_ PFILE_OBJECT _In_ TYPE_OF_OPEN PFCB _In_opt_ PCCB Ccb
Definition: cdprocs.h:592
enum _TYPE_OF_OPEN TYPE_OF_OPEN
#define IRP_MJ_PNP
Definition: cdrw_usr.h:52
#define IRP_CONTEXT_FLAG_IN_FSP
Definition: cdstruc.h:1219
#define IRP_CONTEXT_FLAG_WAIT
Definition: cdstruc.h:1215
IRP_CONTEXT * PIRP_CONTEXT
Definition: cdstruc.h:1211
_In_ PIRP Irp
Definition: csq.h:116
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4137
NTSTATUS FatCommonQueryEa(IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
Definition: ea.c:250
NTSTATUS FatCommonSetEa(IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
Definition: ea.c:659
#define SetFlag(_F, _SF)
Definition: ext2fs.h:187
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
PVOID FatRemoveOverflowEntry(IN PVOLUME_DEVICE_OBJECT VolDo)
Definition: fspdisp.c:452
#define Dbg
Definition: fspdisp.c:32
ULONG FatExceptionFilter(IN PIRP_CONTEXT IrpContext, IN PEXCEPTION_POINTERS ExceptionPointer)
Definition: fatdata.c:204
#define DebugTrace(INDENT, LEVEL, X, Y)
Definition: fatdata.h:313
TYPE_OF_OPEN FatDecodeFileObject(_In_ PFILE_OBJECT FileObject, _Outptr_ PVCB *Vcb, _Outptr_ PFCB *FcbOrDcb, _Outptr_ PCCB *Ccb)
Definition: filobsup.c:176
#define FatCompleteRequest(IRPCONTEXT, IRP, STATUS)
Definition: fatprocs.h:2633
#define IRP_CONTEXT_FLAG_RECURSIVE_CALL
Definition: fatstruc.h:1566
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
#define FsRtlEnterFileSystem
#define FsRtlExitFileSystem
#define FSRTL_FSP_TOP_LEVEL_IRP
Definition: fsrtltypes.h:59
Status
Definition: gdiplustypes.h:25
VOID NTAPI IoSetTopLevelIrp(IN PIRP Irp)
Definition: irp.c:2000
#define STATUS_PENDING
Definition: ntstatus.h:82
#define Vcb
Definition: cdprocs.h:1415
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:66
#define _SEH2_GetExceptionInformation()
Definition: pseh2_64.h:164
#define IRP_MJ_DIRECTORY_CONTROL
Definition: rdpdr.c:51
#define IRP_MJ_CLOSE
Definition: rdpdr.c:45
#define IRP_MJ_READ
Definition: rdpdr.c:46
#define IRP_MJ_DEVICE_CONTROL
Definition: rdpdr.c:52
#define IRP_MJ_QUERY_VOLUME_INFORMATION
Definition: rdpdr.c:50
#define IRP_MJ_LOCK_CONTROL
Definition: rdpdr.c:53
#define IRP_MJ_WRITE
Definition: rdpdr.c:47
#define IRP_MJ_SET_INFORMATION
Definition: rdpdr.c:49
#define IRP_MJ_CREATE
Definition: rdpdr.c:44
#define IRP_MJ_QUERY_INFORMATION
Definition: rdpdr.c:48
#define STATUS_SUCCESS
Definition: shellext.h:65
base of all file and directory entries
Definition: entries.h:83
Definition: cdstruc.h:1067
Definition: cdstruc.h:902
PFILE_OBJECT FileObject
Definition: iotypes.h:3169
PDEVICE_OBJECT DeviceObject
Definition: iotypes.h:3223
Definition: cdstruc.h:498
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_In_ UCHAR MajorFunction
Definition: wdfdevice.h:1697
#define IRP_MJ_QUERY_EA
#define IRP_MJ_FILE_SYSTEM_CONTROL
#define IRP_MJ_SET_VOLUME_INFORMATION
#define IRP_MJ_SET_EA
#define IRP_MJ_FLUSH_BUFFERS
#define IRP_MJ_SHUTDOWN
#define IRP_MJ_CLEANUP
#define NT_ASSERT
Definition: rtlfuncs.h:3310
unsigned char UCHAR
Definition: xmlstorage.h:181

◆ FatRemoveOverflowEntry()

PVOID FatRemoveOverflowEntry ( IN PVOLUME_DEVICE_OBJECT  VolDo)

Definition at line 452 of file fspdisp.c.

455{
456 PVOID Entry;
457 KIRQL SavedIrql;
458
459 KeAcquireSpinLock( &VolDo->OverflowQueueSpinLock, &SavedIrql );
460
461 if (VolDo->OverflowQueueCount > 0) {
462
463 //
464 // There is overflow work to do in this volume so we'll
465 // decrement the Overflow count, dequeue the IRP, and release
466 // the Event
467 //
468
469 VolDo->OverflowQueueCount -= 1;
470
471 Entry = RemoveHeadList( &VolDo->OverflowQueue );
472
473 } else {
474
475 VolDo->PostedRequestCount -= 1;
476
477 Entry = NULL;
478 }
479
480 KeReleaseSpinLock( &VolDo->OverflowQueueSpinLock, SavedIrql );
481
482 return Entry;
483}
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
#define RemoveHeadList(ListHead)
Definition: env_spec_w32.h:964

Referenced by FatFspDispatch().