From e76f60a3e83f54a448d0015536d0e33d5c89009f Mon Sep 17 00:00:00 2001 From: Pete Batard Date: Fri, 10 Jun 2016 12:42:43 +0100 Subject: [PATCH] [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 --- src/badblocks.c | 12 +--- src/format.c | 101 ++++++++++++++++---------------- src/ms-sys/.msvc/ms-sys.vcxproj | 4 -- src/ms-sys/file.c | 74 ++++++++++++++++------- src/rufus.h | 1 + src/rufus.rc | 10 ++-- src/smart.c | 4 +- src/smart.h | 5 -- src/syslinux.c | 7 +-- src/syslinux/libfat/cache.c | 16 ++--- src/syslinux/libfat/libfatint.h | 4 +- 11 files changed, 125 insertions(+), 113 deletions(-) diff --git a/src/badblocks.c b/src/badblocks.c index 4e4386b5..8b96b910 100644 --- a/src/badblocks.c +++ b/src/badblocks.c @@ -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); } /* diff --git a/src/format.c b/src/format.c index 73e3914d..b78495d4 100644 --- a/src/format.c +++ b/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 '%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 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); diff --git a/src/ms-sys/.msvc/ms-sys.vcxproj b/src/ms-sys/.msvc/ms-sys.vcxproj index f9ad39d1..f0f6426a 100644 --- a/src/ms-sys/.msvc/ms-sys.vcxproj +++ b/src/ms-sys/.msvc/ms-sys.vcxproj @@ -144,7 +144,6 @@ ../inc;%(AdditionalIncludeDirectories) MultiThreadedDebug ProgramDatabase - /analyze:stacksize32850 %(AdditionalOptions) 28252;28253 CompileAsC @@ -163,7 +162,6 @@ ../inc;%(AdditionalIncludeDirectories) MultiThreaded ProgramDatabase - /analyze:stacksize32850 %(AdditionalOptions) 28252;28253 CompileAsC @@ -179,7 +177,6 @@ ../inc;%(AdditionalIncludeDirectories) MultiThreadedDebug ProgramDatabase - /analyze:stacksize32850 %(AdditionalOptions) 28252;28253 CompileAsC @@ -198,7 +195,6 @@ ../inc;%(AdditionalIncludeDirectories) MultiThreaded ProgramDatabase - /analyze:stacksize32850 %(AdditionalOptions) 28252;28253 CompileAsC diff --git a/src/ms-sys/file.c b/src/ms-sys/file.c index 42076da6..906b1239 100644 --- a/src/ms-sys/file.c +++ b/src/ms-sys/file.c @@ -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 */ diff --git a/src/rufus.h b/src/rufus.h index 197f8682..72166714 100644 --- a/src/rufus.h +++ b/src/rufus.h @@ -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) diff --git a/src/rufus.rc b/src/rufus.rc index f9547ca0..a1ec4cb9 100644 --- a/src/rufus.rc +++ b/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" diff --git a/src/smart.c b/src/smart.c index a12b1f32..72b60149 100644 --- a/src/smart.c +++ b/src/smart.c @@ -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 diff --git a/src/smart.h b/src/smart.h index 6f1fe155..a3e5f758 100644 --- a/src/smart.h +++ b/src/smart.h @@ -21,11 +21,6 @@ * along with this program. If not, see . */ -#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:;} diff --git a/src/syslinux.c b/src/syslinux.c index f67627e1..4b737a9c 100644 --- a/src/syslinux.c +++ b/src/syslinux.c @@ -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); diff --git a/src/syslinux/libfat/cache.c b/src/syslinux/libfat/cache.c index 3d08b683..5b989765 100644 --- a/src/syslinux/libfat/cache.c +++ b/src/syslinux/libfat/cache.c @@ -17,21 +17,17 @@ */ #include +#include #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); } } diff --git a/src/syslinux/libfat/libfatint.h b/src/syslinux/libfat/libfatint.h index 5f098b5a..d7a57fbe 100644 --- a/src/syslinux/libfat/libfatint.h +++ b/src/syslinux/libfat/libfatint.h @@ -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,