mirror of https://github.com/pbatard/rufus.git
[misc] use the more univerasal _mm_alloc() instead of _aligned_malloc()
* Also ensure that our buffers are aligned * Also remove the use of static buffers in ms-sys
This commit is contained in:
Pete Batard
parent
3fdf622933
commit
e76f60a3e8
|
|
@ -256,19 +256,11 @@ static blk_t next_bad = 0;
|
|||
static bb_badblocks_iterate bb_iter = NULL;
|
||||
|
||||
static __inline void *allocate_buffer(size_t size) {
|
||||
#ifdef __MINGW32__
|
||||
return __mingw_aligned_malloc(size, BB_SYS_PAGE_SIZE);
|
||||
#else
|
||||
return _aligned_malloc(size, BB_SYS_PAGE_SIZE);
|
||||
#endif
|
||||
return _mm_malloc(size, BB_SYS_PAGE_SIZE);
|
||||
}
|
||||
|
||||
static __inline void free_buffer(void* p) {
|
||||
#ifdef __MINGW32__
|
||||
__mingw_aligned_free(p);
|
||||
#else
|
||||
_aligned_free(p);
|
||||
#endif
|
||||
_mm_free(p);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
101
src/format.c
101
src/format.c
|
|
@ -847,7 +847,7 @@ static BOOL WriteMBR(HANDLE hPhysicalDrive)
|
|||
{
|
||||
BOOL r = FALSE;
|
||||
DWORD size;
|
||||
unsigned char* buf = NULL;
|
||||
unsigned char* buffer = NULL;
|
||||
FAKE_FD fake_fd = { 0 };
|
||||
FILE* fp = (FILE*)&fake_fd;
|
||||
const char* using_msg = "Using %s MBR\n";
|
||||
|
|
@ -859,14 +859,14 @@ static BOOL WriteMBR(HANDLE hPhysicalDrive)
|
|||
|
||||
// FormatEx rewrites the MBR and removes the LBA attribute of FAT16
|
||||
// and FAT32 partitions - we need to correct this in the MBR
|
||||
buf = (unsigned char*)malloc(SelectedDrive.SectorSize);
|
||||
if (buf == NULL) {
|
||||
buffer = (unsigned char*)_mm_malloc(SelectedDrive.SectorSize, 16);
|
||||
if (buffer == NULL) {
|
||||
uprintf("Could not allocate memory for MBR");
|
||||
FormatStatus = ERROR_SEVERITY_ERROR|FAC(FACILITY_STORAGE)|ERROR_NOT_ENOUGH_MEMORY;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (!read_sectors(hPhysicalDrive, SelectedDrive.SectorSize, 0, 1, buf)) {
|
||||
if (!read_sectors(hPhysicalDrive, SelectedDrive.SectorSize, 0, 1, buffer)) {
|
||||
uprintf("Could not read MBR\n");
|
||||
FormatStatus = ERROR_SEVERITY_ERROR|FAC(FACILITY_STORAGE)|ERROR_READ_FAULT;
|
||||
goto out;
|
||||
|
|
@ -874,30 +874,30 @@ static BOOL WriteMBR(HANDLE hPhysicalDrive)
|
|||
|
||||
switch (ComboBox_GetItemData(hFileSystem, ComboBox_GetCurSel(hFileSystem))) {
|
||||
case FS_FAT16:
|
||||
if (buf[0x1c2] == 0x0e) {
|
||||
if (buffer[0x1c2] == 0x0e) {
|
||||
uprintf("Partition is already FAT16 LBA...\n");
|
||||
} else if ((buf[0x1c2] != 0x04) && (buf[0x1c2] != 0x06)) {
|
||||
uprintf("Warning: converting a non FAT16 partition to FAT16 LBA: FS type=0x%02x\n", buf[0x1c2]);
|
||||
} else if ((buffer[0x1c2] != 0x04) && (buffer[0x1c2] != 0x06)) {
|
||||
uprintf("Warning: converting a non FAT16 partition to FAT16 LBA: FS type=0x%02x\n", buffer[0x1c2]);
|
||||
}
|
||||
buf[0x1c2] = 0x0e;
|
||||
buffer[0x1c2] = 0x0e;
|
||||
break;
|
||||
case FS_FAT32:
|
||||
if (buf[0x1c2] == 0x0c) {
|
||||
if (buffer[0x1c2] == 0x0c) {
|
||||
uprintf("Partition is already FAT32 LBA...\n");
|
||||
} else if (buf[0x1c2] != 0x0b) {
|
||||
uprintf("Warning: converting a non FAT32 partition to FAT32 LBA: FS type=0x%02x\n", buf[0x1c2]);
|
||||
} else if (buffer[0x1c2] != 0x0b) {
|
||||
uprintf("Warning: converting a non FAT32 partition to FAT32 LBA: FS type=0x%02x\n", buffer[0x1c2]);
|
||||
}
|
||||
buf[0x1c2] = 0x0c;
|
||||
buffer[0x1c2] = 0x0c;
|
||||
break;
|
||||
}
|
||||
if ((IsChecked(IDC_BOOT)) && (tt == TT_BIOS)) {
|
||||
// Set first partition bootable - masquerade as per the DiskID selected
|
||||
buf[0x1be] = IsChecked(IDC_RUFUS_MBR) ?
|
||||
buffer[0x1be] = IsChecked(IDC_RUFUS_MBR) ?
|
||||
(BYTE)ComboBox_GetItemData(hDiskID, ComboBox_GetCurSel(hDiskID)):0x80;
|
||||
uprintf("Set bootable USB partition as 0x%02X\n", buf[0x1be]);
|
||||
uprintf("Set bootable USB partition as 0x%02X\n", buffer[0x1be]);
|
||||
}
|
||||
|
||||
if (!write_sectors(hPhysicalDrive, SelectedDrive.SectorSize, 0, 1, buf)) {
|
||||
if (!write_sectors(hPhysicalDrive, SelectedDrive.SectorSize, 0, 1, buffer)) {
|
||||
uprintf("Could not write MBR\n");
|
||||
FormatStatus = ERROR_SEVERITY_ERROR|FAC(FACILITY_STORAGE)|ERROR_WRITE_FAULT;
|
||||
goto out;
|
||||
|
|
@ -970,7 +970,7 @@ notify:
|
|||
uprintf("Failed to notify system about disk properties update: %s\n", WindowsErrorString());
|
||||
|
||||
out:
|
||||
safe_free(buf);
|
||||
safe_mm_free(buffer);
|
||||
return r;
|
||||
}
|
||||
|
||||
|
|
@ -1143,7 +1143,7 @@ static BOOL SetupWinPE(char drive_letter)
|
|||
HANDLE handle = INVALID_HANDLE_VALUE;
|
||||
DWORD i, j, size, rw_size, index = 0;
|
||||
BOOL r = FALSE;
|
||||
char* buf = NULL;
|
||||
char* buffer = NULL;
|
||||
|
||||
index = ((img_report.winpe&WINPE_I386) == WINPE_I386)?0:1;
|
||||
// Allow other values than harddisk 1, as per user choice for disk ID
|
||||
|
|
@ -1197,10 +1197,10 @@ static BOOL SetupWinPE(char drive_letter)
|
|||
uprintf("Could not get size for file %s: %s\n", dst, WindowsErrorString());
|
||||
goto out;
|
||||
}
|
||||
buf = (char*)malloc(size);
|
||||
if (buf == NULL)
|
||||
buffer = (char*)malloc(size);
|
||||
if (buffer == NULL)
|
||||
goto out;
|
||||
if ((!ReadFile(handle, buf, size, &rw_size, NULL)) || (size != rw_size)) {
|
||||
if ((!ReadFile(handle, buffer, size, &rw_size, NULL)) || (size != rw_size)) {
|
||||
uprintf("Could not read file %s: %s\n", dst, WindowsErrorString());
|
||||
goto out;
|
||||
}
|
||||
|
|
@ -1209,16 +1209,16 @@ static BOOL SetupWinPE(char drive_letter)
|
|||
// Patch setupldr.bin
|
||||
uprintf("Patching file %s\n", dst);
|
||||
// Remove CRC check for 32 bit part of setupldr.bin from Win2k3
|
||||
if ((size > 0x2061) && (buf[0x2060] == 0x74) && (buf[0x2061] == 0x03)) {
|
||||
buf[0x2060] = 0xeb;
|
||||
buf[0x2061] = 0x1a;
|
||||
if ((size > 0x2061) && (buffer[0x2060] == 0x74) && (buffer[0x2061] == 0x03)) {
|
||||
buffer[0x2060] = 0xeb;
|
||||
buffer[0x2061] = 0x1a;
|
||||
uprintf(" 0x00002060: 0x74 0x03 -> 0xEB 0x1A (disable Win2k3 CRC check)\n");
|
||||
}
|
||||
for (i=1; i<size-32; i++) {
|
||||
for (j=0; j<ARRAYSIZE(patch_str_org); j++) {
|
||||
if (safe_strnicmp(&buf[i], patch_str_org[j], strlen(patch_str_org[j])-1) == 0) {
|
||||
uprintf(" 0x%08X: '%s' -> '%s'\n", i, &buf[i], patch_str_rep[j]);
|
||||
strcpy(&buf[i], patch_str_rep[j]);
|
||||
if (safe_strnicmp(&buffer[i], patch_str_org[j], strlen(patch_str_org[j])-1) == 0) {
|
||||
uprintf(" 0x%08X: '%s' -> '%s'\n", i, &buffer[i], patch_str_rep[j]);
|
||||
strcpy(&buffer[i], patch_str_rep[j]);
|
||||
i += (DWORD)max(strlen(patch_str_org[j]), strlen(patch_str_rep[j])); // in case org is a substring of rep
|
||||
}
|
||||
}
|
||||
|
|
@ -1229,33 +1229,30 @@ static BOOL SetupWinPE(char drive_letter)
|
|||
for (i=0; i<size-32; i++) {
|
||||
// rdisk(0) -> rdisk(#) disk masquerading
|
||||
// NB: only the first one seems to be needed
|
||||
if (safe_strnicmp(&buf[i], rdisk_zero, strlen(rdisk_zero)-1) == 0) {
|
||||
buf[i+6] = 0x30 + ComboBox_GetCurSel(hDiskID);
|
||||
uprintf(" 0x%08X: '%s' -> 'rdisk(%c)'\n", i, rdisk_zero, buf[i+6]);
|
||||
if (safe_strnicmp(&buffer[i], rdisk_zero, strlen(rdisk_zero)-1) == 0) {
|
||||
buffer[i+6] = 0x30 + ComboBox_GetCurSel(hDiskID);
|
||||
uprintf(" 0x%08X: '%s' -> 'rdisk(%c)'\n", i, rdisk_zero, buffer[i+6]);
|
||||
}
|
||||
// $WIN_NT$_~BT -> i386
|
||||
if (safe_strnicmp(&buf[i], win_nt_bt_org, strlen(win_nt_bt_org)-1) == 0) {
|
||||
uprintf(" 0x%08X: '%s' -> '%s%s'\n", i, &buf[i], win_nt_bt_rep, &buf[i+strlen(win_nt_bt_org)]);
|
||||
strcpy(&buf[i], win_nt_bt_rep);
|
||||
if (safe_strnicmp(&buffer[i], win_nt_bt_org, strlen(win_nt_bt_org)-1) == 0) {
|
||||
uprintf(" 0x%08X: '%s' -> '%s%s'\n", i, &buffer[i], win_nt_bt_rep, &buffer[i+strlen(win_nt_bt_org)]);
|
||||
strcpy(&buffer[i], win_nt_bt_rep);
|
||||
// This ensures that we keep the terminator backslash
|
||||
buf[i+strlen(win_nt_bt_rep)] = buf[i+strlen(win_nt_bt_org)];
|
||||
buf[i+strlen(win_nt_bt_rep)+1] = 0;
|
||||
buffer[i+strlen(win_nt_bt_rep)] = buffer[i+strlen(win_nt_bt_org)];
|
||||
buffer[i+strlen(win_nt_bt_rep)+1] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!WriteFileWithRetry(handle, buf, size, &rw_size, WRITE_RETRIES)) {
|
||||
if (!WriteFileWithRetry(handle, buffer, size, &rw_size, WRITE_RETRIES)) {
|
||||
uprintf("Could not write patched file: %s\n", WindowsErrorString());
|
||||
goto out;
|
||||
}
|
||||
safe_free(buf);
|
||||
safe_closehandle(handle);
|
||||
|
||||
r = TRUE;
|
||||
|
||||
out:
|
||||
safe_closehandle(handle);
|
||||
safe_free(buf);
|
||||
safe_free(buffer);
|
||||
return r;
|
||||
}
|
||||
|
||||
|
|
@ -1466,7 +1463,7 @@ static BOOL WriteDrive(HANDLE hPhysicalDrive, HANDLE hSourceImage)
|
|||
LARGE_INTEGER li;
|
||||
DWORD rSize, wSize, BufSize;
|
||||
uint64_t wb, target_size = hSourceImage?img_report.projected_size:SelectedDrive.DiskSize;
|
||||
uint8_t *buffer = NULL, *aligned_buffer;
|
||||
uint8_t *buffer = NULL;
|
||||
int i;
|
||||
|
||||
// We poked the MBR and other stuff, so we need to rewind
|
||||
|
|
@ -1482,16 +1479,20 @@ static BOOL WriteDrive(HANDLE hPhysicalDrive, HANDLE hSourceImage)
|
|||
bled_exit();
|
||||
} else {
|
||||
uprintf(hSourceImage?"Writing Image...":"Zeroing drive...");
|
||||
// Our buffer size must be a multiple of the sector size
|
||||
// Our buffer size must be a multiple of the sector size and *ALIGNED* to the sector size
|
||||
BufSize = ((DD_BUFFER_SIZE + SelectedDrive.SectorSize - 1) / SelectedDrive.SectorSize) * SelectedDrive.SectorSize;
|
||||
buffer = (uint8_t*)calloc(BufSize + SelectedDrive.SectorSize, 1); // +1 sector for align
|
||||
buffer = (uint8_t*)_mm_malloc(BufSize, SelectedDrive.SectorSize);
|
||||
if (buffer == NULL) {
|
||||
FormatStatus = ERROR_SEVERITY_ERROR | FAC(FACILITY_STORAGE) | ERROR_NOT_ENOUGH_MEMORY;
|
||||
uprintf("could not allocate disk write buffer");
|
||||
uprintf("Could not allocate disk write buffer");
|
||||
goto out;
|
||||
}
|
||||
// Sanity check
|
||||
if ((uintptr_t)buffer % SelectedDrive.SectorSize != 0) {
|
||||
FormatStatus = ERROR_SEVERITY_ERROR | FAC(FACILITY_STORAGE) | ERROR_READ_FAULT;
|
||||
uprintf("Write buffer is not aligned");
|
||||
goto out;
|
||||
}
|
||||
// http://msdn.microsoft.com/en-us/library/windows/desktop/aa365747.aspx does buffer sector alignment
|
||||
aligned_buffer = ((void *)((((uintptr_t)(buffer)) + (SelectedDrive.SectorSize)-1) & (~(((uintptr_t)(SelectedDrive.SectorSize)) - 1))));
|
||||
|
||||
// Don't bother trying for something clever, using double buffering overlapped and whatnot:
|
||||
// With Windows' default optimizations, sync read + sync write for sequential operations
|
||||
|
|
@ -1506,7 +1507,7 @@ static BOOL WriteDrive(HANDLE hPhysicalDrive, HANDLE hSourceImage)
|
|||
}
|
||||
|
||||
if (hSourceImage != NULL) {
|
||||
s = ReadFile(hSourceImage, aligned_buffer, BufSize, &rSize, NULL);
|
||||
s = ReadFile(hSourceImage, buffer, BufSize, &rSize, NULL);
|
||||
if (!s) {
|
||||
FormatStatus = ERROR_SEVERITY_ERROR | FAC(FACILITY_STORAGE) | ERROR_READ_FAULT;
|
||||
uprintf("read error: %s", WindowsErrorString());
|
||||
|
|
@ -1525,7 +1526,7 @@ static BOOL WriteDrive(HANDLE hPhysicalDrive, HANDLE hSourceImage)
|
|||
rSize = ((rSize + SelectedDrive.SectorSize - 1) / SelectedDrive.SectorSize) * SelectedDrive.SectorSize;
|
||||
for (i = 0; i < WRITE_RETRIES; i++) {
|
||||
CHECK_FOR_USER_CANCEL;
|
||||
s = WriteFile(hPhysicalDrive, aligned_buffer, rSize, &wSize, NULL);
|
||||
s = WriteFile(hPhysicalDrive, buffer, rSize, &wSize, NULL);
|
||||
if ((s) && (wSize == rSize))
|
||||
break;
|
||||
if (s)
|
||||
|
|
@ -1547,7 +1548,7 @@ static BOOL WriteDrive(HANDLE hPhysicalDrive, HANDLE hSourceImage)
|
|||
RefreshDriveLayout(hPhysicalDrive);
|
||||
ret = TRUE;
|
||||
out:
|
||||
safe_free(buffer);
|
||||
safe_mm_free(buffer);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
@ -2033,7 +2034,7 @@ DWORD WINAPI SaveImageThread(void* param)
|
|||
}
|
||||
|
||||
uprintf("Saving to image '%s'...", vhd_save->path);
|
||||
buffer = (uint8_t*)malloc(DD_BUFFER_SIZE);
|
||||
buffer = (uint8_t*)_mm_malloc(DD_BUFFER_SIZE, 16);
|
||||
if (buffer == NULL) {
|
||||
FormatStatus = ERROR_SEVERITY_ERROR|FAC(FACILITY_STORAGE)|ERROR_NOT_ENOUGH_MEMORY;
|
||||
uprintf("could not allocate buffer");
|
||||
|
|
@ -2094,7 +2095,7 @@ DWORD WINAPI SaveImageThread(void* param)
|
|||
|
||||
out:
|
||||
safe_free(vhd_save->path);
|
||||
safe_free(buffer);
|
||||
safe_mm_free(buffer);
|
||||
safe_closehandle(hDestImage);
|
||||
safe_unlockclose(hPhysicalDrive);
|
||||
PostMessage(hMainDialog, UM_FORMAT_COMPLETED, (WPARAM)TRUE, 0);
|
||||
|
|
|
|||
|
|
@ -144,7 +144,6 @@
|
|||
<AdditionalIncludeDirectories>../inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
|
||||
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
|
||||
<AdditionalOptions>/analyze:stacksize32850 %(AdditionalOptions)</AdditionalOptions>
|
||||
<DisableSpecificWarnings>28252;28253</DisableSpecificWarnings>
|
||||
<CompileAs>CompileAsC</CompileAs>
|
||||
</ClCompile>
|
||||
|
|
@ -163,7 +162,6 @@
|
|||
<AdditionalIncludeDirectories>../inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
|
||||
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
|
||||
<AdditionalOptions>/analyze:stacksize32850 %(AdditionalOptions)</AdditionalOptions>
|
||||
<DisableSpecificWarnings>28252;28253</DisableSpecificWarnings>
|
||||
<CompileAs>CompileAsC</CompileAs>
|
||||
</ClCompile>
|
||||
|
|
@ -179,7 +177,6 @@
|
|||
<AdditionalIncludeDirectories>../inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
|
||||
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
|
||||
<AdditionalOptions>/analyze:stacksize32850 %(AdditionalOptions)</AdditionalOptions>
|
||||
<DisableSpecificWarnings>28252;28253</DisableSpecificWarnings>
|
||||
<CompileAs>CompileAsC</CompileAs>
|
||||
</ClCompile>
|
||||
|
|
@ -198,7 +195,6 @@
|
|||
<AdditionalIncludeDirectories>../inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
|
||||
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
|
||||
<AdditionalOptions>/analyze:stacksize32850 %(AdditionalOptions)</AdditionalOptions>
|
||||
<DisableSpecificWarnings>28252;28253</DisableSpecificWarnings>
|
||||
<CompileAs>CompileAsC</CompileAs>
|
||||
</ClCompile>
|
||||
|
|
|
|||
|
|
@ -99,22 +99,37 @@ int64_t read_sectors(HANDLE hDrive, uint64_t SectorSize,
|
|||
int contains_data(FILE *fp, uint64_t Position,
|
||||
const void *pData, uint64_t Len)
|
||||
{
|
||||
unsigned char aucBuf[MAX_DATA_LEN];
|
||||
int r = 0;
|
||||
unsigned char *aucBuf = _mm_malloc(MAX_DATA_LEN, 16);
|
||||
|
||||
if (!read_data(fp, Position, aucBuf, Len))
|
||||
return 0;
|
||||
if (memcmp(pData, aucBuf, (size_t)Len))
|
||||
return 0;
|
||||
return 1;
|
||||
if(aucBuf == NULL)
|
||||
return 0;
|
||||
|
||||
if(!read_data(fp, Position, aucBuf, Len))
|
||||
goto out;
|
||||
|
||||
if(memcmp(pData, aucBuf, (size_t)Len))
|
||||
goto out;
|
||||
|
||||
r = 1;
|
||||
|
||||
out:
|
||||
_mm_free(aucBuf);
|
||||
return r;
|
||||
} /* contains_data */
|
||||
|
||||
int read_data(FILE *fp, uint64_t Position,
|
||||
void *pData, uint64_t Len)
|
||||
{
|
||||
unsigned char aucBuf[MAX_DATA_LEN];
|
||||
int r = 0;
|
||||
unsigned char *aucBuf = _mm_malloc(MAX_DATA_LEN, 16);
|
||||
FAKE_FD* fd = (FAKE_FD*)fp;
|
||||
HANDLE hDrive = (HANDLE)fd->_handle;
|
||||
uint64_t StartSector, EndSector, NumSectors;
|
||||
|
||||
if (aucBuf == NULL)
|
||||
return 0;
|
||||
|
||||
Position += fd->_offset;
|
||||
|
||||
StartSector = Position/ulBytesPerSector;
|
||||
|
|
@ -123,32 +138,44 @@ int read_data(FILE *fp, uint64_t Position,
|
|||
|
||||
if((NumSectors*ulBytesPerSector) > MAX_DATA_LEN)
|
||||
{
|
||||
uprintf("contains_data: please increase MAX_DATA_LEN in file.h\n");
|
||||
return 0;
|
||||
uprintf("read_data: Please increase MAX_DATA_LEN in file.h\n");
|
||||
goto out;
|
||||
}
|
||||
|
||||
if(Len > 0xFFFFFFFFUL)
|
||||
{
|
||||
uprintf("contains_data: Len is too big\n");
|
||||
return 0;
|
||||
uprintf("read_data: Len is too big\n");
|
||||
goto out;
|
||||
}
|
||||
|
||||
if(read_sectors(hDrive, ulBytesPerSector, StartSector,
|
||||
NumSectors, aucBuf) <= 0)
|
||||
return 0;
|
||||
goto out;
|
||||
|
||||
memcpy(pData, &aucBuf[Position - StartSector*ulBytesPerSector], (size_t)Len);
|
||||
return 1;
|
||||
|
||||
r = 1;
|
||||
|
||||
out:
|
||||
_mm_free(aucBuf);
|
||||
return r;
|
||||
} /* read_data */
|
||||
|
||||
/* May read/write the same sector many times, but compatible with existing ms-sys */
|
||||
int write_data(FILE *fp, uint64_t Position,
|
||||
const void *pData, uint64_t Len)
|
||||
{
|
||||
unsigned char aucBuf[MAX_DATA_LEN];
|
||||
int r = 0;
|
||||
/* Windows' WriteFile() may require a buffer that is aligned to the sector size */
|
||||
/* TODO: We may need to increase the alignment if we get report of issues on 4K */
|
||||
unsigned char *aucBuf = _mm_malloc(MAX_DATA_LEN, 512);
|
||||
FAKE_FD* fd = (FAKE_FD*)fp;
|
||||
HANDLE hDrive = (HANDLE)fd->_handle;
|
||||
uint64_t StartSector, EndSector, NumSectors;
|
||||
|
||||
if (aucBuf == NULL)
|
||||
return 0;
|
||||
|
||||
Position += fd->_offset;
|
||||
|
||||
StartSector = Position/ulBytesPerSector;
|
||||
|
|
@ -157,26 +184,31 @@ int write_data(FILE *fp, uint64_t Position,
|
|||
|
||||
if((NumSectors*ulBytesPerSector) > MAX_DATA_LEN)
|
||||
{
|
||||
uprintf("Please increase MAX_DATA_LEN in file.h\n");
|
||||
return 0;
|
||||
uprintf("write_data: Please increase MAX_DATA_LEN in file.h\n");
|
||||
goto out;
|
||||
}
|
||||
|
||||
if(Len > 0xFFFFFFFFUL)
|
||||
{
|
||||
uprintf("write_data: Len is too big\n");
|
||||
return 0;
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* Data to write may not be aligned on a sector boundary => read into a sector buffer first */
|
||||
if(read_sectors(hDrive, ulBytesPerSector, StartSector,
|
||||
NumSectors, aucBuf) <= 0)
|
||||
return 0;
|
||||
goto out;
|
||||
|
||||
if(!memcpy(&aucBuf[Position - StartSector*ulBytesPerSector], pData, (size_t)Len))
|
||||
return 0;
|
||||
goto out;
|
||||
|
||||
if(write_sectors(hDrive, ulBytesPerSector, StartSector,
|
||||
NumSectors, aucBuf) <= 0)
|
||||
return 0;
|
||||
return 1;
|
||||
goto out;
|
||||
|
||||
r = 1;
|
||||
|
||||
out:
|
||||
_mm_free(aucBuf);
|
||||
return r;
|
||||
} /* write_data */
|
||||
|
|
|
|||
|
|
@ -94,6 +94,7 @@
|
|||
#define CHECK_FOR_USER_CANCEL if (IS_ERROR(FormatStatus)) goto out
|
||||
|
||||
#define safe_free(p) do {free((void*)p); p = NULL;} while(0)
|
||||
#define safe_mm_free(p) do {_mm_free((void*)p); p = NULL;} while(0)
|
||||
#define safe_min(a, b) min((size_t)(a), (size_t)(b))
|
||||
#define safe_strcp(dst, dst_max, src, count) do {memcpy(dst, src, safe_min(count, dst_max)); \
|
||||
((char*)dst)[safe_min(count, dst_max)-1] = 0;} while(0)
|
||||
|
|
|
|||
10
src/rufus.rc
10
src/rufus.rc
|
|
@ -33,7 +33,7 @@ LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL
|
|||
IDD_DIALOG DIALOGEX 12, 12, 242, 376
|
||||
STYLE DS_SETFONT | DS_MODALFRAME | DS_CENTER | WS_MINIMIZEBOX | WS_POPUP | WS_CAPTION | WS_SYSMENU
|
||||
EXSTYLE WS_EX_ACCEPTFILES
|
||||
CAPTION "Rufus 2.10.957"
|
||||
CAPTION "Rufus 2.10.958"
|
||||
FONT 8, "Segoe UI Symbol", 400, 0, 0x0
|
||||
BEGIN
|
||||
LTEXT "Device",IDS_DEVICE_TXT,9,6,200,8
|
||||
|
|
@ -320,8 +320,8 @@ END
|
|||
//
|
||||
|
||||
VS_VERSION_INFO VERSIONINFO
|
||||
FILEVERSION 2,10,957,0
|
||||
PRODUCTVERSION 2,10,957,0
|
||||
FILEVERSION 2,10,958,0
|
||||
PRODUCTVERSION 2,10,958,0
|
||||
FILEFLAGSMASK 0x3fL
|
||||
#ifdef _DEBUG
|
||||
FILEFLAGS 0x1L
|
||||
|
|
@ -338,13 +338,13 @@ BEGIN
|
|||
BEGIN
|
||||
VALUE "CompanyName", "Akeo Consulting (http://akeo.ie)"
|
||||
VALUE "FileDescription", "Rufus"
|
||||
VALUE "FileVersion", "2.10.957"
|
||||
VALUE "FileVersion", "2.10.958"
|
||||
VALUE "InternalName", "Rufus"
|
||||
VALUE "LegalCopyright", "© 2011-2016 Pete Batard (GPL v3)"
|
||||
VALUE "LegalTrademarks", "http://www.gnu.org/copyleft/gpl.html"
|
||||
VALUE "OriginalFilename", "rufus.exe"
|
||||
VALUE "ProductName", "Rufus"
|
||||
VALUE "ProductVersion", "2.10.957"
|
||||
VALUE "ProductVersion", "2.10.958"
|
||||
END
|
||||
END
|
||||
BLOCK "VarFileInfo"
|
||||
|
|
|
|||
|
|
@ -331,7 +331,7 @@ BOOL Identify(HANDLE hPhysical)
|
|||
// You'll get an error here if your compiler does not properly pack the IDENTIFY struct
|
||||
COMPILE_TIME_ASSERT(sizeof(IDENTIFY_DEVICE_DATA) == 512);
|
||||
|
||||
idd = (IDENTIFY_DEVICE_DATA*)_aligned_malloc(sizeof(IDENTIFY_DEVICE_DATA), 0x10);
|
||||
idd = (IDENTIFY_DEVICE_DATA*)_mm_malloc(sizeof(IDENTIFY_DEVICE_DATA), 0x10);
|
||||
if (idd == NULL)
|
||||
return FALSE;
|
||||
|
||||
|
|
@ -352,7 +352,7 @@ BOOL Identify(HANDLE hPhysical)
|
|||
if (i >= ARRAYSIZE(pt))
|
||||
uprintf("NO ATA FOR YOU!\n");
|
||||
|
||||
_aligned_free(idd);
|
||||
_mm_free(idd);
|
||||
return TRUE;
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -21,11 +21,6 @@
|
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#if defined(__MINGW32__)
|
||||
#define _aligned_malloc __mingw_aligned_malloc
|
||||
#define _aligned_free __mingw_aligned_free
|
||||
#endif
|
||||
|
||||
// From http://stackoverflow.com/a/9284679
|
||||
#define COMPILE_TIME_ASSERT(pred) switch(0) {case 0: case pred:;}
|
||||
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ unsigned long syslinux_ldlinux_len[2];
|
|||
unsigned char* syslinux_mboot = NULL;
|
||||
unsigned long syslinux_mboot_len;
|
||||
|
||||
// Workaround for 4K support
|
||||
/* Workaround for 4K support */
|
||||
uint32_t SECTOR_SHIFT = 9;
|
||||
uint32_t SECTOR_SIZE = 512;
|
||||
uint32_t LIBFAT_SECTOR_SHIFT = 9;
|
||||
|
|
@ -128,7 +128,7 @@ BOOL InstallSyslinux(DWORD drive_index, char drive_letter, int fs_type)
|
|||
LIBFAT_SECTOR_MASK = SECTOR_SIZE - 1;
|
||||
|
||||
/* sectbuf should be aligned to at least 8 bytes - see github #767 */
|
||||
sectbuf = _aligned_malloc(SECTOR_SIZE, 16);
|
||||
sectbuf = _mm_malloc(SECTOR_SIZE, 16);
|
||||
if (sectbuf == NULL)
|
||||
goto out;
|
||||
|
||||
|
|
@ -382,8 +382,7 @@ BOOL InstallSyslinux(DWORD drive_index, char drive_letter, int fs_type)
|
|||
r = TRUE;
|
||||
|
||||
out:
|
||||
if (sectbuf != NULL)
|
||||
_aligned_free(sectbuf);
|
||||
safe_mm_free(sectbuf);
|
||||
safe_free(syslinux_ldlinux[0]);
|
||||
safe_free(syslinux_ldlinux[1]);
|
||||
safe_free(sectors);
|
||||
|
|
|
|||
|
|
@ -17,21 +17,17 @@
|
|||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <malloc.h>
|
||||
#include "libfatint.h"
|
||||
|
||||
/*
|
||||
* We need to align our sector buffers to at least the 8-byte mark, as some Windows
|
||||
* NB: We need to align our sector buffers to at least the 8-byte mark, as some Windows
|
||||
* disk devices, notably O2Micro PCI-E SD card readers, return ERROR_INVALID_PARAMETER
|
||||
* when attempting to use ReadFile() against a non 8-byte aligned buffer.
|
||||
* For good measure, we'll go further and align our buffers on a 16-byte boundary.
|
||||
* Also, since struct libfat_sector's data[0] is our buffer, this means we must BOTH
|
||||
* align that member in the struct declaration, and use aligned malloc/free.
|
||||
*/
|
||||
#if defined(__MINGW32__)
|
||||
#define _aligned_malloc __mingw_aligned_malloc
|
||||
#define _aligned_free __mingw_aligned_free
|
||||
#endif
|
||||
|
||||
extern void _uprintf(const char *format, ...);
|
||||
void *libfat_get_sector(struct libfat_filesystem *fs, libfat_sector_t n)
|
||||
{
|
||||
|
|
@ -43,10 +39,10 @@ void *libfat_get_sector(struct libfat_filesystem *fs, libfat_sector_t n)
|
|||
}
|
||||
|
||||
/* Not found in cache */
|
||||
ls = _aligned_malloc(sizeof(struct libfat_sector) + LIBFAT_SECTOR_SIZE, 16);
|
||||
ls = _mm_malloc(sizeof(struct libfat_sector) + LIBFAT_SECTOR_SIZE, 16);
|
||||
if (!ls) {
|
||||
libfat_flush(fs);
|
||||
ls = _aligned_malloc(sizeof(struct libfat_sector) + LIBFAT_SECTOR_SIZE, 16);
|
||||
ls = _mm_malloc(sizeof(struct libfat_sector) + LIBFAT_SECTOR_SIZE, 16);
|
||||
|
||||
if (!ls)
|
||||
return NULL; /* Can't allocate memory */
|
||||
|
|
@ -54,7 +50,7 @@ void *libfat_get_sector(struct libfat_filesystem *fs, libfat_sector_t n)
|
|||
|
||||
if (fs->read(fs->readptr, ls->data, LIBFAT_SECTOR_SIZE, n)
|
||||
!= LIBFAT_SECTOR_SIZE) {
|
||||
_aligned_free(ls);
|
||||
_mm_free(ls);
|
||||
return NULL; /* I/O error */
|
||||
}
|
||||
|
||||
|
|
@ -74,6 +70,6 @@ void libfat_flush(struct libfat_filesystem *fs)
|
|||
|
||||
for (ls = lsnext; ls; ls = lsnext) {
|
||||
lsnext = ls->next;
|
||||
_aligned_free(ls);
|
||||
_mm_free(ls);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,12 +30,12 @@
|
|||
#define ALIGN_END(m)
|
||||
#endif
|
||||
|
||||
struct libfat_sector {
|
||||
ALIGN_START(16) struct libfat_sector {
|
||||
libfat_sector_t n; /* Sector number */
|
||||
struct libfat_sector *next; /* Next in list */
|
||||
/* data[0] MUST be aligned to at least 8 bytes - see cache.c */
|
||||
ALIGN_START(16) char data[0] ALIGN_END(16);
|
||||
};
|
||||
} ALIGN_END(16);
|
||||
|
||||
enum fat_type {
|
||||
FAT12,
|
||||
|
|
|
|||
Loading…
Reference in New Issue