diff --git a/config/grub/message b/config/grub/message index d8dba2927..3e6694a59 100644 Binary files a/config/grub/message and b/config/grub/message differ diff --git a/lfs/grub b/lfs/grub index 50f415133..3b063a606 100644 --- a/lfs/grub +++ b/lfs/grub @@ -32,6 +32,7 @@ include Config +#VER = 0.95 VER = 0.97 THISAPP = grub-$(VER) @@ -81,46 +82,29 @@ $(TARGET) : $(patsubst %,$(DIR_DL)/%,$(objects)) @$(PREBUILD) @rm -rf $(DIR_APP) && cd $(DIR_SRC) && tar zxf $(DIR_DL)/$(DL_FILE) -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.93-configfile.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.90-symlinkmenulst.patch -# cd $(DIR_APP) && patch -Np0 < $(DIR_SRC)/src/patches/grub-0.93-endedit.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.90-append.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.91-bootonce.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.93-graphics.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.91-splashimagehelp.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.93-graphics-bootterm.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.93-special-device-names.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.94-i2o.patch -# cd $(DIR_APP)/netboot && patch -Np0 < $(DIR_SRC)/src/patches/grub-0.93-rtl8139.patch +# Patch SuSE 10.2 + cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/SuSE10.2/grub-0.97-path-patch + cd $(DIR_APP) && patch -Np0 < $(DIR_SRC)/src/patches/SuSE10.2/use_ferror.diff + cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/SuSE10.2/grub-R + cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/SuSE10.2/bad-assert-sideeffect + cd $(DIR_APP) && patch -Np0 < $(DIR_SRC)/src/patches/SuSE10.2/grub-gfxmenu-v8.diff + cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/SuSE10.2/grub-0.97-devicemap.diff + cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/SuSE10.2/grub-linux-setup-fix + cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/SuSE10.2/fix-uninitialized + cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/SuSE10.2/force-LBA-off.diff + cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/SuSE10.2/grub-0.97-initrdaddr.diff + cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/SuSE10.2/grub-0.97-protexec.patch + cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/SuSE10.2/grub-path-cfg.diff - cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.97/grub-0.97-configfile.patch - cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.97/grub-0.97-symlinkmenulst.patch -# cd $(DIR_APP) && patch -Np0 < $(DIR_SRC)/src/patches/grub-0.93-endedit.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.90-append.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.91-bootonce.patch - cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.97/grub-0.97-misc.patch - cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.97/grub-0.97-dirs.patch - -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.93-graphics.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.91-splashimagehelp.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.93-graphics-bootterm.patch - cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.97/grub-0.97-splash.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.97/grub-0.97-wildcards.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.97/grub-0.96-PIC.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.97/grub-0.96-bounced-checks.patch - cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.93-special-device-names.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.97/grub-0.96-i2o-raid.patch - cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.94-i2o.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.97/grub-0.96-nxstack.patch -# cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/grub-0.97/grub-0.96-netboot-pic.patch - cd $(DIR_APP)/netboot && patch -Np0 < $(DIR_SRC)/src/patches/grub-0.93-rtl8139.patch + cd $(DIR_APP) && perl -pi -e 's,/usr/lib/grub/i386-pc,/usr/share/grub/i386-pc,' docs/grub.texi cd $(DIR_APP) && autoreconf --install --force - cd $(DIR_APP) && CFLAGS="-Os -fno-stack-protector" \ - STAGE2_CFLAGS="-Os -fno-stack-protector" \ + cd $(DIR_APP) && CFLAGS="-0s -fno-stack-protector" \ + STAGE2_CFLAGS="-0s -fno-stack-protector" \ ./configure --prefix=/usr --datadir=/usr/share \ - --enable-rtl8139 \ - --enable-ne --enable-ne-scan=0x300 \ + --disable-rtl8139 \ + --disable-auto-linux-mem-opt \ + --disable-ne \ --disable-nls \ --disable-fat \ --disable-ffs \ @@ -129,6 +113,7 @@ $(TARGET) : $(patsubst %,$(DIR_DL)/%,$(objects)) --disable-vstafs \ --disable-jfs \ --disable-xfs + cd $(DIR_APP) && make cd $(DIR_APP) && make install diff --git a/src/patches/SuSE10.2/bad-assert-sideeffect b/src/patches/SuSE10.2/bad-assert-sideeffect new file mode 100644 index 000000000..9afb573b1 --- /dev/null +++ b/src/patches/SuSE10.2/bad-assert-sideeffect @@ -0,0 +1,15 @@ +--- grub-0.95/lib/device.c.orig 2004-05-23 18:34:29.000000000 +0200 ++++ grub-0.95/lib/device.c 2004-09-21 18:15:23.785137837 +0200 +@@ -828,9 +828,11 @@ int + is_disk_device (char **map, int drive) + { + struct stat st; ++ int retval; + + assert (map[drive] != 0); +- assert (stat (map[drive], &st) == 0); ++ retval = stat (map[drive], &st); ++ assert (retval == 0); + /* For now, disk devices under Linux are all block devices. */ + return S_ISBLK (st.st_mode); + } diff --git a/src/patches/SuSE10.2/chainloader-devicefix b/src/patches/SuSE10.2/chainloader-devicefix new file mode 100644 index 000000000..7635e0a43 --- /dev/null +++ b/src/patches/SuSE10.2/chainloader-devicefix @@ -0,0 +1,13 @@ +--- grub-0.97/stage2/builtins.c.orig 2005-02-15 22:58:23.000000000 +0100 ++++ grub-0.97/stage2/builtins.c 2006-04-19 16:26:33.000000000 +0200 +@@ -455,6 +455,10 @@ chainloader_func (char *arg, int flags) + *((unsigned long *) (BOOTSEC_LOCATION + BOOTSEC_BPB_HIDDEN_SECTORS)) + = part_start; + ++ /* if a new device was specified, make sure DX is passed correctly */ ++ if ('(' == *file) ++ set_device(file); ++ + errnum = ERR_NONE; + + return 0; diff --git a/src/patches/SuSE10.2/fix-uninitialized b/src/patches/SuSE10.2/fix-uninitialized new file mode 100644 index 000000000..eff2ebac3 --- /dev/null +++ b/src/patches/SuSE10.2/fix-uninitialized @@ -0,0 +1,11 @@ +--- grub-0.97/netboot/i82586.c.orig 2003-07-09 13:45:37.000000000 +0200 ++++ grub-0.97/netboot/i82586.c 2006-04-20 18:50:20.000000000 +0200 +@@ -735,7 +735,7 @@ static unsigned char exos_i186_init[] = + static int exos205_probe2(void) + { + unsigned short i; +- unsigned short shmem[10]; ++ unsigned short shmem[10] = { 0,0,0,0,0,0,0,0,0,0 }; + + /* Fix the ISCP address and base. */ + init_words[3] = scb_base; diff --git a/src/patches/SuSE10.2/force-LBA-off.diff b/src/patches/SuSE10.2/force-LBA-off.diff new file mode 100644 index 000000000..194bffd5b --- /dev/null +++ b/src/patches/SuSE10.2/force-LBA-off.diff @@ -0,0 +1,143 @@ +diff -ur grub-0.93~/docs/grub.texi grub-0.93/docs/grub.texi +--- grub-0.93~/docs/grub.texi 2003-02-06 12:30:12.000000000 +0100 ++++ grub-0.93/docs/grub.texi 2003-02-06 14:15:30.000000000 +0100 +@@ -2632,7 +2632,7 @@ + @node install + @subsection install + +-@deffn Command install [@option{--force-lba}] [@option{--stage2=os_stage2_file}] stage1_file [@option{d}] dest_dev stage2_file [addr] [@option{p}] [config_file] [real_config_file] ++@deffn Command install [@option{--force-lba[=off]}] [@option{--stage2=os_stage2_file}] stage1_file [@option{d}] dest_dev stage2_file [addr] [@option{p}] [config_file] [real_config_file] + This command is fairly complex, and you should not use this command + unless you are familiar with GRUB. Use @command{setup} (@pxref{setup}) + instead. +@@ -2679,6 +2679,13 @@ + bitmap even if they do have the support. So GRUB provides a solution to + ignore the wrong bitmap, that is, the option @option{--force-lba}. Don't + use this option if you know that your BIOS doesn't have LBA support. ++On the other hand there is at least one known BIOS that does the opposite, ++it claims to support LBA and then fails to provide it. Iff you have an ++Adaptec 2940 with BIOS revision 1.21 ( newer ones just work and older ones ++don't make the false claim ), or otherwise experience grub hanging ++after stage1, you can try to use the option @option{--force-lba=off}, ++as long as all disk blocks involved in booting reside ++within the first 1024 cylinders. + + @strong{Caution3:} You must specify the option @option{--stage2} in the + grub shell, if you cannot unmount the filesystem where your stage2 file +diff -ur grub-0.93~/stage1/stage1.S grub-0.93/stage1/stage1.S +--- grub-0.93~/stage1/stage1.S 2002-09-08 03:58:08.000000000 +0200 ++++ grub-0.93/stage1/stage1.S 2003-02-06 13:19:50.000000000 +0100 +@@ -163,7 +163,11 @@ + /* check if AH=0x42 is supported if FORCE_LBA is zero */ + MOV_MEM_TO_AL(ABS(force_lba)) /* movb ABS(force_lba), %al */ + testb %al, %al ++ /* check if LBA is forced OFF 0x80 <= %al <= 0xff */ ++ js chs_mode ++ /* or forced ON 0x01 <= %al <= 0x7f */ + jnz lba_mode ++ /* otherwise trust BIOS int's result */ + andw $1, %cx + jz chs_mode + +diff -ur grub-0.93~/stage2/asm.S grub-0.93/stage2/asm.S +--- grub-0.93~/stage2/asm.S 2003-02-06 12:30:12.000000000 +0100 ++++ grub-0.93/stage2/asm.S 2003-02-06 13:35:32.000000000 +0100 +@@ -1083,7 +1083,11 @@ + /* check if AH=0x42 is supported if FORCE_LBA is zero */ + movb EXT_C(force_lba), %al + testb %al, %al ++ /* check if LBA is forced OFF 0x80 <= %al <= 0xff */ ++ js 1f ++ /* or forced ON 0x01 <= %al <= 0x7f */ + jnz 2f ++ /* otherwise trust BIOS int's result */ + andw $1, %cx + jnz 2f + +diff -ur grub-0.93~/stage2/builtins.c grub-0.93/stage2/builtins.c +--- grub-0.93~/stage2/builtins.c 2003-02-06 12:30:12.000000000 +0100 ++++ grub-0.93/stage2/builtins.c 2003-02-06 13:56:01.000000000 +0100 +@@ -1832,7 +1832,12 @@ + /* First, check the GNU-style long option. */ + while (1) + { +- if (grub_memcmp ("--force-lba", arg, sizeof ("--force-lba") - 1) == 0) ++ if (grub_memcmp ("--force-lba=off", arg, sizeof ("--force-lba=off") - 1) == 0) ++ { ++ is_force_lba = 0xff; ++ arg = skip_to (0, arg); ++ } ++ else if (grub_memcmp ("--force-lba", arg, sizeof ("--force-lba") - 1) == 0) + { + is_force_lba = 1; + arg = skip_to (0, arg); +@@ -2253,7 +2258,7 @@ + "install", + install_func, + BUILTIN_CMDLINE, +- "install [--stage2=STAGE2_FILE] [--force-lba] STAGE1 [d] DEVICE STAGE2 [ADDR] [p] [CONFIG_FILE] [REAL_CONFIG_FILE]", ++ "install [--stage2=STAGE2_FILE] [--force-lba[=off]] STAGE1 [d] DEVICE STAGE2 [ADDR] [p] [CONFIG_FILE] [REAL_CONFIG_FILE]", + "Install STAGE1 on DEVICE, and install a blocklist for loading STAGE2" + " as a Stage 2. If the option `d' is present, the Stage 1 will always" + " look for the disk where STAGE2 was installed, rather than using" +@@ -2266,8 +2271,9 @@ + " 1.5 and REAL_CONFIG_FILE is present, then the Stage 2 CONFIG_FILE is" + " patched with the configuration filename REAL_CONFIG_FILE." + " If the option `--force-lba' is specified, disable some sanity checks" +- " for LBA mode. If the option `--stage2' is specified, rewrite the Stage" +- " 2 via your OS's filesystem instead of the raw device." ++ " for LBA mode, `--force-lba=off' will disable it completely. If the" ++ " option `--stage2' is specified, rewrite the Stage 2 via your OS's" ++ " filesystem instead of the raw device." + }; + + +@@ -3898,7 +3904,12 @@ + /* Check if the user specifies --force-lba. */ + while (1) + { +- if (grub_memcmp ("--force-lba", arg, sizeof ("--force-lba") - 1) == 0) ++ if (grub_memcmp ("--force-lba=off", arg, sizeof ("--force-lba=off") - 1) == 0) ++ { ++ is_force_lba = 0xff; ++ arg = skip_to (0, arg); ++ } ++ else if (grub_memcmp ("--force-lba", arg, sizeof ("--force-lba") - 1) == 0) + { + is_force_lba = 1; + arg = skip_to (0, arg); +@@ -4026,7 +4037,9 @@ + #if 1 + /* Don't embed a drive number unnecessarily. */ + grub_sprintf (cmd_arg, "%s%s%s%s %s%s %s p %s %s", +- is_force_lba? "--force-lba " : "", ++ is_force_lba ? ++ (is_force_lba == 0xff ? "--force-lba=off " : "--force-lba ") ++ : "", + stage2_arg? stage2_arg : "", + stage2_arg? " " : "", + stage1, +@@ -4079,17 +4092,18 @@ + "setup", + setup_func, + BUILTIN_CMDLINE | BUILTIN_HELP_LIST, +- "setup [--prefix=DIR] [--stage2=STAGE2_FILE] [--force-lba] INSTALL_DEVICE [IMAGE_DEVICE]", ++ "setup [--prefix=DIR] [--stage2=STAGE2_FILE] [--force-lba[=off]] INSTALL_DEVICE [IMAGE_DEVICE]", + "Set up the installation of GRUB automatically. This command uses" + " the more flexible command \"install\" in the backend and installs" + " GRUB into the device INSTALL_DEVICE. If IMAGE_DEVICE is specified," + " then find the GRUB images in the device IMAGE_DEVICE, otherwise" + " use the current \"root device\", which can be set by the command" + " \"root\". If you know that your BIOS should support LBA but GRUB" +- " doesn't work in LBA mode, specify the option `--force-lba'." +- " If you install GRUB under the grub shell and you cannot unmount the" +- " partition where GRUB images reside, specify the option `--stage2'" +- " to tell GRUB the file name under your OS." ++ " doesn't work in LBA mode, specify the option `--force-lba'. If the" ++ " BIOS claims to support LBA mode but really doesn't, use" ++ " `--force-lba=off'. If you install GRUB under the grub shell and" ++ " you cannot unmount the partition where GRUB images reside, specify" ++ " the option `--stage2' to tell GRUB the file name under your OS." + }; + + diff --git a/src/patches/SuSE10.2/gcc4-diff b/src/patches/SuSE10.2/gcc4-diff new file mode 100644 index 000000000..94c00e2b6 --- /dev/null +++ b/src/patches/SuSE10.2/gcc4-diff @@ -0,0 +1,160 @@ +--- grub-0.96/netboot/main.c ++++ grub-0.96/netboot/main.c +@@ -54,9 +54,9 @@ + + static int vendorext_isvalid; + static unsigned long netmask; +-static struct bootpd_t bootp_data; ++struct bootpd_t bootp_data; + static unsigned long xid; +-static unsigned char *end_of_rfc1533 = NULL; ++unsigned char *end_of_rfc1533 = NULL; + + #ifndef NO_DHCP_SUPPORT + #endif /* NO_DHCP_SUPPORT */ +--- grub-0.96/stage2/disk_io.c ++++ grub-0.96/stage2/disk_io.c +@@ -128,7 +128,7 @@ + int filemax; + + static inline unsigned long +-log2 (unsigned long word) ++grub_log2 (unsigned long word) + { + asm volatile ("bsfl %1,%0" + : "=r" (word) +@@ -140,7 +140,7 @@ + rawread (int drive, int sector, int byte_offset, int byte_len, char *buf) + { + int slen, sectors_per_vtrack; +- int sector_size_bits = log2 (buf_geom.sector_size); ++ int sector_size_bits = grub_log2 (buf_geom.sector_size); + + if (byte_len <= 0) + return 1; +@@ -163,7 +163,7 @@ + } + buf_drive = drive; + buf_track = -1; +- sector_size_bits = log2 (buf_geom.sector_size); ++ sector_size_bits = grub_log2 (buf_geom.sector_size); + } + + /* Make sure that SECTOR is valid. */ +--- grub-0.96/stage2/fsys_ext2fs.c ++++ grub-0.96/stage2/fsys_ext2fs.c +@@ -193,7 +193,7 @@ + + + /* ext2/super.c */ +-#define log2(n) ffz(~(n)) ++#define grub_log2(n) ffz(~(n)) + + #define EXT2_SUPER_MAGIC 0xEF53 /* include/linux/ext2_fs.h */ + #define EXT2_ROOT_INO 2 /* include/linux/ext2_fs.h */ +@@ -216,7 +216,7 @@ + + /* linux/ext2_fs.h */ + #define EXT2_ADDR_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) / sizeof (__u32)) +-#define EXT2_ADDR_PER_BLOCK_BITS(s) (log2(EXT2_ADDR_PER_BLOCK(s))) ++#define EXT2_ADDR_PER_BLOCK_BITS(s) (grub_log2(EXT2_ADDR_PER_BLOCK(s))) + + /* linux/ext2_fs.h */ + #define EXT2_BLOCK_SIZE_BITS(s) ((s)->s_log_block_size + 10) +@@ -537,7 +537,7 @@ + + /* look up an inode */ + group_id = (current_ino - 1) / (SUPERBLOCK->s_inodes_per_group); +- group_desc = group_id >> log2 (EXT2_DESC_PER_BLOCK (SUPERBLOCK)); ++ group_desc = group_id >> grub_log2 (EXT2_DESC_PER_BLOCK (SUPERBLOCK)); + desc = group_id & (EXT2_DESC_PER_BLOCK (SUPERBLOCK) - 1); + #ifdef E2DEBUG + printf ("ipg=%d, dpb=%d\n", SUPERBLOCK->s_inodes_per_group, +@@ -553,7 +553,7 @@ + gdp = GROUP_DESC; + ino_blk = gdp[desc].bg_inode_table + + (((current_ino - 1) % (SUPERBLOCK->s_inodes_per_group)) +- >> log2 (EXT2_BLOCK_SIZE (SUPERBLOCK) / sizeof (struct ext2_inode))); ++ >> grub_log2 (EXT2_BLOCK_SIZE (SUPERBLOCK) / sizeof (struct ext2_inode))); + #ifdef E2DEBUG + printf ("inode table fsblock=%d\n", ino_blk); + #endif /* E2DEBUG */ +--- grub-0.96/stage2/fsys_fat.c ++++ grub-0.96/stage2/fsys_fat.c +@@ -55,7 +55,7 @@ + #define FAT_CACHE_SIZE 2048 + + static __inline__ unsigned long +-log2 (unsigned long word) ++grub_log2 (unsigned long word) + { + __asm__ ("bsfl %1,%0" + : "=r" (word) +@@ -84,9 +84,9 @@ + if (bpb.sects_per_clust == 0) + return 0; + +- FAT_SUPER->sectsize_bits = log2 (FAT_CVT_U16 (bpb.bytes_per_sect)); ++ FAT_SUPER->sectsize_bits = grub_log2 (FAT_CVT_U16 (bpb.bytes_per_sect)); + FAT_SUPER->clustsize_bits +- = FAT_SUPER->sectsize_bits + log2 (bpb.sects_per_clust); ++ = FAT_SUPER->sectsize_bits + grub_log2 (bpb.sects_per_clust); + + /* Fill in info about super block */ + FAT_SUPER->num_sectors = FAT_CVT_U16 (bpb.short_sectors) +--- grub-0.96/stage2/fsys_iso9660.c ++++ grub-0.96/stage2/fsys_iso9660.c +@@ -57,7 +57,7 @@ + + + static inline unsigned long +-log2 (unsigned long word) ++grub_log2 (unsigned long word) + { + asm volatile ("bsfl %1,%0" + : "=r" (word) +@@ -68,7 +68,7 @@ + static int + iso9660_devread (int sector, int byte_offset, int byte_len, char *buf) + { +- unsigned short sector_size_lg2 = log2(buf_geom.sector_size); ++ unsigned short sector_size_lg2 = grub_log2(buf_geom.sector_size); + + /* + * We have to use own devread() function since BIOS return wrong geometry +--- grub-0.96/stage2/fsys_reiserfs.c ++++ grub-0.96/stage2/fsys_reiserfs.c +@@ -367,7 +367,7 @@ + + + static __inline__ unsigned long +-log2 (unsigned long word) ++grub_log2 (unsigned long word) + { + __asm__ ("bsfl %1,%0" + : "=r" (word) +@@ -609,7 +609,7 @@ + + INFO->version = super.s_version; + INFO->blocksize = super.s_blocksize; +- INFO->fullblocksize_shift = log2 (super.s_blocksize); ++ INFO->fullblocksize_shift = grub_log2 (super.s_blocksize); + INFO->blocksize_shift = INFO->fullblocksize_shift - SECTOR_BITS; + INFO->cached_slots = + (FSYSREISER_CACHE_SIZE >> INFO->fullblocksize_shift) - 1; +--- grub-0.96/stage2/iso9660.h ++++ grub-0.96/stage2/iso9660.h +@@ -73,11 +73,11 @@ + + typedef struct __iso_16bit { + u_int16_t l, b; +-} iso_16bit_t __attribute__ ((packed)); ++} iso_16bit_t; + + typedef struct __iso_32bit { + u_int32_t l, b; +-} iso_32bit_t __attribute__ ((packed)); ++} iso_32bit_t; + + typedef u_int8_t iso_date_t[7]; + diff --git a/src/patches/SuSE10.2/grub-0.97-devicemap.diff b/src/patches/SuSE10.2/grub-0.97-devicemap.diff new file mode 100644 index 000000000..f2f28195b --- /dev/null +++ b/src/patches/SuSE10.2/grub-0.97-devicemap.diff @@ -0,0 +1,118 @@ +diff -Burbp grub-0.93.orig/grub/main.c grub-0.93/grub/main.c +--- grub-0.93.orig/grub/main.c 2003-06-10 18:29:37.000000000 +0200 ++++ grub-0.93/grub/main.c 2003-06-10 18:30:36.000000000 +0200 +@@ -44,7 +44,7 @@ int use_curses = 0; + int verbose = 0; + int read_only = 0; + int floppy_disks = 1; +-char *device_map_file = 0; ++char *device_map_file = "/boot/grub/device.map"; + static int default_boot_drive; + static int default_install_partition; + static char *default_config_file; +diff -Burbp grub-0.93.orig/lib/device.c grub-0.93/lib/device.c +--- grub-0.93.orig/lib/device.c 2003-06-10 18:29:37.000000000 +0200 ++++ grub-0.93/lib/device.c 2003-06-10 18:30:36.000000000 +0200 +@@ -382,6 +382,7 @@ read_device_map (FILE *fp, char **map, c + probing devices. */ + char buf[1024]; /* XXX */ + int line_number = 0; ++ int retval = 0; /* default to failure */ + + while (fgets (buf, sizeof (buf), fp)) + { +@@ -408,14 +409,14 @@ read_device_map (FILE *fp, char **map, c + if (*ptr != '(') + { + show_error (line_number, "No open parenthesis found"); +- return 0; ++ continue; + } + + ptr++; + if ((*ptr != 'f' && *ptr != 'h') || *(ptr + 1) != 'd') + { + show_error (line_number, "Bad drive name"); +- return 0; ++ continue; + } + + if (*ptr == 'f') +@@ -426,7 +427,7 @@ read_device_map (FILE *fp, char **map, c + if (drive < 0 || drive > 8) + { + show_error (line_number, "Bad device number"); +- return 0; ++ continue; + } + + if (! is_floppy) +@@ -435,7 +436,7 @@ read_device_map (FILE *fp, char **map, c + if (*ptr != ')') + { + show_error (line_number, "No close parenthesis found"); +- return 0; ++ continue; + } + + ptr++; +@@ -446,7 +447,7 @@ read_device_map (FILE *fp, char **map, c + if (! *ptr) + { + show_error (line_number, "No filename found"); +- return 0; ++ continue; + } + + /* Terminate the filename. */ +@@ -464,9 +465,11 @@ read_device_map (FILE *fp, char **map, c + + map[drive] = strdup (ptr); + assert (map[drive]); ++ ++ retval = 1; /* at least 1 drive configured successfully */ + } + +- return 1; ++ return retval; + } + + /* Initialize the device map MAP. *MAP will be allocated from the heap +@@ -671,7 +674,7 @@ write_to_partition (char **map, int driv + int sector, int size, const char *buf) + { + char dev[PATH_MAX]; /* XXX */ +- int fd; ++ int fd, len, pnum; + + if ((partition & 0x00FF00) != 0x00FF00) + { +@@ -689,7 +692,16 @@ write_to_partition (char **map, int driv + if (strcmp (dev + strlen(dev) - 5, "/disc") == 0) + strcpy (dev + strlen(dev) - 5, "/part"); + } +- sprintf (dev + strlen(dev), "%d", ((partition >> 16) & 0xFF) + 1); ++ ++ len = strlen(dev); ++ pnum = ((partition >> 16) & 0xFF); ++ if (isdigit(dev[len-1])) ++ { ++ /* It is obviously some RAID disk: "/dev//c0d0" . "p1" */ ++ sprintf (dev + len, "p%d", pnum + 1); ++ } ++ else ++ sprintf (dev + len, "%d", pnum + 1); + + /* Open the partition. */ + fd = open (dev, O_RDWR); +--- grub-0.94/util/grub-md5-crypt.in.orig 2003-07-09 04:45:51.000000000 -0700 ++++ grub-0.94/util/grub-md5-crypt.in 2004-05-11 09:26:31.943224317 -0700 +@@ -88,7 +88,7 @@ + fi + + # Run the grub shell. +-$grub_shell --batch --device-map=/dev/null <header == LINUX_MAGIC_SIGNATURE && lh->version >= 0x0203 +- ? lh->initrd_addr_max : LINUX_INITRD_MAX_ADDRESS); ++ max_addr = LINUX_INITRD_MAX_ADDRESS; ++ if (lh->header == LINUX_MAGIC_SIGNATURE && ++ lh->version >= 0x0203 && ++ lh->initrd_addr_max < max_addr) ++ max_addr = lh->initrd_addr_max; + if (moveto + len >= max_addr) + moveto = (max_addr - len) & 0xfffff000; + diff --git a/src/patches/SuSE10.2/grub-0.97-path-patch b/src/patches/SuSE10.2/grub-0.97-path-patch new file mode 100644 index 000000000..1547af1c1 --- /dev/null +++ b/src/patches/SuSE10.2/grub-0.97-path-patch @@ -0,0 +1,70 @@ +diff -ur grub-0.93/Makefile.am grub-0.93.new/Makefile.am +--- grub-0.93/Makefile.am 2002-07-01 16:15:36.000000000 +0200 ++++ grub-0.93.new/Makefile.am 2003-02-04 13:03:36.000000000 +0100 +@@ -2,3 +2,4 @@ + AUTOMAKE_OPTIONS = 1.5 + SUBDIRS = netboot stage2 stage1 lib grub util docs + EXTRA_DIST = BUGS MAINTENANCE ++pkgdatadir=$(datadir) +diff -ur grub-0.93/stage1/Makefile.am grub-0.93.new/stage1/Makefile.am +--- grub-0.93/stage1/Makefile.am 2002-09-08 03:58:08.000000000 +0200 ++++ grub-0.93.new/stage1/Makefile.am 2003-02-04 13:03:36.000000000 +0100 +@@ -1,4 +1,4 @@ +-pkglibdir = $(libdir)/$(PACKAGE)/$(host_cpu)-$(host_vendor) ++pkglibdir = /usr/lib/grub + nodist_pkglib_DATA = stage1 + + CLEANFILES = $(nodist_pkglib_DATA) +diff -ur grub-0.93/stage2/Makefile.am grub-0.93.new/stage2/Makefile.am +--- grub-0.93/stage2/Makefile.am 2002-11-29 19:00:53.000000000 +0100 ++++ grub-0.93.new/stage2/Makefile.am 2003-02-04 13:03:36.000000000 +0100 +@@ -26,7 +26,7 @@ + -DSUPPORT_SERIAL=1 -DSUPPORT_HERCULES=1 -fwritable-strings + + # Stage 2 and Stage 1.5's. +-pkglibdir = $(libdir)/$(PACKAGE)/$(host_cpu)-$(host_vendor) ++pkglibdir = /usr/lib/grub + + EXTRA_PROGRAMS = nbloader.exec pxeloader.exec diskless.exec + +diff -ur grub-0.93/util/grub-install.in grub-0.93.new/util/grub-install.in +--- grub-0.93/util/grub-install.in 2002-05-20 13:21:50.000000000 +0200 ++++ grub-0.93.new/util/grub-install.in 2003-02-04 13:03:36.000000000 +0100 +@@ -27,7 +27,7 @@ + host_cpu=@host_cpu@ + host_os=@host_os@ + host_vendor=@host_vendor@ +-pkglibdir=${libdir}/${PACKAGE}/${host_cpu}-${host_vendor} ++pkglibdir=${libdir}/${PACKAGE}/ + + grub_shell=${sbindir}/grub + grub_set_default=${sbindir}/grub-set-default +@@ -378,14 +378,19 @@ + exit 1 + fi + +-# Copy the GRUB images to the GRUB directory. +-for file in ${grubdir}/stage1 ${grubdir}/stage2 ${grubdir}/*stage1_5; do +- rm -f $file || exit 1 +-done +-for file in \ +- ${pkglibdir}/stage1 ${pkglibdir}/stage2 ${pkglibdir}/*stage1_5; do +- cp -f $file ${grubdir} || exit 1 +-done ++# FHS says that /usr/share is used for architecture independent data, ++# so all stage-files are directly installed to /usr/lib/grub. ++# Therefor this part is no longer needed. ++# <--cut_here--> ++## Copy the GRUB images to the GRUB directory. ++#for file in ${grubdir}/stage1 ${grubdir}/stage2 ${grubdir}/*stage1_5; do ++# rm -f $file || exit 1 ++#done ++#for file in \ ++# ${pkglibdir}/stage1 ${pkglibdir}/stage2 ${pkglibdir}/*stage1_5; do ++# cp -f $file ${grubdir} || exit 1 ++#done ++# <--uncut--> + + # Make sure that GRUB reads the same images as the host OS. + test -n "$mkimg" && img_file=`$mkimg` +Only in grub-0.93.new/util: grub-install.in.orig diff --git a/src/patches/SuSE10.2/grub-0.97-protexec.patch b/src/patches/SuSE10.2/grub-0.97-protexec.patch new file mode 100644 index 000000000..430e9ac6b --- /dev/null +++ b/src/patches/SuSE10.2/grub-0.97-protexec.patch @@ -0,0 +1,56 @@ +--- grub-0.96/grub/asmstub.c ++++ grub-0.96/grub/asmstub.c +@@ -43,6 +43,8 @@ + #include + #include + ++#include ++ + #ifdef __linux__ + # include /* ioctl */ + # if !defined(__GLIBC__) || \ +@@ -140,14 +142,30 @@ + } + + assert (grub_scratch_mem == 0); +- scratch = malloc (0x100000 + EXTENDED_MEMSIZE + 15); ++#ifdef MAP_32BIT ++#define MY_MAP_SET MAP_PRIVATE | MAP_GROWSDOWN | MAP_ANONYMOUS | MAP_32BIT ++#else ++#define MY_MAP_SET MAP_PRIVATE | MAP_GROWSDOWN | MAP_ANONYMOUS ++#endif ++ scratch = mmap(NULL, ++ 0x100000 + EXTENDED_MEMSIZE + 15, ++ PROT_EXEC | PROT_READ | PROT_WRITE, ++ MY_MAP_SET, ++ -1, ++ 0); ++ + assert (scratch); + grub_scratch_mem = (char *) ((((int) scratch) >> 4) << 4); + + /* FIXME: simulate the memory holes using mprot, if available. */ + + assert (disks == 0); +- disks = malloc (NUM_DISKS * sizeof (*disks)); ++ disks = mmap(NULL, ++ NUM_DISKS * sizeof (*disks), ++ PROT_EXEC | PROT_READ | PROT_WRITE, ++ MY_MAP_SET, ++ -1, ++ 0); + assert (disks); + /* Initialize DISKS. */ + for (i = 0; i < NUM_DISKS; i++) +@@ -213,9 +231,9 @@ + /* Release memory. */ + restore_device_map (device_map); + device_map = 0; +- free (disks); ++ munmap(disks, NUM_DISKS * sizeof (*disks)); + disks = 0; +- free (scratch); ++ munmap(scratch, 0x100000 + EXTENDED_MEMSIZE + 15); + grub_scratch_mem = 0; + + if (serial_device) diff --git a/src/patches/SuSE10.2/grub-0.97.tar.gz b/src/patches/SuSE10.2/grub-0.97.tar.gz new file mode 100644 index 000000000..2cdf71ba3 Binary files /dev/null and b/src/patches/SuSE10.2/grub-0.97.tar.gz differ diff --git a/src/patches/SuSE10.2/grub-R b/src/patches/SuSE10.2/grub-R new file mode 100644 index 000000000..9924d96f1 --- /dev/null +++ b/src/patches/SuSE10.2/grub-R @@ -0,0 +1,61 @@ +--- grub-0.96/stage2/builtins.c.orig 2004-06-20 15:33:04.000000000 +0200 ++++ grub-0.96/stage2/builtins.c 2005-09-02 14:38:53.000000000 +0200 +@@ -762,11 +762,11 @@ + default_func (char *arg, int flags) + { + #ifndef SUPPORT_DISKLESS +- if (grub_strcmp (arg, "saved") == 0) ++ if (grub_strcmp (arg, "saved") == 0 || (saved_entryno & 0x4000)) + { +- default_entry = saved_entryno; +- return 0; ++ default_entry = saved_entryno & 0x3fff; + } ++ else + #endif /* SUPPORT_DISKLESS */ + + if (! safe_parse_maxint (&arg, &default_entry)) +@@ -787,6 +787,22 @@ + #endif + }; + ++#ifndef SUPPORT_DISKLESS ++static int savedefault_func (char *arg, int flags); ++void __savedefault_once_reset() ++{ ++ if (saved_entryno & 0x4000) ++ { ++ int saved_current_entryno = current_entryno; ++ grub_timeout = 0; ++ current_entryno = default_entry; ++ savedefault_func("\0", BUILTIN_SCRIPT); ++ current_entryno = saved_current_entryno; ++ saved_entryno &= 0x3fff; ++ } ++} ++#endif /* SUPPORT_DISKLESS */ ++ + + #ifdef GRUB_UTIL + /* device */ +--- grub-0.96/stage2/stage2.c~ 2004-07-24 20:53:47.000000000 +0200 ++++ grub-0.96/stage2/stage2.c 2005-09-02 14:45:04.000000000 +0200 +@@ -827,6 +827,7 @@ + return pos; + } + ++extern void __savedefault_once_reset(); + + /* This is the starting function in C. */ + void +@@ -1048,7 +1049,9 @@ + } + while (is_preset); + } +- ++#ifndef SUPPORT_DISKLESS ++ __savedefault_once_reset(); ++#endif + if (! num_entries) + { + /* If no acceptable config file, goto command-line, starting diff --git a/src/patches/SuSE10.2/grub-gfxmenu-v8.diff b/src/patches/SuSE10.2/grub-gfxmenu-v8.diff new file mode 100644 index 000000000..6c4a429dc --- /dev/null +++ b/src/patches/SuSE10.2/grub-gfxmenu-v8.diff @@ -0,0 +1,994 @@ +--- docs/grub.texi ++++ docs/grub.texi +@@ -2118,6 +2118,7 @@ + * default:: Set the default entry + * fallback:: Set the fallback entry + * hiddenmenu:: Hide the menu interface ++* gfxmenu:: Use graphical menu interface + * timeout:: Set the timeout + * title:: Start a menu entry + @end menu +@@ -2150,6 +2151,15 @@ + @end deffn + + ++@node gfxmenu ++@subsection gfxmenu ++ ++@deffn Command gfxmenu file ++Use the graphical menu interface. The graphics data are taken from ++@var{file} and must be created using 'mkbootmsg' from the gfxboot package. ++@end deffn ++ ++ + @node hiddenmenu + @subsection hiddenmenu + +--- grub/asmstub.c ++++ grub/asmstub.c +@@ -498,6 +498,32 @@ + return 0; + } + ++/* graphical menu functions . */ ++int ++gfx_init (gfx_data_t *gfx_data) ++{ ++ return 0; ++} ++ ++int ++gfx_done (gfx_data_t *gfx_data) ++{ ++ return 0; ++} ++ ++int ++gfx_input (gfx_data_t *gfx_data, int *menu_entry) ++{ ++ return 0; ++} ++ ++int ++gfx_setup_menu (gfx_data_t *gfx_data) ++{ ++ return 0; ++} ++ ++ + /* low-level timing info */ + int + getrtsecs (void) +--- stage2/asm.S ++++ stage2/asm.S +@@ -1614,6 +1614,286 @@ + popl %ebp + ret + ++ ++/* ++ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ++ * ++ * graphical menu functions ++ * ++ */ ++ ++/* ++ * int gfx_init (gfx_data_t *gfx_data) ++ * ++ * init gfx things ++ * ++ * return vales: ++ * 0: ok ++ * 1: failed ++ * sets gfx_data->ok ++ */ ++ ++ENTRY(gfx_init) ++ pushl %ebp ++ movl %esp, %ebp ++ ++ pushl %edi ++ pushl %esi ++ pushl %ebx ++ ++ movl 8(%ebp),%edx ++ movl %edx,%edi ++ leal gfx_ofs_sys_cfg(%edx),%esi ++ andl $0xf,%edi ++ shrl $4,%edx ++ ++ pushl %ebp ++ ++ call EXT_C(prot_to_real) ++ .code16 ++ ++ pushw %ds ++ movw %dx,%ds ++ ++ lcall *gfx_ofs_jmp_table + 4 * 0 (%di) ++ ++ sbbl %ebx,%ebx ++ negl %ebx ++ ++ popw %ds ++ ++ DATA32 call EXT_C(real_to_prot) ++ .code32 ++ ++ popl %ebp ++ ++ movl %ebx,%eax ++ xorl $1,%ebx ++ movl 8(%ebp),%edx ++ movl %ebx,gfx_ofs_ok(%edx) ++ ++ popl %ebx ++ popl %esi ++ popl %edi ++ ++ popl %ebp ++ ret ++ ++ ++/* ++ * int gfx_done (gfx_data_t *gfx_data) ++ * ++ * shut down gfx things ++ * ++ * return vales: ++ * always 0 ++ * sets gfx_data->ok ++ */ ++ ++ENTRY(gfx_done) ++ pushl %ebp ++ movl %esp, %ebp ++ ++ pushl %edi ++ pushl %esi ++ pushl %ebx ++ ++ movl 8(%ebp),%edx ++ movl %edx,%ebx ++ andl $0xf,%ebx ++ shrl $4,%edx ++ ++ pushl %ebp ++ ++ call EXT_C(prot_to_real) ++ .code16 ++ ++ pushw %ds ++ ++ movw %dx,%ds ++ ++ lcall *gfx_ofs_jmp_table + 4 * 1 (%bx) ++ ++ popw %ds ++ ++ DATA32 call EXT_C(real_to_prot) ++ .code32 ++ ++ popl %ebp ++ ++ xorl %eax,%eax ++ movl 8(%ebp),%edx ++ movl %eax,gfx_ofs_ok(%edx) ++ ++ popl %ebx ++ popl %esi ++ popl %edi ++ ++ popl %ebp ++ ret ++ ++ ++/* ++ * int gfx_input (gfx_data_t *gfx_data, int *menu_entry) ++ * ++ * let user enter a command line ++ * ++ * uses gfx_data->cmdline as buffer ++ * ++ * return values: ++ * 1: abort ++ * 2: boot ++ * menu_entry: selected entry ++ */ ++ ++ENTRY(gfx_input) ++ pushl %ebp ++ movl %esp, %ebp ++ ++ pushl %edi ++ pushl %esi ++ pushl %ebx ++ ++ movl 8(%ebp),%edx ++ movl %edx,%ebx ++ leal gfx_ofs_sys_cfg(%edx),%esi ++ andl $0xf,%ebx ++ shrl $4,%edx ++ ++ pushl %ebp ++ ++ call EXT_C(prot_to_real) ++ .code16 ++ ++ pushw %ds ++ ++ movw %dx,%ds ++ ++ movl gfx_ofs_cmdline(%bx),%edi ++ movl gfx_ofs_cmdline_len(%bx),%ecx ++ movl gfx_ofs_timeout(%bx),%eax ++ imull $18,%eax ++ ++ lcall *gfx_ofs_jmp_table + 4 * 2 (%bx) ++ ++ movl %eax,%ecx ++ ++ popw %ds ++ ++ DATA32 call EXT_C(real_to_prot) ++ .code32 ++ ++ popl %ebp ++ ++ movl 12(%ebp),%edx ++ movl %ebx,(%edx) ++ ++ movl %ecx,%eax ++ ++ popl %ebx ++ popl %esi ++ popl %edi ++ ++ popl %ebp ++ ret ++ ++ ++/* ++ * int gfx_setup_menu (gfx_data_t *gfx_data) ++ * ++ * draw boot menu ++ * ++ * return values: ++ * always 0 ++ */ ++ ++/* menu entry descriptor */ ++#define menu_entries 0 ++#define menu_default 2 /* seg:ofs */ ++#define menu_ent_list 6 /* seg:ofs */ ++#define menu_ent_size 10 ++#define menu_arg_list 12 /* seg:ofs */ ++#define menu_arg_size 16 ++#define sizeof_menu_desc 18 ++ ++ENTRY(gfx_setup_menu) ++ pushl %ebp ++ movl %esp, %ebp ++ ++ pushl %edi ++ pushl %esi ++ pushl %ebx ++ ++ movl 8(%ebp),%edx ++ movl %edx,%ebx ++ andl $0xf,%ebx ++ shrl $4,%edx ++ ++ call EXT_C(prot_to_real) ++ .code16 ++ ++ pushw %ds ++ ++ movw %dx,%ds ++ shll $4,%edx ++ ++ subw $sizeof_menu_desc,%sp ++ movw %esp,%ebp ++ ++ movl gfx_ofs_menu_entries(%bx),%eax ++ movw %ax,menu_entries(%bp) ++ ++ movl gfx_ofs_menu_default_entry(%bx),%eax ++ subl %edx,%eax ++ movw %ax,menu_default(%bp) ++ movw %ds,menu_default+2(%bp) ++ ++ movl gfx_ofs_menu_list(%bx),%eax ++ subl %edx,%eax ++ movw %ax,menu_ent_list(%bp) ++ movw %ds,menu_ent_list+2(%bp) ++ ++ movl gfx_ofs_menu_entry_len(%bx),%eax ++ movw %ax,menu_ent_size(%bp) ++ ++ movl gfx_ofs_args_list(%bx),%eax ++ subl %edx,%eax ++ movw %ax,menu_arg_list(%bp) ++ movw %ds,menu_arg_list+2(%bp) ++ ++ movl gfx_ofs_args_entry_len(%bx),%eax ++ movw %ax,menu_arg_size(%bp) ++ ++ movl %ss,%esi ++ shll $4,%esi ++ addl %ebp,%esi ++ ++ lcall %ds: *gfx_ofs_jmp_table + 4 * 3 (%bx) ++ ++ addw $sizeof_menu_desc,%sp ++ ++ popw %ds ++ ++ DATA32 call EXT_C(real_to_prot) ++ .code32 ++ ++ xorl %eax,%eax ++ ++ popl %ebx ++ popl %esi ++ popl %edi ++ ++ popl %ebp ++ ret ++ ++ ++/* ++ * ++ * end graphics stuff ++ * ++ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ++ */ ++ + + /* + * gateA20(int linear) +--- stage2/builtins.c ++++ stage2/builtins.c +@@ -63,6 +63,8 @@ + int fallback_entries[MAX_FALLBACK_ENTRIES]; + /* The number of current entry. */ + int current_entryno; ++/* graphics file */ ++char graphics_file[64]; + /* The address for Multiboot command-line buffer. */ + static char *mb_cmdline; + /* The password. */ +@@ -1351,6 +1353,26 @@ + }; + + ++/* graphics */ ++static int ++gfxmenu_func (char *arg, int flags) ++{ ++ memmove(graphics_file, arg, sizeof graphics_file - 1); ++ graphics_file[sizeof graphics_file - 1] = 0; ++ ++ return 0; ++} ++ ++static struct builtin builtin_gfxmenu = ++{ ++ "gfxmenu", ++ gfxmenu_func, ++ BUILTIN_MENU | BUILTIN_HELP_LIST, ++ "gfxmenu FILE", ++ "Use the graphical menu from FILE." ++}; ++ ++ + /* geometry */ + static int + geometry_func (char *arg, int flags) +@@ -4874,6 +4896,7 @@ + &builtin_find, + &builtin_fstest, + &builtin_geometry, ++ &builtin_gfxmenu, + &builtin_halt, + &builtin_help, + &builtin_hiddenmenu, +--- stage2/shared.h ++++ stage2/shared.h +@@ -374,6 +374,22 @@ + #endif /* WITHOUT_LIBC_STUBS */ + + ++/* see typedef gfx_data_t below */ ++#define gfx_ofs_ok 0x00 ++#define gfx_ofs_code_seg 0x04 ++#define gfx_ofs_jmp_table 0x08 ++#define gfx_ofs_sys_cfg 0x38 ++#define gfx_ofs_cmdline 0x6c ++#define gfx_ofs_cmdline_len 0x70 ++#define gfx_ofs_menu_list 0x74 ++#define gfx_ofs_menu_default_entry 0x78 ++#define gfx_ofs_menu_entries 0x7c ++#define gfx_ofs_menu_entry_len 0x80 ++#define gfx_ofs_args_list 0x84 ++#define gfx_ofs_args_entry_len 0x88 ++#define gfx_ofs_timeout 0x8c ++ ++ + #ifndef ASM_FILE + /* + * Below this should be ONLY defines and other constructs for C code. +@@ -595,6 +611,38 @@ + extern int default_entry; + extern int current_entryno; + ++ ++/* ++ * graphics menu stuff ++ * ++ * Note: gfx_data and all data referred to in it must lie within a 64k area. ++ */ ++typedef struct { ++ unsigned ok; /* set while we're in graphics mode */ ++ unsigned code_seg; /* code segment of binary graphics code */ ++ unsigned jmp_table[12]; /* link to graphics functions */ ++ unsigned char sys_cfg[52]; /* sys_cfg[0]: identifies boot loader (grub == 2) */ ++ char *cmdline; /* command line returned by gfx_input() */ ++ unsigned cmdline_len; /* length of the above */ ++ char *menu_list; /* list of menu entries, each of fixed length (menu_entry_len) */ ++ char *menu_default_entry; /* the default entry */ ++ unsigned menu_entries; /* number of entries in menu_list */ ++ unsigned menu_entry_len; /* one entry */ ++ char *args_list; /* same structure as menu_list, menu_entries entries */ ++ unsigned args_entry_len; /* one entry */ ++ unsigned timeout; /* in seconds (0: no timeout) */ ++} __attribute__ ((packed)) gfx_data_t; ++ ++extern gfx_data_t *graphics_data; ++ ++/* pointer to graphics image data */ ++extern char graphics_file[64]; ++ ++int gfx_init(gfx_data_t *gfx_data); ++int gfx_done(gfx_data_t *gfx_data); ++int gfx_input(gfx_data_t *gfx_data, int *menu_entry); ++int gfx_setup_menu(gfx_data_t *gfx_data); ++ + /* The constants for password types. */ + typedef enum + { +--- stage2/stage2.c ++++ stage2/stage2.c +@@ -22,6 +22,8 @@ + + grub_jmp_buf restart_env; + ++gfx_data_t *graphics_data; ++ + #if defined(PRESET_MENU_STRING) || defined(SUPPORT_DISKLESS) + + # if defined(PRESET_MENU_STRING) +@@ -310,6 +312,12 @@ + + if (! auth && password) + { ++ if (*graphics_file) ++ { ++ printf ("\ ++ WARNING: graphical menu doesn\'t work\ ++ in conjunction with the password feature\n" ); ++ } + printf ("\ + Press enter to boot the selected OS or \'p\' to enter a\n\ + password to unlock the next set of features."); +@@ -753,6 +761,493 @@ + } + + ++ ++#if 0 ++/* for debugging */ ++static void hexdump(unsigned char *buf, unsigned len) ++{ ++ int i, j = 0; ++ char s[17]; ++ unsigned addr = (unsigned) buf; ++ ++ s[16] = 0; ++ while(len--) { ++ i = buf[j]; ++ i = i & 0xff; ++ s[j & 15] = (i >= 0x20 && i <= 0x7e) ? i : '.'; ++ if(!(j & 15)) { ++ printf("%x ", j + addr); ++ } ++ if(!(j & 7) && (j & 15)) printf(" "); ++ /* stupid grub_printf */ ++ printf("%x", (i >> 4) & 0x0f); ++ printf("%x ", i & 0x0f); ++ if(!(++j & 15)) { ++ printf(" %s\n", s); ++ } ++ } ++ ++ if(j & 15) { ++ s[j & 15] = 0; ++ if(!(j & 8)) printf(" "); ++ i = 1 + 3 * (16 - (j & 15)); ++ while(i--) printf(" "); ++ printf("%s\n", s); ++ } ++} ++#endif ++ ++ ++/* kernel + (grub-)module options */ ++#define GFX_CMD_BUF_SIZE 512 ++ ++/* command line separator char */ ++#define GFX_CMD_SEP 1 ++ ++/* ++ * Go through config entry and find kernel args, if any. ++ * Put things into buf and return it. ++ */ ++static char *get_kernel_args(char *cfg, char *buf) ++{ ++ int i, j; ++ char *s, *t = "", *p, *t2; ++ ++ *(p = buf) = 0; ++ ++ for(j = 0; ; j++) { ++ s = get_entry(cfg, j, 0); ++ if(!*s) break; ++ if( ++ (!memcmp(s, "kernel", 6) || !memcmp(s, "module", 6)) && ++ (s[6] == ' ' || s[6] == '\t') ++ ) { ++ t = skip_to(0, s); ++ t2 = s[0] == 'm' ? strstr(t, "initrd") : NULL; ++ if(*t) t = skip_to(0, t); ++ if(t2 && t2 < t) break; /* module is likely a normal initrd -> skip */ ++ i = strlen(t); ++ if(p - buf + i > GFX_CMD_BUF_SIZE - 2) break; ++ *p++ = GFX_CMD_SEP; ++ strcpy(p, t); ++ p += i; ++ ++ continue; ++ } ++ } ++ ++ if(*buf) buf++; /* skip initial separator char */ ++ ++ return buf; ++} ++ ++ ++/* ++ * Check header and return code start offset. ++ */ ++static unsigned magic_ok(unsigned char *buf) ++{ ++ if( ++ *(unsigned *) buf == 0x0b2d97f00 && /* magic id */ ++ (buf[4] == 8) /* version 8 */ ++ ) { ++ return *(unsigned *) (buf + 8); ++ } ++ ++ return 0; ++} ++ ++ ++/* ++ * Search cpio archive for gfx file. ++ */ ++static unsigned find_file(unsigned char *buf, unsigned len, unsigned *gfx_file_start, unsigned *file_len) ++{ ++ unsigned i, fname_len, code_start = 0; ++ ++ *gfx_file_start = 0; ++ ++ for(i = 0; i < len;) { ++ if((len - i) >= 0x1a && (buf[i] + (buf[i + 1] << 8)) == 0x71c7) { ++ fname_len = *(unsigned short *) (buf + i + 20); ++ *file_len = *(unsigned short *) (buf + i + 24) + (*(unsigned short *) (buf + i + 22) << 16); ++ i += 26 + fname_len; ++ i = ((i + 1) & ~1); ++ if((code_start = magic_ok(buf + i))) { ++ *gfx_file_start = i; ++ return code_start; ++ } ++ i += *file_len; ++ i = ((i + 1) & ~1); ++ } ++ else { ++ break; ++ } ++ } ++ ++ return code_start; ++} ++ ++static inline unsigned char * stack_ptr(void) ++{ ++ unsigned char * u; ++ ++ asm("movl %%esp, %0" : "=r" (u)); ++ ++ return u; ++} ++ ++static void sleep(int delay) ++{ ++ int tick, last_tick = currticks(); ++ ++ delay *= 18; ++ ++ while(delay--) { ++ while((tick = currticks()) == last_tick) { } ++ last_tick = tick; ++ } ++} ++ ++static void wait_for_key() ++{ ++ printf("Press a key to continue..."); ++ getkey(); ++ printf("\r \r"); ++} ++ ++ ++/* ++ * Leave that much space on the heap. Everything else goes to the graphics ++ * functions. ++ * ++ * 0x2000 is _not_ enough ++ */ ++#define MIN_HEAP_SIZE 0x4000 ++#define MIN_GFX_FREE 0x1000 ++ ++#define SC_BOOTLOADER 0 ++#define SC_FAILSAFE 3 ++#define SC_SYSCONFIG_SIZE 4 ++#define SC_BOOTLOADER_SEG 8 ++#define SC_XMEM_0 24 ++#define SC_XMEM_1 26 ++#define SC_XMEM_2 28 ++#define SC_XMEM_3 30 ++#define SC_FILE 32 ++#define SC_ARCHIVE_START 36 ++#define SC_ARCHIVE_END 40 ++#define SC_MEM0_START 44 ++#define SC_MEM0_END 48 ++ ++/* ++ * Does normally not return. ++ */ ++static void ++run_graphics_menu (char *menu_entries, char *config_entries, int num_entries, ++ char *heap, int entryno) ++{ ++ unsigned char *buf, *buf_ext; ++ unsigned buf_size, buf_ext_size, code_start, file_start; ++ char *s, *t, *t2, *cfg, *new_config, *p; ++ char *saved_heap; ++ int i, j, max_len, gfx_file_size, verbose; ++ int selected_entry; ++ gfx_data_t *gfx_data; ++ char *cmd_buf; ++ unsigned mem0_start, mem0_end, file_len; ++ ++ /* ++ * check gfx_data_t struct offsets for consistency; gcc will optimize away ++ * the whole block ++ */ ++ ++ /* dummy function to make ld fail */ ++ { ++ extern void wrong_struct_size(void); ++ #define gfx_ofs_check(a) if(gfx_ofs_##a != (char *) &gfx_data->a - (char *) gfx_data) wrong_struct_size(); ++ gfx_ofs_check(ok); ++ gfx_ofs_check(code_seg); ++ gfx_ofs_check(jmp_table); ++ gfx_ofs_check(sys_cfg); ++ gfx_ofs_check(cmdline); ++ gfx_ofs_check(cmdline_len); ++ gfx_ofs_check(menu_list); ++ gfx_ofs_check(menu_default_entry); ++ gfx_ofs_check(menu_entries); ++ gfx_ofs_check(menu_entry_len); ++ gfx_ofs_check(args_list); ++ gfx_ofs_check(args_entry_len); ++ gfx_ofs_check(timeout); ++ #undef gfx_ofs_check ++ } ++ ++ if(!num_entries) return; ++ ++ graphics_data = gfx_data = (gfx_data_t *) heap; ++ heap += sizeof *gfx_data; ++ memset(gfx_data, 0, sizeof *gfx_data); ++ ++ gfx_data->sys_cfg[SC_BOOTLOADER] = 2; /* bootloader: grub */ ++ gfx_data->sys_cfg[SC_SYSCONFIG_SIZE] = 52; /* config data size */ ++ *(unsigned short *) (gfx_data->sys_cfg + SC_BOOTLOADER_SEG) = (unsigned) gfx_data >> 4; /* segment */ ++ gfx_data->sys_cfg[SC_XMEM_0] = 0x21; /* 1MB @ 2MB */ ++ gfx_data->sys_cfg[SC_XMEM_1] = 0x41; /* 1MB @ 4MB */ ++ verbose = (*(unsigned char *) 0x417) & 3 ? 1 : 0; /* SHIFT pressed */ ++ gfx_data->sys_cfg[SC_FAILSAFE] = verbose; ++ ++ gfx_data->timeout = grub_timeout >= 0 ? grub_timeout : 0; ++ ++ ++ /* setup command line edit buffer */ ++ ++ gfx_data->cmdline_len = 256; ++ ++ gfx_data->cmdline = heap; ++ heap += gfx_data->cmdline_len; ++ memset(gfx_data->cmdline, 0, gfx_data->cmdline_len); ++ ++ cmd_buf = heap; ++ heap += GFX_CMD_BUF_SIZE; ++ ++ /* setup menu entries */ ++ ++ for(i = max_len = 0; i < num_entries; i++) { ++ j = strlen(get_entry(menu_entries, i, 0)); ++ if(j > max_len) max_len = j; ++ } ++ ++ if(!max_len) return; ++ ++ gfx_data->menu_entry_len = max_len + 1; ++ gfx_data->menu_entries = num_entries; ++ ++ gfx_data->menu_list = heap; ++ heap += gfx_data->menu_entry_len * gfx_data->menu_entries; ++ ++ memset(gfx_data->menu_list, 0, gfx_data->menu_entry_len * gfx_data->menu_entries); ++ ++ for(i = 0; i < (int) gfx_data->menu_entries; i++) { ++ strcpy(gfx_data->menu_list + i * gfx_data->menu_entry_len, get_entry(menu_entries, i, 0)); ++ } ++ ++ gfx_data->menu_default_entry = gfx_data->menu_list + entryno * gfx_data->menu_entry_len; ++ ++ ++ /* setup list of kernel args */ ++ ++ for(i = max_len = 0; i < num_entries; i++) { ++ s = get_kernel_args(get_entry(config_entries, i, 1), cmd_buf); ++ j = strlen(s); ++ if(j > max_len) max_len = j; ++ } ++ ++ gfx_data->args_entry_len = max_len + 1; ++ ++ gfx_data->args_list = heap; ++ heap += gfx_data->args_entry_len * gfx_data->menu_entries; ++ ++ memset(gfx_data->args_list, 0, gfx_data->args_entry_len * gfx_data->menu_entries); ++ ++ for(i = 0; i < (int) gfx_data->menu_entries; i++) { ++ strcpy(gfx_data->args_list + i* gfx_data->args_entry_len, get_kernel_args(get_entry(config_entries, i, 1), cmd_buf)); ++ } ++ ++ ++ /* go back here when we no longer need the graphics data */ ++ saved_heap = heap; ++ ++ ++ /* get memory area to be used by graphics functions */ ++ ++ /* use 1MB starting at 2MB as file buffer */ ++ buf_ext = (unsigned char *) (2 << 20); ++ buf_ext_size = 1 << 20; ++ ++ /* must be 16-byte aligned */ ++ buf = (unsigned char *) (((unsigned) heap + 0xf) & ~0xf); ++ ++ buf_size = stack_ptr() - buf - MIN_HEAP_SIZE; ++ buf_size &= ~0xf; ++ ++ mem0_start = (unsigned) buf; ++ mem0_end = mem0_start + buf_size; ++ ++ if(verbose) { ++ printf("low memory 0x%x - 0x%x (%d bytes)\n", mem0_start, mem0_end, buf_size); ++ wait_for_key(); ++ } ++ ++ heap += buf_size; ++ ++ /* read the file */ ++ ++ if(!grub_open(graphics_file)) { ++ printf("%s: file not found\n", graphics_file); ++ sleep(5); ++ heap = saved_heap; ++ return; ++ } ++ ++ gfx_file_size = grub_read(buf_ext, buf_ext_size); ++ ++ grub_close(); ++ ++ if(gfx_file_size <= 0) { ++ printf("%s: read error\n", graphics_file); ++ sleep(5); ++ heap = saved_heap; ++ return; ++ } ++ ++ if(verbose) { ++ printf("%s: %d bytes (%d bytes left)\n", graphics_file, gfx_file_size, buf_ext_size - gfx_file_size); ++ wait_for_key(); ++ } ++ ++ /* locate file inside cpio archive */ ++ if(!(code_start = find_file(buf_ext, gfx_file_size, &file_start, &file_len))) { ++ printf("%s: invalid file format\n", graphics_file); ++ sleep(5); ++ heap = saved_heap; ++ return; ++ } ++ ++ if(verbose) { ++ printf("init: start 0x%x, len %d; code offset 0x%x\n", file_start, file_len, code_start); ++ wait_for_key(); ++ } ++ ++ if(file_len - code_start + MIN_GFX_FREE > buf_size) { ++ printf("not enough free memory: %d extra bytes need\n", file_len - code_start + MIN_GFX_FREE - buf_size); ++ sleep(5); ++ heap = saved_heap; ++ return; ++ } ++ ++ memcpy((void *) buf, (void *) (buf_ext + file_start + code_start), file_len - code_start); ++ ++ mem0_start += file_len - code_start; ++ mem0_start = (mem0_start + 3) & ~3; /* align */ ++ ++ /* init interface to graphics functions */ ++ ++ *(unsigned *) (gfx_data->sys_cfg + SC_FILE) = (unsigned) buf_ext + file_start; ++ *(unsigned *) (gfx_data->sys_cfg + SC_ARCHIVE_START) = (unsigned) buf_ext; ++ *(unsigned *) (gfx_data->sys_cfg + SC_ARCHIVE_END) = (unsigned) buf_ext + gfx_file_size; ++ *(unsigned *) (gfx_data->sys_cfg + SC_MEM0_START) = mem0_start; ++ *(unsigned *) (gfx_data->sys_cfg + SC_MEM0_END) = mem0_end; ++ ++ gfx_data->code_seg = (unsigned) buf >> 4; ++ ++ if(verbose) { ++ printf("init 0x%x, archive 0x%x - 0x%x, low mem 0x%x - 0x%x\ncode seg 0x%x\n", ++ (unsigned) buf_ext + file_start, ++ (unsigned) buf_ext, (unsigned) buf_ext + gfx_file_size, ++ mem0_start, mem0_end, gfx_data->code_seg ++ ); ++ wait_for_key(); ++ } ++ ++ for(i = 0; (unsigned) i < sizeof gfx_data->jmp_table / sizeof *gfx_data->jmp_table; i++) { ++ gfx_data->jmp_table[i] = (gfx_data->code_seg << 16) + ((unsigned short *) buf)[i]; ++ } ++ ++ if(verbose) { ++ for(i = 0; i < 12; i++) { ++ printf("%d: 0x%x\n", i, gfx_data->jmp_table[i]); ++ } ++ ++ for(i = 0; i < gfx_data->menu_entries; i++) { ++ printf("\"%s\" -- \"%s\"\n", ++ gfx_data->menu_list + i * gfx_data->menu_entry_len, ++ gfx_data->args_list + i * gfx_data->args_entry_len ++ ); ++ } ++ ++ printf("default: \"%s\"\n", gfx_data->menu_default_entry); ++ wait_for_key(); ++ } ++ ++ /* switch to graphics mode */ ++ ++ if(gfx_init(gfx_data)) { ++ printf("graphics initialization failed\n"); ++ sleep(5); ++ heap = saved_heap; ++ return; ++ } ++ ++ gfx_setup_menu(gfx_data); ++ ++ i = gfx_input(gfx_data, &selected_entry); ++ ++ /* ESC -> show text menu */ ++ if(i == 1) { ++ gfx_done(gfx_data); ++ grub_timeout = -1; ++ ++ heap = saved_heap; ++ return; ++ } ++ ++ gfx_done(gfx_data); ++ ++ heap = saved_heap; /* free most of the graphics data */ ++ ++ // printf("cmdline: >%s<, entry = %d\n", gfx_data->cmdline, selected_entry); ++ ++ if(selected_entry < 0 || selected_entry > num_entries) return; ++ ++ ++ /* create new config with modified kernel option */ ++ ++ cfg = get_entry(config_entries, selected_entry, 1); ++ ++ new_config = heap; ++ ++ for(p = gfx_data->cmdline, i = 0; ; i++) { ++ s = get_entry(cfg, i, 0); ++ if(!*s) { ++ if(!i) *heap++ = 0; ++ *heap++ = 0; ++ break; ++ } ++ /* note: must match get_kernel_args() */ ++ if( ++ (!memcmp(s, "kernel", 6) || !memcmp(s, "module", 6)) && ++ (s[6] == ' ' || s[6] == '\t') ++ ) { ++ t = skip_to(0, s); ++ t2 = s[0] == 'm' ? strstr(t, "initrd") : NULL; ++ if(*t) t = skip_to(0, t); ++ if(t2 && t2 < t) { /* module is likely a normal initrd -> skip */ ++ strcpy(heap, s); ++ heap += strlen(s) + 1; ++ continue; ++ } ++ memmove(heap, s, t - s); ++ heap += t - s; ++ *heap++ = ' '; ++ while(*p && *p != GFX_CMD_SEP) *heap++ = *p++; ++ *heap++ = 0; ++ if(*p == GFX_CMD_SEP) p++; ++ } ++ else { ++ strcpy(heap, s); ++ heap += strlen(s) + 1; ++ } ++ } ++ ++ *heap++ = 0; ++ ++ // hexdump(new_config, heap - new_config); ++ // getkey(); ++ ++ run_script(new_config, heap); ++} ++ ++ + static int + get_line_from_config (char *cmdline, int maxlen, int read_from_file) + { +@@ -1062,9 +1557,12 @@ + } + else + { +- /* Run menu interface. */ +- run_menu (menu_entries, config_entries, num_entries, +- menu_entries + menu_len, default_entry); ++ if (*graphics_file && !password && show_menu && grub_timeout) ++ { ++ run_graphics_menu(menu_entries, config_entries, num_entries,menu_entries + menu_len, default_entry); ++ } ++ /* Run menu interface. */ ++ run_menu (menu_entries, config_entries, num_entries, menu_entries + menu_len, default_entry); + } + } + } diff --git a/src/patches/SuSE10.2/grub-linux-setup-fix b/src/patches/SuSE10.2/grub-linux-setup-fix new file mode 100644 index 000000000..cf879242e --- /dev/null +++ b/src/patches/SuSE10.2/grub-linux-setup-fix @@ -0,0 +1,12 @@ +--- grub-0.95/stage2/builtins.c.orig 2004-05-14 21:30:52.000000000 +0200 ++++ grub-0.95/stage2/builtins.c 2005-03-02 17:01:27.568051824 +0100 +@@ -3884,6 +3884,9 @@ + } + } + ++ /* force buffer cache invalidation after embedding */ ++ buf_drive = -1; ++ + /* Construct a string that is used by the command "install" as its + arguments. */ + sprint_device (installed_drive, installed_partition); diff --git a/src/patches/SuSE10.2/grub-path-cfg.diff b/src/patches/SuSE10.2/grub-path-cfg.diff new file mode 100644 index 000000000..f1aadfad9 --- /dev/null +++ b/src/patches/SuSE10.2/grub-path-cfg.diff @@ -0,0 +1,152 @@ +diff -ru ../grub-0.97-save/docs/grub.8 ./docs/grub.8 +--- ../grub-0.97-save/docs/grub.8 2005-05-08 04:48:56.000000000 +0200 ++++ ./docs/grub.8 2006-09-18 21:26:18.800377712 +0200 +@@ -15,7 +15,7 @@ + specify stage2 boot_drive [default=0x0] + .TP + \fB\-\-config\-file\fR=\fIFILE\fR +-specify stage2 config_file [default=/boot/grub/menu.lst] ++specify stage2 config_file [default=/boot/grub/grub.conf] + .TP + \fB\-\-device\-map\fR=\fIFILE\fR + use the device map file FILE +diff -ru ../grub-0.97-save/docs/grub.texi ./docs/grub.texi +--- ../grub-0.97-save/docs/grub.texi 2006-09-16 21:29:53.000000000 +0200 ++++ ./docs/grub.texi 2006-09-18 21:29:54.573575200 +0200 +@@ -687,7 +687,7 @@ + For booting from a CD-ROM, GRUB uses a special Stage 2 called + @file{stage2_eltorito}. The only GRUB files you need to have in your + bootable CD-ROM are this @file{stage2_eltorito} and optionally a config file +-@file{menu.lst}. You don't need to use @file{stage1} or @file{stage2}, ++@file{grub.conf}. You don't need to use @file{stage1} or @file{stage2}, + because El Torito is quite different from the standard boot process. + + Here is an example of procedures to make a bootable CD-ROM +@@ -710,7 +710,7 @@ + $ @kbd{cp /usr/share/grub/i386-pc/stage2_eltorito iso/boot/grub} + @end example + +-If desired, make the config file @file{menu.lst} under @file{iso/boot/grub} ++If desired, make the config file @file{grub.conf} under @file{iso/boot/grub} + (@pxref{Configuration}), and copy any files and directories for the disc to the + directory @file{iso/}. + +@@ -1265,7 +1265,7 @@ + keys) that will do everything to boot an OS. + + To enable the menu, you need a configuration file, +-@file{menu.lst} under the boot directory. We'll analyze an example ++@file{grub.conf} under the boot directory. We'll analyze an example + file. + + The file first contains some general settings, the menu interface +@@ -1538,7 +1538,7 @@ + foo:ht=1:ha=63655d0334a7:ip=145.71.35.127:\ + :bf=/nbgrub:\ + :tc=.allhost:\ +- :T150="(nd)/tftpboot/menu.lst.foo": ++ :T150="(nd)/tftpboot/grub.conf.foo": + @end group + @end example + +@@ -1882,8 +1882,8 @@ + + An absolute file name resembles a Unix absolute file name, using + @samp{/} for the directory separator (not @samp{\} as in DOS). One +-example is @samp{(hd0,0)/boot/grub/menu.lst}. This means the file +-@file{/boot/grub/menu.lst} in the first partition of the first hard ++example is @samp{(hd0,0)/boot/grub/grub.conf}. This means the file ++@file{/boot/grub/grub.conf} in the first partition of the first hard + disk. If you omit the device name in an absolute file name, GRUB uses + GRUB's @dfn{root device} implicitly. So if you set the root device to, + say, @samp{(hd1,0)} by the command @command{root} (@pxref{root}), then +@@ -3559,7 +3559,7 @@ + + @item --config-file=@var{file} + Read the configuration file @var{file} instead of +-@file{/boot/grub/menu.lst}. The format is the same as the normal GRUB ++@file{/boot/grub/grub.conf}. The format is the same as the normal GRUB + syntax. See @ref{Filesystem}, for more information. + + @item --boot-drive=@var{drive} +diff -ru ../grub-0.97-save/grub/asmstub.c ./grub/asmstub.c +--- ../grub-0.97-save/grub/asmstub.c 2006-09-16 21:29:52.000000000 +0200 ++++ ./grub/asmstub.c 2006-09-18 21:31:08.793292088 +0200 +@@ -73,7 +73,7 @@ + unsigned long boot_drive = 0; + int saved_entryno = 0; + char version_string[] = VERSION; +-char config_file[128] = "/boot/grub/menu.lst"; /* FIXME: arbitrary */ ++char config_file[128] = "/boot/grub/grub.conf"; /* FIXME: arbitrary */ + unsigned long linux_text_len = 0; + char *linux_data_tmp_addr = 0; + char *linux_data_real_addr = 0; +diff -ru ../grub-0.97-save/stage1/Makefile.am ./stage1/Makefile.am +--- ../grub-0.97-save/stage1/Makefile.am 2006-09-16 21:29:52.000000000 +0200 ++++ ./stage1/Makefile.am 2006-09-18 21:09:46.550222664 +0200 +@@ -1,4 +1,4 @@ +-pkglibdir = /usr/lib/grub ++pkglibdir = /usr/share/grub/i386-pc + nodist_pkglib_DATA = stage1 + + CLEANFILES = $(nodist_pkglib_DATA) +#diff -ru ../grub-0.97-save/stage1/Makefile.in ./stage1/Makefile.in +#--- ../grub-0.97-save/stage1/Makefile.in 2006-09-16 21:30:10.000000000 +0200 +#+++ ./stage1/Makefile.in 2006-09-18 21:10:36.337653824 +0200 +#@@ -66,7 +66,7 @@ +# ETAGS = etags +# CTAGS = ctags +# DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +#-pkglibdir = /usr/lib/grub +#+pkglibdir = /usr/share/grub/i386-pc +# ACLOCAL = @ACLOCAL@ +# AMDEP_FALSE = @AMDEP_FALSE@ +# AMDEP_TRUE = @AMDEP_TRUE@ +diff -ru ../grub-0.97-save/stage2/Makefile.am ./stage2/Makefile.am +--- ../grub-0.97-save/stage2/Makefile.am 2006-09-16 21:29:52.000000000 +0200 ++++ ./stage2/Makefile.am 2006-09-18 21:11:46.148041032 +0200 +@@ -27,7 +27,7 @@ + -DUSE_MD5_PASSWORDS=1 -DSUPPORT_SERIAL=1 -DSUPPORT_HERCULES=1 + + # Stage 2 and Stage 1.5's. +-pkglibdir = /usr/lib/grub ++pkglibdir = /usr/share/grub/i386-pc + + EXTRA_PROGRAMS = nbloader.exec pxeloader.exec diskless.exec + +#diff -ru ../grub-0.97-save/stage2/Makefile.in ./stage2/Makefile.in +#--- ../grub-0.97-save/stage2/Makefile.in 2006-09-16 21:30:12.000000000 +0200 +#+++ ./stage2/Makefile.in 2006-09-18 21:12:09.087553696 +0200 +#@@ -442,7 +442,7 @@ +# DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +# +# # Stage 2 and Stage 1.5's. +#-pkglibdir = /usr/lib/grub +#+pkglibdir = /usr/share/grub/i386-pc +# ACLOCAL = @ACLOCAL@ +# AMDEP_FALSE = @AMDEP_FALSE@ +# AMDEP_TRUE = @AMDEP_TRUE@ +diff -ru ../grub-0.97-save/stage2/asm.S ./stage2/asm.S +--- ../grub-0.97-save/stage2/asm.S 2006-09-16 21:29:52.000000000 +0200 ++++ ./stage2/asm.S 2006-09-18 21:31:53.404510152 +0200 +@@ -98,7 +98,7 @@ + .string VERSION + VARIABLE(config_file) + #ifndef STAGE1_5 +- .string "/boot/grub/menu.lst" ++ .string "/boot/grub/grub.conf" + #else /* STAGE1_5 */ + .long 0xffffffff + .string "/boot/grub/stage2" +diff -ru ../grub-0.97-save/stage2/builtins.c ./stage2/builtins.c +--- ../grub-0.97-save/stage2/builtins.c 2006-09-16 21:29:52.000000000 +0200 ++++ ./stage2/builtins.c 2006-09-18 21:32:39.562493072 +0200 +@@ -4022,7 +4022,7 @@ + + /* The prefix was determined. */ + grub_sprintf (stage2, "%s%s", prefix, "/stage2"); +- grub_sprintf (config_filename, "%s%s", prefix, "/menu.lst"); ++ grub_sprintf (config_filename, "%s%s", prefix, "/grub.conf"); + *real_config_filename = 0; + + /* Check if stage2 exists. */ diff --git a/src/patches/SuSE10.2/grub.spec b/src/patches/SuSE10.2/grub.spec new file mode 100644 index 000000000..2d754c253 --- /dev/null +++ b/src/patches/SuSE10.2/grub.spec @@ -0,0 +1,384 @@ +# +# spec file for package grub (Version 0.97) +# +# Copyright (c) 2006 SUSE LINUX Products GmbH, Nuernberg, Germany. +# This file and all modifications and additions to the pristine +# package are under the same license as the package itself. +# +# Please submit bugfixes or comments via http://bugs.opensuse.org/ +# + +# norootforbuild +# usedforbuild aaa_base acl attr audit-libs autoconf automake bash bind-libs bind-utils binutils bison bzip2 coreutils cpio cpp cpp41 cracklib cvs cyrus-sasl db diffutils e2fsprogs file filesystem fillup findutils flex gawk gcc gcc41 gdbm gdbm-devel gettext gettext-devel glibc glibc-devel glibc-locale gpm grep groff gzip info insserv klogd less libacl libattr libcom_err libgcc41 libltdl libmudflap41 libnscd libstdc++41 libtool libvolume_id libxcrypt libzio m4 make man mktemp module-init-tools ncurses ncurses-devel net-tools netcfg openldap2-client openssl pam pam-modules patch perl permissions popt procinfo procps psmisc pwdutils rcs readline rpm sed strace sysvinit tar tcpd texinfo timezone unzip util-linux vim zlib zlib-devel + +# Commandline: +Name: grub +%ifarch x86_64 +BuildRequires: gcc41-32bit glibc-devel-32bit ncurses-32bit ncurses-devel-32bit +%endif +License: GPL +Group: System/Boot +Version: 0.97 +Release: 22 +Source0: %{name}-%{version}.tar.gz +Source1: installgrub +Source2: grubonce +Patch0: %{name}-%{version}-path-patch +Patch1: use_ferror.diff +Patch2: grub-R +Patch3: bad-assert-sideeffect +Patch4: %{name}-gfxmenu-v8.diff +Patch5: reiser-unpack +Patch6: chainloader-devicefix +Patch7: %{name}-%{version}-devicemap.diff +Patch8: grub-linux-setup-fix +Patch9: fix-uninitialized +Patch10: force-LBA-off.diff +Patch11: gcc4-diff +Patch12: %{name}-%{version}-initrdaddr.diff +Patch20: stage2-dir-callback.diff +Patch21: stage2-wildcard.diff +Patch22: stage2-wildcard-zerowidth.diff +Patch23: stage2-wildcard-doc.diff +Patch24: grub-%{version}-protexec.patch +URL: http://www.gnu.org/software/grub/grub.en.html +BuildRoot: %{_tmppath}/%{name}-%{version}-build +Summary: Grand Unified Boot Loader +PreReq: fileutils sh-utils + +%description +GNU GRUB is a multiboot boot loader. It was derived from GRUB. It is an +attempt to produce a boot loader for IBM PC-compatible machines that +has both the ability to be friendly to beginning or otherwise +nontechnically interested users and the flexibility to help experts in +diverse environments. It is compatible with Free/Net/OpenBSD and Linux. +It supports Win 9x/NT and OS/2 via chainloaders. It has a menu +interface and a command line interface. + + + +Authors: +-------- + Alessandro Rubini + Chip Salzenberg + Edmund GRIMLEY EVANS + Edward Killips + Gordon Matzigkeit + Jochen Hoenicke + Khimenko Victor + Klaus Reichl + Michael Hohmuth + OKUJI Yoshinori + Pavel Roskin + +%debug_package +%prep +%setup +rm -f acconfig.h || true +%patch -p1 -E +%patch1 +%patch2 -p1 +%patch3 -p1 +%patch4 +%patch5 -p1 +%patch6 -p1 +%patch7 -p1 +%patch8 -p1 +%patch9 -p1 +%patch10 -p1 +%patch11 -p1 +%patch12 -p1 +# Disable the wildcard feature +#%patch20 -p1 +#%patch21 -p1 +#%patch22 -p1 +#%patch23 -p1 +%patch24 -p1 + +%build +perl -pi -e 's,/usr/share/grub/i386-pc,/usr/lib/grub,' docs/grub.texi +%{?suse_update_config:%{suse_update_config -l -f . }} +autoreconf --force --install +%ifarch x86_64 + EXTRACFLAGS=' -fno-strict-aliasing -minline-all-stringops -m32 -fno-asynchronous-unwind-tables ' +%else + EXTRACFLAGS=' -fno-strict-aliasing -minline-all-stringops' +%endif +CFLAGS="$RPM_OPT_FLAGS -Os -DNDEBUG -W -Wall -Wpointer-arith $EXTRACFLAGS" ./configure \ + --prefix=/usr --infodir=%{_infodir} --mandir=%{_mandir} --datadir=/usr/lib \ + --disable-auto-linux-mem-opt --enable-diskless \ + --enable-{3c50{3,7},3c5{0,2}9,3c595,3c90x,cs89x0,davicom,depca,eepro{,100},epic100} \ + --enable-{exos205,lance,ne,ne2100,ni{50,52,65}00,ns8390} \ + --enable-{rtl8139,sk-g16,smc9000,tiara,tulip,via-rhine,w89c840,wd} +make +(cd stage2; mv nbgrub pxegrub ..) +mv stage2/stage2{,.netboot} +make clean +CFLAGS="$RPM_OPT_FLAGS -Os -DNDEBUG -W -Wall -Wpointer-arith $EXTRACFLAGS" ./configure \ + --prefix=/usr --infodir=%{_infodir} --mandir=%{_mandir} --datadir=/usr/lib \ + --disable-auto-linux-mem-opt +make + +%install +[ "$RPM_BUILD_ROOT" != "" -a -d $RPM_BUILD_ROOT ] && rm -rf $RPM_BUILD_ROOT; +make -k DESTDIR=$RPM_BUILD_ROOT install +mkdir -p $RPM_BUILD_ROOT/boot/grub +ln -sfn . $RPM_BUILD_ROOT/boot/boot +(cd $RPM_BUILD_ROOT/usr/lib/grub && mv *-suse/* . && rmdir *-suse) >/dev/null 2>&1 || true +cp -p {nb,pxe}grub stage2/stage2{,.netboot} $RPM_BUILD_ROOT/usr/lib/grub +cp -p %{SOURCE2} $RPM_BUILD_ROOT/usr/sbin/. +# This fine script used to do everything at once, which +# isn't necessary any more with Yast2 support. +# Kept only for reference and historical reasons. +# install -o root -g root -m 744 %{SOURCE1} /usr/sbin +# grub-terminfo is irrelevant to us +rm -f $RPM_BUILD_ROOT/usr/sbin/grub-terminfo +rm -f $RPM_BUILD_ROOT/usr/share/man/man8/grub-terminfo* + +%clean +[ "$RPM_BUILD_ROOT" != "" -a -d $RPM_BUILD_ROOT ] && rm -rf $RPM_BUILD_ROOT; + +%preun +%install_info --delete --info-dir=%{_infodir} %{_infodir}/%{name}.info.gz +%install_info --delete --info-dir=%{_infodir} %{_infodir}/multiboot.info.gz + +%files +%defattr(-,root,root) +%doc BUGS NEWS TODO README THANKS AUTHORS INSTALL ChangeLog COPYING +%docdir %{_infodir} +%docdir %{_mandir} +%docdir /usr/share/doc/packages/grub +%dir /boot/grub +/usr/bin/mbchk +%{_infodir}/grub*.gz +%{_infodir}/multiboot.info.gz +%{_mandir}/man1/mbchk.1.gz +%{_mandir}/man8/grub-install.8.gz +%{_mandir}/man8/grub.8.gz +%{_mandir}/man8/grub-md5-crypt.8.gz +/usr/sbin/grub +/usr/sbin/grubonce +/usr/sbin/grub-set-default +/usr/sbin/grub-install +/usr/sbin/grub-md5-crypt +#/usr/sbin/installgrub +%dir /boot/boot +/usr/lib/grub + +%post +# should anything go wrong the system will remain bootable : +[ -e /boot/grub/stage2 ] && mv /boot/grub/stage2{,.old} +# copy especially stage2 over, because it will be modified in-place ! +cp -p /usr/lib/grub/*stage1* /boot/grub 2>/dev/null || true +cp -p /usr/lib/grub/*/*stage1* /boot/grub 2>/dev/null || true +#special hack for #46843 +dd if=/usr/lib/grub/stage2 of=/boot/grub/stage2 bs=256k +sync +# command sequence to update-install stage1/stage2. +# leave everything else alone ! +[ -e /etc/grub.conf ] && /usr/sbin/grub --batch < /etc/grub.conf >/dev/null 2>&1 +%install_info --info-dir=%{_infodir} %{_infodir}/%{name}.info.gz +%install_info --info-dir=%{_infodir} %{_infodir}/multiboot.info.gz +exit 0 + +%changelog -n grub +* Fri Aug 25 2006 - snwint@suse.de +- needs gcc41-32bit +* Thu Aug 24 2006 - snwint@suse.de +- support latest gfxmenu +* Mon Jul 17 2006 - snwint@suse.de +- extended gfxmenu interface to pass options for 'module' lines (#160066) +- merged various gfxmenu patch fragments into one patch +* Thu Apr 20 2006 - duwe@suse.de +- fix incorrect DL contents e.g. on chainloader (fd0)+1 + (Bug #158072) +- initialize array in intel netcard probe (Bug #144171) +* Wed Jan 25 2006 - mls@suse.de +- converted neededforbuild to BuildRequires +* Thu Nov 24 2005 - snwint@suse.de +- support latest gfxboot +* Thu Nov 10 2005 - duwe@suse.de +- update to 0.97 +* Fri Sep 09 2005 - coolo@suse.de +- make grubonce shutup +* Fri Sep 02 2005 - duwe@suse.de +- Make grubonce work with the new 0.96 savedefault, + (fixing bug #95082, and by coincidence 99185 along the way, too) +* Fri Jun 10 2005 - ro@suse.de +- fix variable type in last change +* Thu Jun 09 2005 - ro@suse.de +- fix gfx display (stackptr diff) (thanks to Steffen) +* Fri Apr 29 2005 - duwe@suse.de +- update to 0.96 +- "grubonce" no handled differently +- re-do gcc4 fix (cleaner now) +- dropped rare NICs sis900 and natsemi in the process, + update from etherboot pending anyways. +* Sat Apr 09 2005 - aj@suse.de +- Compile with GCC4. +* Wed Mar 02 2005 - duwe@suse.de +- force cache reloading after "embed", for + the "setup" shortcut. This fixes Bug #66454 +* Fri Feb 18 2005 - agruen@suse.de +- Disable the wildcard feature. +* Sun Feb 06 2005 - ro@suse.de +- fix build on i386 +- use RPM_OPT_FLAGS +* Sat Feb 05 2005 - ro@suse.de +- use PROT_EXEC (from grub bug-tracking system) +* Fri Jan 28 2005 - snwint@suse.de +- updated gfxboot patch +* Wed Oct 06 2004 - sf@suse.de +- dd stage2 instead of copying it (#46843) +* Fri Oct 01 2004 - max@suse.de +- Added ncurses-devel-32bit and ncurses-devel-32bit to + neededforbuild to make history and command completion work + on x86_64 [Bug #46577]. +* Thu Sep 30 2004 - duwe@suse.de +- try to defragment stage2 if it resides on reiserfs. + This should fix sporadic failures we see. +* Thu Sep 30 2004 - agruen@suse.de +- Wildcard feature: + + stage2-wildcard-zerowidth.diff: Allow zero-width matches (so + that the asterisk in wildcard matches has the usual file glob + sematics). + + stage2-wildcard-doc.diff: Document the wildcard feature. +* Tue Sep 21 2004 - duwe@suse.de +- removed one ill side effect of assert(), most likely + fixing blocker #44520 +* Tue Sep 07 2004 - duwe@suse.de +- added "grubonce" script to demonstrate & ease "savedefault --once" +* Mon Sep 06 2004 - agruen@suse.de +- Fix usage of wrong variable in wildcard code. +* Sun Aug 22 2004 - agruen@suse.de +- stage2-dir-callback.diff: Make the dir command more flexible, + and clean up a bit. +- stage2-wildcard.diff: Implement wildcard menu entries. +* Mon Jul 26 2004 - duwe@suse.de +- update to the latest version, 0.95 +* Thu May 13 2004 - duwe@suse.de +- added -fno-strict-aliasing to CFLAGS, as suggested + per autobuild. +* Thu May 13 2004 - duwe@suse.de +- fix at least Bugs #32351,#36460,#34576,#38774 and #27486, + maybe also #35262 +* Fri Mar 05 2004 - duwe@suse.de +- fix bug #35352, the initrd patch only seemed to have gone into + 0.94, the semantics differ slightly :-( +* Mon Mar 01 2004 - duwe@suse.de +- quick fix for changed --datadir in 0.94, + detected by automated build checks. +* Mon Mar 01 2004 - duwe@suse.de +- upgrade to 0.94 +- integrate iso9660 FS +- network booting temporarily disabled +* Wed Jan 14 2004 - snwint@suse.de +- understand new gfxboot file format +* Sat Jan 10 2004 - adrian@suse.de +- add %%defattr +* Thu Aug 28 2003 - snwint@suse.de +- graphics patch had been accidentally disabled +* Thu Aug 14 2003 - duwe@suse.de +- another graphics consolidation, to allow + modular maintenance +* Thu Jul 31 2003 - duwe@suse.de +- reconsolidated graphics patches +- fix for machines with > 1GB of mem + (thanks to Karsten Keil for reporting/finding this) +- fix for hardware RAID device naming scheme +* Tue May 27 2003 - snwint@suse.de +- no graphics menu if 'savedefault --once' is used (#25356) +* Wed May 21 2003 - mmj@suse.de +- Don't package grub-terminfo +* Sat Mar 08 2003 - snwint@suse.de +- no graphics menu if 'hiddenmenu' is used (#23538) +* Thu Mar 06 2003 - kukuk@suse.de +- Remove not used cyrus-sasl from neededforbuild +* Wed Feb 19 2003 - duwe@suse.de +- use -minline-all-stringops to work around broken gcc +* Tue Feb 11 2003 - ro@suse.de +- combine the two postinstalls +* Mon Feb 10 2003 - mmj@suse.de +- Use %%install_info macros [#23420] +* Mon Feb 10 2003 - snwint@suse.de +- fixed evil bug in graphics patch +* Mon Feb 10 2003 - duwe@suse.de +- Now build network and non-network stage2 (Blocker #23502 ) +- #19984 considered fixed now, too +* Sun Feb 09 2003 - snwint@suse.de +- updated graphics patch +* Thu Feb 06 2003 - duwe@suse.de +- update to 0.93 version +- patches rediffed accordingly +- gfx patches consolidated +- made patch to force LBA off (untested) +* Thu Jan 16 2003 - nadvornik@suse.cz +- fixed the 'valid preprocessing token' error +* Thu Nov 28 2002 - duwe@suse.de +- added an "important" security fix ;-) + passwd not working along with gfxmenu is now + made obvious and warned about. +- made grub compile with gcc-3.3 and hopefully up. +* Thu Nov 14 2002 - duwe@suse.de + (candidate to PUTONFTP -- please test) +- imported totally rewritten memory layout + handling from CVS. This should work around the + broken nforce chipsets. +- made device.map more robust: + * use /boot/grub/device.map by default if it exists + * erroneous lines are now skipped, and don't lead to + no device.map at all any more. +* Thu Oct 10 2002 - kukuk@suse.de +- remove requires from bootsplash +* Wed Sep 11 2002 - adrian@suse.de +- remove PreReq to itself +* Tue Sep 10 2002 - duwe@suse.de +- added --disable-auto-linux-mem-opt to ./configure options. + This prevents grub from arbitrarily adding "mem=" to kernel opts. + This anachronism was necessary for some 2.2 Linux kernels, and + breaks on MXT machines (#19288). +* Fri Sep 06 2002 - duwe@suse.de +- added "lilo -R" feature on strong popular demand (#18538) +* Tue Sep 03 2002 - snwint@suse.de +- fixed Requires +* Tue Aug 27 2002 - snwint@suse.de +- graphics: free some memory before loading kernel (#18291) +* Mon Aug 26 2002 - sf@suse.de +- add glibc-devel-32bit to compile on x86_64 +* Thu Aug 22 2002 - sf@suse.de +- added x86_64 +- compile with -m32 -fno-unwind-asynchronous-tables on x86_64 +* Tue Aug 20 2002 - mmj@suse.de +- Correct PreReq +* Wed Jul 24 2002 - duwe@suse.de +- converted to safe update scheme using /etc/grub.conf + *stage* are now copied from /usr/lib/grub [FHS compliant] + to /boot/grub and remain functioning after uninstall. + Now configurable with next Yast2; remove previous versions + with "rpm -e", from here on "rpm -U" simply works. +- grub shell & friends moved to /usr/sbin + (you already have that functionality w/ GRUB even before + the kernel is booted, save for a mounted root FS) +* Thu Jul 18 2002 - snwint@suse.de +- basic graphics patch +* Thu Jun 20 2002 - stepan@suse.de +- update to 0.92 (bugfix release) +* Thu Apr 04 2002 - pthomas@suse.de +- Fixed to build with new autoconf/automake. +* Fri Feb 01 2002 - pthomas@suse.de +- Update to 0.91 +- Clean up spec file. +- Handle the chase of /boot not being on its own partition correctly. +* Mon Mar 19 2001 - tw@suse.de +- switched to grub 0.5.96.1 so the patch of device.c is no longer needed +- build --recheck into the installgrub-script +* Mon Jan 15 2001 - tw@suse.de +- Don't install the stage bootloaders in /usr/share as FHS + prohibits doing so. +- Because the stage-bootloaders are not in /usr/share, they have + to be copied by "grub-install". +- Added a new script to ./util "installgrub", which automatically + searches the most common partition-types, the kernels and the initrds + and installs the bootmanager without action by the user. +- There was a bug in ./lib/device.c, that causes a DISK WRITE ERROR. + It is fixed now. (Only a O_RDONLY needed to be changed to O_RDRW) diff --git a/src/patches/SuSE10.2/grubonce b/src/patches/SuSE10.2/grubonce new file mode 100755 index 000000000..dd90e8625 --- /dev/null +++ b/src/patches/SuSE10.2/grubonce @@ -0,0 +1,57 @@ +#!/usr/bin/perl + +# Keep this sort of configurable for the future. +$GRUBDIR="/boot/grub"; + +# Parse the menu file, and see if we can get a match for a maybe given arg. +open(MENU, "<$GRUBDIR/menu.lst") || die "no menu.lst in $GRUBDIR"; +$gotit = 0; +$titleno = -1; +$global_default = undef; +while() { + m,\s*default\s+(.+), && $titleno == -1 && ($global_default = $1); + next unless m,\s*title\s+(.*),i; + $title_name = $1; + $titleno++; + + if (@ARGV > 0) { + # Argument may be entirely numerical, in which case it is an index, + # or a perl RE that leads to the first title matching. + if (( $ARGV[0] =~ m,[0-9]+, && $titleno eq $ARGV[0] ) || + ( $ARGV[0] !~ m,[0-9]+, && $title_name =~ m,$ARGV[0],i) ) { + $gotit = 1; + last; + } + } else { + print "$titleno: $title_name\n"; + } +} +close(MENU); + +print "Warning: you haven't set a global default!\n" if !defined($global_default); + +# Without a command line argument, we have now listet the titles and are done. +exit 0 if @ARGV < 1; + +# Else the user wants to write the default file. We have better found a match! +if ($gotit > 0) { + print "Warning: your global default is 'saved'; changing default permanently!" + if $global_default eq "saved"; + + print "Using entry #$titleno: $title_name\n"; + + # set the magic one-time flag + $titleno |= 0x4000; + + open(DEFFILE, ">$GRUBDIR/default") || + die "Cannot open default file for writing"; + $buf = $titleno . "\0" . "\n" x 9; + syswrite(DEFFILE, $buf, 10); + close(DEFFILE); + + exit 0; +} else { + print $ARGV[0] . " not found in $GRUBDIR/menu.lst\n"; + exit 1; +} + diff --git a/src/patches/SuSE10.2/installgrub b/src/patches/SuSE10.2/installgrub new file mode 100644 index 000000000..fa3defa11 --- /dev/null +++ b/src/patches/SuSE10.2/installgrub @@ -0,0 +1,477 @@ +#!/bin/bash +# +# installgrub +# +# Program to automatically install GNU/GrUB under Linux +# +# Copyright: (c) SuSE GmbH, Nuernberg, Germany +# +# Authors: Thorsten Wandersmann +# Philipp Thomas +# +# $Id: installgrub,v 0.15 2002/01/22 18:06:14 pthomas Exp $ +# + + +################################################################################ +# +# Name: funct_see +# +# Synopsis: funct_see +# +# Description: sets -x + +function funct_see () { + set -x +return +} +#------------------------------------------------------------------------------- + + +################################################################################ +# +# Name: funct_help +# +# Synopsis: funct_help help +# funct_help "message" +# +# Description: funct_help will print out the help for the programm if +# the keyword "help" is passed to it and will exit with "0". +# In other cases it will print out the "message" as error, print +# out the help and then exit with "1". + +function funct_help () { + if [ "$1" = "help" ]; then + funct_print_help + exit 0 + fi + + echo "WARNING: $1" + echo "" + funct_print_help + exit 1 +} +#------------------------------------------------------------------------------- + + +################################################################################ +# +# Name: funct_print_help +# +# Synopsis: funct_help +# +# Description: funct_print_help only prints out the helpscreen and then +# returns. +# + +function funct_print_help () { + funct_version + echo "" + echo "NAME: installgrub" + echo "Synopsis: $0 help" + echo " $0 ide|scsi [debug]" + echo " $0 version" + echo "Description:" + echo "$0 will install grub on your system and, hopefully, will correctly" + echo "find all things needed." + echo "Usage: help - will print out this screen" + echo " ide|scsi - GRUB enumerates all drives, ide and scsi, beginning" + echo " with '0', just like the BIOS will report them." + echo " What it does not regard is SCSI/IDE boot order." + echo " If you have SCSI and IDE hard disks installed," + echo " GRUB will start enumeration with the SCSI drives." + echo " So in order to correctly install GRUB, you" + echo " have to tell it whether booting starts with IDE" + echo " or SCSI" + echo " debug - causes a lot of messages to be written to" + echo " /var/log/installgrub.msg" + echo " version - prints out the version" + echo "" + echo "Send bugreports to 'pthomas@suse.de'" + echo "" +return +} +#------------------------------------------------------------------------------- + + +################################################################################ +# +# Name: funct_version +# +# Synopsios: funct_version +# +# Description: Extract version info from RCS tag. +# + +function funct_version () { + + VERSION=`cat $0 | grep "^#.*Id" | gawk '{print $4" checked in on "$5}'` + echo "This is 'installgrub' version $VERSION." +return +} +#------------------------------------------------------------------------------- + +################################################################################ +# +# Name: funct_entry +# +# Description: Prepare an entry +# + +function funct_entry() { + DESCR=$1 + O_ROOT=`echo $CASE | cut -d"-" -f2` + O_ROOT_NR=`echo $O_ROOT | cut -c 9-10` + O_ROOT_HD=`echo $O_ROOT | cut -c 1-8` + G_O_HD=`grep $O_ROOT_HD /boot/grub/device.map | cut -c 2-4` + G_O_NR=`expr $O_ROOT_NR - 1` + G_O="($G_O_HD,$G_O_NR)" + + ENTRY="$ENTRY\n\n# Entry -- $DESCR\ntitle $DESCR on $O_ROOT\nroot $G_O\nmakeaktive\nchainloader +1" + +} +#------------------------------------------------------------------------------- + + +################################################################################ +# +# Name: funct_options +# +# Description: Sort the options given at the command-line. +# + +function funct_options() { + + if [ "$1" = "debug" -o "$2" = "debug" ]; then + DEB="yes" + fi + + if [ "$1" = "help" -o "$2" = "help" ]; then + funct_help help + exit 0 + fi + + if [ "$1" = "version" -o "$2" = "version" ]; then + funct_version + exit 0 + fi + + if [ "$1" = "scsi" -o "$2" = "scsi" ]; then + DEVICE="scsi" + fi + + if [ "$1" = "ide" -o "$2" = "ide" ]; then + DEVICE="ide" + fi + + test "$DEVICE" || funct_help "No device specified" +return +} +#------------------------------------------------------------------------------- + + +################################################################################ +# +# Name: funct_parts +# +# Synopsis: funct_parts +# +# Descriptiuon: Searches the root-partition for GrUB (the Partition +# that inhabits /boot) and the Linux Root Partition. +# + +function funct_parts () { + + L_BOOT=`grep "[[:space:]]/boot[[:space:]]" /etc/fstab | cut -d" " -f1` + L_ROOT=`grep "[[:space:]]/[[:space:]]" /etc/fstab | cut -d" " -f1` + + test -d "/boot" -a -z "$L_BOOT" && BOOT="d" + test -L "/boot" -a -z "$L_BOOT" && BOOT="l" + + case "$BOOT" in + d) + L_BOOT="$L_ROOT" + ;; + l) + BO_LINK=`ls -l /boot | gawk '{sub(/\/$/, "");print $NF}'` + L_BOOT=`grep "[[:space:]]$BO_LINK[[:space:]]" /etc/fstab | gawk '{print $1}'` + test "$L_BOOT" || L_BOOT="$L_ROOT" + ;; + *) + test -e "/boot" || \ + funct_help \ + "No /boot found! If you use another Directory, please make a Link." + ;; + esac + + L_BOOT_NR=`echo $L_BOOT | cut -c 9-10` + L_BOOT_HD=`echo $L_BOOT | cut -c 1-8` + G_ROOT_HD=`grep $L_BOOT_HD /boot/grub/device.map | cut -c 2-4` + G_ROOT_NR=`expr $L_BOOT_NR - 1` + G_ROOT="($G_ROOT_HD,$G_ROOT_NR)" +return +} +#------------------------------------------------------------------------------- + + +################################################################################ +# +# Name: funct_ide +# +# Synopsis: funct_ide +# +# Description: Serches the first IDE-HD-Drive. +# + +function funct_ide () { + + FDISK=`sfdisk -l | grep "^Disk" | grep "/dev/hd" | cut -c 6-13` + COUNTER=0 + + for i in $FDISK; do + eval FDISK_$COUNTER="$i" + COUNTER=`expr $COUNTER + 1` + done + + echo $FDISK_0 + +return +} +#------------------------------------------------------------------------------- + + +################################################################################ +# +# Name funct_ginst +# +# Synopsis: funct_ginst +# +# Description: "Installs" GrUB, that means, generates the /boot/grub/device.map +# file. +# + +function funct_ginst () { + + + case "$DEVICE" in + scsi) + grub-install --recheck --root-directory=/boot /dev/sda + ;; + ide) + IDE=`funct_ide` + grub-install --recheck --root-directory=/boot $IDE + ;; + esac + # Seems, that the documentation is not right anymore. IDE seems to be + # always the first disk in grub. So its better to always do IDE as + # first boot in mix-systems. So you can say, use always (hd0) + I_ROOT="hd0" + # This is kind of a test. + +return +} +#------------------------------------------------------------------------------- + + +################################################################################ +# +# Name: funct_oses +# +# Synopsis: +# +# Description: Searches all partitions and add those found to the menu +# + +function funct_oses () { + + KERNELS=`file /boot/* | grep Kernel | cut -d":" -f1 | cut -d"/" -f3` + + for i in $KERNELS; do +INITRD="" +INITRD_FILE="" + + SUFFIX=`echo $i | gawk 'BEGIN {FS="vmlinuz"}{print $2}'` + + test -e /boot/initrd && INITRD_FILE="initrd" + test -e "/boot/initrd$SUFFIX" && INITRD_FILE="initrd$SUFFIX" + + test "$INITRD_FILE" && INITRD="initrd /$INITRD_FILE" + test "$INITRD" || INITRD_FILE="" + + ENTRY="$ENTRY\n\n# Entry -- $i with initrd: $INITRD_FILE\ntitle Linux on $L_ROOT -- \"$i\", \"$INITRD_FILE\", \"$G_ROOT\"\nroot $G_ROOT\nkernel /$i root=$L_ROOT\n$INITRD" + done + + PARTITIONS=`sfdisk -d | grep "^/dev" | gawk 'BEGIN {FIELDWIDTHS = "10 37 2"}{print $3"-"$1}'` + + for CASE in $PARTITIONS; do + case "$CASE" in + "1-"* | "4-"* | "6-"* | "b-"* | "c-"* | "e-"* | "1-"* | \ + "11-"* | "14-"* | "16-"* | "1b-"* | "1c-"* | "1e-"* | \ + "24-"* | "c1-"* | "c4-"* | "c6-"* | "e1-"* | "e3-"* ) + funct_entry "DOS/Win" + ;; + "7-"* | "17-"* | "84-"* ) + funct_entry "OS/2" + ;; + "a-"* ) + funct_entry "OS/2 BootManager" + ;; + "17-"* | "84-"* ) + funct_entry "WinNT" + ;; + "82-"* ) + SWAPP=`echo $CASE | cut -d"-" -f2` + SWAPT=`mount $SWAPP /tmp 2>&1 | grep swapspace ; + umount /tmp 2>/dev/null` + test "$SWAPT" || funct_entry "Solaris or SWAP !!!" ;; + esac + done +return +} +#------------------------------------------------------------------------------- + + +################################################################################ +# +# Name: funct_build +# +# Synopsis: funct_build +# +# Description: Builds the menu.lst file. +# + +function funct_build () { + DATE=`date` + ENTRY="# Automatic generated on $DATE\ntimeout 30\ndefault 0\ncolor green/light-gray black/cyan" + funct_oses + ENTRY="$ENTRY\n\n# Automatic End\n# Inserting Menu.own\n\n" + + test -e /boot/grub/menu.lst && cp /boot/grub/menu.lst /boot/grub/menu.old + echo -e "$ENTRY" > /boot/grub/menu.lst + test -e /boot/grub/menu.own && cat /boot/grub/menu.own >> /boot/grub/menu.lst + ENTRY="$ENTRY\n\n# Inserting Menu.own end\n\n# Have a lot of fun ..." +return +} +#------------------------------------------------------------------------------- + + +################################################################################ +# +# Name: funct_write +# +# Synopsis: funct_write +# +# Description: Writes GrUB to MBR +# +# Notice: Because of "EOF" there is no format. +# + +function funct_write () { + +grub << EOF +root $G_ROOT +install /boot/grub/stage1 d ($I_ROOT) ($I_ROOT)1+16 p $G_ROOT/boot/grub/stage2 /boot/grub/menu.lst +quit +EOF + +return +} +#------------------------------------------------------------------------------- + +################################################################################ +# +# This is the Main-Programm ;-) +# + + +test "$1" = "see" -o "$2" = "see" -o "$3" = "see" && funct_see + +funct_options $1 $2 +funct_ginst +funct_parts +funct_build +funct_write + +exit 0 +#------------------------------------------------------------------------------- + + +################################################################################ +# +# End Of INSTALLGRUB +# +# $Log: installgrub,v $ +# Revision 0.15 2002/01/22 18:06:14 pthomas +# - Output bugreport address in help, not in version. +# - Reformat help output a bit. +# +# Revision 0.14 2002/01/22 18:00:02 pthomas +# Correct typo. +# +# Revision 0.13 2002/01/22 14:58:14 pthomas +# Correct spelling and comments. +# Change bugreport address to pthomas@suse.de +# +# Revision 0.12 2000/12/19 12:14:46 root +# - fixed the version information in help +# - rewrote the part, the scripts looks for the patitions. +# that means, now its a case, and all partitions will go throug it. +# - droped funct_debug its useless now. +# +# Revision 0.11 2000/09/23 13:19:40 root +# found kind of a bug +# the manuel of grub says, that your hd-order depends on the bios. +# that means: is the first thing to boot ide or scsi. +# well in single-systems this do nithing, but it seems, that +# against the manuel, the ide-drive is always the first one in grub. +# even if the bios says something else. +# so i got an error to boot from scsi. after booting in bios from scsi +# all went well. +# +# Revision 0.10 2000/09/23 12:05:06 root +# did a fix for scsi ide mix-systems +# rerun grub-install with an existing device.map can couse nothing. +# so if a hd is added, it could be, that it will not be found. +# better to remove the file first and then run grub-install +# +# Revision 0.9 2000/09/23 11:06:27 root +# enterd the possibility to have an menu.own file. +# menu.own will be appand below the automatic entrys. +# old menu.lst will be saved to menu.old +# +# Revision 0.8 2000/09/23 08:33:29 root +# make os/2 and nt detection ready. +# build in detection of /boot, if /boot is not SuSE-Standard +# fixed initrd-Entry +# todo: description fixing of the functions +# will rebuild the detection of the OSes -> going throug all partitions +# and than go through a case. +# +# Revision 0.7 2000/09/18 11:53:22 root +# fixed debug-messages +# added option see for set -x +# todo: correct the descriptions of the functions +# +# Revision 0.6 2000/09/18 07:22:59 root +# minor bug fixed +# +# Revision 0.5 2000/09/18 07:18:55 root +# made it nicer +# mor functions, structure for other OS +# all kernels, with different initrds +# +# Revision 0.4 2000/09/15 13:42:26 root +# minor bug fixed +# +# Revision 0.3 2000/09/15 13:37:02 root +# First Version that really installs grub, but only linux +# +# Revision 0.2 2000/09/15 12:16:12 root +# ok, now it works as i wanted it +# +# Revision 0.1 2000/09/15 11:54:37 root +# First little try, only for testing. +# It will do nothing, because GrUB is disabled in this version. +# Lets see if the idea is working. +# + diff --git a/src/patches/SuSE10.2/reiser-unpack b/src/patches/SuSE10.2/reiser-unpack new file mode 100644 index 000000000..5b1c3c461 --- /dev/null +++ b/src/patches/SuSE10.2/reiser-unpack @@ -0,0 +1,45 @@ +--- grub-0.95/stage2/filesys.h.orig 2004-05-14 21:36:43.000000000 +0200 ++++ grub-0.95/stage2/filesys.h 2004-09-30 17:16:20.741176364 +0200 +@@ -73,6 +73,16 @@ + int reiserfs_read (char *buf, int len); + int reiserfs_dir (char *dirname); + int reiserfs_embed (int *start_sector, int needed_sectors); ++#if defined(__linux__) && defined (GRUB_UTIL) ++#include ++#include ++#include ++#include ++#include ++/* from */ ++#define REISERFS_SUPER_MAGIC 0x52654973 ++#define REISERFS_IOC_UNPACK _IOW(0xCD,1,long) ++#endif + #else + #define FSYS_REISERFS_NUM 0 + #endif +--- grub-0.95/stage2/builtins.c.orig 2004-05-14 21:30:52.000000000 +0200 ++++ grub-0.95/stage2/builtins.c 2004-09-30 17:18:52.342818812 +0200 +@@ -1807,9 +1807,23 @@ + #ifdef GRUB_UTIL + else if (grub_memcmp ("--stage2=", arg, sizeof ("--stage2=") - 1) == 0) + { ++ int fd; + stage2_os_file = arg + sizeof ("--stage2=") - 1; + arg = skip_to (0, arg); + nul_terminate (stage2_os_file); ++ ++#if defined(__linux__) && defined (FSYS_REISERFS) ++ if ((fd=open(stage2_os_file, O_RDONLY)) >= 0) ++ { ++ struct statfs buf; ++ /* see if the file sits on a reiserfs, ++ and try do defragment it if so. */ ++ fstatfs(fd, &buf); ++ if (buf.f_type == REISERFS_SUPER_MAGIC) ++ ioctl (fd, REISERFS_IOC_UNPACK, 1); ++ } ++#endif /* __linux__ && FSYS_REISERFS */ ++ + } + #endif /* GRUB_UTIL */ + else diff --git a/src/patches/SuSE10.2/stage2-dir-callback.diff b/src/patches/SuSE10.2/stage2-dir-callback.diff new file mode 100644 index 000000000..2ae6d4242 --- /dev/null +++ b/src/patches/SuSE10.2/stage2-dir-callback.diff @@ -0,0 +1,708 @@ +Index: grub-0.95/stage2/fsys_jfs.c +=================================================================== +--- grub-0.95.orig/stage2/fsys_jfs.c ++++ grub-0.95/stage2/fsys_jfs.c +@@ -270,7 +270,7 @@ jfs_read (char *buf, int len) + } + + int +-jfs_dir (char *dirname) ++jfs_dir (char *dirname, void (*handle)(char *)) + { + char *ptr, *rest, ch; + ldtentry_t *de; +@@ -357,12 +357,9 @@ jfs_dir (char *dirname) + + cmp = (!*dirname) ? -1 : substring (dirname, namebuf); + #ifndef STAGE1_5 +- if (print_possibilities && ch != '/' +- && cmp <= 0) { +- if (print_possibilities > 0) +- print_possibilities = -print_possibilities; +- print_a_completion (namebuf); +- } else ++ if (handle && ch != '/' && cmp <= 0) ++ handle (namebuf); ++ else + #endif + if (cmp == 0) { + parent_inum = inum; +@@ -372,9 +369,6 @@ jfs_dir (char *dirname) + } + de = next_dentry (); + if (de == NULL) { +- if (print_possibilities < 0) +- return 1; +- + errnum = ERR_FILE_NOT_FOUND; + *rest = ch; + return 0; +Index: grub-0.95/stage2/fsys_minix.c +=================================================================== +--- grub-0.95.orig/stage2/fsys_minix.c ++++ grub-0.95/stage2/fsys_minix.c +@@ -294,7 +294,7 @@ minix_read (char *buf, int len) + inode of the file we were trying to look up + side effects: none yet */ + int +-minix_dir (char *dirname) ++minix_dir (char *dirname, void (*handle)(char *)) + { + int current_ino = MINIX_ROOT_INO; /* start at the root */ + int updir_ino = current_ino; /* the parent of the current directory */ +@@ -457,18 +457,9 @@ minix_dir (char *dirname) + give up */ + if (loc >= INODE->i_size) + { +- if (print_possibilities < 0) +- { +-#if 0 +- putchar ('\n'); +-#endif +- } +- else +- { +- errnum = ERR_FILE_NOT_FOUND; +- *rest = ch; +- } +- return (print_possibilities < 0); ++ errnum = ERR_FILE_NOT_FOUND; ++ *rest = ch; ++ return 0; + } + + /* else, find the (logical) block component of our location */ +@@ -510,20 +501,15 @@ minix_dir (char *dirname) + str_chk = substring (dirname, dp->name); + + # ifndef STAGE1_5 +- if (print_possibilities && ch != '/' +- && (!*dirname || str_chk <= 0)) +- { +- if (print_possibilities > 0) +- print_possibilities = -print_possibilities; +- print_a_completion (dp->name); +- } ++ if (handle && ch != '/' && (!*dirname || str_chk <= 0)) ++ handle (dp->name); + # endif + + dp->name[namelen] = saved_c; + } + + } +- while (!dp->inode || (str_chk || (print_possibilities && ch != '/'))); ++ while (!dp->inode || (str_chk || (handle && ch != '/'))); + + current_ino = dp->inode; + *(dirname = rest) = ch; +Index: grub-0.95/stage2/fsys_reiserfs.c +=================================================================== +--- grub-0.95.orig/stage2/fsys_reiserfs.c ++++ grub-0.95/stage2/fsys_reiserfs.c +@@ -991,7 +991,7 @@ reiserfs_read (char *buf, int len) + * the size of the file. + */ + int +-reiserfs_dir (char *dirname) ++reiserfs_dir (char *dirname, void (*handle)(char *)) + { + struct reiserfs_de_head *de_head; + char *rest, ch; +@@ -1123,7 +1123,7 @@ reiserfs_dir (char *dirname) + *rest = 0; + + # ifndef STAGE1_5 +- if (print_possibilities && ch != '/') ++ if (handle && ch != '/') + do_possibilities = 1; + # endif /* ! STAGE1_5 */ + +@@ -1170,10 +1170,8 @@ reiserfs_dir (char *dirname) + { + if (cmp <= 0) + { +- if (print_possibilities > 0) +- print_possibilities = -print_possibilities; + *name_end = 0; +- print_a_completion (filename); ++ handle (filename); + *name_end = tmp; + } + } +@@ -1189,12 +1187,6 @@ reiserfs_dir (char *dirname) + num_entries--; + } + } +- +-# ifndef STAGE1_5 +- if (print_possibilities < 0) +- return 1; +-# endif /* ! STAGE1_5 */ +- + errnum = ERR_FILE_NOT_FOUND; + *rest = ch; + return 0; +Index: grub-0.95/stage2/fsys_iso9660.c +=================================================================== +--- grub-0.95.orig/stage2/fsys_iso9660.c ++++ grub-0.95/stage2/fsys_iso9660.c +@@ -133,7 +133,7 @@ iso9660_mount (void) + } + + int +-iso9660_dir (char *dirname) ++iso9660_dir (char *dirname, void (*handle)(char *)) + { + struct iso_directory_record *idr; + RR_ptr_t rr_ptr; +@@ -346,7 +346,7 @@ iso9660_dir (char *dirname) + if (name_len >= pathlen + && !memcmp(name, dirname, pathlen)) + { +- if (dirname[pathlen] == '/' || !print_possibilities) ++ if (dirname[pathlen] == '/' || !handle) + { + /* + * DIRNAME is directory component of pathname, +@@ -377,11 +377,9 @@ iso9660_dir (char *dirname) + else /* Completion */ + { + #ifndef STAGE1_5 +- if (print_possibilities > 0) +- print_possibilities = -print_possibilities; + memcpy(NAME_BUF, name, name_len); + NAME_BUF[name_len] = '\0'; +- print_a_completion (NAME_BUF); ++ handle (NAME_BUF); + #endif + } + } +@@ -390,7 +388,7 @@ iso9660_dir (char *dirname) + size -= ISO_SECTOR_SIZE; + } /* size>0 */ + +- if (dirname[pathlen] == '/' || print_possibilities >= 0) ++ if (dirname[pathlen] == '/' || handle) + { + errnum = ERR_FILE_NOT_FOUND; + return 0; +Index: grub-0.95/stage2/fsys_fat.c +=================================================================== +--- grub-0.95.orig/stage2/fsys_fat.c ++++ grub-0.95/stage2/fsys_fat.c +@@ -286,7 +286,7 @@ fat_read (char *buf, int len) + } + + int +-fat_dir (char *dirname) ++fat_dir (char *dirname, void (*handle)(char *)) + { + char *rest, ch, dir_buf[FAT_DIRENTRY_LENGTH]; + char *filename = (char *) NAME_BUF; +@@ -342,7 +342,7 @@ fat_dir (char *dirname) + *rest = 0; + + # ifndef STAGE1_5 +- if (print_possibilities && ch != '/') ++ if (handle && ch != '/') + do_possibilities = 1; + # endif + +@@ -353,16 +353,6 @@ fat_dir (char *dirname) + { + if (!errnum) + { +-# ifndef STAGE1_5 +- if (print_possibilities < 0) +- { +-#if 0 +- putchar ('\n'); +-#endif +- return 1; +- } +-# endif /* STAGE1_5 */ +- + errnum = ERR_FILE_NOT_FOUND; + *rest = ch; + } +@@ -457,11 +447,7 @@ fat_dir (char *dirname) + { + print_filename: + if (substring (dirname, filename) <= 0) +- { +- if (print_possibilities > 0) +- print_possibilities = -print_possibilities; +- print_a_completion (filename); +- } ++ handle (filename); + continue; + } + # endif /* STAGE1_5 */ +Index: grub-0.95/stage2/filesys.h +=================================================================== +--- grub-0.95.orig/stage2/filesys.h ++++ grub-0.95/stage2/filesys.h +@@ -24,7 +24,7 @@ + #define FSYS_FFS_NUM 1 + int ffs_mount (void); + int ffs_read (char *buf, int len); +-int ffs_dir (char *dirname); ++int ffs_dir (char *dirname, void (*handle)(char *)); + int ffs_embed (int *start_sector, int needed_sectors); + #else + #define FSYS_FFS_NUM 0 +@@ -34,7 +34,7 @@ int ffs_embed (int *start_sector, int ne + #define FSYS_UFS2_NUM 1 + int ufs2_mount (void); + int ufs2_read (char *buf, int len); +-int ufs2_dir (char *dirname); ++int ufs2_dir (char *dirname, void (*handle)(char *)); + int ufs2_embed (int *start_sector, int needed_sectors); + #else + #define FSYS_UFS2_NUM 0 +@@ -44,7 +44,7 @@ int ufs2_embed (int *start_sector, int n + #define FSYS_FAT_NUM 1 + int fat_mount (void); + int fat_read (char *buf, int len); +-int fat_dir (char *dirname); ++int fat_dir (char *dirname, void (*handle)(char *)); + #else + #define FSYS_FAT_NUM 0 + #endif +@@ -53,7 +53,7 @@ int fat_dir (char *dirname); + #define FSYS_EXT2FS_NUM 1 + int ext2fs_mount (void); + int ext2fs_read (char *buf, int len); +-int ext2fs_dir (char *dirname); ++int ext2fs_dir (char *dirname, void (*handle)(char *)); + #else + #define FSYS_EXT2FS_NUM 0 + #endif +@@ -62,7 +62,7 @@ int ext2fs_dir (char *dirname); + #define FSYS_MINIX_NUM 1 + int minix_mount (void); + int minix_read (char *buf, int len); +-int minix_dir (char *dirname); ++int minix_dir (char *dirname, void (*handle)(char *)); + #else + #define FSYS_MINIX_NUM 0 + #endif +@@ -71,7 +71,7 @@ int minix_dir (char *dirname); + #define FSYS_REISERFS_NUM 1 + int reiserfs_mount (void); + int reiserfs_read (char *buf, int len); +-int reiserfs_dir (char *dirname); ++int reiserfs_dir (char *dirname, void (*handle)(char *)); + int reiserfs_embed (int *start_sector, int needed_sectors); + #else + #define FSYS_REISERFS_NUM 0 +@@ -81,7 +81,7 @@ int reiserfs_embed (int *start_sector, i + #define FSYS_VSTAFS_NUM 1 + int vstafs_mount (void); + int vstafs_read (char *buf, int len); +-int vstafs_dir (char *dirname); ++int vstafs_dir (char *dirname, void (*handle)(char *)); + #else + #define FSYS_VSTAFS_NUM 0 + #endif +@@ -90,7 +90,7 @@ int vstafs_dir (char *dirname); + #define FSYS_JFS_NUM 1 + int jfs_mount (void); + int jfs_read (char *buf, int len); +-int jfs_dir (char *dirname); ++int jfs_dir (char *dirname, void (*handle)(char *)); + int jfs_embed (int *start_sector, int needed_sectors); + #else + #define FSYS_JFS_NUM 0 +@@ -100,7 +100,7 @@ int jfs_embed (int *start_sector, int ne + #define FSYS_XFS_NUM 1 + int xfs_mount (void); + int xfs_read (char *buf, int len); +-int xfs_dir (char *dirname); ++int xfs_dir (char *dirname, void (*handle)(char *)); + #else + #define FSYS_XFS_NUM 0 + #endif +@@ -109,7 +109,7 @@ int xfs_dir (char *dirname); + #define FSYS_TFTP_NUM 1 + int tftp_mount (void); + int tftp_read (char *buf, int len); +-int tftp_dir (char *dirname); ++int tftp_dir (char *dirname, void (*handle)(char *)); + void tftp_close (void); + #else + #define FSYS_TFTP_NUM 0 +@@ -119,7 +119,7 @@ void tftp_close (void); + #define FSYS_ISO9660_NUM 1 + int iso9660_mount (void); + int iso9660_read (char *buf, int len); +-int iso9660_dir (char *dirname); ++int iso9660_dir (char *dirname, void (*handle)(char *)); + #else + #define FSYS_ISO9660_NUM 0 + #endif +@@ -150,16 +150,10 @@ struct fsys_entry + char *name; + int (*mount_func) (void); + int (*read_func) (char *buf, int len); +- int (*dir_func) (char *dirname); ++ int (*dir_func) (char *dirname, void (*print_one)(char *)); + void (*close_func) (void); + int (*embed_func) (int *start_sector, int needed_sectors); + }; + +-#ifdef STAGE1_5 +-# define print_possibilities 0 +-#else +-extern int print_possibilities; +-#endif +- + extern int fsmax; + extern struct fsys_entry fsys_table[NUM_FSYS + 1]; +Index: grub-0.95/stage2/fsys_ext2fs.c +=================================================================== +--- grub-0.95.orig/stage2/fsys_ext2fs.c ++++ grub-0.95/stage2/fsys_ext2fs.c +@@ -491,7 +491,7 @@ int ext2_is_fast_symlink (void) + * side effects: messes up GROUP_DESC buffer area + */ + int +-ext2fs_dir (char *dirname) ++ext2fs_dir (char *dirname, void (*handle)(char *)) + { + int current_ino = EXT2_ROOT_INO; /* start at the root */ + int updir_ino = current_ino; /* the parent of the current directory */ +@@ -517,7 +517,6 @@ ext2fs_dir (char *dirname) + #ifdef E2DEBUG + unsigned char *i; + #endif /* E2DEBUG */ +- + /* loop invariants: + current_ino = inode to lookup + dirname = pointer to filename component we are cur looking up within +@@ -709,18 +708,9 @@ ext2fs_dir (char *dirname) + give up */ + if (loc >= INODE->i_size) + { +- if (print_possibilities < 0) +- { +-# if 0 +- putchar ('\n'); +-# endif +- } +- else +- { +- errnum = ERR_FILE_NOT_FOUND; +- *rest = ch; +- } +- return (print_possibilities < 0); ++ errnum = ERR_FILE_NOT_FOUND; ++ *rest = ch; ++ return 0; + } + + /* else, find the (logical) block component of our location */ +@@ -761,20 +751,15 @@ ext2fs_dir (char *dirname) + str_chk = substring (dirname, dp->name); + + # ifndef STAGE1_5 +- if (print_possibilities && ch != '/' +- && (!*dirname || str_chk <= 0)) +- { +- if (print_possibilities > 0) +- print_possibilities = -print_possibilities; +- print_a_completion (dp->name); +- } ++ if (handle && ch != '/' && (!*dirname || str_chk <= 0)) ++ handle (dp->name); + # endif + + dp->name[dp->name_len] = saved_c; + } + + } +- while (!dp->inode || (str_chk || (print_possibilities && ch != '/'))); ++ while (!dp->inode || (str_chk || (handle && ch != '/'))); + + current_ino = dp->inode; + *(dirname = rest) = ch; +Index: grub-0.95/stage2/fsys_ffs.c +=================================================================== +--- grub-0.95.orig/stage2/fsys_ffs.c ++++ grub-0.95/stage2/fsys_ffs.c +@@ -180,7 +180,7 @@ ffs_read (char *buf, int len) + + + int +-ffs_dir (char *dirname) ++ffs_dir (char *dirname, void (*handle)(char *)) + { + char *rest, ch; + int block, off, loc, map, ino = ROOTINO; +@@ -236,13 +236,6 @@ loop: + { + if (loc >= INODE->i_size) + { +-#if 0 +- putchar ('\n'); +-#endif +- +- if (print_possibilities < 0) +- return 1; +- + errnum = ERR_FILE_NOT_FOUND; + *rest = ch; + return 0; +@@ -267,18 +260,13 @@ loop: + loc += dp->d_reclen; + + #ifndef STAGE1_5 +- if (dp->d_ino && print_possibilities && ch != '/' ++ if (dp->d_ino && handle && ch != '/' + && (!*dirname || substring (dirname, dp->d_name) <= 0)) +- { +- if (print_possibilities > 0) +- print_possibilities = -print_possibilities; +- +- print_a_completion (dp->d_name); +- } ++ handle (dp->d_name); + #endif /* STAGE1_5 */ + } + while (!dp->d_ino || (substring (dirname, dp->d_name) != 0 +- || (print_possibilities && ch != '/'))); ++ || (handle && ch != '/'))); + + /* only get here if we have a matching directory entry */ + +Index: grub-0.95/stage2/fsys_vstafs.c +=================================================================== +--- grub-0.95.orig/stage2/fsys_vstafs.c ++++ grub-0.95/stage2/fsys_vstafs.c +@@ -115,7 +115,7 @@ vstafs_nextdir (void) + } + + int +-vstafs_dir (char *dirname) ++vstafs_dir (char *dirname, void (*handle)(char *)) + { + char *fn, ch; + struct dir_entry *d; +@@ -146,14 +146,9 @@ vstafs_dir (char *dirname) + continue; + + #ifndef STAGE1_5 +- if (print_possibilities && ch != '/' ++ if (handle && ch != '/' + && (! *dirname || strcmp (dirname, d->name) <= 0)) +- { +- if (print_possibilities > 0) +- print_possibilities = -print_possibilities; +- +- printf (" %s", d->name); +- } ++ handle(d->name); + #endif + if (! grub_strcmp (dirname, d->name)) + { +@@ -168,12 +163,6 @@ vstafs_dir (char *dirname) + *(dirname = fn) = ch; + if (! d) + { +- if (print_possibilities < 0) +- { +- putchar ('\n'); +- return 1; +- } +- + errnum = ERR_FILE_NOT_FOUND; + return 0; + } +Index: grub-0.95/stage2/fsys_ufs2.c +=================================================================== +--- grub-0.95.orig/stage2/fsys_ufs2.c ++++ grub-0.95/stage2/fsys_ufs2.c +@@ -204,7 +204,7 @@ ufs2_read (char *buf, int len) + } + + int +-ufs2_dir (char *dirname) ++ufs2_dir (char *dirname, void (*handle)(char *)) + { + char *rest, ch; + int block, off, loc, ino = ROOTINO; +@@ -261,9 +261,6 @@ loop: + { + if (loc >= INODE_UFS2->di_size) + { +- if (print_possibilities < 0) +- return 1; +- + errnum = ERR_FILE_NOT_FOUND; + *rest = ch; + return 0; +@@ -288,18 +285,13 @@ loop: + loc += dp->d_reclen; + + #ifndef STAGE1_5 +- if (dp->d_ino && print_possibilities && ch != '/' ++ if (dp->d_ino && handle && ch != '/' + && (!*dirname || substring (dirname, dp->d_name) <= 0)) +- { +- if (print_possibilities > 0) +- print_possibilities = -print_possibilities; +- +- print_a_completion (dp->d_name); +- } ++ handle (dp->d_name); + #endif /* STAGE1_5 */ + } + while (!dp->d_ino || (substring (dirname, dp->d_name) != 0 +- || (print_possibilities && ch != '/'))); ++ || (handle && ch != '/'))); + + /* only get here if we have a matching directory entry */ + +Index: grub-0.95/stage2/disk_io.c +=================================================================== +--- grub-0.95.orig/stage2/disk_io.c ++++ grub-0.95/stage2/disk_io.c +@@ -36,7 +36,6 @@ void (*disk_read_hook) (int, int, int) = + void (*disk_read_func) (int, int, int) = NULL; + + #ifndef STAGE1_5 +-int print_possibilities; + + static int do_completion; + static int unique; +@@ -1479,7 +1478,7 @@ print_completions (int is_filename, int + if (! is_completion) + grub_printf (" Possible files are:"); + +- dir (buf); ++ dir (buf, print_a_completion); + + if (is_completion && *unique_string) + { +@@ -1498,7 +1497,7 @@ print_completions (int is_filename, int + *ptr = '/'; + *(ptr + 1) = 0; + +- dir (buf); ++ dir (buf, print_a_completion); + + /* Restore the original unique value. */ + unique = 1; +@@ -1626,12 +1625,7 @@ grub_open (char *filename) + if (!errnum && fsys_type == NUM_FSYS) + errnum = ERR_FSYS_MOUNT; + +-# ifndef STAGE1_5 +- /* set "dir" function to open a file */ +- print_possibilities = 0; +-# endif +- +- if (!errnum && (*(fsys_table[fsys_type].dir_func)) (filename)) ++ if (!errnum && (*(fsys_table[fsys_type].dir_func)) (filename, NULL)) + { + #ifndef NO_DECOMPRESSION + return gunzip_test_header (); +@@ -1752,7 +1746,7 @@ grub_seek (int offset) + } + + int +-dir (char *dirname) ++dir (char *dirname, void (*handle)(char *)) + { + #ifndef NO_DECOMPRESSION + compressed_file = 0; +@@ -1761,19 +1755,18 @@ dir (char *dirname) + if (!(dirname = setup_part (dirname))) + return 0; + ++ errnum = 0; + if (*dirname != '/') + errnum = ERR_BAD_FILENAME; +- +- if (fsys_type == NUM_FSYS) ++ else if (fsys_type == NUM_FSYS) + errnum = ERR_FSYS_MOUNT; +- +- if (errnum) +- return 0; +- +- /* set "dir" function to list completions */ +- print_possibilities = 1; +- +- return (*(fsys_table[fsys_type].dir_func)) (dirname); ++ else ++ { ++ fsys_table[fsys_type].dir_func (dirname, handle); ++ if (errnum == ERR_FILE_NOT_FOUND) ++ errnum = 0; ++ } ++ return errnum == 0; + } + #endif /* STAGE1_5 */ + +Index: grub-0.95/stage2/fsys_xfs.c +=================================================================== +--- grub-0.95.orig/stage2/fsys_xfs.c ++++ grub-0.95/stage2/fsys_xfs.c +@@ -534,7 +534,7 @@ xfs_read (char *buf, int len) + } + + int +-xfs_dir (char *dirname) ++xfs_dir (char *dirname, void (*handle)(char *)) + { + xfs_ino_t ino, parent_ino, new_ino; + xfs_fsize_t di_size; +@@ -595,11 +595,9 @@ xfs_dir (char *dirname) + for (;;) { + cmp = (!*dirname) ? -1 : substring (dirname, name); + #ifndef STAGE1_5 +- if (print_possibilities && ch != '/' && cmp <= 0) { +- if (print_possibilities > 0) +- print_possibilities = -print_possibilities; +- print_a_completion (name); +- } else ++ if (handle && ch != '/' && cmp <= 0) ++ handle (name); ++ else + #endif + if (cmp == 0) { + parent_ino = ino; +@@ -610,9 +608,6 @@ xfs_dir (char *dirname) + } + name = next_dentry (&new_ino); + if (name == NULL) { +- if (print_possibilities < 0) +- return 1; +- + errnum = ERR_FILE_NOT_FOUND; + *rest = ch; + return 0; +Index: grub-0.95/netboot/fsys_tftp.c +=================================================================== +--- grub-0.95.orig/netboot/fsys_tftp.c ++++ grub-0.95/netboot/fsys_tftp.c +@@ -409,7 +409,7 @@ tftp_read (char *addr, int size) + /* Check if the file DIRNAME really exists. Get the size and save it in + FILEMAX. */ + int +-tftp_dir (char *dirname) ++tftp_dir (char *dirname, void (*handle)(char *)) + { + int ch; + +@@ -418,7 +418,7 @@ tftp_dir (char *dirname) + #endif + + /* In TFTP, there is no way to know what files exist. */ +- if (print_possibilities) ++ if (handle) + return 1; + + /* Don't know the size yet. */ diff --git a/src/patches/SuSE10.2/stage2-wildcard-doc.diff b/src/patches/SuSE10.2/stage2-wildcard-doc.diff new file mode 100644 index 000000000..a8275b594 --- /dev/null +++ b/src/patches/SuSE10.2/stage2-wildcard-doc.diff @@ -0,0 +1,55 @@ +Index: grub-0.95/docs/grub.texi +=================================================================== +--- grub-0.95.orig/docs/grub.texi ++++ grub-0.95/docs/grub.texi +@@ -1933,6 +1933,7 @@ These commands can only be used in the m + * gfxmenu:: Use graphical menu interface + * timeout:: Set the timeout + * title:: Start a menu entry ++* wildcard:: Define a wildcard boot entry + @end menu + + +@@ -2001,6 +2002,42 @@ the line, starting with the first non-sp + @end deffn + + ++@node wildcard ++@subsection wildcard ++ ++@deffn Command wildcard pathname ++Treat this boot entry as a wildcard entry: The ++wildcard, title, kernel, and initrd commands (see @ref{Menu-specific ++commands} and @ref{Command-line and menu entry commands}) each have an ++asterisk (*) in their value. A filename match is performed on the ++@var{pathname} of the wildcard command. For each match, the entire boot ++entry is duplicated. The part of the filename whcih matches the asterisk ++in the wildcard command replaces the asterisks in the title, kernel, and ++initrd commands. For example, with the files vmlinuz-2.6.5-1 and ++vmlinuz-2.6.8-8 below (hd0,7)/boot, the following entry in the stage 2 ++configuration file: ++ ++@example ++title Linux-* ++ wildcard (hd0,7)/boot/vmlinuz-* ++ kernel (hd0,7)/boot/vmlinuz-* root=/dev/hda8 ++ initrd (hd0,7)/boot/initrd-* ++@end example ++ ++would expand as follows: ++ ++@example ++title Linux-2.6.5-1 ++ wildcard (hd0,7)/boot/vmlinuz-2.6.5-1 ++ kernel (hd0,7)/boot/vmlinuz-2.6.5-1 root=/dev/hda8 ++ initrd (hd0,7)/boot/initrd-2.6.5-1 ++title Linux-2.6.8-8 ++ wildcard (hd0,7)/boot/vmlinuz-2.6.8-8 ++ kernel (hd0,7)/boot/vmlinuz-2.6.8-8 root=/dev/hda8 ++ initrd (hd0,7)/boot/initrd-2.6.8-8 ++@end example ++@end deffn ++ + @node General commands + @section The list of general commands + diff --git a/src/patches/SuSE10.2/stage2-wildcard-zerowidth.diff b/src/patches/SuSE10.2/stage2-wildcard-zerowidth.diff new file mode 100644 index 000000000..efb69e7a6 --- /dev/null +++ b/src/patches/SuSE10.2/stage2-wildcard-zerowidth.diff @@ -0,0 +1,121 @@ +Index: grub-0.95/stage2/stage2.c +=================================================================== +--- grub-0.95.orig/stage2/stage2.c ++++ grub-0.95/stage2/stage2.c +@@ -1264,11 +1264,11 @@ wildcard_handler(char *name) + p = name + grub_strlen (name) - grub_strlen (wildcard_suffix); + /* [n .. p) is the part matching the asterisk */ + +- if (p <= n || grub_strcmp (p, wildcard_suffix) != 0) +- return; /* zero-length match or suffix mismatch */ ++ if (p < n || grub_strcmp (p, wildcard_suffix) != 0) ++ return; /* suffix mismatch */ + + /* store this match */ +- if (p - n + 2 > sizeof (wildcard_matches) - ++ if (p - n + 1 > sizeof (wildcard_matches) - + (end_wildcard_matches - wildcard_matches)) + return; /* out of space */ + while (n < p) +@@ -1279,7 +1279,7 @@ wildcard_handler(char *name) + /* Wildcard expand the GLOB argument. Return NULL upon failure, or + a list of 0-terminated expansions, terminated by a zero-length string. */ + char * +-wildcard (char *glob) ++wildcard (char *glob, int *len) + { + char path[128], *p; + int ret; +@@ -1324,25 +1324,25 @@ wildcard (char *glob) + wildcard_prefix[grub_strlen (wildcard_prefix)] = '*'; + if (!ret) + return NULL; +- *end_wildcard_matches++ = 0; ++ *len = end_wildcard_matches - wildcard_matches; + return wildcard_matches; + } + + #define skip(str) ((str) + grub_strlen (str) + 1) + +-static void inplace_sort (char *str); ++static void inplace_sort (char *str, int len); + + static void +-inplace_sort (char *str) ++inplace_sort (char *str, int len) + { + int m, n = 0; +- char *s, *t, *x; ++ char *s, *t; + +- for (s = str; *s; s = skip (s)) +- n++; +- + /* we use x as temporary storage */ +- x = s + 1; ++ char *x = str + len; ++ ++ for (s = str; s < x; s = skip (s)) ++ n++; + + for (; n >= 2; n--) + { +@@ -1368,6 +1368,8 @@ inplace_sort (char *str) + } + } + ++#undef skip ++ + static int this_config_len (const char *config); + static int + this_config_len (const char *config) +@@ -1468,16 +1470,16 @@ cmain (void) + } + if (*w == 0 && (*c == ' ' || *c == '\t' || *c == '=')) + { +- int len; ++ int len, wlen; + + /* This is a wildcard command. Advance to the argument. */ + while (*c == ' ' || *c == '\t' || *c == '=') + c++; + + /* Expand wildcard entry. */ +- w = wildcard (c); ++ w = wildcard (c, &wlen); + if (w) +- inplace_sort (w); ++ inplace_sort (w, wlen); + + /* Remove the wildcard command from the command section; + it has no meaning beyond the wildcard expansion just +@@ -1487,7 +1489,7 @@ cmain (void) + config_len - (command - config_entries)); + config_len -= len; + +- while (w && *w) ++ while (w && wlen) + { + /* Insert expansion before the wildcard entry in the + list of entry names. */ +@@ -1511,6 +1513,7 @@ cmain (void) + config_len += len; + + num_entries++; ++ wlen -= grub_strlen (w) + 1; + w += grub_strlen (w) + 1; + } + +Index: grub-0.95/stage2/shared.h +=================================================================== +--- grub-0.95.orig/stage2/shared.h ++++ grub-0.95/stage2/shared.h +@@ -1012,7 +1012,7 @@ void grub_close (void); + int dir (char *dirname, void (*handle)(char *)); + + /* Wildcard expand the last pathname component of GLOB. */ +-char *wildcard (char *glob); ++char *wildcard (char *glob, int *len); + + int set_bootdev (int hdbias); + diff --git a/src/patches/SuSE10.2/stage2-wildcard.diff b/src/patches/SuSE10.2/stage2-wildcard.diff new file mode 100644 index 000000000..495b4f4d3 --- /dev/null +++ b/src/patches/SuSE10.2/stage2-wildcard.diff @@ -0,0 +1,403 @@ +Index: grub-0.95/stage2/shared.h +=================================================================== +--- grub-0.95.orig/stage2/shared.h ++++ grub-0.95/stage2/shared.h +@@ -1008,9 +1008,11 @@ int grub_seek (int offset); + /* Close a file. */ + void grub_close (void); + +-/* List the contents of the directory that was opened with GRUB_OPEN, +- printing all completions. */ +-int dir (char *dirname); ++/* List the contents of DIRECTORY. */ ++int dir (char *dirname, void (*handle)(char *)); ++ ++/* Wildcard expand the last pathname component of GLOB. */ ++char *wildcard (char *glob); + + int set_bootdev (int hdbias); + +Index: grub-0.95/stage2/stage2.c +=================================================================== +--- grub-0.95.orig/stage2/stage2.c ++++ grub-0.95/stage2/stage2.c +@@ -1240,6 +1240,192 @@ get_line_from_config (char *cmdline, int + } + + ++char *wildcard_prefix, *wildcard_suffix; ++char wildcard_matches[1024], *end_wildcard_matches; ++ ++static void wildcard_handler(char *name); ++ ++/* Match one directory entry against the current wildcard. If the entry ++ matches, store it in WILDCARD_MATCHES. Silently ignore entries that ++ don't fit into WILDCARD_MATCHES anymore. */ ++static void ++wildcard_handler(char *name) ++{ ++ char *n = name, *p = wildcard_prefix; ++ ++ while (*p && *p == *n) ++ { ++ p++; ++ n++; ++ } ++ if (*p) ++ return; /* prefix mismatch */ ++ ++ p = name + grub_strlen (name) - grub_strlen (wildcard_suffix); ++ /* [n .. p) is the part matching the asterisk */ ++ ++ if (p <= n || grub_strcmp (p, wildcard_suffix) != 0) ++ return; /* zero-length match or suffix mismatch */ ++ ++ /* store this match */ ++ if (p - n + 2 > sizeof (wildcard_matches) - ++ (end_wildcard_matches - wildcard_matches)) ++ return; /* out of space */ ++ while (n < p) ++ *end_wildcard_matches++ = *n++; ++ *end_wildcard_matches++ = 0; ++} ++ ++/* Wildcard expand the GLOB argument. Return NULL upon failure, or ++ a list of 0-terminated expansions, terminated by a zero-length string. */ ++char * ++wildcard (char *glob) ++{ ++ char path[128], *p; ++ int ret; ++ ++ end_wildcard_matches = wildcard_matches; ++ if (grub_strlen (glob) + 1 > sizeof (path)) { ++ errnum = ERR_FILELENGTH; ++ return NULL; /* cannot handle pathnames this long */ ++ } ++ grub_strcpy (path, glob); ++ p = path; ++ while (*p) ++ p++; ++ wildcard_suffix = p; ++ while (p > path && *p != '/') ++ p--; ++ if (*p != '/') ++ { ++ errnum = ERR_BAD_FILETYPE; ++ return NULL; /* Cannot wildcard device names */ ++ } ++ *(++p) = 0; ++ wildcard_prefix = glob + (p - path); ++ for (p = wildcard_prefix;; p++) ++ { ++ if (*p == 0) ++ { ++ /* We cannot do exact matches: this cannot be represented in the ++ result list. */ ++ return NULL; ++ } ++ else if (*p == '*') ++ { ++ *p++ = 0; ++ wildcard_suffix = p; ++ break; ++ } ++ } ++ ++ ret = dir (path, wildcard_handler); ++ /* restore original argument */ ++ wildcard_prefix[grub_strlen (wildcard_prefix)] = '*'; ++ if (!ret) ++ return NULL; ++ *end_wildcard_matches++ = 0; ++ return wildcard_matches; ++} ++ ++#define skip(str) ((str) + grub_strlen (str) + 1) ++ ++static void inplace_sort (char *str); ++ ++static void ++inplace_sort (char *str) ++{ ++ int m, n = 0; ++ char *s, *t, *x; ++ ++ for (s = str; *s; s = skip (s)) ++ n++; ++ ++ /* we use x as temporary storage */ ++ x = s + 1; ++ ++ for (; n >= 2; n--) ++ { ++ s = str; ++ t = skip (s); ++ ++ for (m = n; m >= 2; m--) ++ { ++ if (grub_strcmp (s, t) > 0) ++ { ++ int ls = skip (s) - s; ++ int lt = skip (t) - t; ++ ++ memcpy (x, s, ls); ++ grub_memmove (s + ls, s + lt, t - (s + ls)); ++ memcpy (s, t, lt); ++ t = t + lt - ls; ++ memcpy (t, x, ls); ++ } ++ s = t; ++ t = skip (t); ++ } ++ } ++} ++ ++static int this_config_len (const char *config); ++static int ++this_config_len (const char *config) ++{ ++ const char *c = config; ++ while (*c) ++ { ++ while (*c) ++ c++; ++ c++; ++ } ++ c++; ++ return c - config; ++} ++ ++static const char * expand_asterisks (const char *str, int *len, ++ const char *subst); ++ ++/* Expand all asterisks (*) in a menu entry or commands section with its ++ substitution. Use a backslash as escape character. */ ++static const char * ++expand_asterisks (const char *str, int *len, const char *subst) ++{ ++ static char buffer[1024]; ++ char *b = buffer, escaped = 0; ++ const char *end = str + *len; ++ ++ while (str < end) ++ { ++ if (*str == '*' && !escaped) ++ { ++ if (b - buffer + grub_strlen (subst) > sizeof (buffer)) ++ { ++ errnum = ERR_FILELENGTH; ++ return NULL; ++ } ++ grub_strcpy (b, subst); ++ b += grub_strlen (subst); ++ } ++ else if (*str == '\\' && !escaped) ++ escaped = 1; ++ else ++ { ++ escaped = 0; ++ if (b - buffer + 1 > sizeof (buffer)) ++ { ++ errnum = ERR_FILELENGTH; ++ return NULL; ++ } ++ *b++ = *str; ++ } ++ str++; ++ } ++ *len = b - buffer; ++ ++ return buffer; ++} ++ + /* This is the starting function in C. */ + void + cmain (void) +@@ -1260,6 +1446,96 @@ cmain (void) + init_config (); + } + ++ auto void expand_wildcard_entries (void); ++ void expand_wildcard_entries (void) ++ { ++ char *config_entry = config_entries; ++ char *menu_entry = menu_entries; ++ ++ while (*menu_entry) ++ { ++ char *command = config_entry; ++ ++ do ++ { ++ char *c = command; ++ const char *w = "wildcard"; ++ ++ while (*w && *c == *w) ++ { ++ c++; ++ w++; ++ } ++ if (*w == 0 && (*c == ' ' || *c == '\t' || *c == '=')) ++ { ++ int len; ++ ++ /* This is a wildcard command. Advance to the argument. */ ++ while (*c == ' ' || *c == '\t' || *c == '=') ++ c++; ++ ++ /* Expand wildcard entry. */ ++ w = wildcard (c); ++ if (w) ++ inplace_sort (w); ++ ++ /* Remove the wildcard command from the command section; ++ it has no meaning beyond the wildcard expansion just ++ performed. */ ++ len = grub_strlen (command) + 1; ++ grub_memmove (command, command + len, ++ config_len - (command - config_entries)); ++ config_len -= len; ++ ++ while (w && *w) ++ { ++ /* Insert expansion before the wildcard entry in the ++ list of entry names. */ ++ len = grub_strlen (menu_entry) + 1; ++ const char *x = expand_asterisks (menu_entry, &len, w); ++ grub_memmove (menu_entry + len, menu_entry, ++ menu_len - (menu_entry - menu_entries)); ++ memcpy (menu_entry, x, len); ++ menu_entry += len; ++ menu_len += len; ++ ++ /* Insert expansion before the wildcard command section ++ in the list of command sections. */ ++ len = this_config_len (config_entry); ++ x = expand_asterisks (config_entry, &len, w); ++ grub_memmove (config_entry + len, config_entry, ++ config_len - (config_entry - ++ config_entries)); ++ memcpy (config_entry, x, len); ++ config_entry += len; ++ config_len += len; ++ ++ num_entries++; ++ w += grub_strlen (w) + 1; ++ } ++ ++ /* Remove the wildcard command section; it has just ++ been expanded. */ ++ len = grub_strlen (menu_entry) + 1; ++ grub_memmove (menu_entry, menu_entry + len, ++ menu_len - (menu_entry - menu_entries)); ++ menu_len -= len; ++ ++ len = this_config_len(config_entry); ++ grub_memmove (config_entry, config_entry + len, ++ config_len - (config_entry - config_entries)); ++ config_len -= len; ++ ++ num_entries--; ++ } ++ command += grub_strlen (command) + 1; ++ } ++ while (*command); ++ menu_entry += grub_strlen (menu_entry) + 1; ++ config_entry += this_config_len(config_entry); ++ } ++ } ++ + /* Initialize the environment for restarting Stage 2. */ + grub_setjmp (restart_env); + +@@ -1379,8 +1655,16 @@ cmain (void) + config_len = prev_config_len; + } + ++ if (is_preset) ++ close_preset_menu (); ++ else ++ grub_close (); ++ + menu_entries[menu_len++] = 0; + config_entries[config_len++] = 0; ++ ++ expand_wildcard_entries(); ++ + grub_memmove (config_entries + config_len, menu_entries, + menu_len); + menu_entries = config_entries + config_len; +@@ -1395,11 +1679,6 @@ cmain (void) + else + default_entry = fallback_entry; + } +- +- if (is_preset) +- close_preset_menu (); +- else +- grub_close (); + } + while (is_preset); + } +Index: grub-0.95/stage2/builtins.c +=================================================================== +--- grub-0.95.orig/stage2/builtins.c ++++ grub-0.95/stage2/builtins.c +@@ -4831,6 +4831,49 @@ static struct builtin builtin_vbeprobe = + }; + + ++/* wildcard */ ++ static int ++wildcard_func (char *arg, int flags) ++{ ++#ifdef DEBUG_WILDCARD ++ char *w = wildcard (arg); ++ ++ if (w) ++ { ++ while (*w) ++ { ++ grub_printf("%s ", w); ++ w += strlen (w) + 1; ++ } ++ grub_printf("\n"); ++ return 1; ++ } ++ else ++ print_error(); ++#endif ++ ++ /* This special command is interpreted in the config file parser. */ ++ return 0; ++} ++ ++static struct builtin builtin_wildcard = ++ { ++ "wildcard", ++ wildcard_func, ++#ifndef DEBUG_WILDCARD ++ BUILTIN_MENU, ++#else ++ BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST, ++ "wildcard GLOB", ++ "Declare this menu entry as a wildcard entry. GLOB is a path containing" ++ " one asterisk. All files matching this expression are looked up; the" ++ " menu entry is duplicated for each match with asterisks in other" ++ " commands replaced by the string matching the asterisk in the wildcard" ++ " command." ++#endif ++}; ++ ++ + /* The table of builtin commands. Sorted in dictionary order. */ + struct builtin *builtin_table[] = + { +@@ -4920,5 +4963,6 @@ struct builtin *builtin_table[] = + &builtin_unhide, + &builtin_uppermem, + &builtin_vbeprobe, ++ &builtin_wildcard, + 0 + }; diff --git a/src/patches/SuSE10.2/use_ferror.diff b/src/patches/SuSE10.2/use_ferror.diff new file mode 100644 index 000000000..6bb8a820f --- /dev/null +++ b/src/patches/SuSE10.2/use_ferror.diff @@ -0,0 +1,15 @@ +Fread doesn't return -1 on error, so use ferror(). + +--- util/mbchk.c.old Tue Jan 22 18:36:17 2002 ++++ util/mbchk.c Tue Jan 22 18:28:54 2002 +@@ -59,7 +59,9 @@ check_multiboot (const char *filename, F + int i; + char buf[8192]; + +- if (fread (buf, 1, 8192, fp) < 0) ++ fread (buf, 1, 8192, fp); ++ ++ if (ferror(fp)) + { + fprintf (stderr, "%s: Read error.\n", filename); + return 0;