summaryrefslogtreecommitdiff
path: root/libntfs-3g/win32_io.c (plain)
blob: ed9fa5218eb349fef42451268aca14e59d1e5aa7
1/*
2 * win32_io.c - A stdio-like disk I/O implementation for low-level disk access
3 * on Win32. Can access an NTFS volume while it is mounted.
4 * Originated from the Linux-NTFS project.
5 *
6 * Copyright (c) 2003-2004 Lode Leroy
7 * Copyright (c) 2003-2006 Anton Altaparmakov
8 * Copyright (c) 2004-2005 Yuval Fledel
9 *
10 * This program/include file is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as published
12 * by the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program/include file is distributed in the hope that it will be
16 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
17 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program (in the main directory of the NTFS-3G
22 * distribution in the file COPYING); if not, write to the Free Software
23 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 */
25
26#include "config.h"
27
28#ifdef HAVE_WINDOWS_H
29#include <windows.h>
30#endif
31#include <winioctl.h>
32
33#ifdef HAVE_STDIO_H
34#include <stdio.h>
35#endif
36#ifdef HAVE_CTYPE_H
37#include <ctype.h>
38#endif
39#ifdef HAVE_ERRNO_H
40#include <errno.h>
41#endif
42#ifdef HAVE_FCNTL_H
43#include <fcntl.h>
44#endif
45
46/* Prevent volume.h from being be loaded, as it conflicts with winnt.h. */
47#define _NTFS_VOLUME_H
48struct ntfs_volume;
49typedef struct ntfs_volume ntfs_volume;
50
51#include "debug.h"
52#include "types.h"
53#include "device.h"
54
55#ifndef MAX_PATH
56#define MAX_PATH 1024
57#endif
58
59#ifndef NTFS_BLOCK_SIZE
60#define NTFS_BLOCK_SIZE 512
61#define NTFS_BLOCK_SIZE_BITS 9
62#endif
63
64#ifndef IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS
65#define IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS 5636096
66#endif
67
68/* Windows 2k+ imports. */
69typedef HANDLE (WINAPI *LPFN_FINDFIRSTVOLUME)(LPTSTR, DWORD);
70typedef BOOL (WINAPI *LPFN_FINDNEXTVOLUME)(HANDLE, LPTSTR, DWORD);
71typedef BOOL (WINAPI *LPFN_FINDVOLUMECLOSE)(HANDLE);
72typedef BOOL (WINAPI *LPFN_SETFILEPOINTEREX)(HANDLE, LARGE_INTEGER,
73 PLARGE_INTEGER, DWORD);
74
75static LPFN_FINDFIRSTVOLUME fnFindFirstVolume = NULL;
76static LPFN_FINDNEXTVOLUME fnFindNextVolume = NULL;
77static LPFN_FINDVOLUMECLOSE fnFindVolumeClose = NULL;
78static LPFN_SETFILEPOINTEREX fnSetFilePointerEx = NULL;
79
80#ifdef UNICODE
81#define FNPOSTFIX "W"
82#else
83#define FNPOSTFIX "A"
84#endif
85
86/**
87 * struct win32_fd -
88 */
89typedef struct {
90 HANDLE handle;
91 s64 pos; /* Logical current position on the volume. */
92 s64 part_start;
93 s64 part_length;
94 int part_hidden_sectors;
95 s64 geo_size, geo_cylinders;
96 DWORD geo_sectors, geo_heads;
97 HANDLE vol_handle;
98} win32_fd;
99
100/**
101 * ntfs_w32error_to_errno - convert a win32 error code to the unix one
102 * @w32error: the win32 error code
103 *
104 * Limited to a relatively small but useful number of codes.
105 */
106static int ntfs_w32error_to_errno(unsigned int w32error)
107{
108 ntfs_log_trace("Converting w32error 0x%x.\n",w32error);
109 switch (w32error) {
110 case ERROR_INVALID_FUNCTION:
111 return EBADRQC;
112 case ERROR_FILE_NOT_FOUND:
113 case ERROR_PATH_NOT_FOUND:
114 case ERROR_INVALID_NAME:
115 return ENOENT;
116 case ERROR_TOO_MANY_OPEN_FILES:
117 return EMFILE;
118 case ERROR_ACCESS_DENIED:
119 return EACCES;
120 case ERROR_INVALID_HANDLE:
121 return EBADF;
122 case ERROR_NOT_ENOUGH_MEMORY:
123 return ENOMEM;
124 case ERROR_OUTOFMEMORY:
125 return ENOSPC;
126 case ERROR_INVALID_DRIVE:
127 case ERROR_BAD_UNIT:
128 return ENODEV;
129 case ERROR_WRITE_PROTECT:
130 return EROFS;
131 case ERROR_NOT_READY:
132 case ERROR_SHARING_VIOLATION:
133 return EBUSY;
134 case ERROR_BAD_COMMAND:
135 return EINVAL;
136 case ERROR_SEEK:
137 case ERROR_NEGATIVE_SEEK:
138 return ESPIPE;
139 case ERROR_NOT_SUPPORTED:
140 return EOPNOTSUPP;
141 case ERROR_BAD_NETPATH:
142 return ENOSHARE;
143 default:
144 /* generic message */
145 return ENOMSG;
146 }
147}
148
149/**
150 * libntfs_SetFilePointerEx - emulation for SetFilePointerEx()
151 *
152 * We use this to emulate SetFilePointerEx() when it is not present. This can
153 * happen since SetFilePointerEx() only exists in Win2k+.
154 */
155static BOOL WINAPI libntfs_SetFilePointerEx(HANDLE hFile,
156 LARGE_INTEGER liDistanceToMove,
157 PLARGE_INTEGER lpNewFilePointer, DWORD dwMoveMethod)
158{
159 liDistanceToMove.LowPart = SetFilePointer(hFile,
160 liDistanceToMove.LowPart, &liDistanceToMove.HighPart,
161 dwMoveMethod);
162 if (liDistanceToMove.LowPart == INVALID_SET_FILE_POINTER &&
163 GetLastError() != NO_ERROR) {
164 if (lpNewFilePointer)
165 lpNewFilePointer->QuadPart = -1;
166 return FALSE;
167 }
168 if (lpNewFilePointer)
169 lpNewFilePointer->QuadPart = liDistanceToMove.QuadPart;
170 return TRUE;
171}
172
173/**
174 * ntfs_device_win32_init_imports - initialize the function pointers
175 *
176 * The Find*Volume and SetFilePointerEx functions exist only on win2k+, as such
177 * we cannot just staticly import them.
178 *
179 * This function initializes the imports if the functions do exist and in the
180 * SetFilePointerEx case, we emulate the function ourselves if it is not
181 * present.
182 *
183 * Note: The values are cached, do be afraid to run it more than once.
184 */
185static void ntfs_device_win32_init_imports(void)
186{
187 HMODULE kernel32 = GetModuleHandle("kernel32");
188 if (!kernel32) {
189 errno = ntfs_w32error_to_errno(GetLastError());
190 ntfs_log_trace("kernel32.dll could not be imported.\n");
191 }
192 if (!fnSetFilePointerEx) {
193 if (kernel32)
194 fnSetFilePointerEx = (LPFN_SETFILEPOINTEREX)
195 GetProcAddress(kernel32,
196 "SetFilePointerEx");
197 /*
198 * If we did not get kernel32.dll or it is not Win2k+, emulate
199 * SetFilePointerEx().
200 */
201 if (!fnSetFilePointerEx) {
202 ntfs_log_debug("SetFilePonterEx() not found in "
203 "kernel32.dll: Enabling emulation.\n");
204 fnSetFilePointerEx = libntfs_SetFilePointerEx;
205 }
206 }
207 /* Cannot do lookups if we could not get kernel32.dll... */
208 if (!kernel32)
209 return;
210 if (!fnFindFirstVolume)
211 fnFindFirstVolume = (LPFN_FINDFIRSTVOLUME)
212 GetProcAddress(kernel32, "FindFirstVolume"
213 FNPOSTFIX);
214 if (!fnFindNextVolume)
215 fnFindNextVolume = (LPFN_FINDNEXTVOLUME)
216 GetProcAddress(kernel32, "FindNextVolume"
217 FNPOSTFIX);
218 if (!fnFindVolumeClose)
219 fnFindVolumeClose = (LPFN_FINDVOLUMECLOSE)
220 GetProcAddress(kernel32, "FindVolumeClose");
221}
222
223/**
224 * ntfs_device_unix_status_flags_to_win32 - convert unix->win32 open flags
225 * @flags: unix open status flags
226 *
227 * Supported flags are O_RDONLY, O_WRONLY and O_RDWR.
228 */
229static __inline__ int ntfs_device_unix_status_flags_to_win32(int flags)
230{
231 int win_mode;
232
233 switch (flags & O_ACCMODE) {
234 case O_RDONLY:
235 win_mode = FILE_READ_DATA;
236 break;
237 case O_WRONLY:
238 win_mode = FILE_WRITE_DATA;
239 break;
240 case O_RDWR:
241 win_mode = FILE_READ_DATA | FILE_WRITE_DATA;
242 break;
243 default:
244 /* error */
245 ntfs_log_trace("Unknown status flags.\n");
246 win_mode = 0;
247 }
248 return win_mode;
249}
250
251
252/**
253 * ntfs_device_win32_simple_open_file - just open a file via win32 API
254 * @filename: name of the file to open
255 * @handle: pointer the a HANDLE in which to put the result
256 * @flags: unix open status flags
257 * @locking: will the function gain an exclusive lock on the file?
258 *
259 * Supported flags are O_RDONLY, O_WRONLY and O_RDWR.
260 *
261 * Return 0 if o.k.
262 * -1 if not, and errno set. In this case handle is trashed.
263 */
264static int ntfs_device_win32_simple_open_file(const char *filename,
265 HANDLE *handle, int flags, BOOL locking)
266{
267 *handle = CreateFile(filename,
268 ntfs_device_unix_status_flags_to_win32(flags),
269 locking ? 0 : (FILE_SHARE_WRITE | FILE_SHARE_READ),
270 NULL, OPEN_EXISTING, 0, NULL);
271 if (*handle == INVALID_HANDLE_VALUE) {
272 errno = ntfs_w32error_to_errno(GetLastError());
273 ntfs_log_trace("CreateFile(%s) failed.\n", filename);
274 return -1;
275 }
276 return 0;
277}
278
279/**
280 * ntfs_device_win32_lock - lock the volume
281 * @handle: a win32 HANDLE for a volume to lock
282 *
283 * Locking a volume means no one can access its contents.
284 * Exiting the process automatically unlocks the volume, except in old NT4s.
285 *
286 * Return 0 if o.k.
287 * -1 if not, and errno set.
288 */
289static int ntfs_device_win32_lock(HANDLE handle)
290{
291 DWORD i;
292
293 if (!DeviceIoControl(handle, FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0, &i,
294 NULL)) {
295 errno = ntfs_w32error_to_errno(GetLastError());
296 ntfs_log_trace("Couldn't lock volume.\n");
297 return -1;
298 }
299 ntfs_log_debug("Volume locked.\n");
300 return 0;
301}
302
303/**
304 * ntfs_device_win32_unlock - unlock the volume
305 * @handle: the win32 HANDLE which the volume was locked with
306 *
307 * Return 0 if o.k.
308 * -1 if not, and errno set.
309 */
310static int ntfs_device_win32_unlock(HANDLE handle)
311{
312 DWORD i;
313
314 if (!DeviceIoControl(handle, FSCTL_UNLOCK_VOLUME, NULL, 0, NULL, 0, &i,
315 NULL)) {
316 errno = ntfs_w32error_to_errno(GetLastError());
317 ntfs_log_trace("Couldn't unlock volume.\n");
318 return -1;
319 }
320 ntfs_log_debug("Volume unlocked.\n");
321 return 0;
322}
323
324/**
325 * ntfs_device_win32_dismount - dismount a volume
326 * @handle: a win32 HANDLE for a volume to dismount
327 *
328 * Dismounting means the system will refresh the volume in the first change it
329 * gets. Usefull after altering the file structures.
330 * The volume must be locked by the current process while dismounting.
331 * A side effect is that the volume is also unlocked, but you must not rely om
332 * this.
333 *
334 * Return 0 if o.k.
335 * -1 if not, and errno set.
336 */
337static int ntfs_device_win32_dismount(HANDLE handle)
338{
339 DWORD i;
340
341 if (!DeviceIoControl(handle, FSCTL_DISMOUNT_VOLUME, NULL, 0, NULL, 0,
342 &i, NULL)) {
343 errno = ntfs_w32error_to_errno(GetLastError());
344 ntfs_log_trace("Couldn't dismount volume.\n");
345 return -1;
346 }
347 ntfs_log_debug("Volume dismounted.\n");
348 return 0;
349}
350
351/**
352 * ntfs_device_win32_getsize - get file size via win32 API
353 * @handle: pointer the file HANDLE obtained via open
354 *
355 * Only works on ordinary files.
356 *
357 * Return The file size if o.k.
358 * -1 if not, and errno set.
359 */
360static s64 ntfs_device_win32_getsize(HANDLE handle)
361{
362 DWORD loword, hiword;
363
364 loword = GetFileSize(handle, &hiword);
365 if (loword == INVALID_FILE_SIZE) {
366 errno = ntfs_w32error_to_errno(GetLastError());
367 ntfs_log_trace("Couldn't get file size.\n");
368 return -1;
369 }
370 return ((s64)hiword << 32) + loword;
371}
372
373/**
374 * ntfs_device_win32_getdisklength - get disk size via win32 API
375 * @handle: pointer the file HANDLE obtained via open
376 * @argp: pointer to result buffer
377 *
378 * Only works on PhysicalDriveX type handles.
379 *
380 * Return The disk size if o.k.
381 * -1 if not, and errno set.
382 */
383static s64 ntfs_device_win32_getdisklength(HANDLE handle)
384{
385 GET_LENGTH_INFORMATION buf;
386 DWORD i;
387
388 if (!DeviceIoControl(handle, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &buf,
389 sizeof(buf), &i, NULL)) {
390 errno = ntfs_w32error_to_errno(GetLastError());
391 ntfs_log_trace("Couldn't get disk length.\n");
392 return -1;
393 }
394 ntfs_log_debug("Disk length: %lld.\n", buf.Length.QuadPart);
395 return buf.Length.QuadPart;
396}
397
398/**
399 * ntfs_device_win32_getntfssize - get NTFS volume size via win32 API
400 * @handle: pointer the file HANDLE obtained via open
401 * @argp: pointer to result buffer
402 *
403 * Only works on NTFS volume handles.
404 * An annoying bug in windows is that an NTFS volume does not occupy the entire
405 * partition, namely not the last sector (which holds the backup boot sector,
406 * and normally not interesting).
407 * Use this function to get the length of the accessible space through a given
408 * volume handle.
409 *
410 * Return The volume size if o.k.
411 * -1 if not, and errno set.
412 */
413static s64 ntfs_device_win32_getntfssize(HANDLE handle)
414{
415 s64 rvl;
416#ifdef FSCTL_GET_NTFS_VOLUME_DATA
417 DWORD i;
418 NTFS_VOLUME_DATA_BUFFER buf;
419
420 if (!DeviceIoControl(handle, FSCTL_GET_NTFS_VOLUME_DATA, NULL, 0, &buf,
421 sizeof(buf), &i, NULL)) {
422 errno = ntfs_w32error_to_errno(GetLastError());
423 ntfs_log_trace("Couldn't get NTFS volume length.\n");
424 return -1;
425 }
426 rvl = buf.NumberSectors.QuadPart * buf.BytesPerSector;
427 ntfs_log_debug("NTFS volume length: 0x%llx.\n", (long long)rvl);
428#else
429 errno = EINVAL;
430 rvl = -1;
431#endif
432 return rvl;
433}
434
435/**
436 * ntfs_device_win32_getgeo - get CHS information of a drive
437 * @handle: an open handle to the PhysicalDevice
438 * @fd: a win_fd structure that will be filled
439 *
440 * Return 0 if o.k.
441 * -1 if not, and errno set.
442 *
443 * In Windows NT+: fills size, sectors, and cylinders and sets heads to -1.
444 * In Windows XP+: fills size, sectors, cylinders, and heads.
445 *
446 * Note: In pre XP, this requires write permission, even though nothing is
447 * actually written.
448 *
449 * If fails, sets sectors, cylinders, heads, and size to -1.
450 */
451static int ntfs_device_win32_getgeo(HANDLE handle, win32_fd *fd)
452{
453 DWORD i;
454 BOOL rvl;
455 BYTE b[sizeof(DISK_GEOMETRY) + sizeof(DISK_PARTITION_INFO) +
456 sizeof(DISK_DETECTION_INFO) + 512];
457
458 rvl = DeviceIoControl(handle, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, NULL,
459 0, &b, sizeof(b), &i, NULL);
460 if (rvl) {
461 ntfs_log_debug("GET_DRIVE_GEOMETRY_EX detected.\n");
462 DISK_DETECTION_INFO *ddi = (PDISK_DETECTION_INFO)
463 (((PBYTE)(&((PDISK_GEOMETRY_EX)b)->Data)) +
464 (((PDISK_PARTITION_INFO)
465 (&((PDISK_GEOMETRY_EX)b)->Data))->
466 SizeOfPartitionInfo));
467 fd->geo_cylinders = ((DISK_GEOMETRY*)&b)->Cylinders.QuadPart;
468 fd->geo_sectors = ((DISK_GEOMETRY*)&b)->SectorsPerTrack;
469 fd->geo_size = ((DISK_GEOMETRY_EX*)&b)->DiskSize.QuadPart;
470 switch (ddi->DetectionType) {
471 case DetectInt13:
472 fd->geo_cylinders = ddi->Int13.MaxCylinders;
473 fd->geo_sectors = ddi->Int13.SectorsPerTrack;
474 fd->geo_heads = ddi->Int13.MaxHeads;
475 return 0;
476 case DetectExInt13:
477 fd->geo_cylinders = ddi->ExInt13.ExCylinders;
478 fd->geo_sectors = ddi->ExInt13.ExSectorsPerTrack;
479 fd->geo_heads = ddi->ExInt13.ExHeads;
480 return 0;
481 case DetectNone:
482 default:
483 break;
484 }
485 } else
486 fd->geo_heads = -1;
487 rvl = DeviceIoControl(handle, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
488 &b, sizeof(b), &i, NULL);
489 if (rvl) {
490 ntfs_log_debug("GET_DRIVE_GEOMETRY detected.\n");
491 fd->geo_cylinders = ((DISK_GEOMETRY*)&b)->Cylinders.QuadPart;
492 fd->geo_sectors = ((DISK_GEOMETRY*)&b)->SectorsPerTrack;
493 fd->geo_size = fd->geo_cylinders * fd->geo_sectors *
494 ((DISK_GEOMETRY*)&b)->TracksPerCylinder *
495 ((DISK_GEOMETRY*)&b)->BytesPerSector;
496 return 0;
497 }
498 errno = ntfs_w32error_to_errno(GetLastError());
499 ntfs_log_trace("Couldn't retrieve disk geometry.\n");
500 fd->geo_cylinders = -1;
501 fd->geo_sectors = -1;
502 fd->geo_size = -1;
503 return -1;
504}
505
506/**
507 * ntfs_device_win32_open_file - open a file via win32 API
508 * @filename: name of the file to open
509 * @fd: pointer to win32 file device in which to put the result
510 * @flags: unix open status flags
511 *
512 * Return 0 if o.k.
513 * -1 if not, and errno set.
514 */
515static __inline__ int ntfs_device_win32_open_file(char *filename, win32_fd *fd,
516 int flags)
517{
518 HANDLE handle;
519
520 if (ntfs_device_win32_simple_open_file(filename, &handle, flags,
521 FALSE)) {
522 /* open error */
523 return -1;
524 }
525 /* fill fd */
526 fd->handle = handle;
527 fd->part_start = 0;
528 fd->part_length = ntfs_device_win32_getsize(handle);
529 fd->pos = 0;
530 fd->part_hidden_sectors = -1;
531 fd->geo_size = -1; /* used as a marker that this is a file */
532 fd->vol_handle = INVALID_HANDLE_VALUE;
533 return 0;
534}
535
536/**
537 * ntfs_device_win32_open_drive - open a drive via win32 API
538 * @drive_id: drive to open
539 * @fd: pointer to win32 file device in which to put the result
540 * @flags: unix open status flags
541 *
542 * return 0 if o.k.
543 * -1 if not, and errno set.
544 */
545static __inline__ int ntfs_device_win32_open_drive(int drive_id, win32_fd *fd,
546 int flags)
547{
548 HANDLE handle;
549 int err;
550 char filename[MAX_PATH];
551
552 sprintf(filename, "\\\\.\\PhysicalDrive%d", drive_id);
553 if ((err = ntfs_device_win32_simple_open_file(filename, &handle, flags,
554 TRUE))) {
555 /* open error */
556 return err;
557 }
558 /* store the drive geometry */
559 ntfs_device_win32_getgeo(handle, fd);
560 /* Just to be sure */
561 if (fd->geo_size == -1)
562 fd->geo_size = ntfs_device_win32_getdisklength(handle);
563 /* fill fd */
564 fd->handle = handle;
565 fd->part_start = 0;
566 fd->part_length = fd->geo_size;
567 fd->pos = 0;
568 fd->part_hidden_sectors = -1;
569 fd->vol_handle = INVALID_HANDLE_VALUE;
570 return 0;
571}
572
573/**
574 * ntfs_device_win32_open_volume_for_partition - find and open a volume
575 *
576 * Windows NT/2k/XP handles volumes instead of partitions.
577 * This function gets the partition details and return an open volume handle.
578 * That volume is the one whose only physical location on disk is the described
579 * partition.
580 *
581 * The function required Windows 2k/XP, otherwise it fails (gracefully).
582 *
583 * Return success: a valid open volume handle.
584 * fail : INVALID_HANDLE_VALUE
585 */
586static HANDLE ntfs_device_win32_open_volume_for_partition(unsigned int drive_id,
587 s64 part_offset, s64 part_length, int flags)
588{
589 HANDLE vol_find_handle;
590 TCHAR vol_name[MAX_PATH];
591
592 /* Make sure all the required imports exist. */
593 if (!fnFindFirstVolume || !fnFindNextVolume || !fnFindVolumeClose) {
594 ntfs_log_trace("Required dll imports not found.\n");
595 return INVALID_HANDLE_VALUE;
596 }
597 /* Start iterating through volumes. */
598 ntfs_log_trace("Entering with drive_id=%d, part_offset=%lld, "
599 "path_length=%lld, flags=%d.\n", drive_id,
600 (unsigned long long)part_offset,
601 (unsigned long long)part_length, flags);
602 vol_find_handle = fnFindFirstVolume(vol_name, MAX_PATH);
603 /* If a valid handle could not be aquired, reply with "don't know". */
604 if (vol_find_handle == INVALID_HANDLE_VALUE) {
605 ntfs_log_trace("FindFirstVolume failed.\n");
606 return INVALID_HANDLE_VALUE;
607 }
608 do {
609 int vol_name_length;
610 HANDLE handle;
611
612 /* remove trailing '/' from vol_name */
613#ifdef UNICODE
614 vol_name_length = wcslen(vol_name);
615#else
616 vol_name_length = strlen(vol_name);
617#endif
618 if (vol_name_length>0)
619 vol_name[vol_name_length-1]=0;
620
621 ntfs_log_debug("Processing %s.\n", vol_name);
622 /* open the file */
623 handle = CreateFile(vol_name,
624 ntfs_device_unix_status_flags_to_win32(flags),
625 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
626 OPEN_EXISTING, 0, NULL);
627 if (handle != INVALID_HANDLE_VALUE) {
628 DWORD bytesReturned;
629#define EXTENTS_SIZE sizeof(VOLUME_DISK_EXTENTS) + 9 * sizeof(DISK_EXTENT)
630 char extents[EXTENTS_SIZE];
631
632 /* Check physical locations. */
633 if (DeviceIoControl(handle,
634 IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
635 NULL, 0, extents, EXTENTS_SIZE,
636 &bytesReturned, NULL)) {
637 if (((VOLUME_DISK_EXTENTS *)extents)->
638 NumberOfDiskExtents == 1) {
639 DISK_EXTENT *extent = &((
640 VOLUME_DISK_EXTENTS *)
641 extents)->Extents[0];
642 if ((extent->DiskNumber==drive_id) &&
643 (extent->StartingOffset.
644 QuadPart==part_offset)
645 && (extent->
646 ExtentLength.QuadPart
647 == part_length)) {
648 /*
649 * Eureka! (Archimedes, 287 BC,
650 * "I have found it!")
651 */
652 fnFindVolumeClose(
653 vol_find_handle);
654 return handle;
655 }
656 }
657 }
658 } else
659 ntfs_log_trace("getExtents() Failed.\n");
660 } while (fnFindNextVolume(vol_find_handle, vol_name, MAX_PATH));
661 /* End of iteration through volumes. */
662 ntfs_log_trace("Closing, volume was not found.\n");
663 fnFindVolumeClose(vol_find_handle);
664 return INVALID_HANDLE_VALUE;
665}
666
667/**
668 * ntfs_device_win32_find_partition - locates partition details by id.
669 * @handle: HANDLE to the PhysicalDrive
670 * @partition_id: the partition number to locate
671 * @part_offset: pointer to where to put the offset to the partition
672 * @part_length: pointer to where to put the length of the partition
673 * @hidden_sectors: pointer to where to put the hidden sectors
674 *
675 * This function requires an open PhysicalDrive handle and a partition_id.
676 * If a partition with the required id is found on the supplied device,
677 * the partition attributes are returned back.
678 *
679 * Returns: TRUE if found, and sets the output parameters.
680 * FALSE if not and errno is set to the error code.
681 */
682static BOOL ntfs_device_win32_find_partition(HANDLE handle, DWORD partition_id,
683 s64 *part_offset, s64 *part_length, int *hidden_sectors)
684{
685 DRIVE_LAYOUT_INFORMATION *drive_layout;
686 unsigned int err, buf_size, part_count;
687 DWORD i;
688
689 /*
690 * There is no way to know the required buffer, so if the ioctl fails,
691 * try doubling the buffer size each time until the ioctl succeeds.
692 */
693 part_count = 8;
694 do {
695 buf_size = sizeof(DRIVE_LAYOUT_INFORMATION) +
696 part_count * sizeof(PARTITION_INFORMATION);
697 drive_layout = malloc(buf_size);
698 if (!drive_layout) {
699 errno = ENOMEM;
700 return FALSE;
701 }
702 if (DeviceIoControl(handle, IOCTL_DISK_GET_DRIVE_LAYOUT, NULL,
703 0, (BYTE*)drive_layout, buf_size, &i, NULL))
704 break;
705 err = GetLastError();
706 free(drive_layout);
707 if (err != ERROR_INSUFFICIENT_BUFFER) {
708 ntfs_log_trace("GetDriveLayout failed.\n");
709 errno = ntfs_w32error_to_errno(err);
710 return FALSE;
711 }
712 ntfs_log_debug("More than %u partitions.\n", part_count);
713 part_count <<= 1;
714 if (part_count > 512) {
715 ntfs_log_trace("GetDriveLayout failed: More than 512 "
716 "partitions?\n");
717 errno = ENOBUFS;
718 return FALSE;
719 }
720 } while (1);
721 for (i = 0; i < drive_layout->PartitionCount; i++) {
722 if (drive_layout->PartitionEntry[i].PartitionNumber ==
723 partition_id) {
724 *part_offset = drive_layout->PartitionEntry[i].
725 StartingOffset.QuadPart;
726 *part_length = drive_layout->PartitionEntry[i].
727 PartitionLength.QuadPart;
728 *hidden_sectors = drive_layout->PartitionEntry[i].
729 HiddenSectors;
730 free(drive_layout);
731 return TRUE;
732 }
733 }
734 free(drive_layout);
735 errno = ENOENT;
736 return FALSE;
737}
738
739/**
740 * ntfs_device_win32_open_partition - open a partition via win32 API
741 * @drive_id: drive to open
742 * @partition_id: partition to open
743 * @fd: win32 file device to return
744 * @flags: unix open status flags
745 *
746 * Return 0 if o.k.
747 * -1 if not, and errno set.
748 *
749 * When fails, fd contents may have not been preserved.
750 */
751static int ntfs_device_win32_open_partition(int drive_id,
752 unsigned int partition_id, win32_fd *fd, int flags)
753{
754 s64 part_start, part_length;
755 HANDLE handle;
756 int err, hidden_sectors;
757 char drive_name[MAX_PATH];
758
759 sprintf(drive_name, "\\\\.\\PhysicalDrive%d", drive_id);
760 /* Open the entire device without locking, ask questions later */
761 if ((err = ntfs_device_win32_simple_open_file(drive_name, &handle,
762 flags, FALSE))) {
763 /* error */
764 return err;
765 }
766 if (ntfs_device_win32_find_partition(handle, partition_id, &part_start,
767 &part_length, &hidden_sectors)) {
768 s64 tmp;
769 HANDLE vol_handle = ntfs_device_win32_open_volume_for_partition(
770 drive_id, part_start, part_length, flags);
771 /* Store the drive geometry. */
772 ntfs_device_win32_getgeo(handle, fd);
773 fd->handle = handle;
774 fd->pos = 0;
775 fd->part_start = part_start;
776 fd->part_length = part_length;
777 fd->part_hidden_sectors = hidden_sectors;
778 tmp = ntfs_device_win32_getntfssize(vol_handle);
779 if (tmp > 0)
780 fd->geo_size = tmp;
781 else
782 fd->geo_size = fd->part_length;
783 if (vol_handle != INVALID_HANDLE_VALUE) {
784 if (((flags & O_RDWR) == O_RDWR) &&
785 ntfs_device_win32_lock(vol_handle)) {
786 CloseHandle(vol_handle);
787 CloseHandle(handle);
788 return -1;
789 }
790 fd->vol_handle = vol_handle;
791 } else {
792 if ((flags & O_RDWR) == O_RDWR) {
793 /* Access if read-write, no volume found. */
794 ntfs_log_trace("Partitions containing Spanned/"
795 "Mirrored volumes are not "
796 "supported in R/W status "
797 "yet.\n");
798 CloseHandle(handle);
799 errno = EOPNOTSUPP;
800 return -1;
801 }
802 fd->vol_handle = INVALID_HANDLE_VALUE;
803 }
804 return 0;
805 } else {
806 ntfs_log_debug("Partition %u not found on drive %d.\n",
807 partition_id, drive_id);
808 CloseHandle(handle);
809 errno = ENODEV;
810 return -1;
811 }
812}
813
814/**
815 * ntfs_device_win32_open - open a device
816 * @dev: a pointer to the NTFS_DEVICE to open
817 * @flags: unix open status flags
818 *
819 * @dev->d_name must hold the device name, the rest is ignored.
820 * Supported flags are O_RDONLY, O_WRONLY and O_RDWR.
821 *
822 * If name is in format "(hd[0-9],[0-9])" then open a partition.
823 * If name is in format "(hd[0-9])" then open a volume.
824 * Otherwise open a file.
825 */
826static int ntfs_device_win32_open(struct ntfs_device *dev, int flags)
827{
828 int drive_id = 0, numparams;
829 unsigned int part = 0;
830 char drive_char;
831 win32_fd fd;
832 int err;
833
834 if (NDevOpen(dev)) {
835 errno = EBUSY;
836 return -1;
837 }
838 ntfs_device_win32_init_imports();
839 numparams = sscanf(dev->d_name, "/dev/hd%c%u", &drive_char, &part);
840 drive_id = toupper(drive_char) - 'A';
841 switch (numparams) {
842 case 0:
843 ntfs_log_debug("win32_open(%s) -> file.\n", dev->d_name);
844 err = ntfs_device_win32_open_file(dev->d_name, &fd, flags);
845 break;
846 case 1:
847 ntfs_log_debug("win32_open(%s) -> drive %d.\n", dev->d_name,
848 drive_id);
849 err = ntfs_device_win32_open_drive(drive_id, &fd, flags);
850 break;
851 case 2:
852 ntfs_log_debug("win32_open(%s) -> drive %d, part %u.\n",
853 dev->d_name, drive_id, part);
854 err = ntfs_device_win32_open_partition(drive_id, part, &fd,
855 flags);
856 break;
857 default:
858 ntfs_log_debug("win32_open(%s) -> unknwon file format.\n",
859 dev->d_name);
860 err = -1;
861 }
862 if (err)
863 return err;
864 ntfs_log_debug("win32_open(%s) -> %p, offset 0x%llx.\n", dev->d_name,
865 dev, fd.part_start);
866 /* Setup our read-only flag. */
867 if ((flags & O_RDWR) != O_RDWR)
868 NDevSetReadOnly(dev);
869 dev->d_private = malloc(sizeof(win32_fd));
870 memcpy(dev->d_private, &fd, sizeof(win32_fd));
871 NDevSetOpen(dev);
872 NDevClearDirty(dev);
873 return 0;
874}
875
876/**
877 * ntfs_device_win32_seek - change current logical file position
878 * @dev: ntfs device obtained via ->open
879 * @offset: required offset from the whence anchor
880 * @whence: whence anchor specifying what @offset is relative to
881 *
882 * Return the new position on the volume on success and -1 on error with errno
883 * set to the error code.
884 *
885 * @whence may be one of the following:
886 * SEEK_SET - Offset is relative to file start.
887 * SEEK_CUR - Offset is relative to current position.
888 * SEEK_END - Offset is relative to end of file.
889 */
890static s64 ntfs_device_win32_seek(struct ntfs_device *dev, s64 offset,
891 int whence)
892{
893 s64 abs_ofs;
894 win32_fd *fd = (win32_fd *)dev->d_private;
895
896 ntfs_log_trace("seek offset = 0x%llx, whence = %d.\n", offset, whence);
897 switch (whence) {
898 case SEEK_SET:
899 abs_ofs = offset;
900 break;
901 case SEEK_CUR:
902 abs_ofs = fd->pos + offset;
903 break;
904 case SEEK_END:
905 /* End of partition != end of disk. */
906 if (fd->part_length == -1) {
907 ntfs_log_trace("Position relative to end of disk not "
908 "implemented.\n");
909 errno = EOPNOTSUPP;
910 return -1;
911 }
912 abs_ofs = fd->part_length + offset;
913 break;
914 default:
915 ntfs_log_trace("Wrong mode %d.\n", whence);
916 errno = EINVAL;
917 return -1;
918 }
919 if (abs_ofs < 0 || abs_ofs > fd->part_length) {
920 ntfs_log_trace("Seeking outsize seekable area.\n");
921 errno = EINVAL;
922 return -1;
923 }
924 fd->pos = abs_ofs;
925 return abs_ofs;
926}
927
928/**
929 * ntfs_device_win32_pio - positioned low level i/o
930 * @fd: win32 device descriptor obtained via ->open
931 * @pos: at which position to do i/o from/to
932 * @count: how many bytes should be transfered
933 * @b: source/destination buffer
934 * @write: TRUE if write transfer and FALSE if read transfer
935 *
936 * On success returns the number of bytes transfered (can be < @count) and on
937 * error returns -1 and errno set. Transfer starts from position @pos on @fd.
938 *
939 * Notes:
940 * - @pos, @buf, and @count must be aligned to NTFS_BLOCK_SIZE.
941 * - When dealing with volumes, a single call must not span both volume
942 * and disk extents.
943 * - Does not use/set @fd->pos.
944 */
945static s64 ntfs_device_win32_pio(win32_fd *fd, const s64 pos,
946 const s64 count, void *b, const BOOL write)
947{
948 LARGE_INTEGER li;
949 HANDLE handle;
950 DWORD bt;
951 BOOL res;
952
953 ntfs_log_trace("pos = 0x%llx, count = 0x%llx, direction = %s.\n",
954 (long long)pos, (long long)count, write ? "write" :
955 "read");
956 li.QuadPart = pos;
957 if (fd->vol_handle != INVALID_HANDLE_VALUE && pos < fd->geo_size) {
958 ntfs_log_debug("Transfering via vol_handle.\n");
959 handle = fd->vol_handle;
960 } else {
961 ntfs_log_debug("Transfering via handle.\n");
962 handle = fd->handle;
963 li.QuadPart += fd->part_start;
964 }
965 if (!fnSetFilePointerEx(handle, li, NULL, FILE_BEGIN)) {
966 errno = ntfs_w32error_to_errno(GetLastError());
967 ntfs_log_trace("SetFilePointer failed.\n");
968 return -1;
969 }
970 if (write)
971 res = WriteFile(handle, b, count, &bt, NULL);
972 else
973 res = ReadFile(handle, b, count, &bt, NULL);
974 if (!res) {
975 errno = ntfs_w32error_to_errno(GetLastError());
976 ntfs_log_trace("%sFile() failed.\n", write ? "Write" : "Read");
977 return -1;
978 }
979 return bt;
980}
981
982/**
983 * ntfs_device_win32_pread_simple - positioned simple read
984 * @fd: win32 device descriptor obtained via ->open
985 * @pos: at which position to read from
986 * @count: how many bytes should be read
987 * @b: a pointer to where to put the contents
988 *
989 * On success returns the number of bytes read (can be < @count) and on error
990 * returns -1 and errno set. Read starts from position @pos.
991 *
992 * Notes:
993 * - @pos, @buf, and @count must be aligned to NTFS_BLOCK_SIZE.
994 * - When dealing with volumes, a single call must not span both volume
995 * and disk extents.
996 * - Does not use/set @fd->pos.
997 */
998static inline s64 ntfs_device_win32_pread_simple(win32_fd *fd, const s64 pos,
999 const s64 count, void *b)
1000{
1001 return ntfs_device_win32_pio(fd, pos, count, b, FALSE);
1002}
1003
1004/**
1005 * ntfs_device_win32_read - read bytes from an ntfs device
1006 * @dev: ntfs device obtained via ->open
1007 * @b: pointer to where to put the contents
1008 * @count: how many bytes should be read
1009 *
1010 * On success returns the number of bytes actually read (can be < @count).
1011 * On error returns -1 with errno set.
1012 */
1013static s64 ntfs_device_win32_read(struct ntfs_device *dev, void *b, s64 count)
1014{
1015 s64 old_pos, to_read, i, br = 0;
1016 win32_fd *fd = (win32_fd *)dev->d_private;
1017 BYTE *alignedbuffer;
1018 int old_ofs, ofs;
1019
1020 old_pos = fd->pos;
1021 old_ofs = ofs = old_pos & (NTFS_BLOCK_SIZE - 1);
1022 to_read = (ofs + count + NTFS_BLOCK_SIZE - 1) &
1023 ~(s64)(NTFS_BLOCK_SIZE - 1);
1024 /* Impose maximum of 2GB to be on the safe side. */
1025 if (to_read > 0x80000000) {
1026 int delta = to_read - count;
1027 to_read = 0x80000000;
1028 count = to_read - delta;
1029 }
1030 ntfs_log_trace("fd = %p, b = %p, count = 0x%llx, pos = 0x%llx, "
1031 "ofs = %i, to_read = 0x%llx.\n", fd, b,
1032 (long long)count, (long long)old_pos, ofs,
1033 (long long)to_read);
1034 if (!((unsigned long)b & (NTFS_BLOCK_SIZE - 1)) && !old_ofs &&
1035 !(count & (NTFS_BLOCK_SIZE - 1)))
1036 alignedbuffer = b;
1037 else {
1038 alignedbuffer = (BYTE *)VirtualAlloc(NULL, to_read, MEM_COMMIT,
1039 PAGE_READWRITE);
1040 if (!alignedbuffer) {
1041 errno = ntfs_w32error_to_errno(GetLastError());
1042 ntfs_log_trace("VirtualAlloc failed for read.\n");
1043 return -1;
1044 }
1045 }
1046 if (fd->vol_handle != INVALID_HANDLE_VALUE && old_pos < fd->geo_size) {
1047 s64 vol_to_read = fd->geo_size - old_pos;
1048 if (count > vol_to_read) {
1049 br = ntfs_device_win32_pread_simple(fd,
1050 old_pos & ~(s64)(NTFS_BLOCK_SIZE - 1),
1051 ofs + vol_to_read, alignedbuffer);
1052 if (br == -1)
1053 goto read_error;
1054 to_read -= br;
1055 if (br < ofs) {
1056 br = 0;
1057 goto read_partial;
1058 }
1059 br -= ofs;
1060 fd->pos += br;
1061 ofs = fd->pos & (NTFS_BLOCK_SIZE - 1);
1062 if (br != vol_to_read)
1063 goto read_partial;
1064 }
1065 }
1066 i = ntfs_device_win32_pread_simple(fd,
1067 fd->pos & ~(s64)(NTFS_BLOCK_SIZE - 1), to_read,
1068 alignedbuffer + br);
1069 if (i == -1) {
1070 if (br)
1071 goto read_partial;
1072 goto read_error;
1073 }
1074 if (i < ofs)
1075 goto read_partial;
1076 i -= ofs;
1077 br += i;
1078 if (br > count)
1079 br = count;
1080 fd->pos = old_pos + br;
1081read_partial:
1082 if (alignedbuffer != b) {
1083 memcpy((void*)b, alignedbuffer + old_ofs, br);
1084 VirtualFree(alignedbuffer, 0, MEM_RELEASE);
1085 }
1086 return br;
1087read_error:
1088 if (alignedbuffer != b)
1089 VirtualFree(alignedbuffer, 0, MEM_RELEASE);
1090 return -1;
1091}
1092
1093/**
1094 * ntfs_device_win32_close - close an open ntfs deivce
1095 * @dev: ntfs device obtained via ->open
1096 *
1097 * Return 0 if o.k.
1098 * -1 if not, and errno set. Note if error fd->vol_handle is trashed.
1099 */
1100static int ntfs_device_win32_close(struct ntfs_device *dev)
1101{
1102 win32_fd *fd = (win32_fd *)dev->d_private;
1103 BOOL rvl;
1104
1105 ntfs_log_trace("Closing device %p.\n", dev);
1106 if (!NDevOpen(dev)) {
1107 errno = EBADF;
1108 return -1;
1109 }
1110 if (fd->vol_handle != INVALID_HANDLE_VALUE) {
1111 if (!NDevReadOnly(dev)) {
1112 ntfs_device_win32_dismount(fd->vol_handle);
1113 ntfs_device_win32_unlock(fd->vol_handle);
1114 }
1115 if (!CloseHandle(fd->vol_handle))
1116 ntfs_log_trace("CloseHandle() failed for volume.\n");
1117 }
1118 rvl = CloseHandle(fd->handle);
1119 free(fd);
1120 if (!rvl) {
1121 errno = ntfs_w32error_to_errno(GetLastError());
1122 ntfs_log_trace("CloseHandle() failed.\n");
1123 return -1;
1124 }
1125 return 0;
1126}
1127
1128/**
1129 * ntfs_device_win32_sync - flush write buffers to disk
1130 * @dev: ntfs device obtained via ->open
1131 *
1132 * Return 0 if o.k.
1133 * -1 if not, and errno set.
1134 *
1135 * Note: Volume syncing works differently in windows.
1136 * Disk cannot be synced in windows.
1137 */
1138static int ntfs_device_win32_sync(struct ntfs_device *dev)
1139{
1140 int err = 0;
1141 BOOL to_clear = TRUE;
1142
1143 if (!NDevReadOnly(dev) && NDevDirty(dev)) {
1144 win32_fd *fd = (win32_fd *)dev->d_private;
1145
1146 if ((fd->vol_handle != INVALID_HANDLE_VALUE) &&
1147 !FlushFileBuffers(fd->vol_handle)) {
1148 to_clear = FALSE;
1149 err = ntfs_w32error_to_errno(GetLastError());
1150 }
1151 if (!FlushFileBuffers(fd->handle)) {
1152 to_clear = FALSE;
1153 if (!err)
1154 err = ntfs_w32error_to_errno(GetLastError());
1155 }
1156 if (!to_clear) {
1157 ntfs_log_trace("Could not sync.\n");
1158 errno = err;
1159 return -1;
1160 }
1161 NDevClearDirty(dev);
1162 }
1163 return 0;
1164}
1165
1166/**
1167 * ntfs_device_win32_pwrite_simple - positioned simple write
1168 * @fd: win32 device descriptor obtained via ->open
1169 * @pos: at which position to write to
1170 * @count: how many bytes should be written
1171 * @b: a pointer to the data to write
1172 *
1173 * On success returns the number of bytes written and on error returns -1 and
1174 * errno set. Write starts from position @pos.
1175 *
1176 * Notes:
1177 * - @pos, @buf, and @count must be aligned to NTFS_BLOCK_SIZE.
1178 * - When dealing with volumes, a single call must not span both volume
1179 * and disk extents.
1180 * - Does not use/set @fd->pos.
1181 */
1182static inline s64 ntfs_device_win32_pwrite_simple(win32_fd *fd, const s64 pos,
1183 const s64 count, const void *b)
1184{
1185 return ntfs_device_win32_pio(fd, pos, count, (void *)b, TRUE);
1186}
1187
1188/**
1189 * ntfs_device_win32_write - write bytes to an ntfs device
1190 * @dev: ntfs device obtained via ->open
1191 * @b: pointer to the data to write
1192 * @count: how many bytes should be written
1193 *
1194 * On success returns the number of bytes actually written.
1195 * On error returns -1 with errno set.
1196 */
1197static s64 ntfs_device_win32_write(struct ntfs_device *dev, const void *b,
1198 s64 count)
1199{
1200 s64 old_pos, to_write, i, bw = 0;
1201 win32_fd *fd = (win32_fd *)dev->d_private;
1202 BYTE *alignedbuffer;
1203 int old_ofs, ofs;
1204
1205 old_pos = fd->pos;
1206 old_ofs = ofs = old_pos & (NTFS_BLOCK_SIZE - 1);
1207 to_write = (ofs + count + NTFS_BLOCK_SIZE - 1) &
1208 ~(s64)(NTFS_BLOCK_SIZE - 1);
1209 /* Impose maximum of 2GB to be on the safe side. */
1210 if (to_write > 0x80000000) {
1211 int delta = to_write - count;
1212 to_write = 0x80000000;
1213 count = to_write - delta;
1214 }
1215 ntfs_log_trace("fd = %p, b = %p, count = 0x%llx, pos = 0x%llx, "
1216 "ofs = %i, to_write = 0x%llx.\n", fd, b,
1217 (long long)count, (long long)old_pos, ofs,
1218 (long long)to_write);
1219 if (NDevReadOnly(dev)) {
1220 ntfs_log_trace("Can't write on a R/O device.\n");
1221 errno = EROFS;
1222 return -1;
1223 }
1224 if (!count)
1225 return 0;
1226 NDevSetDirty(dev);
1227 if (!((unsigned long)b & (NTFS_BLOCK_SIZE - 1)) && !old_ofs &&
1228 !(count & (NTFS_BLOCK_SIZE - 1)))
1229 alignedbuffer = (BYTE *)b;
1230 else {
1231 s64 end;
1232
1233 alignedbuffer = (BYTE *)VirtualAlloc(NULL, to_write,
1234 MEM_COMMIT, PAGE_READWRITE);
1235 if (!alignedbuffer) {
1236 errno = ntfs_w32error_to_errno(GetLastError());
1237 ntfs_log_trace("VirtualAlloc failed for write.\n");
1238 return -1;
1239 }
1240 /* Read first sector if start of write not sector aligned. */
1241 if (ofs) {
1242 i = ntfs_device_win32_pread_simple(fd,
1243 old_pos & ~(s64)(NTFS_BLOCK_SIZE - 1),
1244 NTFS_BLOCK_SIZE, alignedbuffer);
1245 if (i != NTFS_BLOCK_SIZE) {
1246 if (i >= 0)
1247 errno = EIO;
1248 goto write_error;
1249 }
1250 }
1251 /*
1252 * Read last sector if end of write not sector aligned and last
1253 * sector is either not the same as the first sector or it is
1254 * the same as the first sector but this has not been read in
1255 * yet, i.e. the start of the write is sector aligned.
1256 */
1257 end = old_pos + count;
1258 if ((end & (NTFS_BLOCK_SIZE - 1)) &&
1259 ((to_write > NTFS_BLOCK_SIZE) || !ofs)) {
1260 i = ntfs_device_win32_pread_simple(fd,
1261 end & ~(s64)(NTFS_BLOCK_SIZE - 1),
1262 NTFS_BLOCK_SIZE, alignedbuffer +
1263 to_write - NTFS_BLOCK_SIZE);
1264 if (i != NTFS_BLOCK_SIZE) {
1265 if (i >= 0)
1266 errno = EIO;
1267 goto write_error;
1268 }
1269 }
1270 /* Copy the data to be written into @alignedbuffer. */
1271 memcpy(alignedbuffer + ofs, b, count);
1272 }
1273 if (fd->vol_handle != INVALID_HANDLE_VALUE && old_pos < fd->geo_size) {
1274 s64 vol_to_write = fd->geo_size - old_pos;
1275 if (count > vol_to_write) {
1276 bw = ntfs_device_win32_pwrite_simple(fd,
1277 old_pos & ~(s64)(NTFS_BLOCK_SIZE - 1),
1278 ofs + vol_to_write, alignedbuffer);
1279 if (bw == -1)
1280 goto write_error;
1281 to_write -= bw;
1282 if (bw < ofs) {
1283 bw = 0;
1284 goto write_partial;
1285 }
1286 bw -= ofs;
1287 fd->pos += bw;
1288 ofs = fd->pos & (NTFS_BLOCK_SIZE - 1);
1289 if (bw != vol_to_write)
1290 goto write_partial;
1291 }
1292 }
1293 i = ntfs_device_win32_pwrite_simple(fd,
1294 fd->pos & ~(s64)(NTFS_BLOCK_SIZE - 1), to_write,
1295 alignedbuffer + bw);
1296 if (i == -1) {
1297 if (bw)
1298 goto write_partial;
1299 goto write_error;
1300 }
1301 if (i < ofs)
1302 goto write_partial;
1303 i -= ofs;
1304 bw += i;
1305 if (bw > count)
1306 bw = count;
1307 fd->pos = old_pos + bw;
1308write_partial:
1309 if (alignedbuffer != b)
1310 VirtualFree(alignedbuffer, 0, MEM_RELEASE);
1311 return bw;
1312write_error:
1313 bw = -1;
1314 goto write_partial;
1315}
1316
1317/**
1318 * ntfs_device_win32_stat - get a unix-like stat structure for an ntfs device
1319 * @dev: ntfs device obtained via ->open
1320 * @buf: pointer to the stat structure to fill
1321 *
1322 * Note: Only st_mode, st_size, and st_blocks are filled.
1323 *
1324 * Return 0 if o.k.
1325 * -1 if not and errno set. in this case handle is trashed.
1326 */
1327static int ntfs_device_win32_stat(struct ntfs_device *dev, struct stat *buf)
1328{
1329 win32_fd *fd = (win32_fd *)dev->d_private;
1330 mode_t st_mode;
1331
1332 switch (GetFileType(fd->handle)) {
1333 case FILE_TYPE_CHAR:
1334 st_mode = S_IFCHR;
1335 break;
1336 case FILE_TYPE_DISK:
1337 st_mode = S_IFBLK;
1338 break;
1339 case FILE_TYPE_PIPE:
1340 st_mode = S_IFIFO;
1341 break;
1342 default:
1343 st_mode = 0;
1344 }
1345 memset(buf, 0, sizeof(struct stat));
1346 buf->st_mode = st_mode;
1347 buf->st_size = fd->part_length;
1348 if (buf->st_size != -1)
1349 buf->st_blocks = buf->st_size >> 9;
1350 else
1351 buf->st_size = 0;
1352 return 0;
1353}
1354
1355/**
1356 * ntfs_win32_hdio_getgeo - get drive geometry
1357 * @dev: ntfs device obtained via ->open
1358 * @argp: pointer to where to put the output
1359 *
1360 * Note: Works on windows NT/2k/XP only.
1361 *
1362 * Return 0 if o.k.
1363 * -1 if not, and errno set. Note if error fd->handle is trashed.
1364 */
1365static __inline__ int ntfs_win32_hdio_getgeo(struct ntfs_device *dev,
1366 struct hd_geometry *argp)
1367{
1368 win32_fd *fd = (win32_fd *)dev->d_private;
1369
1370 argp->heads = fd->geo_heads;
1371 argp->sectors = fd->geo_sectors;
1372 argp->cylinders = fd->geo_cylinders;
1373 argp->start = fd->part_hidden_sectors;
1374 return 0;
1375}
1376
1377/**
1378 * ntfs_win32_blksszget - get block device sector size
1379 * @dev: ntfs device obtained via ->open
1380 * @argp: pointer to where to put the output
1381 *
1382 * Note: Works on windows NT/2k/XP only.
1383 *
1384 * Return 0 if o.k.
1385 * -1 if not, and errno set. Note if error fd->handle is trashed.
1386 */
1387static __inline__ int ntfs_win32_blksszget(struct ntfs_device *dev,int *argp)
1388{
1389 win32_fd *fd = (win32_fd *)dev->d_private;
1390 DWORD bytesReturned;
1391 DISK_GEOMETRY dg;
1392
1393 if (DeviceIoControl(fd->handle, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
1394 &dg, sizeof(DISK_GEOMETRY), &bytesReturned, NULL)) {
1395 /* success */
1396 *argp = dg.BytesPerSector;
1397 return 0;
1398 }
1399 errno = ntfs_w32error_to_errno(GetLastError());
1400 ntfs_log_trace("GET_DRIVE_GEOMETRY failed.\n");
1401 return -1;
1402}
1403
1404static int ntfs_device_win32_ioctl(struct ntfs_device *dev, int request,
1405 void *argp)
1406{
1407 win32_fd *fd = (win32_fd *)dev->d_private;
1408
1409 ntfs_log_trace("win32_ioctl(%d) called.\n", request);
1410 switch (request) {
1411#if defined(BLKGETSIZE)
1412 case BLKGETSIZE:
1413 ntfs_log_debug("BLKGETSIZE detected.\n");
1414 if (fd->part_length >= 0) {
1415 *(int *)argp = (int)(fd->part_length / 512);
1416 return 0;
1417 }
1418 errno = EOPNOTSUPP;
1419 return -1;
1420#endif
1421#if defined(BLKGETSIZE64)
1422 case BLKGETSIZE64:
1423 ntfs_log_debug("BLKGETSIZE64 detected.\n");
1424 if (fd->part_length >= 0) {
1425 *(s64 *)argp = fd->part_length;
1426 return 0;
1427 }
1428 errno = EOPNOTSUPP;
1429 return -1;
1430#endif
1431#ifdef HDIO_GETGEO
1432 case HDIO_GETGEO:
1433 ntfs_log_debug("HDIO_GETGEO detected.\n");
1434 return ntfs_win32_hdio_getgeo(dev, (struct hd_geometry *)argp);
1435#endif
1436#ifdef BLKSSZGET
1437 case BLKSSZGET:
1438 ntfs_log_debug("BLKSSZGET detected.\n");
1439 return ntfs_win32_blksszget(dev, (int *)argp);
1440#endif
1441#ifdef BLKBSZSET
1442 case BLKBSZSET:
1443 ntfs_log_debug("BLKBSZSET detected.\n");
1444 /* Nothing to do on Windows. */
1445 return 0;
1446#endif
1447 default:
1448 ntfs_log_debug("unimplemented ioctl %d.\n", request);
1449 errno = EOPNOTSUPP;
1450 return -1;
1451 }
1452}
1453
1454static s64 ntfs_device_win32_pread(struct ntfs_device *dev, void *b,
1455 s64 count, s64 offset)
1456{
1457 return ntfs_pread(dev, offset, count, b);
1458}
1459
1460static s64 ntfs_device_win32_pwrite(struct ntfs_device *dev, const void *b,
1461 s64 count, s64 offset)
1462{
1463 return ntfs_pwrite(dev, offset, count, b);
1464}
1465
1466struct ntfs_device_operations ntfs_device_win32_io_ops = {
1467 .open = ntfs_device_win32_open,
1468 .close = ntfs_device_win32_close,
1469 .seek = ntfs_device_win32_seek,
1470 .read = ntfs_device_win32_read,
1471 .write = ntfs_device_win32_write,
1472 .pread = ntfs_device_win32_pread,
1473 .pwrite = ntfs_device_win32_pwrite,
1474 .sync = ntfs_device_win32_sync,
1475 .stat = ntfs_device_win32_stat,
1476 .ioctl = ntfs_device_win32_ioctl
1477};
1478
generated by cgit at 2024-05-19 05:17:33 (GMT)