ReactOS  0.4.14-dev-1034-g1e60116
fastio.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: GNU GENERAL PUBLIC LICENSE VERSION 2
3  * PROJECT: ReiserFs file system driver for Windows NT/2000/XP/Vista.
4  * FILE: fastio.c
5  * PURPOSE:
6  * PROGRAMMER: Mark Piper, Matt Wu, Bo Brantén.
7  * HOMEPAGE:
8  * UPDATE HISTORY:
9  */
10 
11 /* INCLUDES *****************************************************************/
12 
13 #include "rfsd.h"
14 
15 /* GLOBALS ***************************************************************/
16 
17 extern PRFSD_GLOBAL RfsdGlobal;
18 
19 /* DEFINITIONS *************************************************************/
20 
21 #ifdef ALLOC_PRAGMA
22 #if DBG
23 #pragma alloc_text(PAGE, RfsdFastIoRead)
24 #if !RFSD_READ_ONLY
25 #pragma alloc_text(PAGE, RfsdFastIoWrite)
26 #endif // !RFSD_READ_ONLY
27 #endif // DBG
28 #pragma alloc_text(PAGE, RfsdFastIoCheckIfPossible)
29 #pragma alloc_text(PAGE, RfsdFastIoQueryBasicInfo)
30 #pragma alloc_text(PAGE, RfsdFastIoQueryStandardInfo)
31 #pragma alloc_text(PAGE, RfsdFastIoQueryNetworkOpenInfo)
32 #pragma alloc_text(PAGE, RfsdFastIoLock)
33 #pragma alloc_text(PAGE, RfsdFastIoUnlockSingle)
34 #pragma alloc_text(PAGE, RfsdFastIoUnlockAll)
35 #pragma alloc_text(PAGE, RfsdFastIoUnlockAllByKey)
36 #endif
37 
38 BOOLEAN NTAPI
39 RfsdFastIoCheckIfPossible (
40  IN PFILE_OBJECT FileObject,
41  IN PLARGE_INTEGER FileOffset,
42  IN ULONG Length,
43  IN BOOLEAN Wait,
44  IN ULONG LockKey,
45  IN BOOLEAN CheckForReadOperation,
46  OUT PIO_STATUS_BLOCK IoStatus,
47  IN PDEVICE_OBJECT DeviceObject
48  )
49 {
50  BOOLEAN bPossible = FastIoIsNotPossible;
51  PRFSD_FCB Fcb;
52  LARGE_INTEGER lLength;
53 
54  PAGED_CODE();
55 
56  lLength.QuadPart = Length;
57 
58  _SEH2_TRY {
59 
60  _SEH2_TRY {
61 
62  FsRtlEnterFileSystem();
63 
64  if (DeviceObject == RfsdGlobal->DeviceObject) {
65  _SEH2_LEAVE;
66  }
67 
68  Fcb = (PRFSD_FCB) FileObject->FsContext;
69 
70  ASSERT(Fcb != NULL);
71 
72  if (Fcb->Identifier.Type == RFSDVCB) {
73  _SEH2_LEAVE;
74  }
75 
76  ASSERT((Fcb->Identifier.Type == RFSDFCB) &&
77  (Fcb->Identifier.Size == sizeof(RFSD_FCB)));
78 
79  if (IsDirectory(Fcb)) {
80  _SEH2_LEAVE;
81  }
82 
83  if (CheckForReadOperation) {
84 
85  bPossible = FsRtlFastCheckLockForRead(
86  &Fcb->FileLockAnchor,
87  FileOffset,
88  &lLength,
89  LockKey,
90  FileObject,
91  PsGetCurrentProcess());
92 
93  } else {
94 
95  if (IsFlagOn(Fcb->Vcb->Flags, VCB_READ_ONLY) ||
96  IsFlagOn(Fcb->Vcb->Flags, VCB_WRITE_PROTECTED)) {
97  bPossible = FastIoIsNotPossible;
98  } else {
99  bPossible = FsRtlFastCheckLockForWrite(
100  &Fcb->FileLockAnchor,
101  FileOffset,
102  &lLength,
103  LockKey,
104  FileObject,
105  PsGetCurrentProcess());
106  }
107  }
108 
109  RfsdPrint((DBG_INFO, "RfsdFastIoCheckIfPossible: %s %s %s\n",
110  RfsdGetCurrentProcessName(),
111  "FASTIO_CHECK_IF_POSSIBLE",
112  Fcb->AnsiFileName.Buffer
113  ));
114 
115  RfsdPrint((DBG_INFO,
116  "RfsdFastIoCheckIfPossible: Offset: %I64xg Length: %xh Key: %u %s %s\n",
117  FileOffset->QuadPart,
118  Length,
119  LockKey,
120  (CheckForReadOperation ? "CheckForReadOperation:" :
121  "CheckForWriteOperation:"),
122  (bPossible ? "Succeeded" : "Failed")));
123  } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
124  bPossible = FastIoIsNotPossible;
125  } _SEH2_END;
126 
127  } _SEH2_FINALLY {
128 
129  FsRtlExitFileSystem();
130  } _SEH2_END;
131 
132  return bPossible;
133 }
134 
135 #if DBG
136 
137 BOOLEAN NTAPI
138 RfsdFastIoRead (IN PFILE_OBJECT FileObject,
139  IN PLARGE_INTEGER FileOffset,
140  IN ULONG Length,
141  IN BOOLEAN Wait,
142  IN ULONG LockKey,
143  OUT PVOID Buffer,
144  OUT PIO_STATUS_BLOCK IoStatus,
145  IN PDEVICE_OBJECT DeviceObject)
146 {
147  BOOLEAN Status;
148  PRFSD_FCB Fcb;
149 
150  PAGED_CODE();
151 
152  Fcb = (PRFSD_FCB) FileObject->FsContext;
153 
154  ASSERT(Fcb != NULL);
155 
156  ASSERT((Fcb->Identifier.Type == RFSDFCB) &&
157  (Fcb->Identifier.Size == sizeof(RFSD_FCB)));
158 
159  RfsdPrint((DBG_INFO, "RfsdFastIoRead: %s %s %s\n",
160  RfsdGetCurrentProcessName(),
161  "FASTIO_READ",
162  Fcb->AnsiFileName.Buffer ));
163 
164  RfsdPrint((DBG_INFO, "RfsdFastIoRead: Offset: %I64xh Length: %xh Key: %u\n",
165  FileOffset->QuadPart,
166  Length,
167  LockKey ));
168 
169  Status = FsRtlCopyRead (
170  FileObject, FileOffset, Length, Wait,
171  LockKey, Buffer, IoStatus, DeviceObject);
172 
173  return Status;
174 }
175 
176 #if !RFSD_READ_ONLY
177 
178 NTAPI BOOLEAN
179 RfsdFastIoWrite (
180  IN PFILE_OBJECT FileObject,
181  IN PLARGE_INTEGER FileOffset,
182  IN ULONG Length,
183  IN BOOLEAN Wait,
184  IN ULONG LockKey,
185  OUT PVOID Buffer,
186  OUT PIO_STATUS_BLOCK IoStatus,
187  IN PDEVICE_OBJECT DeviceObject)
188 {
189  BOOLEAN bRet;
190  PRFSD_FCB Fcb;
191 
192  PAGED_CODE();
193 
194  Fcb = (PRFSD_FCB) FileObject->FsContext;
195 
196  ASSERT(Fcb != NULL);
197 
198  ASSERT((Fcb->Identifier.Type == RFSDFCB) &&
199  (Fcb->Identifier.Size == sizeof(RFSD_FCB)));
200 
201  RfsdPrint((DBG_INFO,
202  "RfsdFastIoWrite: %s %s %s\n",
203  RfsdGetCurrentProcessName(),
204  "FASTIO_WRITE",
205  Fcb->AnsiFileName.Buffer ));
206 
207  RfsdPrint((DBG_INFO,
208  "RfsdFastIoWrite: Offset: %I64xh Length: %xh Key: %xh\n",
209  FileOffset->QuadPart,
210  Length,
211  LockKey ));
212 
213  if (IsFlagOn(Fcb->Vcb->Flags, VCB_READ_ONLY)) {
214  DbgBreak();
215  return FALSE;
216  }
217 
218  bRet = FsRtlCopyWrite (
219  FileObject, FileOffset, Length, Wait,
220  LockKey, Buffer, IoStatus, DeviceObject);
221 
222  return bRet;
223 }
224 
225 #endif // !RFSD_READ_ONLY
226 
227 #endif /* DBG */
228 
229 BOOLEAN NTAPI
230 RfsdFastIoQueryBasicInfo (IN PFILE_OBJECT FileObject,
231  IN BOOLEAN Wait,
232  OUT PFILE_BASIC_INFORMATION Buffer,
233  OUT PIO_STATUS_BLOCK IoStatus,
234  IN PDEVICE_OBJECT DeviceObject)
235 {
236  BOOLEAN Status = FALSE;
237  PRFSD_FCB Fcb = 0;
238  BOOLEAN FcbMainResourceAcquired = FALSE;
239 
240  PAGED_CODE();
241 
242  _SEH2_TRY {
243 
244  _SEH2_TRY {
245 
246  FsRtlEnterFileSystem();
247 
248  if (DeviceObject == RfsdGlobal->DeviceObject) {
249  IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
250  Status = TRUE;
251  _SEH2_LEAVE;
252  }
253 
254  Fcb = (PRFSD_FCB) FileObject->FsContext;
255 
256  ASSERT(Fcb != NULL);
257 
258  if (Fcb->Identifier.Type == RFSDVCB) {
259  IoStatus->Status = STATUS_INVALID_PARAMETER;
260  Status = TRUE;
261  _SEH2_LEAVE;
262  }
263 
264  ASSERT((Fcb->Identifier.Type == RFSDFCB) &&
265  (Fcb->Identifier.Size == sizeof(RFSD_FCB)));
266 
267  RfsdPrint((DBG_INFO,
268  "RfsdFastIoQueryBasicInfo: %s %s %s\n",
269  RfsdGetCurrentProcessName(),
270  "FASTIO_QUERY_BASIC_INFO",
271  Fcb->AnsiFileName.Buffer
272  ));
273 
274  if (!ExAcquireResourceSharedLite(
275  &Fcb->MainResource,
276  Wait)) {
277  Status = FALSE;
278  _SEH2_LEAVE;
279  }
280 
281  FcbMainResourceAcquired = TRUE;
282 
283  RtlZeroMemory(Buffer, sizeof(FILE_BASIC_INFORMATION));
284 
285  /*
286  typedef struct _FILE_BASIC_INFORMATION {
287  LARGE_INTEGER CreationTime;
288  LARGE_INTEGER LastAccessTime;
289  LARGE_INTEGER LastWriteTime;
290  LARGE_INTEGER ChangeTime;
291  ULONG FileAttributes;
292  } FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION;
293  */
294 
295  Buffer->CreationTime = RfsdSysTime(Fcb->Inode->i_ctime);
296  Buffer->LastAccessTime = RfsdSysTime(Fcb->Inode->i_atime);
297  Buffer->LastWriteTime = RfsdSysTime(Fcb->Inode->i_mtime);
298  Buffer->ChangeTime = RfsdSysTime(Fcb->Inode->i_mtime);
299 
300 
301  Buffer->FileAttributes = Fcb->RfsdMcb->FileAttr;
302 
303  IoStatus->Information = sizeof(FILE_BASIC_INFORMATION);
304 
305  IoStatus->Status = STATUS_SUCCESS;
306 
307  Status = TRUE;
308  } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
309 
310  IoStatus->Status = _SEH2_GetExceptionCode();
311  Status = TRUE;
312  } _SEH2_END;
313 
314  } _SEH2_FINALLY {
315 
316  if (FcbMainResourceAcquired)
317  {
318  ExReleaseResourceForThreadLite(
319  &Fcb->MainResource,
320  ExGetCurrentResourceThread()
321  );
322  }
323 
324  FsRtlExitFileSystem();
325  } _SEH2_END;
326 
327 
328  if (Status == FALSE) {
329 
330  RfsdPrint((DBG_ERROR,
331  "RfsdFastIoQueryBasicInfo: %s %s *** Status: FALSE ***\n",
332  RfsdGetCurrentProcessName(),
333  "FASTIO_QUERY_BASIC_INFO"
334  ));
335  } else if (IoStatus->Status != STATUS_SUCCESS) {
336 
337  RfsdPrint((DBG_ERROR,
338  "RfsdFastIoQueryBasicInfo: %s %s *** Status: %s (%#x) ***\n",
339  RfsdGetCurrentProcessName(),
340  "FASTIO_QUERY_BASIC_INFO",
341  RfsdNtStatusToString(IoStatus->Status),
342  IoStatus->Status
343  ));
344  }
345 
346  return Status;
347 }
348 
349 BOOLEAN NTAPI
350 RfsdFastIoQueryStandardInfo (
351  IN PFILE_OBJECT FileObject,
352  IN BOOLEAN Wait,
353  OUT PFILE_STANDARD_INFORMATION Buffer,
354  OUT PIO_STATUS_BLOCK IoStatus,
355  IN PDEVICE_OBJECT DeviceObject
356  )
357 {
358  BOOLEAN Status = FALSE;
359  PRFSD_VCB Vcb;
360  PRFSD_FCB Fcb = 0;
361  BOOLEAN FcbMainResourceAcquired = FALSE;
362  LONGLONG FileSize;
363  LONGLONG AllocationSize;
364 
365  PAGED_CODE();
366 
367  _SEH2_TRY {
368 
369  _SEH2_TRY {
370 
371  FsRtlEnterFileSystem();
372 
373  if (DeviceObject == RfsdGlobal->DeviceObject) {
374 
375  IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
376  Status = TRUE;
377  _SEH2_LEAVE;
378  }
379 
380  Fcb = (PRFSD_FCB) FileObject->FsContext;
381 
382  ASSERT(Fcb != NULL);
383 
384  if (Fcb->Identifier.Type == RFSDVCB) {
385  IoStatus->Status = STATUS_INVALID_PARAMETER;
386  Status = TRUE;
387  _SEH2_LEAVE;
388  }
389 
390  ASSERT((Fcb->Identifier.Type == RFSDFCB) &&
391  (Fcb->Identifier.Size == sizeof(RFSD_FCB)));
392 
393  RfsdPrint((DBG_INFO,
394  "RfsdFastIoQueryStandardInfo: %s %s %s\n",
395  RfsdGetCurrentProcessName(),
396  "FASTIO_QUERY_STANDARD_INFO",
397  Fcb->AnsiFileName.Buffer ));
398 
399  Vcb = Fcb->Vcb;
400 
401  if (!ExAcquireResourceSharedLite(
402  &Fcb->MainResource,
403  Wait )) {
404  Status = FALSE;
405  _SEH2_LEAVE;
406  }
407 
408  FcbMainResourceAcquired = TRUE;
409 
410  RtlZeroMemory(Buffer, sizeof(FILE_STANDARD_INFORMATION));
411 
412  /*
413  typedef struct _FILE_STANDARD_INFORMATION {
414  LARGE_INTEGER AllocationSize;
415  LARGE_INTEGER EndOfFile;
416  ULONG NumberOfLinks;
417  BOOLEAN DeletePending;
418  BOOLEAN Directory;
419  } FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION;
420  */
421 
422  FileSize = (LONGLONG) Fcb->Inode->i_size;
423 
424 #if DISABLED
425  if (S_ISREG(Fcb->Inode->i_mode))
426  FileSize |= ((LONGLONG)(Fcb->Inode->i_size_high) << 32);
427 #endif
428 
429  AllocationSize = CEILING_ALIGNED(FileSize, (ULONGLONG)Vcb->BlockSize); // TODO: This is incorrect for file tails...
430 
431  Buffer->AllocationSize.QuadPart = AllocationSize;
432  Buffer->EndOfFile.QuadPart = FileSize;
433  Buffer->NumberOfLinks = Fcb->Inode->i_links_count;
434 
435  if (IsFlagOn(Fcb->Vcb->Flags, VCB_READ_ONLY)) {
436  Buffer->DeletePending = FALSE;
437  } else {
438  Buffer->DeletePending = IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING);
439  }
440 
441  if (FlagOn(Fcb->RfsdMcb->FileAttr, FILE_ATTRIBUTE_DIRECTORY)) {
442  Buffer->Directory = TRUE;
443  } else {
444  Buffer->Directory = FALSE;
445  }
446 
447  IoStatus->Information = sizeof(FILE_STANDARD_INFORMATION);
448 
449  IoStatus->Status = STATUS_SUCCESS;
450 
451  Status = TRUE;
452 
453  } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
454 
455  IoStatus->Status = _SEH2_GetExceptionCode();
456  Status = TRUE;
457  } _SEH2_END;
458 
459  } _SEH2_FINALLY {
460  if (FcbMainResourceAcquired) {
461  ExReleaseResourceForThreadLite(
462  &Fcb->MainResource,
463  ExGetCurrentResourceThread()
464  );
465  }
466 
467  FsRtlExitFileSystem();
468  } _SEH2_END;
469 
470 #if DBG
471  if (Status == FALSE) {
472  RfsdPrint((DBG_INFO,
473  "RfsdFastIoQueryStandardInfo: %s %s *** Status: FALSE ***\n",
474  RfsdGetCurrentProcessName(),
475  "FASTIO_QUERY_STANDARD_INFO" ));
476  } else if (IoStatus->Status != STATUS_SUCCESS) {
477  RfsdPrint((DBG_INFO,
478  "RfsdFastIoQueryStandardInfo: %s %s *** Status: %s (%#x) ***\n",
479  RfsdGetCurrentProcessName(),
480  "FASTIO_QUERY_STANDARD_INFO",
481  RfsdNtStatusToString(IoStatus->Status),
482  IoStatus->Status ));
483  }
484 #endif
485 
486  return Status;
487 }
488 
489 BOOLEAN NTAPI
490 RfsdFastIoLock (
491  IN PFILE_OBJECT FileObject,
492  IN PLARGE_INTEGER FileOffset,
493  IN PLARGE_INTEGER Length,
494  IN PEPROCESS Process,
495  IN ULONG Key,
496  IN BOOLEAN FailImmediately,
497  IN BOOLEAN ExclusiveLock,
498  OUT PIO_STATUS_BLOCK IoStatus,
499  IN PDEVICE_OBJECT DeviceObject
500  )
501 {
502  BOOLEAN Status = FALSE;
503  PRFSD_FCB Fcb;
504 
505  PAGED_CODE();
506 
507  _SEH2_TRY {
508 
509  _SEH2_TRY {
510 
511  FsRtlEnterFileSystem();
512 
513  if (DeviceObject == RfsdGlobal->DeviceObject) {
514  IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
515  Status = TRUE;
516  _SEH2_LEAVE;
517  }
518 
519  Fcb = (PRFSD_FCB) FileObject->FsContext;
520 
521  ASSERT(Fcb != NULL);
522 
523  if (Fcb->Identifier.Type == RFSDVCB) {
524 
525  IoStatus->Status = STATUS_INVALID_PARAMETER;
526  Status = TRUE;
527  _SEH2_LEAVE;
528  }
529 
530  ASSERT((Fcb->Identifier.Type == RFSDFCB) &&
531  (Fcb->Identifier.Size == sizeof(RFSD_FCB)));
532 
533  if (IsDirectory(Fcb)) {
534  DbgBreak();
535  IoStatus->Status = STATUS_INVALID_PARAMETER;
536  Status = TRUE;
537  _SEH2_LEAVE;
538  }
539 
540  RfsdPrint((DBG_INFO,
541  "RfsdFastIoLock: %s %s %s\n",
542  RfsdGetCurrentProcessName(),
543  "FASTIO_LOCK",
544  Fcb->AnsiFileName.Buffer ));
545 
546  RfsdPrint((DBG_INFO,
547  "RfsdFastIoLock: Offset: %I64xh Length: %I64xh Key: %u %s%s\n",
548  FileOffset->QuadPart,
549  Length->QuadPart,
550  Key,
551  (FailImmediately ? "FailImmediately " : ""),
552  (ExclusiveLock ? "ExclusiveLock " : "") ));
553 
554  if (Fcb->Header.IsFastIoPossible != FastIoIsQuestionable) {
555  RfsdPrint((DBG_INFO,
556  "RfsdFastIoLock: %s %s %s\n",
557  RfsdGetCurrentProcessName(),
558  "FastIoIsQuestionable",
559  Fcb->AnsiFileName.Buffer ));
560 
561  Fcb->Header.IsFastIoPossible = FastIoIsQuestionable;
562  }
563 
564 #ifdef _MSC_VER
565 #pragma prefast( suppress: 28159, "bug in prefast" )
566 #endif
567  Status = FsRtlFastLock(
568  &Fcb->FileLockAnchor,
569  FileObject,
570  FileOffset,
571  Length,
572  Process,
573  Key,
574  FailImmediately,
575  ExclusiveLock,
576  IoStatus,
577  NULL,
578  FALSE);
579  } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
580  IoStatus->Status = _SEH2_GetExceptionCode();
581  Status = TRUE;
582  } _SEH2_END;
583 
584  } _SEH2_FINALLY {
585  FsRtlExitFileSystem();
586  } _SEH2_END;
587 
588 #if DBG
589  if (Status == FALSE) {
590  RfsdPrint((DBG_ERROR,
591  "RfsdFastIoLock: %s %s *** Status: FALSE ***\n",
592  RfsdGetCurrentProcessName(),
593  "FASTIO_LOCK"
594  ));
595  } else if (IoStatus->Status != STATUS_SUCCESS) {
596  RfsdPrint((DBG_ERROR,
597  "RfsdFastIoLock: %s %s *** Status: %s (%#x) ***\n",
598  RfsdGetCurrentProcessName(),
599  "FASTIO_LOCK",
600  RfsdNtStatusToString(IoStatus->Status),
601  IoStatus->Status
602  ));
603  }
604 #endif
605 
606  return Status;
607 }
608 
609 BOOLEAN NTAPI
610 RfsdFastIoUnlockSingle (
611  IN PFILE_OBJECT FileObject,
612  IN PLARGE_INTEGER FileOffset,
613  IN PLARGE_INTEGER Length,
614  IN PEPROCESS Process,
615  IN ULONG Key,
616  OUT PIO_STATUS_BLOCK IoStatus,
617  IN PDEVICE_OBJECT DeviceObject
618  )
619 {
620  BOOLEAN Status = FALSE;
621  PRFSD_FCB Fcb;
622 
623  PAGED_CODE();
624 
625  _SEH2_TRY {
626 
627  _SEH2_TRY {
628 
629  FsRtlEnterFileSystem();
630 
631  if (DeviceObject == RfsdGlobal->DeviceObject) {
632  IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
633  Status = TRUE;
634  _SEH2_LEAVE;
635  }
636 
637  Fcb = (PRFSD_FCB) FileObject->FsContext;
638 
639  ASSERT(Fcb != NULL);
640 
641  if (Fcb->Identifier.Type == RFSDVCB) {
642  DbgBreak();
643  IoStatus->Status = STATUS_INVALID_PARAMETER;
644  Status = TRUE;
645  _SEH2_LEAVE;
646  }
647 
648  ASSERT((Fcb->Identifier.Type == RFSDFCB) &&
649  (Fcb->Identifier.Size == sizeof(RFSD_FCB)));
650 
651  if (IsDirectory(Fcb)) {
652 
653  DbgBreak();
654  IoStatus->Status = STATUS_INVALID_PARAMETER;
655  Status = TRUE;
656  _SEH2_LEAVE;
657  }
658 
659  RfsdPrint((DBG_INFO,
660  "RfsdFastIoUnlockSingle: %s %s %s\n",
661  RfsdGetCurrentProcessName(),
662  "FASTIO_UNLOCK_SINGLE",
663  Fcb->AnsiFileName.Buffer ));
664 
665  RfsdPrint((DBG_INFO,
666  "RfsdFastIoUnlockSingle: Offset: %I64xh Length: %I64xh Key: %u\n",
667  FileOffset->QuadPart,
668  Length->QuadPart,
669  Key ));
670 
671  IoStatus->Status = FsRtlFastUnlockSingle(
672  &Fcb->FileLockAnchor,
673  FileObject,
674  FileOffset,
675  Length,
676  Process,
677  Key,
678  NULL,
679  FALSE);
680 
681  IoStatus->Information = 0;
682 
683  Status = TRUE;
684  } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
685  IoStatus->Status = _SEH2_GetExceptionCode();
686  Status = TRUE;
687  } _SEH2_END;
688 
689  } _SEH2_FINALLY {
690 
691  FsRtlExitFileSystem();
692  } _SEH2_END;
693 
694 #if DBG
695  if (Status == FALSE) {
696 
697  RfsdPrint((DBG_ERROR,
698  "RfsdFastIoUnlockSingle: %s %s *** Status: FALSE ***\n",
699  RfsdGetCurrentProcessName(),
700  "FASTIO_UNLOCK_SINGLE" ));
701  } else if (IoStatus->Status != STATUS_SUCCESS) {
702  RfsdPrint((DBG_ERROR,
703  "RfsdFastIoUnlockSingle: %s %s *** Status: %s (%#x) ***\n",
704  RfsdGetCurrentProcessName(),
705  "FASTIO_UNLOCK_SINGLE",
706  RfsdNtStatusToString(IoStatus->Status),
707  IoStatus->Status ));
708  }
709 #endif
710 
711  return Status;
712 }
713 
714 BOOLEAN NTAPI
715 RfsdFastIoUnlockAll (
716  IN PFILE_OBJECT FileObject,
717  IN PEPROCESS Process,
718  OUT PIO_STATUS_BLOCK IoStatus,
719  IN PDEVICE_OBJECT DeviceObject)
720 {
721  BOOLEAN Status = FALSE;
722  PRFSD_FCB Fcb;
723 
724  PAGED_CODE();
725 
726  _SEH2_TRY {
727 
728  _SEH2_TRY {
729 
730  FsRtlEnterFileSystem();
731 
732  if (DeviceObject == RfsdGlobal->DeviceObject) {
733  IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
734  Status = TRUE;
735  _SEH2_LEAVE;
736  }
737 
738  Fcb = (PRFSD_FCB) FileObject->FsContext;
739 
740  ASSERT(Fcb != NULL);
741 
742  if (Fcb->Identifier.Type == RFSDVCB) {
743  DbgBreak();
744  IoStatus->Status = STATUS_INVALID_PARAMETER;
745  Status = TRUE;
746  _SEH2_LEAVE;
747  }
748 
749  ASSERT((Fcb->Identifier.Type == RFSDFCB) &&
750  (Fcb->Identifier.Size == sizeof(RFSD_FCB)));
751 
752  if (IsDirectory(Fcb)) {
753  DbgBreak();
754  IoStatus->Status = STATUS_INVALID_PARAMETER;
755  Status = TRUE;
756  _SEH2_LEAVE;
757  }
758 
759  RfsdPrint((DBG_INFO,
760  "RfsdFastIoUnlockAll: %s %s %s\n",
761  RfsdGetCurrentProcessName(),
762  "FASTIO_UNLOCK_ALL",
763  Fcb->AnsiFileName.Buffer
764  ));
765 
766  IoStatus->Status = FsRtlFastUnlockAll(
767  &Fcb->FileLockAnchor,
768  FileObject,
769  Process,
770  NULL );
771 
772  IoStatus->Information = 0;
773 
774  Status = TRUE;
775  } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
776  IoStatus->Status = _SEH2_GetExceptionCode();
777  Status = TRUE;
778  } _SEH2_END;
779 
780  } _SEH2_FINALLY {
781 
782  FsRtlExitFileSystem();
783  } _SEH2_END;
784 
785 #if DBG
786  if (Status == FALSE) {
787 
788  RfsdPrint((DBG_ERROR,
789  "RfsdFastIoUnlockAll: %s %s *** Status: FALSE ***\n",
790  RfsdGetCurrentProcessName(),
791  "FASTIO_UNLOCK_ALL"
792  ));
793  } else if (IoStatus->Status != STATUS_SUCCESS) {
794  RfsdPrint((DBG_ERROR,
795  "RfsdFastIoUnlockAll: %s %s *** Status: %s (%#x) ***\n",
796  RfsdGetCurrentProcessName(),
797  "FASTIO_UNLOCK_ALL",
798  RfsdNtStatusToString(IoStatus->Status),
799  IoStatus->Status
800  ));
801  }
802 #endif
803 
804  return Status;
805 }
806 
807 BOOLEAN NTAPI
808 RfsdFastIoUnlockAllByKey (
809  IN PFILE_OBJECT FileObject,
810 #ifdef __REACTOS__
811  IN PVOID Process,
812 #else
813  IN PEPROCESS Process,
814 #endif
815  IN ULONG Key,
816  OUT PIO_STATUS_BLOCK IoStatus,
817  IN PDEVICE_OBJECT DeviceObject
818  )
819 {
820  BOOLEAN Status = FALSE;
821  PRFSD_FCB Fcb;
822 
823  PAGED_CODE();
824 
825  _SEH2_TRY {
826 
827  _SEH2_TRY {
828 
829  FsRtlEnterFileSystem();
830 
831  if (DeviceObject == RfsdGlobal->DeviceObject) {
832  IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
833  Status = TRUE;
834  _SEH2_LEAVE;
835  }
836 
837  Fcb = (PRFSD_FCB) FileObject->FsContext;
838 
839  ASSERT(Fcb != NULL);
840 
841  if (Fcb->Identifier.Type == RFSDVCB) {
842  DbgBreak();
843  IoStatus->Status = STATUS_INVALID_PARAMETER;
844  Status = TRUE;
845  _SEH2_LEAVE;
846  }
847 
848  ASSERT((Fcb->Identifier.Type == RFSDFCB) &&
849  (Fcb->Identifier.Size == sizeof(RFSD_FCB)));
850 
851  if (IsDirectory(Fcb)) {
852 
853  DbgBreak();
854  IoStatus->Status = STATUS_INVALID_PARAMETER;
855  Status = TRUE;
856  _SEH2_LEAVE;
857  }
858 
859  RfsdPrint((DBG_INFO,
860  "RfsdFastIoUnlockAllByKey: %s %s %s\n",
861  RfsdGetCurrentProcessName(),
862  "FASTIO_UNLOCK_ALL_BY_KEY",
863  Fcb->AnsiFileName.Buffer
864  ));
865 
866  RfsdPrint((DBG_INFO,
867  "RfsdFastIoUnlockAllByKey: Key: %u\n",
868  Key
869  ));
870 
871  IoStatus->Status = FsRtlFastUnlockAllByKey(
872  &Fcb->FileLockAnchor,
873  FileObject,
874  Process,
875  Key,
876  NULL
877  );
878 
879  IoStatus->Information = 0;
880 
881  Status = TRUE;
882 
883  } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
884 
885  IoStatus->Status = _SEH2_GetExceptionCode();
886  Status = TRUE;
887  } _SEH2_END;
888 
889  } _SEH2_FINALLY {
890  FsRtlExitFileSystem();
891  } _SEH2_END;
892 
893 #if DBG
894  if (Status == FALSE) {
895 
896  RfsdPrint((DBG_ERROR,
897  "RfsdFastIoUnlockAllByKey: %s %s *** Status: FALSE ***\n",
898  RfsdGetCurrentProcessName(),
899  "FASTIO_UNLOCK_ALL_BY_KEY"
900  ));
901  } else if (IoStatus->Status != STATUS_SUCCESS) {
902 
903  RfsdPrint((DBG_ERROR,
904  "RfsdFastIoUnlockAllByKey: %s %s *** Status: %s (%#x) ***\n",
905  RfsdGetCurrentProcessName(),
906  "FASTIO_UNLOCK_ALL_BY_KEY",
907  RfsdNtStatusToString(IoStatus->Status),
908  IoStatus->Status
909  ));
910  }
911 #endif
912 
913  return Status;
914 }
915 
916 BOOLEAN NTAPI
917 RfsdFastIoQueryNetworkOpenInfo (
918  IN PFILE_OBJECT FileObject,
919  IN BOOLEAN Wait,
920  IN OUT PFILE_NETWORK_OPEN_INFORMATION PFNOI,
921  OUT PIO_STATUS_BLOCK IoStatus,
922  IN PDEVICE_OBJECT DeviceObject
923  )
924 {
925  BOOLEAN bResult = FALSE;
926  PRFSD_FCB Fcb = NULL;
927  BOOLEAN FcbResourceAcquired = FALSE;
928 
929  PAGED_CODE();
930 
931  _SEH2_TRY {
932 
933  FsRtlEnterFileSystem();
934 
935  if (DeviceObject == RfsdGlobal->DeviceObject) {
936  IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
937  _SEH2_LEAVE;
938  }
939 
940  Fcb = (PRFSD_FCB) FileObject->FsContext;
941 
942  ASSERT(Fcb != NULL);
943 
944  if (Fcb->Identifier.Type == RFSDVCB) {
945  DbgBreak();
946  IoStatus->Status = STATUS_INVALID_PARAMETER;
947  _SEH2_LEAVE;
948  }
949 
950  ASSERT((Fcb->Identifier.Type == RFSDFCB) &&
951  (Fcb->Identifier.Size == sizeof(RFSD_FCB)));
952 
953  RfsdPrint((DBG_INFO,
954  "%-16.16s %-31s %s\n",
955  RfsdGetCurrentProcessName(),
956  "FASTIO_QUERY_NETWORK_OPEN_INFO",
957  Fcb->AnsiFileName.Buffer
958  ));
959 
960  if (FileObject->FsContext2) {
961  _SEH2_LEAVE;
962  }
963 
964  if (!FlagOn(Fcb->Flags, FCB_PAGE_FILE)) {
965 
966  if (!ExAcquireResourceSharedLite(
967  &Fcb->MainResource,
968  Wait
969  )) {
970  _SEH2_LEAVE;
971  }
972 
973  FcbResourceAcquired = TRUE;
974  }
975 
976  if (IsDirectory(Fcb)) {
977  PFNOI->AllocationSize.QuadPart = 0;
978  PFNOI->EndOfFile.QuadPart = 0;
979  } else {
980  PFNOI->AllocationSize = Fcb->Header.AllocationSize;
981  PFNOI->EndOfFile = Fcb->Header.FileSize;
982  }
983 
984  PFNOI->FileAttributes = Fcb->RfsdMcb->FileAttr;
985  if (PFNOI->FileAttributes == 0) {
986  PFNOI->FileAttributes = FILE_ATTRIBUTE_NORMAL;
987  }
988 
989  PFNOI->CreationTime = RfsdSysTime(Fcb->Inode->i_ctime);
990  PFNOI->LastAccessTime = RfsdSysTime(Fcb->Inode->i_atime);
991  PFNOI->LastWriteTime = RfsdSysTime(Fcb->Inode->i_mtime);
992  PFNOI->ChangeTime = RfsdSysTime(Fcb->Inode->i_mtime);
993 
994  bResult = TRUE;
995 
996  IoStatus->Status = STATUS_SUCCESS;
997  IoStatus->Information = sizeof(FILE_NETWORK_OPEN_INFORMATION);
998 
999  } _SEH2_FINALLY {
1000 
1001  if (FcbResourceAcquired) {
1002  ExReleaseResourceLite(&Fcb->MainResource);
1003  }
1004 
1005  FsRtlExitFileSystem();
1006  } _SEH2_END;
1007 
1008  return bResult;
1009 }
ExGetCurrentResourceThread
#define ExGetCurrentResourceThread()
Definition: env_spec_w32.h:633
IN
#define IN
Definition: typedefs.h:39
TRUE
#define TRUE
Definition: types.h:120
RfsdFastIoRead
BOOLEAN NTAPI RfsdFastIoRead(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
FsRtlFastCheckLockForRead
BOOLEAN NTAPI FsRtlFastCheckLockForRead(IN PFILE_LOCK FileLock, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, IN ULONG Key, IN PFILE_OBJECT FileObject, IN PVOID Process)
Definition: filelock.c:752
FsRtlEnterFileSystem
#define FsRtlEnterFileSystem
FsRtlExitFileSystem
#define FsRtlExitFileSystem
_FCB::Header
FSRTL_ADVANCED_FCB_HEADER Header
Definition: cdstruc.h:931
IoStatus
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG IN BOOLEAN OUT PIO_STATUS_BLOCK IoStatus
Definition: fatprocs.h:2650
CEILING_ALIGNED
#define CEILING_ALIGNED(T, A, B)
Definition: ext2fs.h:111
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
_FILE_STANDARD_INFORMATION
Definition: propsheet.cpp:53
_FCB::FileAttributes
ULONG FileAttributes
Definition: cdstruc.h:983
_FILE_NETWORK_OPEN_INFORMATION
Definition: from_kernel.h:207
STATUS_INVALID_DEVICE_REQUEST
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
RfsdFastIoUnlockAllByKey
BOOLEAN NTAPI RfsdFastIoUnlockAllByKey(IN PFILE_OBJECT FileObject, IN PEPROCESS Process, IN ULONG Key, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:808
_EPROCESS
Definition: pstypes.h:1191
RFSDVCB
Definition: rfsd.h:323
CheckForReadOperation
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG IN BOOLEAN CheckForReadOperation
Definition: fatprocs.h:2650
FCB_DELETE_PENDING
#define FCB_DELETE_PENDING
Definition: ext2fs.h:879
PAGED_CODE
#define PAGED_CODE()
Definition: video.h:57
FILE_NETWORK_OPEN_INFORMATION
struct _FILE_NETWORK_OPEN_INFORMATION FILE_NETWORK_OPEN_INFORMATION
_RFSD_GLOBAL::DeviceObject
PDEVICE_OBJECT DeviceObject
Definition: rfsd.h:407
_SEH2_TRY
_SEH2_TRY
Definition: create.c:4250
RFSDFCB
Definition: rfsd.h:324
RfsdNtStatusToString
PUCHAR RfsdNtStatusToString(IN NTSTATUS Status)
RfsdGlobal
PRFSD_GLOBAL RfsdGlobal
Definition: init.c:17
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:1087
_RFSD_GLOBAL
Definition: rfsd.h:382
RfsdSysTime
LARGE_INTEGER RfsdSysTime(IN ULONG i_time)
Definition: misc.c:47
PRFSD_FCB
struct _RFSD_FCB * PRFSD_FCB
_FCB::Identifier
NTFSIDENTIFIER Identifier
Definition: ntfs.h:511
NTAPI
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
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:829
FailImmediately
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ULONG BOOLEAN FailImmediately
Definition: fatprocs.h:2697
IsFlagOn
#define IsFlagOn(a, b)
Definition: ext2fs.h:177
RfsdFastIoCheckIfPossible
BOOLEAN NTAPI RfsdFastIoCheckIfPossible(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, IN BOOLEAN CheckForReadOperation, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:39
PsGetCurrentProcess
#define PsGetCurrentProcess
Definition: psfuncs.h:17
RfsdFastIoUnlockAll
BOOLEAN NTAPI RfsdFastIoUnlockAll(IN PFILE_OBJECT FileObject, IN PEPROCESS Process, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:715
EXCEPTION_EXECUTE_HANDLER
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185
NULL
smooth NULL
Definition: ftsmooth.c:416
Buffer
Definition: bufpool.h:45
_DEVICE_OBJECT
Definition: env_spec_w32.h:413
FileObject
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:593
FILE_ATTRIBUTE_DIRECTORY
#define FILE_ATTRIBUTE_DIRECTORY
Definition: nt_native.h:705
RfsdFastIoQueryStandardInfo
BOOLEAN NTAPI RfsdFastIoQueryStandardInfo(IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, OUT PFILE_STANDARD_INFORMATION Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:350
LockKey
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG LockKey
Definition: fatprocs.h:2650
LONGLONG
int64_t LONGLONG
Definition: typedefs.h:67
if
if(!(yy_init))
Definition: macro.lex.yy.c:714
RfsdGetCurrentProcessName
#define RfsdGetCurrentProcessName()
Definition: rfsd.h:1095
ULONGLONG
uint64_t ULONGLONG
Definition: typedefs.h:66
Vcb
#define Vcb
Definition: cdprocs.h:1425
RfsdFastIoQueryBasicInfo
BOOLEAN NTAPI RfsdFastIoQueryBasicInfo(IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, OUT PFILE_BASIC_INFORMATION Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:230
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
ExReleaseResourceLite
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817
PFILE_OBJECT
* PFILE_OBJECT
Definition: iotypes.h:1955
ASSERT
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
_FCB::Flags
ULONG Flags
Definition: ntfs.h:532
VCB_WRITE_PROTECTED
#define VCB_WRITE_PROTECTED
Definition: ext2fs.h:796
FILE_ATTRIBUTE_NORMAL
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:126
IsDirectory
_Must_inspect_result_ _In_ PFLT_INSTANCE _Out_ PBOOLEAN IsDirectory
Definition: fltkernel.h:1139
RfsdPrint
#define RfsdPrint(arg)
Definition: rfsd.h:1069
NTFSIDENTIFIER::Type
ULONG Type
Definition: ntfs.h:95
FILE_STANDARD_INFORMATION
#define FILE_STANDARD_INFORMATION
Definition: disk.h:54
FileSize
_Must_inspect_result_ _Out_ PLARGE_INTEGER FileSize
Definition: fsrtlfuncs.h:108
DBG_ERROR
#define DBG_ERROR
Definition: ffsdrv.h:1031
FlagOn
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
FsRtlFastUnlockAll
NTSTATUS NTAPI FsRtlFastUnlockAll(IN PFILE_LOCK FileLock, IN PFILE_OBJECT FileObject, IN PEPROCESS Process, IN PVOID Context OPTIONAL)
Definition: filelock.c:1026
_FCB::MainResource
ERESOURCE MainResource
Definition: ntfs.h:524
VCB_READ_ONLY
#define VCB_READ_ONLY
Definition: ext2fs.h:795
RfsdFastIoLock
BOOLEAN NTAPI RfsdFastIoLock(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, IN PEPROCESS Process, IN ULONG Key, IN BOOLEAN FailImmediately, IN BOOLEAN ExclusiveLock, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:490
Status
Status
Definition: gdiplustypes.h:24
AllocationSize
IN PFCB IN PFILE_OBJECT FileObject IN ULONG AllocationSize
Definition: fatprocs.h:310
DeviceObject
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
_IO_STATUS_BLOCK
Definition: env_spec_w32.h:870
RfsdFastIoUnlockSingle
BOOLEAN NTAPI RfsdFastIoUnlockSingle(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, IN PEPROCESS Process, IN ULONG Key, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:610
_SEH2_END
_SEH2_END
Definition: create.c:4424
FileOffset
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:151
_SEH2_FINALLY
_SEH2_FINALLY
Definition: create.c:4395
FCB_PAGE_FILE
#define FCB_PAGE_FILE
Definition: ext2fs.h:872
ExclusiveLock
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ULONG BOOLEAN BOOLEAN ExclusiveLock
Definition: fatprocs.h:2697
ExAcquireResourceSharedLite
BOOLEAN NTAPI ExAcquireResourceSharedLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:885
_LARGE_INTEGER
Definition: typedefs.h:101
FsRtlCopyRead
BOOLEAN NTAPI FsRtlCopyRead(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:64
FsRtlCopyWrite
BOOLEAN NTAPI FsRtlCopyWrite(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:264
_FILE_BASIC_INFORMATION
Definition: nt_native.h:938
RfsdFastIoQueryNetworkOpenInfo
BOOLEAN NTAPI RfsdFastIoQueryNetworkOpenInfo(IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, IN OUT PFILE_NETWORK_OPEN_INFORMATION PFNOI, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: fastio.c:917
Process
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
OUT
#define OUT
Definition: typedefs.h:40
_RFSD_VCB
Definition: rfsd.h:479
ULONG
unsigned int ULONG
Definition: retypes.h:1
RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
_FCB::Vcb
PVCB Vcb
Definition: cdstruc.h:939
DbgBreak
#define DbgBreak()
Definition: ext2fs.h:46
ExReleaseResourceForThreadLite
VOID NTAPI ExReleaseResourceForThreadLite(IN PERESOURCE Resource, IN ERESOURCE_THREAD Thread)
Definition: resource.c:1844
DBG_INFO
#define DBG_INFO
Definition: ffsdrv.h:1034
_SEH2_EXCEPT
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
_SEH2_GetExceptionCode
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
_SEH2_LEAVE
#define _SEH2_LEAVE
Definition: filesup.c:20
Fcb
_In_ PFCB Fcb
Definition: cdprocs.h:151
STATUS_SUCCESS
return STATUS_SUCCESS
Definition: btrfs.c:2938
S_ISREG
#define S_ISREG(mode)
Definition: various.h:17
FsRtlFastLock
#define FsRtlFastLock(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)
Definition: fsrtlfuncs.h:1581
FsRtlFastCheckLockForWrite
BOOLEAN NTAPI FsRtlFastCheckLockForWrite(IN PFILE_LOCK FileLock, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, IN ULONG Key, IN PFILE_OBJECT FileObject, IN PVOID Process)
Definition: filelock.c:786
NTFSIDENTIFIER::Size
ULONG Size
Definition: ntfs.h:96
_LARGE_INTEGER::QuadPart
LONGLONG QuadPart
Definition: typedefs.h:113
_RFSD_FCB
Definition: rfsd.h:603
RfsdFastIoWrite
BOOLEAN NTAPI RfsdFastIoWrite(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Wait
IN BOOLEAN Wait
Definition: fatprocs.h:1529
FILE_BASIC_INFORMATION
#define FILE_BASIC_INFORMATION
Definition: disk.h:53