Changeset 114


Ignore:
Timestamp:
Mar 26, 2010, 12:57:34 PM (4 years ago)
Author:
stepan
Message:

grub interface update

  • add support for "default" (aka grubonce) support through cmos
  • add dumpmem command
  • add isolinux parser

Signed-off-by: Stefan Reinauer <stepan@…>

Location:
trunk/filo
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/filo/Config.in

    r105 r114  
    7979        help 
    8080          Time in second before booting AUTOBOOT_FILE 
     81 
     82config ISOLINUX_PARSER 
     83        bool "Support for parsing isolinux.cfg config files" 
     84        default n 
     85        depends on USE_GRUB 
     86        help 
     87          If you enable this function, FILO will be able to parse isolinux.cfg 
     88          config files in addition to filo.lst/menu.lst files. 
    8189 
    8290endmenu 
  • trunk/filo/include/grub/shared.h

    r83 r114  
    133133} grub_error_t; 
    134134 
    135 extern int saved_entryno; 
    136135extern char config_file[]; 
    137136 
  • trunk/filo/main/grub/builtins.c

    r103 r114  
    33 * 
    44 *  Copyright (C) 1999,2000,2001,2002,2004  Free Software Foundation, Inc. 
    5  *  Copyright (C) 2005-2008 coresystems GmbH 
     5 *  Copyright (C) 2005-2010 coresystems GmbH 
    66 * 
    77 * This program is free software; you can redistribute it and/or modify 
     
    2121#include <libpayload-config.h> 
    2222#include <libpayload.h> 
     23#include <getopt.h> 
     24 
    2325#include <config.h> 
    2426#include <fs.h> 
     
    4648unsigned long install_partition = 0x20000; 
    4749unsigned long boot_drive = 0; 
    48 int saved_entryno = 0; 
    4950char config_file[128] = "\0"; 
    5051 
     
    337338static int default_func(char *arg, int flags) 
    338339{ 
     340        unsigned char buf[1]; 
     341        if (get_option(buf, "boot_default")) 
     342                buf[0] = 0xff; 
     343         
     344        if ((unsigned char)buf[0] != 0xff) { 
     345                printf("Default override by CMOS.\n"); 
     346                return 0; 
     347        } 
     348 
    339349        if (!safe_parse_maxint(&arg, &default_entry)) 
    340350                return 1; 
     
    355365 
    356366#if CONFIG_DEVELOPER_TOOLS 
    357 /* default */ 
     367/* dumpmem */ 
     368static int dumpmem_func(char *arg, int flags) 
     369{ 
     370        int ret = string_to_args("dumpmem", arg); 
     371        unsigned int mem_base, mem_len; 
     372        void *i; 
     373 
     374        if(ret || (string_argc != 3)) { 
     375                errnum = ERR_BAD_ARGUMENT; 
     376                return 1; 
     377        } 
     378 
     379        // FIXME 
     380        if (!safe_parse_maxint(&string_argv[1], &mem_base)) 
     381                return 1; 
     382        if (!safe_parse_maxint(&string_argv[2], &mem_len)) 
     383                return 1; 
     384 
     385        grub_printf("Dumping memory at 0x%08x (0x%x bytes)\n", 
     386                        mem_base, mem_len); 
     387 
     388        for (i=phys_to_virt(mem_base); i<phys_to_virt(mem_base + mem_len); i++) { 
     389                if (((unsigned long)i & 0x0f) == 0) 
     390                        grub_printf("\n%08x:", i); 
     391                unsigned char val = *((unsigned char *)i); 
     392                grub_printf(" %02x", val); 
     393        } 
     394        grub_printf("\n"); 
     395 
     396        return 0; 
     397} 
     398 
     399static struct builtin builtin_dumpmem = { 
     400        "dumpmem", 
     401        dumpmem_func, 
     402        BUILTIN_CMDLINE | BUILTIN_HELP_LIST, 
     403        "dumpmem", 
     404        "Dump memory" 
     405}; 
     406 
     407/* dumppm */ 
    358408static int dumppm_func(char *arg, int flags) 
    359409{ 
     
    652702 
    653703        if (disk == -1) { 
    654                 /* The user did specify a FILO name already */ 
    655                 // grub_printf("No drive.\n"); 
    656                 len = 0;        // just copy the drive name 
     704                int cnt = 0; 
     705                len = 0; 
     706                while ((arg[cnt] != 0) && (arg[cnt+1] != 0)) { 
     707                        if (arg[cnt] == ':' && arg[cnt+1] == '/') { 
     708                                /* The user did specify a FILO name already */ 
     709                                len = cnt; 
     710                                break; 
     711                        } 
     712                        cnt++; 
     713                } 
    657714        } else { 
    658715                if (part == -1) {       // No partition 
     
    896953                        for (i=0; i<lspci_indent; i++) 
    897954                                grub_printf("|  "); 
    898                         grub_printf("|- %x:%x.%x [%x:%x]\n", bus, slot, func, 
     955                        grub_printf("|- %02x:%02x.%x [%04x:%04x]\n", bus, slot, func, 
    899956                                        val & 0xffff, val >> 16); 
    900957 
     
    17051762        &builtin_default, 
    17061763#ifdef CONFIG_DEVELOPER_TOOLS 
     1764        &builtin_dumpmem, 
    17071765        &builtin_dumppm, 
    17081766#endif 
  • trunk/filo/main/grub/grub.c

    r83 r114  
    3333char DEFAULT_FILE_BUF[DEFAULT_FILE_BUFLEN]; /* THe buffer for the filename of "/boot/grub/default".  */ 
    3434char CMDLINE_BUF[CMDLINE_BUFLEN]; /* The buffer for the command-line.  */ 
     35#ifdef CONFIG_ISOLINUX_PARSER 
     36char CMDLINE_TMP[CMDLINE_BUFLEN]; /* The buffer for the command-line.  */ 
     37#endif 
    3538char HISTORY_BUF[HISTORY_BUFLEN]; /* The history buffer for the command-line. */ 
    3639char COMPLETION_BUF[COMPLETION_BUFLEN]; /* The buffer for the completion.  */ 
     
    174177                        if (probe_menulst(bootdevice, "/boot/menu.lst")) 
    175178                                return; 
     179#ifdef CONFIG_ISOLINUX_PARSER 
     180                        if (probe_menulst(bootdevice, "/boot/isolinux/isolinux.cfg")) 
     181                                return; 
     182                        if (probe_menulst(bootdevice, "/isolinux/isolinux.cfg")) 
     183                                return; 
     184#endif 
    176185                } 
    177186        } while (bootdevice); 
     
    872881} 
    873882 
     883#ifdef CONFIG_ISOLINUX_PARSER 
     884static int rewrite_isolinux_config(void) 
     885{ 
     886        /* TODO implement "default" */ 
     887        /* TODO implement "timeout" */ 
     888        if (!memcmp(CMDLINE_BUF, "LABEL ", 6) || 
     889            !memcmp(CMDLINE_BUF, "label ", 6)) { 
     890                strcpy(CMDLINE_TMP, "title "); 
     891                strlcat(CMDLINE_TMP, CMDLINE_BUF + 6, NEW_HEAPSIZE - 6); 
     892                memcpy(CMDLINE_BUF, CMDLINE_TMP, NEW_HEAPSIZE); 
     893        } else 
     894        if (!memcmp(CMDLINE_BUF, "KERNEL ", 7) || 
     895            !memcmp(CMDLINE_BUF, "kernel ", 7)) { 
     896                char *spos; 
     897                int pstart = 7, plen = 0; 
     898                strcpy(CMDLINE_TMP, "kernel "); 
     899 
     900                /* Find path of kernel */ 
     901                if (strstr(CMDLINE_BUF, " /")) { 
     902                        // Our kernel has an absolute path, so 
     903                        // we only grab the device portion of the 
     904                        // config file 
     905                         
     906                        // (hd0,0)/configfile.cfg or hda1:/configfile.cfg 
     907                        spos = strchr(config_file, '/'); 
     908                        if (!spos) { 
     909                                // (hd0,0)configfile.cfg 
     910                                spos = strchr(config_file, ')'); 
     911                                if (spos) spos++; 
     912                        } 
     913                        if (!spos) { 
     914                                // hda1:configfile.cfg 
     915                                spos = strchr(config_file, ':'); 
     916                                if (spos) spos++; 
     917                        } 
     918                } else { 
     919                        spos = strrchr(config_file, '/'); 
     920                        if (spos) spos++; 
     921                } 
     922 
     923                if (spos) { 
     924                        char sback = spos[0]; 
     925                        spos[0]=0; 
     926                        strlcat(CMDLINE_TMP, config_file, NEW_HEAPSIZE); 
     927                        plen = strlen(CMDLINE_TMP) - pstart; // path name len 
     928                        spos[0]=sback; 
     929                } 
     930 
     931                /* copy kernel name */ 
     932                strlcat(CMDLINE_TMP, CMDLINE_BUF + 7, NEW_HEAPSIZE); 
     933 
     934                /* recalculate the new kernel path length, 
     935                 * we're going to need this for initrd 
     936                 */ 
     937                plen = strrchr(CMDLINE_TMP, '/') - (CMDLINE_TMP + 7) + 1; 
     938 
     939                /* read APPEND line */ 
     940                get_line_from_config(CMDLINE_BUF, NEW_HEAPSIZE, 1); 
     941                if (!memcmp(CMDLINE_BUF, "APPEND ", 7) || 
     942                    !memcmp(CMDLINE_BUF, "append ", 7)) { 
     943                        /* append APPEND line */ 
     944                        strlcat(CMDLINE_TMP, " ", NEW_HEAPSIZE); 
     945                        strlcat(CMDLINE_TMP, CMDLINE_BUF + 7, NEW_HEAPSIZE); 
     946                        spos = strstr(CMDLINE_TMP, "initrd=") + 7; 
     947                        if (spos && plen) { 
     948                                strncpy(spos, CMDLINE_TMP + pstart, plen); 
     949                                spos[plen] = 0; 
     950                                spos = strstr(CMDLINE_BUF, "initrd=") + 7; 
     951                                strlcat(CMDLINE_TMP, spos, NEW_HEAPSIZE); 
     952                        } 
     953                } 
     954 
     955                /* copy temp string to real string */ 
     956                memcpy(CMDLINE_BUF, CMDLINE_TMP, NEW_HEAPSIZE); 
     957        } else { 
     958                // printf("skip: %s\n", CMDLINE_BUF); 
     959                return 1; 
     960        } 
     961        return 0; 
     962} 
     963#endif 
     964 
    874965int is_opened = 0, is_preset = 0; 
    875966 
     
    9131004        /* Never return.  */ 
    9141005        for (;;) { 
     1006                char buf[10];   /* This is good enough.  */ 
    9151007                char *default_file = (char *) DEFAULT_FILE_BUF; 
    9161008                int i; 
     
    9211013 
    9221014                /* Get a saved default entry if possible.  */ 
    923                 saved_entryno = 0; 
    9241015                *default_file = 0; 
    9251016 
    926                 strncat(default_file, config_file, DEFAULT_FILE_BUFLEN); 
    927                 for (i = strlen(default_file); i >= 0; i--) 
    928                         if (default_file[i] == '/') { 
    929                                 i++; 
    930                                 break; 
    931                         } 
    932                 default_file[i] = 0; 
    933                 strncat(default_file + i, "default", DEFAULT_FILE_BUFLEN - i); 
    934                 if (file_open(default_file)) { 
    935                         char buf[10];   /* This is good enough.  */ 
    936                         char *p = buf; 
    937                         int len; 
    938  
    939                         len = file_read(buf, sizeof(buf)); 
    940                         if (len > 0) { 
    941                                 buf[sizeof(buf) - 1] = 0; 
    942                                 safe_parse_maxint(&p, &saved_entryno); 
    943                         } 
    944  
    945                         file_close(); 
     1017                /* Look into CMOS first */ 
     1018                if (!get_option(buf, "boot_default")) { 
     1019                        default_entry = ((unsigned char)buf[0] != 0xff) ? 
     1020                                (unsigned char)buf[0] : 0; 
     1021                } else { 
     1022                        strncat(default_file, config_file, DEFAULT_FILE_BUFLEN); 
     1023                        for (i = strlen(default_file); i >= 0; i--) 
     1024                                if (default_file[i] == '/') { 
     1025                                        i++; 
     1026                                        break; 
     1027                                } 
     1028                        default_file[i] = 0; 
     1029                        strncat(default_file + i, "default", DEFAULT_FILE_BUFLEN - i); 
     1030                        if (file_open(default_file)) { 
     1031                                char *p = buf; 
     1032                                int len; 
     1033 
     1034                                len = file_read(buf, sizeof(buf)); 
     1035                                if (len > 0) { 
     1036                                        buf[sizeof(buf) - 1] = 0; 
     1037                                        safe_parse_maxint(&p, &default_entry); 
     1038                                } 
     1039 
     1040                                file_close(); 
     1041                        } 
    9461042                } 
    9471043 
     
    9491045 
    9501046                do { 
     1047#ifdef CONFIG_ISOLINUX_PARSER 
     1048                        int isolinux_cfg = 0; 
     1049#endif 
    9511050                        /* STATE 0:  Before any title command. 
    9521051                           STATE 1:  In a title command. 
     
    9611060                                is_opened = file_open(config_file); 
    9621061                                errnum = ERR_NONE; 
     1062#ifdef CONFIG_ISOLINUX_PARSER 
     1063                                if (strstr(config_file, "isolinux.cfg")) { 
     1064                                        printf("detected isolinux.cfg\n"); 
     1065                                        isolinux_cfg = 1; 
     1066                                } 
     1067#endif 
    9631068                        } 
    9641069 
     
    9761081                        while (get_line_from_config(cmdline, NEW_HEAPSIZE, !is_preset)) { 
    9771082                                struct builtin *builtin; 
     1083#ifdef CONFIG_ISOLINUX_PARSER 
     1084                                if (isolinux_cfg) { 
     1085                                        if (rewrite_isolinux_config()) 
     1086                                                continue; 
     1087                                } 
     1088#endif 
    9781089 
    9791090                                /* Get the pointer to the builtin structure.  */ 
Note: See TracChangeset for help on using the changeset viewer.