com32/gfxboot/gfxboot.c

   1 /*
   2  *
   3  * gfxboot.c
   4  *
   5  * A com32 module to load gfxboot graphics.
   6  *
   7  * Copyright (c) 2009 Steffen Winterfeldt.
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License as published by the
  11  * Free Software Foundation, Inc., 53 Temple Place Ste 330, Boston MA
  12  * 02111-1307, USA; either version 2 of the License, or (at your option) any
  13  * later version; incorporated herein by reference.
  14  *
  15  */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20 #include <string.h>
  21 #include <fcntl.h>
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <minmax.h>
  25
  26 #include <syslinux/loadfile.h>
  27 #include <syslinux/config.h>
  28 #include <syslinux/linux.h>
  29 #include <syslinux/boot.h>
  30 #include <console.h>
  31 #include <com32.h>
  32
  33
  34 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  35 #define MAX_CONFIG_LINE_LEN     2048
  36 #define MAX_CMDLINE_LEN         2048
  37
  38 // buffer for realmode callback
  39 // must be at least block size; can in theory be larger than 4k, but there's
  40 // not enough space left
  41 #define REALMODE_BUF_SIZE       4096
  42
  43 // gfxboot working memory in MB
  44 #define GFX_MEMORY_SIZE         7
  45
  46 // read chunk size for progress bar
  47 #define CHUNK_SIZE      (64 << 10)
  48
  49 // callback function numbers
  50 #define GFX_CB_INIT             0
  51 #define GFX_CB_DONE             1
  52 #define GFX_CB_INPUT            2
  53 #define GFX_CB_MENU_INIT        3
  54 #define GFX_CB_INFOBOX_INIT     4
  55 #define GFX_CB_INFOBOX_DONE     5
  56 #define GFX_CB_PROGRESS_INIT    6
  57 #define GFX_CB_PROGRESS_DONE    7
  58 #define GFX_CB_PROGRESS_UPDATE  8
  59 #define GFX_CB_PROGRESS_LIMIT   9               // unused
  60 #define GFX_CB_PASSWORD_INIT    10
  61 #define GFX_CB_PASSWORD_DONE    11
  62
  63 // real mode code chunk, will be placed into bounce buffer
  64 extern void realmode_callback_start, realmode_callback_end;
  65
  66 // gets in the way
  67 #undef linux
  68
  69
  70 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  71 // gfxboot config data (64 bytes)
  72 typedef struct __attribute__ ((packed)) {
  73   uint8_t bootloader;           //  0: boot loader type (0: lilo, 1: syslinux, 2: grub)
  74   uint8_t sector_shift;         //  1: sector shift
  75   uint8_t media_type;           //  2: media type (0: disk, 1: floppy, 2: cdrom)
  76   uint8_t failsafe;             //  3: turn on failsafe mode (bitmask)
  77                                 //    0: SHIFT pressed
  78                                 //    1: skip gfxboot
  79                                 //    2: skip monitor detection
  80   uint8_t sysconfig_size;       //  4: size of sysconfig data
  81   uint8_t boot_drive;           //  5: BIOS boot drive
  82   uint16_t callback;            //  6: offset to callback handler
  83   uint16_t bootloader_seg;      //  8: code/data segment used by bootloader; must follow gfx_callback
  84   uint16_t serial_port;         // 10: syslinux initialized serial port from 'serial' option
  85   uint32_t user_info_0;         // 12: data for info box
  86   uint32_t user_info_1;         // 16: data for info box
  87   uint32_t bios_mem_size;       // 20: BIOS memory size (in bytes)
  88   uint16_t xmem_0;              // 24: extended mem area 0 (start:size in MB; 12:4 bits) - obsolete
  89   uint16_t xmem_1;              // 26: extended mem area 1 - obsolete
  90   uint16_t xmem_2;              // 28: extended mem area 2 - obsolete
  91   uint16_t xmem_3;              // 30: extended mem area 3 - obsolete
  92   uint32_t file;                // 32: start of gfx file
  93   uint32_t archive_start;       // 36: start of cpio archive
  94   uint32_t archive_end;         // 40: end of cpio archive
  95   uint32_t mem0_start;          // 44: low free memory start
  96   uint32_t mem0_end;            // 48: low free memory end
  97   uint32_t xmem_start;          // 52: extended mem start
  98   uint32_t xmem_end;            // 56: extended mem end
  99   uint16_t features;            // 60: feature flags returned by GFX_CB_INIT
 100                                 //    0: GFX_CB_MENU_INIT accepts 32 bit addresses
 101                                 //    1: knows about xmem_start, xmem_end
 102   uint16_t reserved_1;          // 62:
 103 } gfx_config_t;
 104
 105
 106 // gfxboot menu description (18 bytes)
 107 typedef struct __attribute__ ((packed)) {
 108   uint16_t entries;
 109   char *default_entry;
 110   char *label_list;
 111   uint16_t label_size;
 112   char *arg_list;
 113   uint16_t arg_size;
 114 } gfx_menu_t;
 115
 116
 117 // menu description
 118 typedef struct menu_s {
 119   struct menu_s *next;
 120   char *label;          // config entry name
 121   char *menu_label;     // text to show in boot menu
 122   char *kernel;         // name of program to load
 123   char *alt_kernel;     // alternative name in case user has replaced it
 124   char *linux;          // de facto an alias for 'kernel'
 125   char *localboot;      // boot from local disk
 126   char *initrd;         // initrd as separate line (instead of as part of 'append')
 127   char *append;         // kernel args
 128   char *ipappend;       // append special pxelinux args (see doc)
 129 } menu_t;
 130
 131
 132 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 133 gfx_config_t gfx_config;
 134 gfx_menu_t gfx_menu;
 135
 136 menu_t *menu;
 137 menu_t *menu_default;
 138 static menu_t *menu_ptr, **menu_next;
 139
 140 struct {
 141   uint32_t jmp_table[12];
 142   uint16_t code_seg;
 143   char fname_buf[64];
 144 } gfx;
 145
 146 void *lowmem_buf;
 147 unsigned lowmem_buf_size;
 148
 149 int timeout;
 150
 151 char cmdline[MAX_CMDLINE_LEN];
 152
 153 void *save_buf;
 154 unsigned save_buf_size;
 155
 156 // progress bar is visible
 157 unsigned progress_active;
 158
 159
 160 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 161 void show_message(char *file);
 162 char *get_config_file_name(void);
 163 char *skip_spaces(char *s);
 164 char *skip_nonspaces(char *s);
 165 void chop_line(char *s);
 166 int read_config_file(const char *filename);
 167 unsigned magic_ok(unsigned char *buf, unsigned *code_size);
 168 unsigned find_file(unsigned char *buf, unsigned len, unsigned *gfx_file_start, unsigned *file_len, unsigned *code_size);
 169 int gfx_init(char *file);
 170 int gfx_menu_init(void);
 171 void gfx_done(void);
 172 int gfx_input(void);
 173 void gfx_infobox(int type, char *str1, char *str2);
 174 void gfx_progress_init(ssize_t kernel_size, char *label);
 175 void gfx_progress_update(ssize_t size);
 176 void gfx_progress_done(void);
 177 ssize_t save_read(int fd, void *buf, size_t size);
 178 void *load_one(char *file, ssize_t *file_size);
 179 void boot(int index);
 180 void boot_entry(menu_t *menu_ptr, char *arg);
 181
 182
 183 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 184 int main(int argc, char **argv)
 185 {
 186   int menu_index;
 187   const union syslinux_derivative_info *sdi;
 188
 189   openconsole(&dev_stdcon_r, &dev_stdcon_w);
 190
 191   lowmem_buf = __com32.cs_bounce;
 192   lowmem_buf_size = __com32.cs_bounce_size;
 193
 194   sdi = syslinux_derivative_info();
 195
 196   gfx_config.sector_shift = sdi->disk.sector_shift;
 197   gfx_config.boot_drive = sdi->disk.drive_number;
 198
 199   if(sdi->c.filesystem == SYSLINUX_FS_PXELINUX) {
 200     gfx_config.sector_shift = 11;
 201     gfx_config.boot_drive = 0;
 202   }
 203
 204   gfx_config.media_type = gfx_config.boot_drive < 0x80 ? 1 : 0;
 205
 206   if(sdi->c.filesystem == SYSLINUX_FS_ISOLINUX) {
 207     gfx_config.media_type = sdi->iso.cd_mode ? 0 : 2;
 208   }
 209
 210   gfx_config.bootloader = 1;
 211   gfx_config.sysconfig_size = sizeof gfx_config;
 212   gfx_config.bootloader_seg = 0;        // apparently not needed
 213
 214   save_buf_size = lowmem_buf_size;
 215   save_buf = malloc(save_buf_size);
 216
 217   if(argc < 2) {
 218     printf("Usage: gfxboot.c32 bootlogo_file [message_file]\n");
 219     if(argc > 2) show_message(argv[2]);
 220
 221     return 0;
 222   }
 223
 224   if(read_config_file("~")) {
 225     printf("Error reading config file\n");
 226     if(argc > 2) show_message(argv[2]);
 227
 228     return 0;
 229   }
 230
 231   if(gfx_init(argv[1])) {
 232     printf("Error setting up gfxboot\n");
 233     if(argc > 2) show_message(argv[2]);
 234
 235     return 0;
 236   }
 237
 238   gfx_menu_init();
 239
 240   for(;;) {
 241     menu_index = gfx_input();
 242
 243     // abort gfx, return to text mode prompt
 244     if(menu_index == -1) {
 245       gfx_done();
 246       break;
 247     }
 248
 249     // does not return if it succeeds
 250     boot(menu_index);
 251   }
 252
 253   if(argc > 2) show_message(argv[2]);
 254
 255   return 0;
 256 }
 257
 258
 259 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 260 void show_message(char *file)
 261 {
 262   int c;
 263   FILE *f;
 264
 265   if(!(f = fopen(file, "r"))) return;
 266
 267   while((c = getc(f)) != EOF) {
 268     if(c < ' ' && c != '\n' && c != '\t') continue;
 269     printf("%c", c);
 270   }
 271
 272   fclose(f);
 273 }
 274
 275
 276 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 277 char *skip_spaces(char *s)
 278 {
 279   while(*s && (*s == ' ' || *s == '\t')) s++;
 280
 281   return s;
 282 }
 283
 284
 285 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 286 char *skip_nonspaces(char *s)
 287 {
 288   while(*s && *s != ' ' && *s != '\t') s++;
 289
 290   return s;
 291 }
 292
 293
 294 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 295 void chop_line(char *s)
 296 {
 297   int i = strlen(s);
 298
 299   if(!i) return;
 300
 301   while(--i >= 0) {
 302     if(s[i] == ' ' || s[i] == '\t' || s[i] == '\n') {
 303       s[i] = 0;
 304     }
 305     else {
 306       break;
 307     }
 308   }
 309 }
 310
 311
 312 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 313 // Read and parse syslinux config file.
 314 //
 315 // return:
 316 //   0: ok, 1: error
 317 //
 318 int read_config_file(const char *filename)
 319 {
 320   FILE *f;
 321   char *s, *t, buf[MAX_CONFIG_LINE_LEN];
 322   unsigned u, top_level = 0;
 323
 324   if(!strcmp(filename, "~")) {
 325     top_level = 1;
 326     filename = syslinux_config_file();
 327     gfx_menu.entries = 0;
 328     gfx_menu.label_size = 0;
 329     gfx_menu.arg_size = 0;
 330     menu_ptr = NULL;
 331     menu_next = &menu;
 332     menu_default = calloc(1, sizeof *menu_default);
 333   }
 334
 335   if(!(f = fopen(filename, "r"))) return 1;
 336
 337   while((s = fgets(buf, sizeof buf, f))) {
 338     chop_line(s);
 339     s = skip_spaces(s);
 340     if(!*s || *s == '#') continue;
 341     t = skip_nonspaces(s);
 342     if(*t) *t++ = 0;
 343     t = skip_spaces(t);
 344
 345     if(!strcasecmp(s, "timeout")) {
 346       timeout = atoi(t);
 347       continue;
 348     }
 349
 350     if(!strcasecmp(s, "default")) {
 351       menu_default->label = strdup(t);
 352       u = strlen(t);
 353       if(u > gfx_menu.label_size) gfx_menu.label_size = u;
 354       continue;
 355     }
 356
 357     if(!strcasecmp(s, "label")) {
 358       menu_ptr = *menu_next = calloc(1, sizeof **menu_next);
 359       menu_next = &menu_ptr->next;
 360       gfx_menu.entries++;
 361       menu_ptr->label = menu_ptr->menu_label = strdup(t);
 362       u = strlen(t);
 363       if(u > gfx_menu.label_size) gfx_menu.label_size = u;
 364       continue;
 365     }
 366
 367     if(!strcasecmp(s, "kernel") && menu_ptr) {
 368       menu_ptr->kernel = strdup(t);
 369       continue;
 370     }
 371
 372     if(!strcasecmp(s, "linux") && menu_ptr) {
 373       menu_ptr->linux = strdup(t);
 374       continue;
 375     }
 376
 377     if(!strcasecmp(s, "localboot") && menu_ptr) {
 378       menu_ptr->localboot = strdup(t);
 379       continue;
 380     }
 381
 382     if(!strcasecmp(s, "initrd") && menu_ptr) {
 383       menu_ptr->initrd = strdup(t);
 384       continue;
 385     }
 386
 387     if(!strcasecmp(s, "append")) {
 388       (menu_ptr ?: menu_default)->append = strdup(t);
 389       u = strlen(t);
 390       if(u > gfx_menu.arg_size) gfx_menu.arg_size = u;
 391       continue;
 392     }
 393
 394     if(!strcasecmp(s, "ipappend")) {
 395       (menu_ptr ?: menu_default)->ipappend = strdup(t);
 396       continue;
 397     }
 398
 399     if(!strcasecmp(s, "menu") && menu_ptr) {
 400       s = skip_spaces(t);
 401       t = skip_nonspaces(s);
 402       if(*t) *t++ = 0;
 403       t = skip_spaces(t);
 404
 405       if(!strcasecmp(s, "label")) {
 406         menu_ptr->menu_label = strdup(t);
 407         u = strlen(t);
 408         if(u > gfx_menu.label_size) gfx_menu.label_size = u;
 409         continue;
 410       }
 411
 412       if(!strcasecmp(s, "include")) {
 413         goto do_include;
 414       }
 415     }
 416
 417     if (!strcasecmp(s, "include")) {
 418 do_include:
 419       s = t;
 420       t = skip_nonspaces(s);
 421       if (*t) *t = 0;
 422       read_config_file(s);
 423     }
 424   }
 425
 426   fclose(f);
 427
 428   if (!top_level)
 429     return 0;
 430
 431   // final '\0'
 432   gfx_menu.label_size++;
 433   gfx_menu.arg_size++;
 434
 435   // ensure we have a default entry
 436   if(!menu_default->label) menu_default->label = menu->label;
 437
 438   if(menu_default->label) {
 439     for(menu_ptr = menu; menu_ptr; menu_ptr = menu_ptr->next) {
 440       if(!strcmp(menu_default->label, menu_ptr->label)) {
 441         menu_default->menu_label = menu_ptr->menu_label;
 442         break;
 443       }
 444     }
 445   }
 446
 447   gfx_menu.default_entry = menu_default->menu_label;
 448   gfx_menu.label_list = calloc(gfx_menu.entries, gfx_menu.label_size);
 449   gfx_menu.arg_list = calloc(gfx_menu.entries, gfx_menu.arg_size);
 450
 451   for(u = 0, menu_ptr = menu; menu_ptr; menu_ptr = menu_ptr->next, u++) {
 452     if(!menu_ptr->append) menu_ptr->append = menu_default->append;
 453     if(!menu_ptr->ipappend) menu_ptr->ipappend = menu_default->ipappend;
 454
 455     if(menu_ptr->menu_label) strcpy(gfx_menu.label_list + u * gfx_menu.label_size, menu_ptr->menu_label);
 456     if(menu_ptr->append) strcpy(gfx_menu.arg_list + u * gfx_menu.arg_size, menu_ptr->append);
 457   }
 458
 459   return 0;
 460 }
 461
 462
 463 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 464 // Check header and return code start offset.
 465 //
 466 unsigned magic_ok(unsigned char *buf, unsigned *code_size)
 467 {
 468   if(
 469     *(unsigned *) buf == 0x0b2d97f00 &&         // magic id
 470     (buf[4] == 8)                               // version 8
 471   ) {
 472     *code_size = *(unsigned *) (buf + 12);
 473     return *(unsigned *) (buf + 8);
 474   }
 475
 476   return 0;
 477 }
 478
 479
 480 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 481 // Search (cpio archive) for gfx file.
 482 //
 483 unsigned find_file(unsigned char *buf, unsigned len, unsigned *gfx_file_start, unsigned *file_len, unsigned *code_size)
 484 {
 485   unsigned i, fname_len, code_start = 0;
 486
 487   *gfx_file_start = 0;
 488   *code_size = 0;
 489
 490   if((code_start = magic_ok(buf, code_size))) return code_start;
 491
 492   for(i = 0; i < len;) {
 493     if((len - i) >= 0x1a && (buf[i] + (buf[i + 1] << 8)) == 0x71c7) {
 494       fname_len = *(unsigned short *) (buf + i + 20);
 495       *file_len = *(unsigned short *) (buf + i + 24) + (*(unsigned short *) (buf + i + 22) << 16);
 496       i += 26 + fname_len;
 497       i = ((i + 1) & ~1);
 498       if((code_start = magic_ok(buf + i, code_size))) {
 499         *gfx_file_start = i;
 500         return code_start;
 501       }
 502       i += *file_len;
 503       i = ((i + 1) & ~1);
 504     }
 505     else {
 506       break;
 507     }
 508   }
 509
 510   return code_start;
 511 }
 512
 513
 514 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 515 // Initialize gfxboot code.
 516 //
 517 // return:
 518 //   0: ok, 1: error
 519 //
 520 int gfx_init(char *file)
 521 {
 522   size_t archive_size = 0;
 523   void *archive;
 524   unsigned code_start, code_size, file_start, file_len, u;
 525   com32sys_t r;
 526   void *lowmem = lowmem_buf;
 527   unsigned lowmem_size = lowmem_buf_size;
 528
 529   progress_active = 0;
 530
 531   printf("Loading %s...\n", file);
 532   if(loadfile(file, &archive, &archive_size)) return 1;
 533
 534   if(!archive_size) return 1;
 535
 536   // printf("%s: %d\n", file, archive_size);
 537
 538   gfx_config.archive_start = (uint32_t) archive;
 539   gfx_config.archive_end = gfx_config.archive_start + archive_size;
 540
 541   // locate file inside cpio archive
 542   if(!(code_start = find_file(archive, archive_size, &file_start, &file_len, &code_size))) {
 543     printf("%s: invalid file format\n", file);
 544     return 1;
 545   }
 546
 547 #if 0
 548   printf(
 549     "code_start = 0x%x, code_size = 0x%x\n"
 550     "archive_start = 0x%x, archive size = 0x%x\n"
 551     "file_start = 0x%x, file_len = 0x%x\n",
 552     code_start, code_size,
 553     gfx_config.archive_start, archive_size,
 554     file_start, file_len
 555   );
 556 #endif
 557
 558   gfx_config.file = gfx_config.archive_start + file_start;
 559
 560   u = &realmode_callback_end - &realmode_callback_start;
 561   u = (u + REALMODE_BUF_SIZE + 0xf) & ~0xf;
 562
 563   if(u + code_size > lowmem_size) {
 564     printf("bounce buffer too small: size %u, needed %u\n", lowmem_size, u + code_size);
 565     return 1;
 566   }
 567
 568   memcpy(lowmem + REALMODE_BUF_SIZE, &realmode_callback_start, &realmode_callback_end - &realmode_callback_start);
 569
 570   // fill in buffer size and location
 571   *(uint16_t *) (lowmem + REALMODE_BUF_SIZE) = REALMODE_BUF_SIZE;
 572   *(uint16_t *) (lowmem + REALMODE_BUF_SIZE + 2) = (uint32_t) lowmem >> 4;
 573
 574   gfx_config.bootloader_seg = ((uint32_t) lowmem + REALMODE_BUF_SIZE) >> 4;
 575   gfx_config.callback = 4;      // start address
 576
 577   lowmem += u;
 578   lowmem_size -= u;
 579
 580   memcpy(lowmem, archive + file_start + code_start, code_size);
 581
 582   gfx_config.mem0_start = (uint32_t) lowmem + code_size;
 583   gfx_config.mem0_end = (uint32_t) lowmem + lowmem_size;
 584   // align a bit
 585   gfx_config.mem0_start = (gfx_config.mem0_start + 0xf) & ~0xf;
 586
 587   gfx_config.xmem_start = (uint32_t) malloc(GFX_MEMORY_SIZE << 20);
 588   if(gfx_config.xmem_start) {
 589     gfx_config.xmem_end = gfx_config.xmem_start + (GFX_MEMORY_SIZE << 20);
 590   }
 591
 592   // fake; not used anyway
 593   gfx_config.bios_mem_size = 256 << 20;
 594
 595   gfx.code_seg = (uint32_t) lowmem >> 4;
 596
 597   for(u = 0; u < sizeof gfx.jmp_table / sizeof *gfx.jmp_table; u++) {
 598     gfx.jmp_table[u] = (gfx.code_seg << 16) + *(uint16_t *) (lowmem + 2 * u);
 599   }
 600
 601 #if 0
 602   for(u = 0; u < sizeof gfx.jmp_table / sizeof *gfx.jmp_table; u++) {
 603     printf("%d: 0x%08x\n", u, gfx.jmp_table[u]);
 604   }
 605 #endif
 606
 607   // we are ready to start
 608
 609   r.esi.l = (uint32_t) &gfx_config;
 610   __farcall(gfx.code_seg, gfx.jmp_table[GFX_CB_INIT], &r, &r);
 611
 612   if((r.eflags.l & EFLAGS_CF)) {
 613     printf("graphics initialization failed\n");
 614
 615     return 1;
 616   }
 617
 618   if((gfx_config.features & 3) != 3) {
 619     gfx_done();
 620
 621     printf("%s: boot graphics code too old, please use newer version\n", file);
 622
 623     return 1;
 624   }
 625
 626
 627   return 0;
 628 }
 629
 630
 631 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 632 int gfx_menu_init(void)
 633 {
 634   com32sys_t r;
 635
 636   r.esi.l = (uint32_t) &gfx_menu;
 637   __farcall(gfx.code_seg, gfx.jmp_table[GFX_CB_MENU_INIT], &r, &r);
 638
 639   return 0;
 640 }
 641
 642
 643 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 644 void gfx_done(void)
 645 {
 646   com32sys_t r;
 647
 648   gfx_progress_done();
 649
 650   __farcall(gfx.code_seg, gfx.jmp_table[GFX_CB_DONE], &r, &r);
 651 }
 652
 653
 654 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 655 // Run gfxboot main loop.
 656 //
 657 // return:
 658 //   boot menu index (-1: go to text mode prompt)
 659 //
 660 int gfx_input(void)
 661 {
 662   com32sys_t r;
 663
 664   r.edi.l = (uint32_t) cmdline;
 665   r.ecx.l = sizeof cmdline;
 666   r.eax.l = timeout * 182 / 100;
 667   timeout = 0;          // use timeout only first time
 668   __farcall(gfx.code_seg, gfx.jmp_table[GFX_CB_INPUT], &r, &r);
 669   if((r.eflags.l & EFLAGS_CF)) r.eax.l = 1;
 670
 671   if(r.eax.l == 1) return -1;
 672
 673   return r.ebx.l;
 674 }
 675
 676
 677 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 678 void gfx_infobox(int type, char *str1, char *str2)
 679 {
 680   com32sys_t r;
 681
 682   r.eax.l = type;
 683   r.esi.l = (uint32_t) str1;
 684   r.edi.l = (uint32_t) str2;
 685   __farcall(gfx.code_seg, gfx.jmp_table[GFX_CB_INFOBOX_INIT], &r, &r);
 686   r.edi.l = r.eax.l = 0;
 687   __farcall(gfx.code_seg, gfx.jmp_table[GFX_CB_INPUT], &r, &r);
 688   __farcall(gfx.code_seg, gfx.jmp_table[GFX_CB_INFOBOX_DONE], &r, &r);
 689 }
 690
 691
 692 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 693 void gfx_progress_init(ssize_t kernel_size, char *label)
 694 {
 695   com32sys_t r;
 696
 697   if(!progress_active) {
 698     r.eax.l = kernel_size >> gfx_config.sector_shift;           // in sectors
 699     r.esi.l = (uint32_t) label;
 700     __farcall(gfx.code_seg, gfx.jmp_table[GFX_CB_PROGRESS_INIT], &r, &r);
 701   }
 702
 703   progress_active = 1;
 704 }
 705
 706
 707 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 708 void gfx_progress_update(ssize_t advance)
 709 {
 710   com32sys_t r;
 711
 712   if(progress_active) {
 713     r.eax.l = advance >> gfx_config.sector_shift;               // in sectors
 714     __farcall(gfx.code_seg, gfx.jmp_table[GFX_CB_PROGRESS_UPDATE], &r, &r);
 715   }
 716 }
 717
 718
 719 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 720 void gfx_progress_done(void)
 721 {
 722   com32sys_t r;
 723
 724   if(progress_active) {
 725     __farcall(gfx.code_seg, gfx.jmp_table[GFX_CB_PROGRESS_DONE], &r, &r);
 726   }
 727
 728   progress_active = 0;
 729 }
 730
 731
 732 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 733 // Like read(2) but preserve bounce buffer.
 734 //
 735 ssize_t save_read(int fd, void *buf, size_t size)
 736 {
 737   ssize_t i;
 738
 739   memcpy(save_buf, lowmem_buf, save_buf_size);
 740   i = read(fd, buf, size);
 741   memcpy(lowmem_buf, save_buf, save_buf_size);
 742
 743   return i;
 744 }
 745
 746
 747 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 748 // Read file and update progress bar.
 749 //
 750 void *load_one(char *file, ssize_t *file_size)
 751 {
 752   int fd;
 753   void *buf = NULL;
 754   char *str;
 755   struct stat sbuf;
 756   ssize_t size = 0, cur, i;
 757
 758   *file_size = 0;
 759
 760   if((fd = open(file, O_RDONLY)) == -1) {
 761     asprintf(&str, "%s: file not found", file);
 762     gfx_infobox(0, str, NULL);
 763     free(str);
 764     return buf;
 765   }
 766
 767   if(!fstat(fd, &sbuf) && S_ISREG(sbuf.st_mode)) size = sbuf.st_size;
 768
 769   i = 0;
 770
 771   if(size) {
 772     buf = malloc(size);
 773     for(i = 1, cur = 0 ; cur < size && i > 0; cur += i) {
 774       i = save_read(fd, buf + cur, min(CHUNK_SIZE, size - cur));
 775       if(i == -1) break;
 776       gfx_progress_update(i);
 777     }
 778   }
 779   else {
 780     do {
 781       buf = realloc(buf, size + CHUNK_SIZE);
 782       i = save_read(fd, buf + size, CHUNK_SIZE);
 783       if(i == -1) break;
 784       size += i;
 785       gfx_progress_update(i);
 786     } while(i > 0);
 787   }
 788
 789   close(fd);
 790
 791   if(i == -1) {
 792     asprintf(&str, "%s: read error @ %d", file, size);
 793     gfx_infobox(0, str, NULL);
 794     free(str);
 795     free(buf);
 796     buf = NULL;
 797     size = 0;
 798   }
 799
 800   *file_size = size;
 801
 802   return buf;
 803 }
 804
 805
 806 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 807 // Boot menu entry.
 808 //
 809 // cmdline can optionally start with label string.
 810 //
 811 void boot(int index)
 812 {
 813   char *arg, *alt_kernel;
 814   menu_t *menu_ptr;
 815   int i, label_len;
 816   unsigned ipapp;
 817   const struct syslinux_ipappend_strings *ipappend;
 818
 819   for(menu_ptr = menu; menu_ptr; menu_ptr = menu_ptr->next, index--) {
 820     if(!index) break;
 821   }
 822
 823   // invalid index or menu entry
 824   if(!menu_ptr || !menu_ptr->menu_label) return;
 825
 826   arg = skip_spaces(cmdline);
 827   label_len = strlen(menu_ptr->menu_label);
 828
 829   // if it does not start with label string, assume first word is kernel name
 830   if(strncmp(arg, menu_ptr->menu_label, label_len)) {
 831     alt_kernel = arg;
 832     arg = skip_nonspaces(arg);
 833     if(*arg) *arg++ = 0;
 834     if(*alt_kernel) menu_ptr->alt_kernel = alt_kernel;
 835   }
 836   else {
 837     arg += label_len;
 838   }
 839
 840   arg = skip_spaces(arg);
 841
 842   // handle IPAPPEND
 843   if(menu_ptr->ipappend && (ipapp = atoi(menu_ptr->ipappend))) {
 844     ipappend = syslinux_ipappend_strings();
 845     for(i = 0; i < ipappend->count; i++) {
 846       if((ipapp & (1 << i)) && ipappend->ptr[i]) {
 847         sprintf(arg + strlen(arg), " %s", ipappend->ptr[i]);
 848       }
 849     }
 850   }
 851
 852   boot_entry(menu_ptr, arg);
 853
 854   gfx_progress_done();
 855 }
 856
 857
 858 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 859 // Load & run kernel.
 860 //
 861 // Returns only on error.
 862 //
 863 void boot_entry(menu_t *menu_ptr, char *arg)
 864 {
 865   void *kernel, *initrd_buf;
 866   ssize_t kernel_size = 0, initrd_size = 0;
 867   struct initramfs *initrd = NULL;
 868   char *file, *cmd_buf;
 869   int fd;
 870   struct stat sbuf;
 871   char *s, *s0, *t, *initrd_arg;
 872
 873   if(!menu_ptr) return;
 874
 875   if(menu_ptr->localboot) {
 876     gfx_done();
 877     syslinux_local_boot(strtol(menu_ptr->localboot, NULL, 0));
 878
 879     return;
 880   }
 881
 882   file = menu_ptr->alt_kernel;
 883   if(!file) file = menu_ptr->kernel;
 884   if(!file) file = menu_ptr->linux;
 885   if(!file) {
 886     gfx_done();
 887     asprintf(&cmd_buf, "%s %s", menu_ptr->label, arg);
 888     syslinux_run_command(cmd_buf);
 889     return;
 890   }
 891
 892   // first, load kernel
 893
 894   kernel_size = 0;
 895
 896   if((fd = open(file, O_RDONLY)) >= 0) {
 897     if(!fstat(fd, &sbuf) && S_ISREG(sbuf.st_mode)) kernel_size = sbuf.st_size;
 898     close(fd);
 899   }
 900
 901   gfx_progress_init(kernel_size, file);
 902
 903   kernel = load_one(file, &kernel_size);
 904
 905   if(!kernel) {
 906     return;
 907   }
 908
 909   if(kernel_size < 1024 || *(uint32_t *) (kernel + 0x202) != 0x53726448) {
 910     // not a linux kernel
 911     gfx_done();
 912     asprintf(&cmd_buf, "%s %s", menu_ptr->label, arg);
 913     syslinux_run_command(cmd_buf);
 914     return;
 915   }
 916
 917   // printf("kernel = %p, size = %d\n", kernel, kernel_size);
 918
 919   // parse cmdline for "initrd" option
 920
 921   initrd_arg = menu_ptr->initrd;
 922
 923   s = s0 = strdup(arg);
 924
 925   while(*s && strncmp(s, "initrd=", sizeof "initrd=" - 1)) {
 926     s = skip_spaces(skip_nonspaces(s));
 927   }
 928
 929   if(*s) {
 930     s += sizeof "initrd=" - 1;
 931     *skip_nonspaces(s) = 0;
 932     initrd_arg = s;
 933   }
 934
 935   if(initrd_arg) {
 936     initrd = initramfs_init();
 937
 938     while((t = strsep(&s, ","))) {
 939       initrd_buf = load_one(t, &initrd_size);
 940
 941       if(!initrd_buf) {
 942         printf("%s: read error\n", t);
 943         free(s0);
 944         return;
 945       }
 946
 947       initramfs_add_data(initrd, initrd_buf, initrd_size, initrd_size, 4);
 948
 949       // printf("initrd = %p, size = %d\n", initrd_buf, initrd_size);
 950     }
 951   }
 952
 953   free(s0);
 954
 955   gfx_done();
 956
 957   syslinux_boot_linux(kernel, kernel_size, initrd, arg);
 958 }
 959
 960