[FASTFAT] Fix size checking in VfatGetFileNameInformation()
[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 * 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 ULONG SectorSize,
40 IN OUT PUCHAR Buffer,
41 IN BOOLEAN Override)
42 {
43 PIO_STACK_LOCATION Stack;
44 IO_STATUS_BLOCK IoStatus;
45 LARGE_INTEGER Offset;
46 KEVENT Event;
47 PIRP Irp;
48 NTSTATUS Status;
49 ULONGLONG RealReadOffset;
50 ULONG RealLength;
51 BOOLEAN AllocatedBuffer = FALSE;
52 PUCHAR ReadBuffer = Buffer;
53
54 DPRINT("NtfsReadDisk(%p, %I64x, %u, %u, %p, %d)\n", DeviceObject, StartingOffset, Length, SectorSize, Buffer, Override);
55
56 KeInitializeEvent(&Event,
57 NotificationEvent,
58 FALSE);
59
60 RealReadOffset = (ULONGLONG)StartingOffset;
61 RealLength = Length;
62
63 if ((RealReadOffset % SectorSize) != 0 || (RealLength % SectorSize) != 0)
64 {
65 RealReadOffset = ROUND_DOWN(StartingOffset, SectorSize);
66 RealLength = ROUND_UP(Length, SectorSize);
67
68 ReadBuffer = ExAllocatePoolWithTag(NonPagedPool, RealLength + SectorSize, TAG_NTFS);
69 if (ReadBuffer == NULL)
70 {
71 DPRINT1("Not enough memory!\n");
72 return STATUS_INSUFFICIENT_RESOURCES;
73 }
74 AllocatedBuffer = TRUE;
75 }
76
77 Offset.QuadPart = RealReadOffset;
78
79 DPRINT("Building synchronous FSD Request...\n");
80 Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
81 DeviceObject,
82 ReadBuffer,
83 RealLength,
84 &Offset,
85 &Event,
86 &IoStatus);
87 if (Irp == NULL)
88 {
89 DPRINT("IoBuildSynchronousFsdRequest failed\n");
90
91 if (AllocatedBuffer)
92 {
93 ExFreePoolWithTag(ReadBuffer, TAG_NTFS);
94 }
95
96 return STATUS_INSUFFICIENT_RESOURCES;
97 }
98
99 if (Override)
100 {
101 Stack = IoGetNextIrpStackLocation(Irp);
102 Stack->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
103 }
104
105 DPRINT("Calling IO Driver... with irp %p\n", Irp);
106 Status = IoCallDriver(DeviceObject, Irp);
107
108 DPRINT("Waiting for IO Operation for %p\n", Irp);
109 if (Status == STATUS_PENDING)
110 {
111 DPRINT("Operation pending\n");
112 KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
113 DPRINT("Getting IO Status... for %p\n", Irp);
114 Status = IoStatus.Status;
115 }
116
117 if (AllocatedBuffer)
118 {
119 if (NT_SUCCESS(Status))
120 {
121 RtlCopyMemory(Buffer, ReadBuffer + (StartingOffset - RealReadOffset), Length);
122 }
123
124 ExFreePoolWithTag(ReadBuffer, TAG_NTFS);
125 }
126
127 DPRINT("NtfsReadDisk() done (Status %x)\n", Status);
128
129 return Status;
130 }
131
132 NTSTATUS
133 NtfsReadSectors(IN PDEVICE_OBJECT DeviceObject,
134 IN ULONG DiskSector,
135 IN ULONG SectorCount,
136 IN ULONG SectorSize,
137 IN OUT PUCHAR Buffer,
138 IN BOOLEAN Override)
139 {
140 LONGLONG Offset;
141 ULONG BlockSize;
142
143 Offset = (LONGLONG)DiskSector * (LONGLONG)SectorSize;
144 BlockSize = SectorCount * SectorSize;
145
146 return NtfsReadDisk(DeviceObject, Offset, BlockSize, SectorSize, Buffer, Override);
147 }
148
149
150 NTSTATUS
151 NtfsDeviceIoControl(IN PDEVICE_OBJECT DeviceObject,
152 IN ULONG ControlCode,
153 IN PVOID InputBuffer,
154 IN ULONG InputBufferSize,
155 IN OUT PVOID OutputBuffer,
156 IN OUT PULONG OutputBufferSize,
157 IN BOOLEAN Override)
158 {
159 PIO_STACK_LOCATION Stack;
160 IO_STATUS_BLOCK IoStatus;
161 KEVENT Event;
162 PIRP Irp;
163 NTSTATUS Status;
164
165 KeInitializeEvent(&Event, NotificationEvent, FALSE);
166
167 DPRINT("Building device I/O control request ...\n");
168 Irp = IoBuildDeviceIoControlRequest(ControlCode,
169 DeviceObject,
170 InputBuffer,
171 InputBufferSize,
172 OutputBuffer,
173 (OutputBufferSize) ? *OutputBufferSize : 0,
174 FALSE,
175 &Event,
176 &IoStatus);
177 if (Irp == NULL)
178 {
179 DPRINT("IoBuildDeviceIoControlRequest() failed\n");
180 return STATUS_INSUFFICIENT_RESOURCES;
181 }
182
183 if (Override)
184 {
185 Stack = IoGetNextIrpStackLocation(Irp);
186 Stack->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
187 }
188
189 DPRINT("Calling IO Driver... with irp %p\n", Irp);
190 Status = IoCallDriver(DeviceObject, Irp);
191 if (Status == STATUS_PENDING)
192 {
193 KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
194 Status = IoStatus.Status;
195 }
196
197 if (OutputBufferSize)
198 {
199 *OutputBufferSize = IoStatus.Information;
200 }
201
202 return Status;
203 }
204
205 /* EOF */