2 /* ----------------------------------------------------------------------- *
4 * Copyright 1998-2004 H. Peter Anvin - All Rights Reserved
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, Inc., 53 Temple Place Ste 330,
9 * Boston MA 02111-1307, USA; either version 2 of the License, or
10 * (at your option) any later version; incorporated herein by reference.
12 * ----------------------------------------------------------------------- */
15 * syslxmod.c - Code to provide a SYSLINUX code set to an installer.
18 #define _XOPEN_SOURCE 500 /* Required on glibc 2.x */
27 #define LDLINUX_MAGIC 0x3eb202fe
46 bs16DriveNumber
= 0x24,
48 bs16BootSignature
= 0x26,
50 bs16VolumeLabel
= 0x2b,
51 bs16FileSysType
= 0x36,
64 bs32BootSignature
= 66,
74 #define bsHeadLen (bsOemName-bsHead)
75 #define bsCode bs32Code /* The common safe choice */
76 #define bsCodeLen (bsSignature-bs32Code)
79 * Access functions for littleendian numbers, possibly misaligned.
81 static inline uint8_t get_8(const unsigned char *p
)
83 return *(const uint8_t *)p
;
86 static inline uint16_t get_16(const unsigned char *p
)
88 #if defined(__i386__) || defined(__x86_64__)
89 /* Littleendian and unaligned-capable */
90 return *(const uint16_t *)p
;
92 return (uint16_t)p
[0] + ((uint16_t)p
[1] << 8);
96 static inline uint32_t get_32(const unsigned char *p
)
98 #if defined(__i386__) || defined(__x86_64__)
99 /* Littleendian and unaligned-capable */
100 return *(const uint32_t *)p
;
102 return (uint32_t)p
[0] + ((uint32_t)p
[1] << 8) +
103 ((uint32_t)p
[2] << 16) + ((uint32_t)p
[3] << 24);
107 static inline void set_16(unsigned char *p
, uint16_t v
)
109 #if defined(__i386__) || defined(__x86_64__)
110 /* Littleendian and unaligned-capable */
114 p
[1] = ((v
>> 8) & 0xff);
118 static inline void set_32(unsigned char *p
, uint32_t v
)
120 #if defined(__i386__) || defined(__x86_64__)
121 /* Littleendian and unaligned-capable */
125 p
[1] = ((v
>> 8) & 0xff);
126 p
[2] = ((v
>> 16) & 0xff);
127 p
[3] = ((v
>> 24) & 0xff);
131 /* Patch the code so that we're running in stupid mode */
132 void syslinux_make_stupid(void)
134 /* Access only one sector at a time */
135 set_16(syslinux_bootsect
+0x1FC, 1);
138 void syslinux_make_bootsect(void *bs
)
140 unsigned char *bootsect
= bs
;
142 memcpy(bootsect
+bsHead
, syslinux_bootsect
+bsHead
, bsHeadLen
);
143 memcpy(bootsect
+bsCode
, syslinux_bootsect
+bsCode
, bsCodeLen
);
147 * Check to see that what we got was indeed an MS-DOS boot sector/superblock;
148 * Return NULL if OK and otherwise an error message;
150 const char *syslinux_check_bootsect(const void *bs
)
154 long long sectors
, fatsectors
, dsectors
;
156 int rootdirents
, clustersize
;
157 const unsigned char *sectbuf
= bs
;
161 /* Must be 0xF0 or 0xF8..0xFF */
162 if ( get_8(sectbuf
+bsMedia
) != 0xF0 &&
163 get_8(sectbuf
+bsMedia
) < 0xF8 )
166 sectorsize
= get_16(sectbuf
+bsBytesPerSec
);
167 if ( sectorsize
== 512 )
169 else if ( sectorsize
== 1024 || sectorsize
== 2048 || sectorsize
== 4096 )
170 return "only 512-byte sectors are supported";
174 clustersize
= get_8(sectbuf
+bsSecPerClust
);
175 if ( clustersize
== 0 || (clustersize
& (clustersize
-1)) )
176 goto invalid
; /* Must be nonzero and a power of 2 */
178 sectors
= get_16(sectbuf
+bsSectors
);
179 sectors
= sectors
? sectors
: get_32(sectbuf
+bsHugeSectors
);
181 dsectors
= sectors
- get_16(sectbuf
+bsResSectors
);
183 fatsectors
= get_16(sectbuf
+bsFATsecs
);
184 fatsectors
= fatsectors
? fatsectors
: get_32(sectbuf
+bs32FATSz32
);
185 fatsectors
*= get_8(sectbuf
+bsFATs
);
186 dsectors
-= fatsectors
;
188 rootdirents
= get_16(sectbuf
+bsRootDirEnts
);
189 dsectors
-= (rootdirents
+sectorsize
/32-1)/sectorsize
;
191 if ( dsectors
< 0 || fatsectors
== 0 )
194 clusters
= dsectors
/clustersize
;
196 if ( clusters
< 0xFFF5 ) {
199 if ( !get_16(sectbuf
+bsFATsecs
) )
202 if ( get_8(sectbuf
+bs16BootSignature
) == 0x29 ) {
203 if ( !memcmp(sectbuf
+bs16FileSysType
, "FAT12 ", 8) ) {
204 if ( clusters
>= 0xFF5 )
205 return "more than 4084 clusters but claims FAT12";
206 } else if ( !memcmp(sectbuf
+bs16FileSysType
, "FAT16 ", 8) ) {
207 if ( clusters
< 0xFF5 )
208 return "less than 4084 clusters but claims FAT16";
209 } else if ( memcmp(sectbuf
+bs16FileSysType
, "FAT ", 8) ) {
210 static char fserr
[] = "filesystem type \"????????\" not supported";
211 memcpy(fserr
+17, sectbuf
+bs16FileSysType
, 8);
215 } else if ( clusters
< 0x0FFFFFF5 ) {
217 /* Moving the FileSysType and BootSignature was a lovely stroke of M$ idiocy */
218 if ( get_8(sectbuf
+bs32BootSignature
) != 0x29 ||
219 memcmp(sectbuf
+bs32FileSysType
, "FAT32 ", 8) )
228 return "this doesn't look like a valid FAT filesystem";
232 * This patches the boot sector and the first sector of ldlinux.sys
233 * based on an ldlinux.sys sector map passed in. Typically this is
234 * handled by writing ldlinux.sys, mapping it, and then overwrite it
235 * with the patched version. If this isn't safe to do because of
236 * an OS which does block reallocation, then overwrite it with
237 * direct access since the location is known.
239 * Return 0 if successful, otherwise -1.
241 int syslinux_patch(const uint32_t *sectors
, int nsectors
)
243 unsigned char *patcharea
, *p
;
244 int nsect
= (syslinux_ldlinux_len
+511) >> 9;
248 if ( nsectors
< nsect
)
251 /* First sector need pointer in boot sector */
252 set_32(syslinux_bootsect
+0x1F8, *sectors
++);
255 /* Search for LDLINUX_MAGIC to find the patch area */
256 for ( p
= syslinux_ldlinux
; get_32(p
) != LDLINUX_MAGIC
; p
+= 4 );
259 /* Set up the totals */
260 dw
= syslinux_ldlinux_len
>> 2; /* COMPLETE dwords! */
261 set_16(patcharea
, dw
);
262 set_16(patcharea
+2, nsect
); /* Does not include the first sector! */
264 /* Set the sector pointers */
269 set_32(p
, *sectors
++);
273 /* Now produce a checksum */
274 set_32(patcharea
+4, 0);
276 csum
= LDLINUX_MAGIC
;
277 for ( i
= 0, p
= syslinux_ldlinux
; i
< dw
; i
++, p
+= 4 )
278 csum
-= get_32(p
); /* Negative checksum */
280 set_32(patcharea
+4, csum
);