3628bb39114db80bb915096a21cbe840cc626d47
[reactos.git] / reactos / drivers / filesystems / ntfs / blockdev.c
1 /*
2 * ReactOS kernel
3 * Copyright (C) 2002 ReactOS Team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
18 *
19 * COPYRIGHT: See COPYING in the top level directory
20 * PROJECT: ReactOS kernel
21 * FILE: drivers/filesystem/ntfs/blockdev.c
22 * PURPOSE: NTFS filesystem driver
23 * PROGRAMMER: Eric Kohl
24 */
25
26 /* INCLUDES *****************************************************************/
27
28 #include "ntfs.h"
29
30 #define NDEBUG
31 #include <debug.h>
32
33 /* FUNCTIONS ****************************************************************/
34
35 NTSTATUS
36 NtfsReadDisk(IN PDEVICE_OBJECT DeviceObject,
37 IN LONGLONG StartingOffset,
38 IN ULONG Length,
39 IN OUT PUCHAR Buffer,
40 IN BOOLEAN Override)
41 {
42 PIO_STACK_LOCATION Stack;
43 IO_STATUS_BLOCK IoStatus;
44 LARGE_INTEGER Offset;
45 KEVENT Event;
46 PIRP Irp;
47 NTSTATUS Status;
48
49 DPRINT("NtfsReadDisk(%p, %I64x, %u, %p, %d)\n", DeviceObject, StartingOffset, Length, Buffer, Override);
50
51 KeInitializeEvent(&Event,
52 NotificationEvent,
53 FALSE);
54
55 Offset.QuadPart = StartingOffset;
56
57 DPRINT("Building synchronous FSD Request...\n");
58 Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
59 DeviceObject,
60 Buffer,
61 Length,
62 &Offset,
63 &Event,
64 &IoStatus);
65 if (Irp == NULL)
66 {
67 DPRINT("IoBuildSynchronousFsdRequest failed\n");
68 return STATUS_INSUFFICIENT_RESOURCES;
69 }
70
71 if (Override)
72 {
73 Stack = IoGetNextIrpStackLocation(Irp);
74 Stack->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
75 }
76
77 DPRINT("Calling IO Driver... with irp %p\n", Irp);
78 Status = IoCallDriver(DeviceObject, Irp);
79
80 DPRINT("Waiting for IO Operation for %p\n", Irp);
81 if (Status == STATUS_PENDING)
82 {
83 DPRINT("Operation pending\n");
84 KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
85 DPRINT("Getting IO Status... for %p\n", Irp);
86 Status = IoStatus.Status;
87 }
88
89 DPRINT("NtfsReadDisk() done (Status %x)\n", Status);
90
91 return Status;
92 }
93
94 NTSTATUS
95 NtfsReadSectors(IN PDEVICE_OBJECT DeviceObject,
96 IN ULONG DiskSector,
97 IN ULONG SectorCount,
98 IN ULONG SectorSize,
99 IN OUT PUCHAR Buffer,
100 IN BOOLEAN Override)
101 {
102 LONGLONG Offset;
103 ULONG BlockSize;
104
105 Offset = (LONGLONG)DiskSector * (LONGLONG)SectorSize;
106 BlockSize = SectorCount * SectorSize;
107
108 return NtfsReadDisk(DeviceObject, Offset, BlockSize, Buffer, Override);
109 }
110
111
112 NTSTATUS
113 NtfsDeviceIoControl(IN PDEVICE_OBJECT DeviceObject,
114 IN ULONG ControlCode,
115 IN PVOID InputBuffer,
116 IN ULONG InputBufferSize,
117 IN OUT PVOID OutputBuffer,
118 IN OUT PULONG OutputBufferSize,
119 IN BOOLEAN Override)
120 {
121 PIO_STACK_LOCATION Stack;
122 IO_STATUS_BLOCK IoStatus;
123 KEVENT Event;
124 PIRP Irp;
125 NTSTATUS Status;
126
127 KeInitializeEvent(&Event, NotificationEvent, FALSE);
128
129 DPRINT("Building device I/O control request ...\n");
130 Irp = IoBuildDeviceIoControlRequest(ControlCode,
131 DeviceObject,
132 InputBuffer,
133 InputBufferSize,
134 OutputBuffer,
135 (OutputBufferSize) ? *OutputBufferSize : 0,
136 FALSE,
137 &Event,
138 &IoStatus);
139 if (Irp == NULL)
140 {
141 DPRINT("IoBuildDeviceIoControlRequest() failed\n");
142 return STATUS_INSUFFICIENT_RESOURCES;
143 }
144
145 if (Override)
146 {
147 Stack = IoGetNextIrpStackLocation(Irp);
148 Stack->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
149 }
150
151 DPRINT("Calling IO Driver... with irp %p\n", Irp);
152 Status = IoCallDriver(DeviceObject, Irp);
153 if (Status == STATUS_PENDING)
154 {
155 KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
156 Status = IoStatus.Status;
157 }
158
159 if (OutputBufferSize)
160 {
161 *OutputBufferSize = IoStatus.Information;
162 }
163
164 return Status;
165 }
166
167 /* EOF */