logo

oasis

Own branch of Oasis Linux (upstream: <https://git.sr.ht/~mcf/oasis/>) git clone https://anongit.hacktivis.me/git/oasis.git

0003-Avoid-__attribute__-packed-requirement.patch (17981B)

    

  1. From 45d27217546b0fdbb4cf89beedb75d2675bb14a4 Mon Sep 17 00:00:00 2001
  2. From: Michael Forney <mforney@mforney.org>
  3. Date: Mon, 6 Sep 2021 22:51:14 -0700
  4. Subject: [PATCH] Avoid __attribute__((packed)) requirement
  6. Also, use portable get_*/set_* functions. Compilers will optimize
  7. the memory access to a single load/store if possible.
  8. ---
  9.  extlinux/main.c         |  46 ++++----
  10.  libinstaller/setadv.c   |  14 +--
  11.  libinstaller/syslxint.h | 255 ++++++++++++----------------------------
  12.  libinstaller/syslxmod.c |  20 ++--
  13.  4 files changed, 112 insertions(+), 223 deletions(-)
  15. diff --git a/extlinux/main.c b/extlinux/main.c
  16. index 04a2036b..0186baba 100644
  17. --- a/extlinux/main.c
  18. +++ b/extlinux/main.c
  19. @@ -236,7 +236,7 @@ static int patch_file_and_bootblock(int fd, const char *dir, int devfd)
  20.      sector_t *sectp;
  21.      uint64_t totalbytes, totalsectors;
  22.      int nsect;
  23. -    struct fat_boot_sector *sbs;
  24. +    unsigned char *sbs;
  25.      char *dirpath, *subpath, *xdirpath;
  26.      int rv;
  27.  
  28. @@ -293,20 +293,20 @@ static int patch_file_and_bootblock(int fd, const char *dir, int devfd)
  29.         early bootstrap share code with the FAT version. */
  30.      dprintf("heads = %u, sect = %u\n", geo.heads, geo.sectors);
  31.  
  32. -    sbs = (struct fat_boot_sector *)syslinux_bootsect;
  33. +    sbs = syslinux_bootsect;
  34.  
  35.      totalsectors = totalbytes >> SECTOR_SHIFT;
  36.      if (totalsectors >= 65536) {
  37. -	set_16(&sbs->bsSectors, 0);
  38. +	set_16(sbs + FAT_BS_SECTORS, 0);
  39.      } else {
  40. -	set_16(&sbs->bsSectors, totalsectors);
  41. +	set_16(sbs + FAT_BS_SECTORS, totalsectors);
  42.      }
  43. -    set_32(&sbs->bsHugeSectors, totalsectors);
  44. +    set_32(sbs + FAT_BS_HUGE_SECTORS, totalsectors);
  45.  
  46. -    set_16(&sbs->bsBytesPerSec, SECTOR_SIZE);
  47. -    set_16(&sbs->bsSecPerTrack, geo.sectors);
  48. -    set_16(&sbs->bsHeads, geo.heads);
  49. -    set_32(&sbs->bsHiddenSecs, geo.start);
  50. +    set_16(sbs + FAT_BS_BYTES_PER_SEC, SECTOR_SIZE);
  51. +    set_16(sbs + FAT_BS_SEC_PER_TRACK, geo.sectors);
  52. +    set_16(sbs + FAT_BS_HEADS, geo.heads);
  53. +    set_32(sbs + FAT_BS_HIDDEN_SECS, geo.start);
  54.  
  55.      /* Construct the boot file map */
  56.  
  57. @@ -346,8 +346,8 @@ int install_bootblock(int fd, const char *device)
  58.  {
  59.      struct ext2_super_block sb;
  60.      struct btrfs_super_block sb2;
  61. -    struct fat_boot_sector sb3;
  62. -    struct ntfs_boot_sector sb4;
  63. +    unsigned char sb3[512];
  64. +    unsigned char sb4[512];
  65.      xfs_sb_t sb5;
  66.      struct ufs_super_block sb6;
  67.      bool ok = false;
  68. @@ -374,7 +374,7 @@ int install_bootblock(int fd, const char *device)
  69.  		return 1;
  70.  	}
  71.  
  72. -	if (fat_check_sb_fields(&sb3))
  73. +	if (fat_check_sb_fields(sb3))
  74.  		ok = true;
  75.      } else if (fs_type == NTFS) {
  76.          if (xpread(fd, &sb4, sizeof(sb4), 0) != sizeof(sb4)) {
  77. @@ -382,7 +382,7 @@ int install_bootblock(int fd, const char *device)
  78.              return 1;
  79.          }
  80.  
  81. -        if (ntfs_check_sb_fields(&sb4))
  82. +        if (ntfs_check_sb_fields(sb4))
  83.               ok = true;
  84.      } else if (fs_type == XFS) {
  85.  	if (xpread(fd, &sb5, sizeof sb5, 0) != sizeof sb5) {
  86. @@ -427,21 +427,19 @@ int install_bootblock(int fd, const char *device)
  87.      }
  88.  
  89.      if (fs_type == VFAT) {
  90. -	struct fat_boot_sector *sbs = (struct fat_boot_sector *)syslinux_bootsect;
  91. -        if (xpwrite(fd, &sbs->FAT_bsHead, FAT_bsHeadLen, 0) != FAT_bsHeadLen ||
  92. -	    xpwrite(fd, &sbs->FAT_bsCode, FAT_bsCodeLen,
  93. -		    offsetof(struct fat_boot_sector, FAT_bsCode)) != FAT_bsCodeLen) {
  94. +	unsigned char *sbs = syslinux_bootsect;
  95. +        if (xpwrite(fd, sbs + FAT_BS_HEAD, FAT_BS_HEAD_LEN, 0) != FAT_BS_HEAD_LEN ||
  96. +	    xpwrite(fd, sbs + FAT_BS_CODE, FAT_BS_CODE_LEN,
  97. +		    FAT_BS_CODE) != FAT_BS_CODE_LEN) {
  98.  	    perror("writing fat bootblock");
  99.  	    return 1;
  100.  	}
  101.      } else if (fs_type == NTFS) {
  102. -        struct ntfs_boot_sector *sbs =
  103. -                (struct ntfs_boot_sector *)syslinux_bootsect;
  104. -        if (xpwrite(fd, &sbs->NTFS_bsHead,
  105. -                    NTFS_bsHeadLen, 0) != NTFS_bsHeadLen ||
  106. -                    xpwrite(fd, &sbs->NTFS_bsCode, NTFS_bsCodeLen,
  107. -                    offsetof(struct ntfs_boot_sector,
  108. -                    NTFS_bsCode)) != NTFS_bsCodeLen) {
  109. +        unsigned char *sbs = syslinux_bootsect;
  110. +        if (xpwrite(fd, sbs + NTFS_BS_HEAD,
  111. +                    NTFS_BS_HEAD_LEN, 0) != NTFS_BS_HEAD_LEN ||
  112. +                    xpwrite(fd, sbs + NTFS_BS_CODE, NTFS_BS_CODE_LEN,
  113. +                    NTFS_BS_CODE) != NTFS_BS_CODE_LEN) {
  114.              perror("writing ntfs bootblock");
  115.              return 1;
  116.          }
  117. diff --git a/libinstaller/setadv.c b/libinstaller/setadv.c
  118. index 214f7fc1..4f1cbc88 100644
  119. --- a/libinstaller/setadv.c
  120. +++ b/libinstaller/setadv.c
  121. @@ -44,14 +44,14 @@ static void cleanup_adv(unsigned char *advbuf)
  122.      uint32_t csum;
  123.  
  124.      /* Make sure both copies agree, and update the checksum */
  125. -    set_32((uint32_t *) advbuf, ADV_MAGIC1);
  126. +    set_32(advbuf, ADV_MAGIC1);
  127.  
  128.      csum = ADV_MAGIC2;
  129.      for (i = 8; i < ADV_SIZE - 4; i += 4)
  130. -	csum -= get_32((uint32_t *) (advbuf + i));
  131. +	csum -= get_32(advbuf + i);
  132.  
  133. -    set_32((uint32_t *) (advbuf + 4), csum);
  134. -    set_32((uint32_t *) (advbuf + ADV_SIZE - 4), ADV_MAGIC3);
  135. +    set_32(advbuf + 4, csum);
  136. +    set_32(advbuf + ADV_SIZE - 4, ADV_MAGIC3);
  137.  
  138.      memcpy(advbuf + ADV_SIZE, advbuf, ADV_SIZE);
  139.  }
  140. @@ -138,13 +138,13 @@ static int adv_consistent(const unsigned char *p)
  141.      int i;
  142.      uint32_t csum;
  143.  
  144. -    if (get_32((uint32_t *) p) != ADV_MAGIC1 ||
  145. -	get_32((uint32_t *) (p + ADV_SIZE - 4)) != ADV_MAGIC3)
  146. +    if (get_32(p) != ADV_MAGIC1 ||
  147. +	get_32(p + ADV_SIZE - 4) != ADV_MAGIC3)
  148.  	return 0;
  149.  
  150.      csum = 0;
  151.      for (i = 4; i < ADV_SIZE - 4; i += 4)
  152. -	csum += get_32((uint32_t *) (p + i));
  153. +	csum += get_32(p + i);
  154.  
  155.      return csum == ADV_MAGIC2;
  156.  }
  157. diff --git a/libinstaller/syslxint.h b/libinstaller/syslxint.h
  158. index 7eee7890..dbc6a0b8 100644
  159. --- a/libinstaller/syslxint.h
  160. +++ b/libinstaller/syslxint.h
  161. @@ -23,56 +23,27 @@
  162.  # define X86_MEM 0
  163.  #endif
  164.  
  165. -#ifdef __GNUC__
  166. -# ifdef __MINGW32__
  167. -   /* gcc 4.7 miscompiles packed structures in MS-bitfield mode */
  168. -#  define PACKED __attribute__((packed,gcc_struct))
  169. -# else
  170. -#  define PACKED __attribute__((packed))
  171. -# endif
  172. -#else
  173. -# error "Need to define PACKED for this compiler"
  174. -#endif
  175. -
  176.  /*
  177.   * Access functions for littleendian numbers, possibly misaligned.
  178.   */
  179. -static inline uint8_t get_8(const uint8_t * p)
  180. +static inline uint8_t get_8(const unsigned char* p)
  181.  {
  182.      return *p;
  183.  }
  184.  
  185. -static inline uint16_t get_16(const uint16_t * p)
  186. +static inline uint16_t get_16(const unsigned char *p)
  187.  {
  188. -#if X86_MEM
  189. -    /* Littleendian and unaligned-capable */
  190. -    return *p;
  191. -#else
  192. -    const uint8_t *pp = (const uint8_t *)p;
  193. -    return pp[0] + ((uint16_t)pp[1] << 8);
  194. -#endif
  195. +    return p[0] | (uint16_t)p[1] << 8;
  196.  }
  197.  
  198. -static inline uint32_t get_32(const uint32_t * p)
  199. +static inline uint32_t get_32(const unsigned char *p)
  200.  {
  201. -#if X86_MEM
  202. -    /* Littleendian and unaligned-capable */
  203. -    return *p;
  204. -#else
  205. -    const uint16_t *pp = (const uint16_t *)p;
  206. -    return get_16(&pp[0]) + ((uint32_t)get_16(&pp[1]) << 16);
  207. -#endif
  208. +    return get_16(&p[0]) | (uint32_t)get_16(&p[2]) << 16;
  209.  }
  210.  
  211. -static inline uint64_t get_64(const uint64_t * p)
  212. +static inline uint64_t get_64(const unsigned char *p)
  213.  {
  214. -#if X86_MEM
  215. -    /* Littleendian and unaligned-capable */
  216. -    return *p;
  217. -#else
  218. -    const uint32_t *pp = (const uint32_t *)p;
  219. -    return get_32(&pp[0]) + ((uint64_t)get_32(&pp[1]) << 32);
  220. -#endif
  221. +    return get_32(&p[0]) | (uint64_t)get_32(&p[2]) << 32;
  222.  }
  223.  
  224.  static inline void set_8(uint8_t *p, uint8_t v)
  225. @@ -80,40 +51,22 @@ static inline void set_8(uint8_t *p, uint8_t v)
  226.      *p = v;
  227.  }
  228.  
  229. -static inline void set_16(uint16_t *p, uint16_t v)
  230. +static inline void set_16(unsigned char *p, uint16_t v)
  231.  {
  232. -#if X86_MEM
  233. -    /* Littleendian and unaligned-capable */
  234. -    *p = v;
  235. -#else
  236. -    uint8_t *pp = (uint8_t *) p;
  237. -    pp[0] = v;
  238. -    pp[1] = v >> 8;
  239. -#endif
  240. +    p[0] = v;
  241. +    p[1] = v >> 8;
  242.  }
  243.  
  244. -static inline void set_32(uint32_t *p, uint32_t v)
  245. +static inline void set_32(unsigned char *p, uint32_t v)
  246.  {
  247. -#if X86_MEM
  248. -    /* Littleendian and unaligned-capable */
  249. -    *p = v;
  250. -#else
  251. -    uint16_t *pp = (uint16_t *) p;
  252. -    set_16(&pp[0], v);
  253. -    set_16(&pp[1], v >> 16);
  254. -#endif
  255. +    set_16(&p[0], v);
  256. +    set_16(&p[2], v >> 16);
  257.  }
  258.  
  259. -static inline void set_64(uint64_t *p, uint64_t v)
  260. +static inline void set_64(unsigned char *p, uint64_t v)
  261.  {
  262. -#if X86_MEM
  263. -    /* Littleendian and unaligned-capable */
  264. -    *p = v;
  265. -#else
  266. -    uint32_t *pp = (uint32_t *) p;
  267. -    set_32(&pp[0], v);
  268. -    set_32(&pp[1], v >> 32);
  269. -#endif
  270. +    set_32(&p[0], v);
  271. +    set_32(&p[4], v >> 32);
  272.  }
  273.  
  274.  /*
  275. @@ -139,35 +92,35 @@ void memset_sl(void _slimg *dst, int c, size_t len);
  276.  /* Sane system ... */
  277.  static inline uint8_t get_8_sl(const uint8_t _slimg * p)
  278.  {
  279. -    return get_8((const uint8_t _force *)p);
  280. +    return get_8((const unsigned char _force *)p);
  281.  }
  282.  static inline uint16_t get_16_sl(const uint16_t _slimg * p)
  283.  {
  284. -    return get_16((const uint16_t _force *)p);
  285. +    return get_16((const unsigned char _force *)p);
  286.  }
  287.  static inline uint32_t get_32_sl(const uint32_t _slimg * p)
  288.  {
  289. -    return get_32((const uint32_t _force *)p);
  290. +    return get_32((const unsigned char _force *)p);
  291.  }
  292.  static inline uint64_t get_64_sl(const uint64_t _slimg * p)
  293.  {
  294. -    return get_64((const uint64_t _force *)p);
  295. +    return get_64((const unsigned char _force *)p);
  296.  }
  297.  static inline void set_8_sl(uint8_t _slimg * p, uint8_t v)
  298.  {
  299. -    set_8((uint8_t _force *)p, v);
  300. +    set_8((unsigned char _force *)p, v);
  301.  }
  302.  static inline void set_16_sl(uint16_t _slimg * p, uint16_t v)
  303.  {
  304. -    set_16((uint16_t _force *)p, v);
  305. +    set_16((unsigned char _force *)p, v);
  306.  }
  307.  static inline void set_32_sl(uint32_t _slimg * p, uint32_t v)
  308.  {
  309. -    set_32((uint32_t _force *)p, v);
  310. +    set_32((unsigned char _force *)p, v);
  311.  }
  312.  static inline void set_64_sl(uint64_t _slimg * p, uint64_t v)
  313.  {
  314. -    set_64((uint64_t _force *)p, v);
  315. +    set_64((unsigned char _force *)p, v);
  316.  }
  317.  static inline void memcpy_to_sl(void _slimg *dst, const void *src, size_t len)
  318.  {
  319. @@ -213,130 +166,68 @@ struct ext_patch_area {
  320.      uint16_t raidpatch;		/* Boot sector RAID mode patch pointer */
  321.  };
  322.  
  323. -/* Sector extent */
  324. -struct syslinux_extent {
  325. -    uint64_t lba;
  326. -    uint16_t len;
  327. -} PACKED;
  328. -
  329.  /* FAT bootsector format, also used by other disk-based derivatives */
  330. -struct fat_boot_sector {
  331. -    uint8_t bsJump[3];
  332. -    char bsOemName[8];
  333. -    uint16_t bsBytesPerSec;
  334. -    uint8_t bsSecPerClust;
  335. -    uint16_t bsResSectors;
  336. -    uint8_t bsFATs;
  337. -    uint16_t bsRootDirEnts;
  338. -    uint16_t bsSectors;
  339. -    uint8_t bsMedia;
  340. -    uint16_t bsFATsecs;
  341. -    uint16_t bsSecPerTrack;
  342. -    uint16_t bsHeads;
  343. -    uint32_t bsHiddenSecs;
  344. -    uint32_t bsHugeSectors;
  345. -
  346. -    union {
  347. -	struct {
  348. -	    uint8_t DriveNumber;
  349. -	    uint8_t Reserved1;
  350. -	    uint8_t BootSignature;
  351. -	    uint32_t VolumeID;
  352. -	    char VolumeLabel[11];
  353. -	    char FileSysType[8];
  354. -	    uint8_t Code[442];
  355. -	} PACKED bs16;
  356. -	struct {
  357. -	    uint32_t FATSz32;
  358. -	    uint16_t ExtFlags;
  359. -	    uint16_t FSVer;
  360. -	    uint32_t RootClus;
  361. -	    uint16_t FSInfo;
  362. -	    uint16_t BkBootSec;
  363. -	    uint8_t Reserved0[12];
  364. -	    uint8_t DriveNumber;
  365. -	    uint8_t Reserved1;
  366. -	    uint8_t BootSignature;
  367. -	    uint32_t VolumeID;
  368. -	    char VolumeLabel[11];
  369. -	    char FileSysType[8];
  370. -	    uint8_t Code[414];
  371. -	} PACKED bs32;
  372. -    } PACKED;
  373. -
  374. -    uint32_t bsMagic;
  375. -    uint16_t bsForwardPtr;
  376. -    uint16_t bsSignature;
  377. -} PACKED;
  378. +#define FAT_BS_JUMP 0x00
  379. +#define FAT_BS_BYTES_PER_SEC 0x0B
  380. +#define FAT_BS_RES_SECTORS 0x0D
  381. +#define FAT_BS_FATS 0x10
  382. +#define FAT_BS_SECTORS 0x13
  383. +#define FAT_BS_SEC_PER_TRACK 0x18
  384. +#define FAT_BS_HEADS 0x1A
  385. +#define FAT_BS_HIDDEN_SECS 0x1C
  386. +#define FAT_BS_HUGE_SECTORS 0x20
  387. +#define FAT_BS_SIGNATURE 0x1FE
  388. +#define FAT_BS16_FILE_SYS_TYPE 0x36
  389. +#define FAT_BS32_FILE_SYS_TYPE 0x52
  390. +#define FAT_BS32_CODE 0x62
  391. +
  392. +#define FAT_BS_HEAD      FAT_BS_JUMP
  393. +#define FAT_BS_HEAD_LEN  FAT_BS_BYTES_PER_SEC
  394. +#define FAT_BS_CODE      FAT_BS32_CODE /* The common safe choice */
  395. +#define FAT_BS_CODE_LEN  FAT_BS_SIGNATURE - FAT_BS_CODE
  396.  
  397.  /* NTFS bootsector format */
  398. -struct ntfs_boot_sector {
  399. -    uint8_t bsJump[3];
  400. -    char bsOemName[8];
  401. -    uint16_t bsBytesPerSec;
  402. -    uint8_t bsSecPerClust;
  403. -    uint16_t bsResSectors;
  404. -    uint8_t bsZeroed_0[3];
  405. -    uint16_t bsZeroed_1;
  406. -    uint8_t bsMedia;
  407. -    uint16_t bsZeroed_2;
  408. -    uint16_t bsUnused_0;
  409. -    uint16_t bsUnused_1;
  410. -    uint32_t bsUnused_2;
  411. -    uint32_t bsZeroed_3;
  412. -    uint32_t bsUnused_3;
  413. -    uint64_t bsTotalSectors;
  414. -    uint64_t bsMFTLogicalClustNr;
  415. -    uint64_t bsMFTMirrLogicalClustNr;
  416. -    uint8_t bsClustPerMFTrecord;
  417. -    uint8_t bsUnused_4[3];
  418. -    uint8_t bsClustPerIdxBuf;
  419. -    uint8_t bsUnused_5[3];
  420. -    uint64_t bsVolSerialNr;
  421. -    uint32_t bsUnused_6;
  422. -
  423. -    uint8_t Code[420];
  424. -
  425. -    uint32_t bsMagic;
  426. -    uint16_t bsForwardPtr;
  427. -    uint16_t bsSignature;
  428. -} PACKED;
  429. -
  430. -#define FAT_bsHead      bsJump
  431. -#define FAT_bsHeadLen   offsetof(struct fat_boot_sector, bsBytesPerSec)
  432. -#define FAT_bsCode	    bs32.Code	/* The common safe choice */
  433. -#define FAT_bsCodeLen   (offsetof(struct fat_boot_sector, bsSignature) - \
  434. -		     offsetof(struct fat_boot_sector, FAT_bsCode))
  435. -
  436. -#define NTFS_bsHead     bsJump
  437. -#define NTFS_bsHeadLen  offsetof(struct ntfs_boot_sector, bsOemName)
  438. -#define NTFS_bsCode     Code
  439. -#define NTFS_bsCodeLen  (offsetof(struct ntfs_boot_sector, bsSignature) - \
  440. -                            offsetof(struct ntfs_boot_sector, NTFS_bsCode))
  441. +#define NTFS_BS_JUMP 0x00
  442. +#define NTFS_BS_OEM_NAME 0x03
  443. +#define NTFS_BS_RES_SECTORS 0x0E
  444. +#define NTFS_BS_ZEROED_0 0x10
  445. +#define NTFS_BS_ZEROED_1 0x13
  446. +#define NTFS_BS_ZEROED_2 0x16
  447. +#define NTFS_BS_ZEROED_3 0x20
  448. +#define NTFS_BS_CODE 0x54
  449. +#define NTFS_BS_SIGNATURE 0x1FE
  450. +
  451. +#define NTFS_BS_HEAD     NTFS_BS_JUMP
  452. +#define NTFS_BS_HEAD_LEN NTFS_BS_OEM_NAME
  453. +#define NTFS_BS_CODE_LEN NTFS_BS_SIGNATURE - NTFS_BS_CODE
  454.  
  455.  /* Check if there are specific zero fields in an NTFS boot sector */
  456. -static inline int ntfs_check_zero_fields(const struct ntfs_boot_sector *sb)
  457. +static inline int ntfs_check_zero_fields(const unsigned char *sb)
  458.  {
  459. -    return !sb->bsResSectors && (!sb->bsZeroed_0[0] && !sb->bsZeroed_0[1] &&
  460. -            !sb->bsZeroed_0[2]) && !sb->bsZeroed_1 && !sb->bsZeroed_2 &&
  461. -            !sb->bsZeroed_3;
  462. +    return !sb[NTFS_BS_RES_SECTORS] && !sb[NTFS_BS_RES_SECTORS + 1] &&
  463. +            !sb[NTFS_BS_ZEROED_0] && !sb[NTFS_BS_ZEROED_0 + 1] &&
  464. +            !sb[NTFS_BS_ZEROED_0 + 2] && !sb[NTFS_BS_ZEROED_1] &&
  465. +            !sb[NTFS_BS_ZEROED_1 + 1] && !sb[NTFS_BS_ZEROED_2] &&
  466. +            !sb[NTFS_BS_ZEROED_2 + 1] && !sb[NTFS_BS_ZEROED_3] &&
  467. +            !sb[NTFS_BS_ZEROED_3 + 1] && !sb[NTFS_BS_ZEROED_3 + 2] &&
  468. +            !sb[NTFS_BS_ZEROED_3 + 3];
  469.  }
  470.  
  471. -static inline int ntfs_check_sb_fields(const struct ntfs_boot_sector *sb)
  472. +static inline int ntfs_check_sb_fields(const unsigned char *sb)
  473.  {
  474.      return ntfs_check_zero_fields(sb) &&
  475. -            (!memcmp(sb->bsOemName, "NTFS    ", 8) ||
  476. -             !memcmp(sb->bsOemName, "MSWIN4.0", 8) ||
  477. -             !memcmp(sb->bsOemName, "MSWIN4.1", 8));
  478. +            (!memcmp(sb + NTFS_BS_OEM_NAME, "NTFS    ", 8) ||
  479. +             !memcmp(sb + NTFS_BS_OEM_NAME, "MSWIN4.0", 8) ||
  480. +             !memcmp(sb + NTFS_BS_OEM_NAME, "MSWIN4.1", 8));
  481.  }
  482.  
  483. -static inline int fat_check_sb_fields(const struct fat_boot_sector *sb)
  484. +static inline int fat_check_sb_fields(const unsigned char *sb)
  485.  {
  486. -    return sb->bsResSectors && sb->bsFATs &&
  487. -            (!memcmp(sb->bs16.FileSysType, "FAT12   ", 8) ||
  488. -             !memcmp(sb->bs16.FileSysType, "FAT16   ", 8) ||
  489. -             !memcmp(sb->bs16.FileSysType, "FAT     ", 8) ||
  490. -             !memcmp(sb->bs32.FileSysType, "FAT32   ", 8));
  491. +    return (sb[FAT_BS_RES_SECTORS] || sb[FAT_BS_RES_SECTORS + 1]) && sb[FAT_BS_FATS] &&
  492. +            (!memcmp(sb + FAT_BS16_FILE_SYS_TYPE, "FAT12   ", 8) ||
  493. +             !memcmp(sb + FAT_BS16_FILE_SYS_TYPE, "FAT16   ", 8) ||
  494. +             !memcmp(sb + FAT_BS16_FILE_SYS_TYPE, "FAT     ", 8) ||
  495. +             !memcmp(sb + FAT_BS32_FILE_SYS_TYPE, "FAT32   ", 8));
  496.  }
  497.  
  498.  #endif /* SYSLXINT_H */
  499. diff --git a/libinstaller/syslxmod.c b/libinstaller/syslxmod.c
  500. index 0ec41641..10f7ccf0 100644
  501. --- a/libinstaller/syslxmod.c
  502. +++ b/libinstaller/syslxmod.c
  503. @@ -32,7 +32,7 @@
  504.  /*
  505.   * Generate sector extents
  506.   */
  507. -static void generate_extents(struct syslinux_extent _slimg *ex, int nptrs,
  508. +static void generate_extents(unsigned char *ex, int nptrs,
  509.  			     const sector_t *sectp, int nsect)
  510.  {
  511.      uint32_t addr = 0x8000;	/* ldlinux.sys starts loading here */
  512. @@ -43,7 +43,7 @@ static void generate_extents(struct syslinux_extent _slimg *ex, int nptrs,
  513.      base = addr;
  514.      len = lba = 0;
  515.  
  516. -    memset_sl(ex, 0, nptrs * sizeof *ex);
  517. +    memset_sl(ex, 0, nptrs * 10);
  518.  
  519.      while (nsect) {
  520.  	sect = *sectp++;
  521. @@ -58,9 +58,9 @@ static void generate_extents(struct syslinux_extent _slimg *ex, int nptrs,
  522.  		goto next;
  523.  	    }
  524.  
  525. -	    set_64_sl(&ex->lba, lba);
  526. -	    set_16_sl(&ex->len, len);
  527. -	    ex++;
  528. +	    set_64(ex, lba);
  529. +	    set_16(ex + 8, len);
  530. +	    ex += 10;
  531.  	}
  532.  
  533.  	base = addr;
  534. @@ -73,9 +73,9 @@ static void generate_extents(struct syslinux_extent _slimg *ex, int nptrs,
  535.      }
  536.  
  537.      if (len) {
  538. -	set_64_sl(&ex->lba, lba);
  539. -	set_16_sl(&ex->len, len);
  540. -	ex++;
  541. +	set_64(ex, lba);
  542. +	set_16(ex + 8, len);
  543. +	ex += 10;
  544.      }
  545.  }
  546.  
  547. @@ -109,7 +109,7 @@ int syslinux_patch(const sector_t *sectp, int nsectors,
  548.  {
  549.      struct patch_area _slimg *patcharea;
  550.      struct ext_patch_area _slimg *epa;
  551. -    struct syslinux_extent _slimg *ex;
  552. +    unsigned char *ex;
  553.      const uint32_t _slimg *wp;
  554.      int nsect = ((boot_image_len + SECTOR_SIZE - 1) >> SECTOR_SHIFT) + 2;
  555.      uint32_t csum;
  556. @@ -152,7 +152,7 @@ int syslinux_patch(const sector_t *sectp, int nsectors,
  557.      }
  558.  
  559.      /* Set the sector extents */
  560. -    ex = slptr(boot_image, &epa->secptroffset);
  561. +    ex = ptr(boot_image, &epa->secptroffset);
  562.      nptrs = get_16_sl(&epa->secptrcnt);
  563.  
  564.  #if 0
  565. -- 
  566. 2.32.0