[NTFS] - In the NtfsAddFilenameToDirectory() function, rename DirectoryContext parame...
[reactos.git] / 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 * PROGRAMMERS: Eric Kohl
24 * Trevor Thompson
25 */
26
27 /* INCLUDES *****************************************************************/
28
29 #include "ntfs.h"
30
31 #define NDEBUG
32 #include <debug.h>
33
34 /* FUNCTIONS ****************************************************************/
35
36 NTSTATUS
37 NtfsReadDisk(IN PDEVICE_OBJECT DeviceObject,
38 IN LONGLONG StartingOffset,
39 IN ULONG Length,
40 IN ULONG SectorSize,
41 IN OUT PUCHAR Buffer,
42 IN BOOLEAN Override)
43 {
44 PIO_STACK_LOCATION Stack;
45 IO_STATUS_BLOCK IoStatus;
46 LARGE_INTEGER Offset;
47 KEVENT Event;
48 PIRP Irp;
49 NTSTATUS Status;
50 ULONGLONG RealReadOffset;
51 ULONG RealLength;
52 BOOLEAN AllocatedBuffer = FALSE;
53 PUCHAR ReadBuffer = Buffer;
54
55 DPRINT("NtfsReadDisk(%p, %I64x, %u, %u, %p, %d)\n", DeviceObject, StartingOffset, Length, SectorSize, Buffer, Override);
56
57 KeInitializeEvent(&Event,
58 NotificationEvent,
59 FALSE);
60
61 RealReadOffset = (ULONGLONG)StartingOffset;
62 RealLength = Length;
63
64 if ((RealReadOffset % SectorSize) != 0 || (RealLength % SectorSize) != 0)
65 {
66 RealReadOffset = ROUND_DOWN(StartingOffset, SectorSize);
67 RealLength = ROUND_UP(Length, SectorSize);
68
69 ReadBuffer = ExAllocatePoolWithTag(NonPagedPool, RealLength + SectorSize, TAG_NTFS);
70 if (ReadBuffer == NULL)
71 {
72 DPRINT1("Not enough memory!\n");
73 return STATUS_INSUFFICIENT_RESOURCES;
74 }
75 AllocatedBuffer = TRUE;
76 }
77
78 Offset.QuadPart = RealReadOffset;
79
80 DPRINT("Building synchronous FSD Request...\n");
81 Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
82 DeviceObject,
83 ReadBuffer,
84 RealLength,
85 &Offset,
86 &Event,
87 &IoStatus);
88 if (Irp == NULL)
89 {
90 DPRINT("IoBuildSynchronousFsdRequest failed\n");
91
92 if (AllocatedBuffer)
93 {
94 ExFreePoolWithTag(ReadBuffer, TAG_NTFS);
95 }
96
97 return STATUS_INSUFFICIENT_RESOURCES;
98 }
99
100 if (Override)
101 {
102 Stack = IoGetNextIrpStackLocation(Irp);
103 Stack->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
104 }
105
106 DPRINT("Calling IO Driver... with irp %p\n", Irp);
107 Status = IoCallDriver(DeviceObject, Irp);
108
109 DPRINT("Waiting for IO Operation for %p\n", Irp);
110 if (Status == STATUS_PENDING)
111 {
112 DPRINT("Operation pending\n");
113 KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
114 DPRINT("Getting IO Status... for %p\n", Irp);
115 Status = IoStatus.Status;
116 }
117
118 if (AllocatedBuffer)
119 {
120 if (NT_SUCCESS(Status))
121 {
122 RtlCopyMemory(Buffer, ReadBuffer + (StartingOffset - RealReadOffset), Length);
123 }
124
125 ExFreePoolWithTag(ReadBuffer, TAG_NTFS);
126 }
127
128 DPRINT("NtfsReadDisk() done (Status %x)\n", Status);
129
130 return Status;
131 }
132
133 /**
134 * @name NtfsWriteDisk
135 * @implemented
136 *
137 * Writes data from the given buffer to the given DeviceObject.
138 *
139 * @param DeviceObject
140 * Device to write to
141 *
142 * @param StartingOffset
143 * Offset, in bytes, from the start of the device object where the data will be written
144 *
145 * @param Length
146 * How much data will be written, in bytes
147 *
148 * @param SectorSize
149 * Size of the sector on the disk that the write must be aligned to
150 *
151 * @param Buffer
152 * The data that's being written to the device
153 *
154 * @return
155 * STATUS_SUCCESS in case of success, STATUS_INSUFFICIENT_RESOURCES if a memory allocation failed,
156 * or whatever status IoCallDriver() sets.
157 *
158 * @remarks Called by NtfsWriteFile(). May perform a read-modify-write operation if the
159 * requested write is not sector-aligned.
160 *
161 */
162 NTSTATUS
163 NtfsWriteDisk(IN PDEVICE_OBJECT DeviceObject,
164 IN LONGLONG StartingOffset,
165 IN ULONG Length,
166 IN ULONG SectorSize,
167 IN const PUCHAR Buffer)
168 {
169 IO_STATUS_BLOCK IoStatus;
170 LARGE_INTEGER Offset;
171 KEVENT Event;
172 PIRP Irp;
173 NTSTATUS Status;
174 ULONGLONG RealWriteOffset;
175 ULONG RealLength;
176 BOOLEAN AllocatedBuffer = FALSE;
177 PUCHAR TempBuffer = NULL;
178
179 DPRINT("NtfsWriteDisk(%p, %I64x, %u, %u, %p)\n", DeviceObject, StartingOffset, Length, SectorSize, Buffer);
180
181 if (Length == 0)
182 return STATUS_SUCCESS;
183
184 RealWriteOffset = (ULONGLONG)StartingOffset;
185 RealLength = Length;
186
187 // Does the write need to be adjusted to be sector-aligned?
188 if ((RealWriteOffset % SectorSize) != 0 || (RealLength % SectorSize) != 0)
189 {
190 ULONGLONG relativeOffset;
191
192 // We need to do a read-modify-write. We'll start be copying the entire
193 // contents of every sector that will be overwritten.
194 // TODO: Optimize (read no more than necessary)
195
196 RealWriteOffset = ROUND_DOWN(StartingOffset, SectorSize);
197 RealLength = ROUND_UP(Length, SectorSize);
198
199 // Would the end of our sector-aligned write fall short of the requested write?
200 if (RealWriteOffset + RealLength < StartingOffset + Length)
201 {
202 RealLength += SectorSize;
203 }
204
205 // Did we underestimate the memory required somehow?
206 if (RealLength + RealWriteOffset < StartingOffset + Length)
207 {
208 DPRINT1("\a\t\t\t\t\tFIXME: calculated less memory than needed!\n");
209 DPRINT1("StartingOffset: %lu\tLength: %lu\tRealWriteOffset: %lu\tRealLength: %lu\n",
210 StartingOffset, Length, RealWriteOffset, RealLength);
211
212 RealLength += SectorSize;
213 }
214
215 // Allocate a buffer to copy the existing data to
216 TempBuffer = ExAllocatePoolWithTag(NonPagedPool, RealLength, TAG_NTFS);
217
218 // Did we fail to allocate it?
219 if (TempBuffer == NULL)
220 {
221 DPRINT1("Not enough memory!\n");
222
223 return STATUS_INSUFFICIENT_RESOURCES;
224 }
225
226 // Read the sectors we'll be overwriting into TempBuffer
227 Status = NtfsReadDisk(DeviceObject, RealWriteOffset, RealLength, SectorSize, TempBuffer, FALSE);
228
229 // Did we fail the read?
230 if (!NT_SUCCESS(Status))
231 {
232 RtlSecureZeroMemory(TempBuffer, RealLength);
233 ExFreePoolWithTag(TempBuffer, TAG_NTFS);
234 return Status;
235 }
236
237 // Calculate where the new data should be written to, relative to the start of TempBuffer
238 relativeOffset = StartingOffset - RealWriteOffset;
239
240 // Modify the tempbuffer with the data being read
241 RtlCopyMemory(TempBuffer + relativeOffset, Buffer, Length);
242
243 AllocatedBuffer = TRUE;
244 }
245
246 // set the destination offset
247 Offset.QuadPart = RealWriteOffset;
248
249 // setup the notification event for the write
250 KeInitializeEvent(&Event,
251 NotificationEvent,
252 FALSE);
253
254 DPRINT("Building synchronous FSD Request...\n");
255
256 // Build an IRP requesting the lower-level [disk] driver to perform the write
257 // TODO: Forward the existing IRP instead
258 Irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE,
259 DeviceObject,
260 // if we allocated a temp buffer, use that instead of the Buffer parameter
261 ((AllocatedBuffer) ? TempBuffer : Buffer),
262 RealLength,
263 &Offset,
264 &Event,
265 &IoStatus);
266 // Did we fail to build the IRP?
267 if (Irp == NULL)
268 {
269 DPRINT1("IoBuildSynchronousFsdRequest failed\n");
270
271 if (AllocatedBuffer)
272 {
273 RtlSecureZeroMemory(TempBuffer, RealLength);
274 ExFreePoolWithTag(TempBuffer, TAG_NTFS);
275 }
276
277 return STATUS_INSUFFICIENT_RESOURCES;
278 }
279
280 // Call the next-lower driver to perform the write
281 DPRINT("Calling IO Driver with irp %p\n", Irp);
282 Status = IoCallDriver(DeviceObject, Irp);
283
284 // Wait until the next-lower driver has completed the IRP
285 DPRINT("Waiting for IO Operation for %p\n", Irp);
286 if (Status == STATUS_PENDING)
287 {
288 DPRINT("Operation pending\n");
289 KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
290 DPRINT("Getting IO Status... for %p\n", Irp);
291 Status = IoStatus.Status;
292 }
293
294 if (AllocatedBuffer)
295 {
296 // zero the buffer before freeing it, so private user data can't be snooped
297 RtlSecureZeroMemory(TempBuffer, RealLength);
298
299 ExFreePoolWithTag(TempBuffer, TAG_NTFS);
300 }
301
302 DPRINT("NtfsWriteDisk() done (Status %x)\n", Status);
303
304 return Status;
305 }
306
307 NTSTATUS
308 NtfsReadSectors(IN PDEVICE_OBJECT DeviceObject,
309 IN ULONG DiskSector,
310 IN ULONG SectorCount,
311 IN ULONG SectorSize,
312 IN OUT PUCHAR Buffer,
313 IN BOOLEAN Override)
314 {
315 LONGLONG Offset;
316 ULONG BlockSize;
317
318 Offset = (LONGLONG)DiskSector * (LONGLONG)SectorSize;
319 BlockSize = SectorCount * SectorSize;
320
321 return NtfsReadDisk(DeviceObject, Offset, BlockSize, SectorSize, Buffer, Override);
322 }
323
324
325 NTSTATUS
326 NtfsDeviceIoControl(IN PDEVICE_OBJECT DeviceObject,
327 IN ULONG ControlCode,
328 IN PVOID InputBuffer,
329 IN ULONG InputBufferSize,
330 IN OUT PVOID OutputBuffer,
331 IN OUT PULONG OutputBufferSize,
332 IN BOOLEAN Override)
333 {
334 PIO_STACK_LOCATION Stack;
335 IO_STATUS_BLOCK IoStatus;
336 KEVENT Event;
337 PIRP Irp;
338 NTSTATUS Status;
339
340 KeInitializeEvent(&Event, NotificationEvent, FALSE);
341
342 DPRINT("Building device I/O control request ...\n");
343 Irp = IoBuildDeviceIoControlRequest(ControlCode,
344 DeviceObject,
345 InputBuffer,
346 InputBufferSize,
347 OutputBuffer,
348 (OutputBufferSize) ? *OutputBufferSize : 0,
349 FALSE,
350 &Event,
351 &IoStatus);
352 if (Irp == NULL)
353 {
354 DPRINT("IoBuildDeviceIoControlRequest() failed\n");
355 return STATUS_INSUFFICIENT_RESOURCES;
356 }
357
358 if (Override)
359 {
360 Stack = IoGetNextIrpStackLocation(Irp);
361 Stack->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
362 }
363
364 DPRINT("Calling IO Driver... with irp %p\n", Irp);
365 Status = IoCallDriver(DeviceObject, Irp);
366 if (Status == STATUS_PENDING)
367 {
368 KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
369 Status = IoStatus.Status;
370 }
371
372 if (OutputBufferSize)
373 {
374 *OutputBufferSize = IoStatus.Information;
375 }
376
377 return Status;
378 }
379
380 /* EOF */