nerd/rufus
1
1
Fork 0
mirror of https://github.com/pbatard/rufus.git synced 2024-08-14 23:57:05 +00:00
Code Issues 1 Projects Releases Wiki Activity

[misc] use the more univerasal _mm_alloc() instead of _aligned_malloc()

Browse source 
* Also ensure that our buffers are aligned
* Also remove the use of static buffers in ms-sys
This commit is contained in:
Pete Batard 2016-06-10 12:42:43 +01:00
parent 3fdf622933
commit e76f60a3e8
11 changed files with 125 additions and 113 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/badblocks.c
View file

@ -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
View file

@ -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);

4
src/ms-sys/.msvc/ms-sys.vcxproj
View file

@ -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>

70
src/ms-sys/file.c
View file

@ -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(aucBuf == NULL)
return 0;
if(!read_data(fp, Position, aucBuf, Len))
return 0;
goto out;
if(memcmp(pData, aucBuf, (size_t)Len))
return 0;
return 1;
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 */

1
src/rufus.h
View file

@ -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
View file

@ -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"

4
src/smart.c
View file

@ -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

5
src/smart.h
View file

@ -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:;}

7
src/syslinux.c
View file

@ -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);

16
src/syslinux/libfat/cache.c
View file

@ -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);
}
}

4
src/syslinux/libfat/libfatint.h
View file

@ -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,