Remove unnecessary executable bits
[reactos.git] / drivers / filesystems / cdfs_new / resrcsup.c
1 /*++
2
3 Copyright (c) 1989-2000 Microsoft Corporation
4
5 Module Name:
6
7 ResrcSup.c
8
9 Abstract:
10
11 This module implements the Cdfs Resource acquisition routines
12
13
14 --*/
15
16 #include "cdprocs.h"
17
18 //
19 // The Bug check file id for this module
20 //
21
22 #define BugCheckFileId (CDFS_BUG_CHECK_RESRCSUP)
23
24 #ifdef ALLOC_PRAGMA
25 #pragma alloc_text(PAGE, CdAcquireForCache)
26 #pragma alloc_text(PAGE, CdFilterCallbackAcquireForCreateSection)
27 #pragma alloc_text(PAGE, CdAcquireResource)
28 #pragma alloc_text(PAGE, CdNoopAcquire)
29 #pragma alloc_text(PAGE, CdNoopRelease)
30 #pragma alloc_text(PAGE, CdReleaseForCreateSection)
31 #pragma alloc_text(PAGE, CdReleaseFromCache)
32 #endif
33
34 \f
35
36 _Requires_lock_held_(_Global_critical_region_)
37 _When_(Type == AcquireExclusive && return != FALSE, _Acquires_exclusive_lock_(*Resource))
38 _When_(Type == AcquireShared && return != FALSE, _Acquires_shared_lock_(*Resource))
39 _When_(Type == AcquireSharedStarveExclusive && return != FALSE, _Acquires_shared_lock_(*Resource))
40 _When_(IgnoreWait == FALSE, _Post_satisfies_(return == TRUE))
41 BOOLEAN
42 CdAcquireResource (
43 _In_ PIRP_CONTEXT IrpContext,
44 _Inout_ PERESOURCE Resource,
45 _In_ BOOLEAN IgnoreWait,
46 _In_ TYPE_OF_ACQUIRE Type
47 )
48
49 /*++
50
51 Routine Description:
52
53 This is the single routine used to acquire file system resources. It
54 looks at the IgnoreWait flag to determine whether to try to acquire the
55 resource without waiting. Returning TRUE/FALSE to indicate success or
56 failure. Otherwise it is driven by the WAIT flag in the IrpContext and
57 will raise CANT_WAIT on a failure.
58
59 Arguments:
60
61 Resource - This is the resource to try and acquire.
62
63 IgnoreWait - If TRUE then this routine will not wait to acquire the
64 resource and will return a boolean indicating whether the resource was
65 acquired. Otherwise we use the flag in the IrpContext and raise
66 if the resource is not acquired.
67
68 Type - Indicates how we should try to get the resource.
69
70 Return Value:
71
72 BOOLEAN - TRUE if the resource is acquired. FALSE if not acquired and
73 IgnoreWait is specified. Otherwise we raise CANT_WAIT.
74
75 --*/
76
77 {
78 BOOLEAN Wait = FALSE;
79 BOOLEAN Acquired;
80 PAGED_CODE();
81
82 //
83 // We look first at the IgnoreWait flag, next at the flag in the Irp
84 // Context to decide how to acquire this resource.
85 //
86
87 if (!IgnoreWait && FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
88
89 Wait = TRUE;
90 }
91
92 //
93 // Attempt to acquire the resource either shared or exclusively.
94 //
95
96 switch (Type) {
97 case AcquireExclusive:
98
99 #ifdef _MSC_VER
100 #pragma prefast( suppress:28137, "prefast believes Wait should be a constant, but this is ok for CDFS" )
101 #endif
102 Acquired = ExAcquireResourceExclusiveLite( Resource, Wait );
103 break;
104
105 case AcquireShared:
106
107 Acquired = ExAcquireResourceSharedLite( Resource, Wait );
108 break;
109
110 case AcquireSharedStarveExclusive:
111
112 Acquired = ExAcquireSharedStarveExclusive( Resource, Wait );
113 break;
114
115 default:
116 Acquired = FALSE;
117 NT_ASSERT( FALSE );
118 }
119
120 //
121 // If not acquired and the user didn't specifiy IgnoreWait then
122 // raise CANT_WAIT.
123 //
124
125 if (!Acquired && !IgnoreWait) {
126
127 CdRaiseStatus( IrpContext, STATUS_CANT_WAIT );
128 }
129
130 return Acquired;
131 }
132
133 \f
134
135 _Requires_lock_held_(_Global_critical_region_)
136 _When_(return!=0, _Acquires_shared_lock_(*Fcb->Resource))
137 BOOLEAN
138 NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
139 CdAcquireForCache (
140 _Inout_ PFCB Fcb,
141 _In_ BOOLEAN Wait
142 )
143
144 /*++
145
146 Routine Description:
147
148 The address of this routine is specified when creating a CacheMap for
149 a file. It is subsequently called by the Lazy Writer for synchronization.
150
151 Arguments:
152
153 Fcb - The pointer supplied as context to the cache initialization
154 routine.
155
156 Wait - TRUE if the caller is willing to block.
157
158 Return Value:
159
160 None
161
162 --*/
163
164 {
165 PAGED_CODE();
166
167 if (!ExAcquireResourceSharedLite( Fcb->Resource, Wait )) {
168
169 return FALSE;
170 }
171
172 NT_ASSERT(IoGetTopLevelIrp() == NULL);
173 IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
174
175 return TRUE;
176 }
177
178 \f
179 _Requires_lock_held_(_Global_critical_region_)
180 _Releases_lock_(*Fcb->Resource)
181 VOID
182 NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
183 CdReleaseFromCache (
184 _Inout_ PFCB Fcb
185 )
186
187 /*++
188
189 Routine Description:
190
191 The address of this routine is specified when creating a CacheMap for
192 a virtual file. It is subsequently called by the Lazy Writer to release
193 a resource acquired above.
194
195 Arguments:
196
197 Fcb - The pointer supplied as context to the cache initialization
198 routine.
199
200 Return Value:
201
202 None
203
204 --*/
205
206 {
207 PAGED_CODE();
208
209 NT_ASSERT(IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
210 IoSetTopLevelIrp( NULL );
211
212 ExReleaseResourceLite( Fcb->Resource );
213 }
214
215 \f
216 BOOLEAN
217 NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
218 CdNoopAcquire (
219 _In_ PVOID Fcb,
220 _In_ BOOLEAN Wait
221 )
222
223 /*++
224
225 Routine Description:
226
227 This routine does nothing.
228
229 Arguments:
230
231 Fcb - The Fcb/Vcb which was specified as a context parameter for this
232 routine.
233
234 Wait - TRUE if the caller is willing to block.
235
236 Return Value:
237
238 TRUE
239
240 --*/
241
242 {
243 PAGED_CODE();
244
245 UNREFERENCED_PARAMETER( Fcb );
246 UNREFERENCED_PARAMETER( Wait );
247
248 return TRUE;
249 }
250
251 \f
252 VOID
253 NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
254 CdNoopRelease (
255 _In_ PVOID Fcb
256 )
257
258 /*++
259
260 Routine Description:
261
262 This routine does nothing.
263
264 Arguments:
265
266 Fcb - The Fcb/Vcb which was specified as a context parameter for this
267 routine.
268
269 Return Value:
270
271 None
272
273 --*/
274
275 {
276 PAGED_CODE();
277
278 UNREFERENCED_PARAMETER( Fcb );
279 }
280
281
282 _Requires_lock_held_(_Global_critical_region_)
283 NTSTATUS
284 NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
285 CdFilterCallbackAcquireForCreateSection (
286 _In_ PFS_FILTER_CALLBACK_DATA CallbackData,
287 _Unreferenced_parameter_ PVOID *CompletionContext
288 )
289
290 /*++
291
292 Routine Description:
293
294 This is the callback routine for MM to use to acquire the file exclusively.
295
296 Arguments:
297
298 FS_FILTER_CALLBACK_DATA - Filter based callback data that provides the file object we
299 want to acquire.
300
301 CompletionContext - Ignored.
302
303 Return Value:
304
305 On success we return STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY.
306
307 If SyncType is SyncTypeCreateSection, we return a status that indicates there are no
308 writers to this file.
309
310 --*/
311
312 {
313 PFILE_OBJECT FileObject;
314
315
316 PAGED_CODE();
317
318 NT_ASSERT( CallbackData->Operation == FS_FILTER_ACQUIRE_FOR_SECTION_SYNCHRONIZATION );
319 NT_ASSERT( CallbackData->SizeOfFsFilterCallbackData == sizeof(FS_FILTER_CALLBACK_DATA) );
320
321 //
322 // Get the file object from the callback data.
323 //
324
325 FileObject = CallbackData->FileObject;
326
327 //
328 // Get the Fcb resource exclusively.
329 //
330
331 ExAcquireResourceExclusiveLite( &((PFCB) FileObject->FsContext)->FcbNonpaged->FcbResource,
332 TRUE );
333
334 //
335 // Take the File resource shared. We need this later on when MM calls
336 // QueryStandardInfo to get the file size.
337 //
338 // If we don't use StarveExclusive, then we can get wedged behind an
339 // exclusive waiter who is waiting on someone else holding it shared in the
340 // read->initializecachemap path (which calls createsection) who is in turn
341 // waiting on us to finish the create section.
342 //
343
344 ExAcquireSharedStarveExclusive( ((PFCB) FileObject->FsContext)->Resource,
345 TRUE );
346
347 //
348 // CDFS is a read-only file system, so we can always indicate no writers.
349 // We only do this for create section synchronization. For others we
350 // return the generic success STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY.
351 //
352
353 if (CallbackData->Parameters.AcquireForSectionSynchronization.SyncType == SyncTypeCreateSection) {
354
355 return STATUS_FILE_LOCKED_WITH_ONLY_READERS;
356
357 } else {
358
359 return STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY;
360 }
361
362 UNREFERENCED_PARAMETER( CompletionContext );
363 }
364
365 \f
366 _Function_class_(FAST_IO_RELEASE_FILE)
367 _Requires_lock_held_(_Global_critical_region_)
368 VOID
369 NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
370 CdReleaseForCreateSection (
371 _In_ PFILE_OBJECT FileObject
372 )
373
374 /*++
375
376 Routine Description:
377
378 This is the callback routine for MM to use to release a file acquired with
379 the AcquireForCreateSection call above.
380
381 Arguments:
382
383 FileObject - File object for a Cdfs stream.
384
385 Return Value:
386
387 None
388
389 --*/
390
391 {
392 PAGED_CODE();
393
394 //
395 // Release the resources.
396 //
397
398 ExReleaseResourceLite( &((PFCB) FileObject->FsContext)->FcbNonpaged->FcbResource );
399 ExReleaseResourceLite( ((PFCB) FileObject->FsContext)->Resource);
400 }
401