1 /* -*- c -*- ------------------------------------------------------------- * 2 * 3 * Copyright 2003-2008 H. Peter Anvin - All Rights Reserved 4 * Portions copyright 2010 Shao Miller 5 * 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. 11 * 12 * ----------------------------------------------------------------------- */ 13 14 /* 15 * mdiskchk.c 16 * 17 * DOS program to check for the existence of a memdisk. 18 * 19 * This program can be compiled for DOS with the OpenWatcom compiler 20 * (http://www.openwatcom.org/): 21 * 22 * wcl -3 -osx -mt mdiskchk.c 23 */ 24 25 #include <ctype.h> 26 #include <stdio.h> 27 #include <string.h> 28 #include <i86.h> /* For MK_FP() */ 29 30 typedef unsigned long uint32_t; 31 typedef unsigned short uint16_t; 32 typedef unsigned char uint8_t; 33 34 /* Pull in MEMDISK common structures */ 35 #include "../memdisk/mstructs.h" 36 37 struct memdiskinfo { 38 struct mdi mdi; 39 40 /* We add our own fields at the end */ 41 int cylinders; 42 int heads; 43 int sectors; 44 }; 45 46 struct memdiskinfo *query_memdisk(int drive) 47 { 48 static struct memdiskinfo mm; 49 uint32_t _eax, _ebx, _ecx, _edx; 50 uint16_t _es, _di; 51 unsigned char _dl = drive; 52 uint16_t bytes; 53 54 __asm { 55 .386; 56 mov eax, 454d0800h; 57 mov ecx, 444d0000h; 58 mov edx, 53490000h; 59 mov dl, _dl; 60 mov ebx, 3f4b0000h; 61 int 13h; 62 mov _eax, eax; 63 mov _ecx, ecx; 64 mov _edx, edx; 65 mov _ebx, ebx; 66 mov _es, es; 67 mov _di, di; 68 } 69 70 if (_eax >> 16 != 0x4d21 || 71 _ecx >> 16 != 0x4d45 || _edx >> 16 != 0x4944 || _ebx >> 16 != 0x4b53) 72 return NULL; 73 74 memset(&mm, 0, sizeof mm); 75 76 bytes = *(uint16_t far *) MK_FP(_es, _di); 77 78 /* 27 is the most we know how to handle */ 79 if (bytes > 27) 80 bytes = 27; 81 82 _fmemcpy((void far *)&mm, (void far *)MK_FP(_es, _di), bytes); 83 84 mm.cylinders = ((_ecx >> 8) & 0xff) + ((_ecx & 0xc0) << 2) + 1; 85 mm.heads = ((_edx >> 8) & 0xff) + 1; 86 mm.sectors = (_ecx & 0x3f); 87 88 return &mm; 89 } 90 91 const char *bootloadername(uint8_t id) 92 { 93 static const struct { 94 uint8_t id, mask; 95 const char *name; 96 } *lp, list[] = { 97 {0x00, 0xf0, "LILO"}, 98 {0x10, 0xf0, "LOADLIN"}, 99 {0x31, 0xff, "SYSLINUX"}, 100 {0x32, 0xff, "PXELINUX"}, 101 {0x33, 0xff, "ISOLINUX"}, 102 {0x34, 0xff, "EXTLINUX"}, 103 {0x30, 0xf0, "SYSLINUX family"}, 104 {0x40, 0xf0, "Etherboot"}, 105 {0x50, 0xf0, "ELILO"}, 106 {0x70, 0xf0, "GrUB"}, 107 {0x80, 0xf0, "U-Boot"}, 108 {0xA0, 0xf0, "Gujin"}, 109 {0xB0, 0xf0, "Qemu"}, 110 {0x00, 0x00, "unknown"} 111 }; 112 113 for (lp = list;; lp++) { 114 if (((id ^ lp->id) & lp->mask) == 0) 115 return lp->name; 116 } 117 } 118 119 /* The function type for an output function */ 120 #define OUTPUT_FUNC_DECL(x) \ 121 void x(const int d, const struct memdiskinfo * const m) 122 typedef OUTPUT_FUNC_DECL((*output_func)); 123 124 /* Show MEMDISK information for the passed structure */ 125 static OUTPUT_FUNC_DECL(normal_output) 126 { 127 if (m == NULL) 128 return; 129 printf("Drive %02X is MEMDISK %u.%02u:\n" 130 "\tAddress = 0x%08lx, len = %lu sectors, chs = %u/%u/%u,\n" 131 "\tloader = 0x%02x (%s),\n" 132 "\tcmdline = %Fs\n", 133 d, m->mdi.version_major, m->mdi.version_minor, 134 m->mdi.diskbuf, m->mdi.disksize, m->cylinders, m->heads, m->sectors, 135 m->mdi.bootloaderid, bootloadername(m->mdi.bootloaderid), 136 MK_FP(m->mdi.cmdline.seg_off.segment, 137 m->mdi.cmdline.seg_off.offset)); 138 } 139 140 /* Yield DOS SET command(s) as output for each MEMDISK kernel argument */ 141 static OUTPUT_FUNC_DECL(batch_output) 142 { 143 if (m != NULL) { 144 char buf[256], *bc; 145 const char far *c = 146 MK_FP(m->mdi.cmdline.seg_off.segment, 147 m->mdi.cmdline.seg_off.offset); 148 const char *have_equals, is_set[] = "=1"; 149 150 while (*c != '\0') { 151 /* Skip whitespace */ 152 while (isspace(*c)) 153 c++; 154 if (*c == '\0') 155 /* Trailing whitespace. That's enough processing */ 156 break; 157 /* Walk the kernel arguments while filling the buffer, 158 * looking for space or NUL or checking for a full buffer 159 */ 160 bc = buf; 161 have_equals = is_set; 162 while ((*c != '\0') && !isspace(*c) && 163 (bc < &buf[sizeof(buf) - 1])) { 164 /* Check if the param is "x=y" */ 165 if (*c == '=') 166 /* "=1" not needed */ 167 have_equals = &is_set[sizeof(is_set) - 1]; 168 *bc = *c; 169 c++; 170 bc++; 171 } 172 /* Found the end of the parameter and optional value sequence */ 173 *bc = '\0'; 174 printf("set %s%s\n", buf, have_equals); 175 } 176 } 177 } 178 179 /* We do not output batch file output by default. We show MEMDISK info */ 180 static output_func show_memdisk = normal_output; 181 182 /* A generic function type */ 183 #define MDISKCHK_FUNC_DECL(x) \ 184 void x(void) 185 typedef MDISKCHK_FUNC_DECL((*mdiskchk_func)); 186 187 static MDISKCHK_FUNC_DECL(do_nothing) 188 { 189 return; 190 } 191 192 static MDISKCHK_FUNC_DECL(show_usage) 193 { 194 printf("\nUsage: mdiskchk [--safe-hooks] [--mbfts] [--batch-output]\n" 195 "\n" 196 "Action: --safe-hooks . . Will scan INT 13h \"safe hook\" chain\n" 197 " --mbfts . . . . Will scan memory for MEMDISK mBFTs\n" 198 " --batch-output . Will output SET command output based\n" 199 " on MEMDISK kernel arguments\n" 200 " --no-sequential Suppresses probing all drive numbers\n"); 201 } 202 203 /* Search memory for mBFTs and report them via the output method */ 204 static MDISKCHK_FUNC_DECL(show_mbfts) 205 { 206 const uint16_t far * const free_base_mem = 207 MK_FP(0x0040, 0x0013); 208 int seg; 209 uint8_t chksum; 210 uint32_t i; 211 const struct mBFT far *mbft; 212 struct memdiskinfo m; 213 struct patch_area far *patch_area; 214 215 for (seg = *free_base_mem / 16; seg < 0x9FFF; seg++) { 216 mbft = MK_FP(seg, 0); 217 /* Check for signature */ 218 if (mbft->acpi.signature[0] != 'm' || 219 mbft->acpi.signature[1] != 'B' || 220 mbft->acpi.signature[2] != 'F' || 221 mbft->acpi.signature[3] != 'T') 222 continue; 223 if (mbft->acpi.length != sizeof(struct mBFT)) 224 continue; 225 /* Check sum */ 226 chksum = 0; 227 for (i = 0; i < sizeof(struct mBFT); i++) 228 chksum += ((const uint8_t far *)mbft)[i]; 229 if (chksum) 230 continue; 231 /* Copy the MDI from the mBFT */ 232 _fmemcpy((void far *)&m, &mbft->mdi, sizeof(struct mdi)); 233 /* Adjust C/H/S since we actually know 234 * it directly for any MEMDISK with an mBFT 235 */ 236 patch_area = (struct patch_area far *)&mbft->mdi; 237 m.cylinders = patch_area->cylinders; 238 m.heads = patch_area->heads; 239 m.sectors = patch_area->sectors; 240 show_memdisk(patch_area->driveno, &m); 241 } 242 } 243 244 /* Walk the "safe hook" chain as far as possible 245 * and report MEMDISKs that we find via the output method 246 */ 247 static MDISKCHK_FUNC_DECL(show_safe_hooks) 248 { 249 const real_addr_t far * const int13 = 250 MK_FP(0x0000, 0x0013 * sizeof(real_addr_t)); 251 const struct safe_hook far *hook = 252 MK_FP(int13->seg_off.segment, int13->seg_off.offset); 253 254 while ((hook->signature[0] == '$') && 255 (hook->signature[1] == 'I') && 256 (hook->signature[2] == 'N') && 257 (hook->signature[3] == 'T') && 258 (hook->signature[4] == '1') && 259 (hook->signature[5] == '3') && 260 (hook->signature[6] == 'S') && 261 (hook->signature[7] == 'F')) { 262 /* Found a valid "safe hook" */ 263 if ((hook->vendor[0] == 'M') && 264 (hook->vendor[1] == 'E') && 265 (hook->vendor[2] == 'M') && 266 (hook->vendor[3] == 'D') && 267 (hook->vendor[4] == 'I') && 268 (hook->vendor[5] == 'S') && 269 (hook->vendor[6] == 'K')) { 270 /* Found a valid MEMDISK "safe hook". It will have an mBFT */ 271 const struct mBFT far *mbft; 272 struct memdiskinfo m; 273 struct patch_area far *patch_area; 274 275 /* Copy the MDI from the mBFT. Offset is a misnomer here */ 276 mbft = MK_FP(hook->mbft >> 4, 0); /* Always aligned */ 277 _fmemcpy((void far *)&m, &mbft->mdi, sizeof(struct mdi)); 278 /* Adjust C/H/S since we actually know 279 * it directly for any MEMDISK with an mBFT 280 */ 281 patch_area = (struct patch_area far *)&mbft->mdi; 282 m.cylinders = patch_area->cylinders; 283 m.heads = patch_area->heads; 284 m.sectors = patch_area->sectors; 285 show_memdisk(patch_area->driveno, &m); 286 } /* if */ 287 /* Step to the next hook in the "safe hook" chain */ 288 hook = MK_FP(hook->old_hook.seg_off.segment, 289 hook->old_hook.seg_off.offset); 290 } /* while */ 291 } 292 293 int main(int argc, char *argv[]) 294 { 295 int d; 296 int found = 0; 297 int sequential_scan = 1; /* Classic behaviour */ 298 const struct memdiskinfo *m; 299 300 /* Default behaviour */ 301 mdiskchk_func usage = do_nothing, 302 safe_hooks = do_nothing, 303 mbfts = do_nothing; 304 305 /* For each argument */ 306 while (--argc) { 307 /* Argument should begin with one of these chars */ 308 if ((*argv[argc] != '/') && (*argv[argc] != '-')) { 309 /* It doesn't. Print usage soon */ 310 usage = show_usage; 311 break; 312 } 313 argv[argc]++; 314 315 /* Next char might be '-' as in "--safe-hooks" */ 316 if (*argv[argc] == '-') 317 argv[argc]++; 318 319 switch (*argv[argc]) { 320 case 'S': 321 case 's': 322 safe_hooks = show_safe_hooks; 323 break; 324 case 'M': 325 case 'm': 326 mbfts = show_mbfts; 327 break; 328 case 'B': 329 case 'b': 330 show_memdisk = batch_output; 331 break; 332 case 'N': 333 case 'n': 334 sequential_scan = 0; 335 break; 336 default: 337 usage = show_usage; 338 } /* switch */ 339 } /* while */ 340 341 safe_hooks(); 342 mbfts(); 343 if (!sequential_scan) 344 goto skip_sequential; 345 for (d = 0; d <= 0xff; d++) { 346 m = query_memdisk(d); 347 if (m != NULL) { 348 found++; 349 show_memdisk(d, m); 350 } 351 } 352 skip_sequential: 353 usage(); 354 355 return found; 356 } 357 358
