4c621e5c2f5a0d7e21938d18ee24f5246dd8b0b5
[reactos.git] / drivers / filesystems / cdfs_new / cleanup.c
1 /*++
2
3 Copyright (c) 1989-2000 Microsoft Corporation
4
5 Module Name:
6
7 Cleanup.c
8
9 Abstract:
10
11 This module implements the File Cleanup routine for Cdfs called by the
12 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_CLEANUP)
24
25
26 NTSTATUS
27 CdCommonCleanup (
28 IN PIRP_CONTEXT IrpContext,
29 IN PIRP Irp
30 )
31
32 /*++
33
34 Routine Description:
35
36 This is the common routine for cleanup of a file/directory called by both
37 the fsd and fsp threads.
38
39 Cleanup is invoked whenever the last handle to a file object is closed.
40 This is different than the Close operation which is invoked when the last
41 reference to a file object is deleted.
42
43 The function of cleanup is to essentially "cleanup" the file/directory
44 after a user is done with it. The Fcb/Dcb remains around (because MM
45 still has the file object referenced) but is now available for another
46 user to open (i.e., as far as the user is concerned the is now closed).
47
48 See close for a more complete description of what close does.
49
50 We do no synchronization in this routine until we get to the point
51 where we modify the counts, share access and volume lock field.
52
53 We need to update the Fcb and Vcb to show that a user handle has been closed.
54 The following structures and fields are affected.
55
56 Vcb:
57
58 VolumeLockFileObject - Did the user lock the volume with this file object.
59 VcbState - Check if we are unlocking the volume here.
60 VcbCleanup - Count of outstanding handles on the volume.
61 DirNotifyQueue - If this file object has pending DirNotify Irps.
62
63 Fcb:
64
65 ShareAccess - If this is a user handle.
66 FcbCleanup - Count of outstanding handles on this Fcb.
67 Oplock - Any outstanding oplocks on this file object.
68 FileLock - Any outstanding filelocks on this file object.
69
70 Arguments:
71
72 Irp - Supplies the Irp to process
73
74 Return Value:
75
76 NTSTATUS - The return status for the operation.
77
78 --*/
79
80 {
81 PFILE_OBJECT FileObject;
82 TYPE_OF_OPEN TypeOfOpen;
83
84 BOOLEAN SendUnlockNotification = FALSE;
85 BOOLEAN AttemptTeardown;
86 BOOLEAN VcbAcquired = FALSE;
87
88 PVCB Vcb;
89 PFCB Fcb;
90 PCCB Ccb;
91
92 KIRQL SavedIrql;
93
94 ASSERT_IRP_CONTEXT( IrpContext );
95 ASSERT_IRP( Irp );
96
97 //
98 // If we were called with our file system device object instead of a
99 // volume device object, just complete this request with STATUS_SUCCESS.
100 //
101
102 if (IrpContext->Vcb == NULL) {
103
104 CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
105 return STATUS_SUCCESS;
106 }
107
108 //
109 // Get the file object out of the Irp and decode the type of open.
110 //
111
112 FileObject = IoGetCurrentIrpStackLocation( Irp )->FileObject;
113
114 TypeOfOpen = CdDecodeFileObject( IrpContext,
115 FileObject,
116 &Fcb,
117 &Ccb );
118
119 //
120 // No work here for either an UnopenedFile object or a StreamFileObject.
121 //
122
123 if (TypeOfOpen <= StreamFileOpen) {
124
125 CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
126
127 return STATUS_SUCCESS;
128 }
129
130 //
131 // Keep a local pointer to the Vcb.
132 //
133
134 Vcb = Fcb->Vcb;
135
136 //
137 // Synchronise with reads while we set the cleanup complete
138 // flag on this fileobject. Once this flag is set, any further
139 // reads will be rejected (CdVerifyFcbOperation)
140 //
141
142 CdAcquireFileExclusive( IrpContext, Fcb);
143
144 //
145 // Set the flag in the FileObject to indicate that cleanup is complete.
146 //
147
148 SetFlag( FileObject->Flags, FO_CLEANUP_COMPLETE );
149
150 CdReleaseFile( IrpContext, Fcb);
151
152 //
153 // Acquire the current file.
154 //
155
156 CdAcquireFcbExclusive( IrpContext, Fcb, FALSE );
157
158 //
159 // Use a try-finally to facilitate cleanup.
160 //
161
162 //try { /* ReactOS Change: Manual removal of SEH since macros to hack around it don't allow multiple SEH usage within one function */
163
164 //
165 // Case on the type of open that we are trying to cleanup.
166 //
167
168 switch (TypeOfOpen) {
169
170 case UserDirectoryOpen:
171
172 //
173 // Check if we need to complete any dir notify Irps on this file object.
174 //
175
176 FsRtlNotifyCleanup( Vcb->NotifySync,
177 &Vcb->DirNotifyList,
178 Ccb );
179
180 break;
181
182 case UserFileOpen:
183
184 //
185 // Coordinate the cleanup operation with the oplock state.
186 // Oplock cleanup operations can always cleanup immediately so no
187 // need to check for STATUS_PENDING.
188 //
189
190 FsRtlCheckOplock( &Fcb->Oplock,
191 Irp,
192 IrpContext,
193 NULL,
194 NULL );
195
196 //
197 // Unlock all outstanding file locks.
198 //
199
200 if (Fcb->FileLock != NULL) {
201
202 FsRtlFastUnlockAll( Fcb->FileLock,
203 FileObject,
204 IoGetRequestorProcess( Irp ),
205 NULL );
206 }
207
208 //
209 // Cleanup the cache map.
210 //
211
212 CcUninitializeCacheMap( FileObject, NULL, NULL );
213
214 //
215 // Check the fast io state.
216 //
217
218 CdLockFcb( IrpContext, Fcb );
219 Fcb->IsFastIoPossible = CdIsFastIoPossible( Fcb );
220 CdUnlockFcb( IrpContext, Fcb );
221
222 break;
223
224 case UserVolumeOpen :
225
226 break;
227
228 default :
229
230 CdBugCheck( TypeOfOpen, 0, 0 );
231 }
232
233 //
234 // Now lock the Vcb in order to modify the fields in the in-memory
235 // structures.
236 //
237
238 CdLockVcb( IrpContext, Vcb );
239
240 //
241 // Decrement the cleanup counts in the Vcb and Fcb.
242 //
243
244 CdDecrementCleanupCounts( IrpContext, Fcb );
245
246 //
247 // If the cleanup count hit zero and the volume is not mounted, we
248 // will want to try to spark teardown.
249 //
250
251 AttemptTeardown = (Vcb->VcbCleanup == 0 && Vcb->VcbCondition == VcbNotMounted);
252
253 //
254 // If this file object has locked the volume then perform the unlock operation.
255 // We do this regardless of explicit or implicit (no share DASD open) lock.
256 //
257
258 if (FileObject == Vcb->VolumeLockFileObject) {
259
260 ASSERT( FlagOn( Vcb->VcbState, VCB_STATE_LOCKED));
261
262 IoAcquireVpbSpinLock( &SavedIrql );
263
264 ClearFlag( Vcb->Vpb->Flags, VPB_LOCKED);
265 ClearFlag( Vcb->VcbState, VCB_STATE_LOCKED );
266 Vcb->VolumeLockFileObject = NULL;
267 SendUnlockNotification = TRUE;
268
269 IoReleaseVpbSpinLock( SavedIrql );
270 }
271
272 CdUnlockVcb( IrpContext, Vcb );
273
274 //
275 // We must clean up the share access at this time, since we may not
276 // get a Close call for awhile if the file was mapped through this
277 // File Object.
278 //
279
280 IoRemoveShareAccess( FileObject, &Fcb->ShareAccess );
281
282 //} finally { /* ReactOS Change: Manual removal of SEH since macros to hack around it don't allow multiple SEH usage within one function */
283
284 CdReleaseFcb( IrpContext, Fcb );
285
286 if (SendUnlockNotification) {
287
288 FsRtlNotifyVolumeEvent( FileObject, FSRTL_VOLUME_UNLOCK );
289 }
290 //} /* ReactOS Change: Manual removal of SEH since macros to hack around it don't allow multiple SEH usage within one function */
291
292 //
293 // If appropriate, try to spark teardown by purging the volume. Should
294 // this very fileobject we were cleaning up be the last reason for the
295 // volume to remain, teardown will commence on completion of this Irp.
296 //
297
298 if (AttemptTeardown) {
299
300 //
301 // Preacquire CdData here, since the purges will generate closes which
302 // may acquire CdData if there is a possibility of tearing the volume
303 // down.
304 //
305
306 CdAcquireCdData( IrpContext);
307
308 try {
309
310 CdAcquireVcbExclusive( IrpContext, Vcb, FALSE );
311 VcbAcquired = TRUE;
312
313 CdPurgeVolume( IrpContext, Vcb, FALSE );
314
315 } finally {
316
317 if (VcbAcquired) { CdReleaseVcb( IrpContext, Vcb ); }
318
319 CdReleaseCdData( IrpContext);
320 }
321 }
322
323 //
324 // If this is a normal termination then complete the request
325 //
326
327 CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
328
329 return STATUS_SUCCESS;
330 }
331
332