From 2beeecded4e3c006665efbaea0a72a0a6e28536d Mon Sep 17 00:00:00 2001 From: basebuilder_pel7x64builder0 Date: Sun, 12 Aug 2018 18:25:02 +0200 Subject: [PATCH] syslinux package update Signed-off-by: basebuilder_pel7x64builder0 --- ...-aliasing-because-not-everything-her.patch | 43 + .../0001-relocs-Move-stop-to-the-end.patch | 768 ++++++++++++++ ...ms-discovered-by-coverity-scan.-8120.patch | 265 +++++ ...0004-Make-some-more-mingw-paths-work.patch | 42 + ...005-Save-Dell-BIOS-chunk-in-PXELINUX.patch | 88 ++ SOURCES/syslinux-4.05-avoid-ext2_fs.h.patch | 965 ++++++++++++++++++ SOURCES/syslinux-4.05-man-pages.patch | 118 +++ SOURCES/syslinux-isohybrid-fix-mbr.patch | 122 +++ SPECS/syslinux.spec | 255 +++++ 9 files changed, 2666 insertions(+) create mode 100644 SOURCES/0001-Don-t-use-strict-aliasing-because-not-everything-her.patch create mode 100644 SOURCES/0001-relocs-Move-stop-to-the-end.patch create mode 100644 SOURCES/0003-Fixes-for-problems-discovered-by-coverity-scan.-8120.patch create mode 100644 SOURCES/0004-Make-some-more-mingw-paths-work.patch create mode 100644 SOURCES/0005-Save-Dell-BIOS-chunk-in-PXELINUX.patch create mode 100644 SOURCES/syslinux-4.05-avoid-ext2_fs.h.patch create mode 100644 SOURCES/syslinux-4.05-man-pages.patch create mode 100644 SOURCES/syslinux-isohybrid-fix-mbr.patch create mode 100644 SPECS/syslinux.spec diff --git a/SOURCES/0001-Don-t-use-strict-aliasing-because-not-everything-her.patch b/SOURCES/0001-Don-t-use-strict-aliasing-because-not-everything-her.patch new file mode 100644 index 00000000..2fbe5610 --- /dev/null +++ b/SOURCES/0001-Don-t-use-strict-aliasing-because-not-everything-her.patch @@ -0,0 +1,43 @@ +From 942cc3fcfb310754009dbd36c7c9c059c3f3f24b Mon Sep 17 00:00:00 2001 +From: Peter Jones +Date: Tue, 23 Sep 2014 13:31:46 -0400 +Subject: [PATCH] Don't use strict aliasing, because not everything here is + ready for it. + +Related: rhbz#1085434 + +Signed-off-by: Peter Jones +--- + gpxe/src/Makefile | 2 +- + mk/build.mk | 2 +- + 2 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/gpxe/src/Makefile b/gpxe/src/Makefile +index cc91d78..2e8ff1e 100644 +--- a/gpxe/src/Makefile ++++ b/gpxe/src/Makefile +@@ -4,7 +4,7 @@ + # + + CLEANUP := +-CFLAGS := ++CFLAGS := -fno-strict-aliasing + ASFLAGS := + LDFLAGS := + MAKEDEPS := Makefile +diff --git a/mk/build.mk b/mk/build.mk +index 0ca82be..15c5ee5 100644 +--- a/mk/build.mk ++++ b/mk/build.mk +@@ -19,7 +19,7 @@ include $(MAKEDIR)/syslinux.mk + OPTFLAGS = -g -Os + INCLUDES = + CFLAGS = -W -Wall -Wno-sign-compare -D_FILE_OFFSET_BITS=64 \ +- $(OPTFLAGS) $(INCLUDES) ++ $(OPTFLAGS) $(INCLUDES) -fno-strict-aliasing + LDFLAGS = + LIBS = + +-- +1.9.3 + diff --git a/SOURCES/0001-relocs-Move-stop-to-the-end.patch b/SOURCES/0001-relocs-Move-stop-to-the-end.patch new file mode 100644 index 00000000..951a47f6 --- /dev/null +++ b/SOURCES/0001-relocs-Move-stop-to-the-end.patch @@ -0,0 +1,768 @@ +From 08278452325454027c6d42bc2d687dc8dd518006 Mon Sep 17 00:00:00 2001 +From: "H. Peter Anvin" +Date: Tue, 29 May 2012 14:08:11 -0700 +Subject: [PATCH] relocs: Move stop to the end + +The Linux kernel puts the stop word at the beginning of the relocation +list (the list is processed backwards); Syslinux puts the stop word at +the beginning of the relocation list (the list is processed forwards.) + +Missed that change when syncing with the kernel version. + +(plus everything to actually make this get built... -- pjones) + +Signed-off-by: H. Peter Anvin +--- +diff --git a/com32/Makefile b/com32/Makefile +index da632a1..b59fd3f 100644 +--- a/com32/Makefile ++++ b/com32/Makefile +@@ -1,5 +1,5 @@ + SUBDIRS = libupload tools lib gpllib libutil modules mboot menu samples rosh cmenu \ +- hdt gfxboot sysdump lua/src ++ hdt gfxboot sysdump lua/src chain + + all tidy dist clean spotless install: + set -e; for d in $(SUBDIRS); do $(MAKE) -C $$d $@; done +diff --git a/com32/chain/Makefile b/com32/chain/Makefile +new file mode 100644 +index 0000000..9d398a8 +--- /dev/null ++++ b/com32/chain/Makefile +@@ -0,0 +1,39 @@ ++## ----------------------------------------------------------------------- ++## ++## Copyright 2001-2010 H. Peter Anvin - All Rights Reserved ++## Copyright 2010 Michal Soltys ++## ++## This program is free software; you can redistribute it and/or modify ++## it under the terms of the GNU General Public License as published by ++## the Free Software Foundation, Inc., 53 Temple Place Ste 330, ++## Boston MA 02111-1307, USA; either version 2 of the License, or ++## (at your option) any later version; incorporated herein by reference. ++## ++## ----------------------------------------------------------------------- ++ ++ ++topdir = ../.. ++MAKEDIR = $(topdir)/mk ++include $(MAKEDIR)/com32.mk ++ ++OBJS = chain.o partiter.o utility.o options.o mangle.o ++ ++all: ++ ++%.o: %.c ++ $(CC) $(MAKEDEPS) $(CFLAGS) $(CHAINEXTOPT) -c -o $@ $< ++ ++tidy dist: ++ rm -f *.o *.lo *.a *.lst .*.d *.tmp ++ ++clean: tidy ++ rm -f *.lnx ++ ++spotless: clean ++ rm -f *.lss *.c32 *.com ++ rm -f *~ \#* ++ ++install: ++ ++ ++-include .*.d +diff --git a/com32/hdt/Makefile b/com32/hdt/Makefile +index f187346..ea9ddfe 100644 +--- a/com32/hdt/Makefile ++++ b/com32/hdt/Makefile +@@ -45,7 +45,7 @@ FLOPPY_DIR ?= floppy + PCI_IDS_FILE ?= $(PWD)/$(FLOPPY_DIR)/pci.ids + GZ_PCI_IDS_FILE ?= $(PCI_IDS_FILE).gz + MENU_COM32 ?= $(com32)/menu/menu.c32 +-CHAIN_COM32 ?= $(com32)/modules/chain.c32 ++CHAIN_COM32 ?= $(com32)/modules/chain.c32 + ART_DIR ?= art/ + QEMU ?= qemu-kvm + +@@ -110,10 +110,16 @@ hdt.iso: hdt.c32 $(topdir)/core/isolinux.bin $(FLOPPY_DIR)/hdt.cfg memtest + mv hdt.iso hdt-$(VERSION).iso + ln -sf hdt-$(VERSION).iso hdt.iso + +-release: spotless hdt.c32 hdt.img hdt.img.gz hdt.iso ++hdt-hybrid.iso: hdt.iso ../../utils/isohybrid ++ cp hdt-$(VERSION).iso hdt-hybrid-$(VERSION).iso ++ ../../utils/isohybrid --partok hdt-hybrid-$(VERSION).iso ++ ln -sf hdt-hybrid-$(VERSION).iso hdt-hybrid.iso ++ ++release: spotless hdt.c32 hdt.img hdt.img.gz hdt.iso hdt-hybrid.iso + mv hdt.c32 hdt_$(NODASH_VERSION).c32 + md5sum hdt_$(NODASH_VERSION).c32 >$(SUM_FILE) + md5sum hdt-$(VERSION).iso >>$(SUM_FILE) ++ md5sum hdt-hybrid-$(VERSION).iso >>$(SUM_FILE) + md5sum hdt-$(VERSION).img >>$(SUM_FILE) + md5sum hdt-$(VERSION).img.gz >>$(SUM_FILE) + +diff --git a/com32/lib/com32.ld b/com32/lib/com32.ld +index 37ee46c..008e4ce 100644 +--- a/com32/lib/com32.ld ++++ b/com32/lib/com32.ld +@@ -36,36 +36,23 @@ SECTIONS + .rodata1 : { *(.rodata1) } + __rodata_end = .; + +- /* Ensure the __preinit_array_start label is properly aligned. We +- could instead move the label definition inside the section, but +- the linker would then create the section even if it turns out to +- be empty, which isn't pretty. */ ++ /* ++ * The difference betwee .ctors/.dtors and .init_array/.fini_array ++ * is the ordering, but we don't use prioritization for libcom32, so ++ * just lump them all together and hope that's okay. ++ */ + . = ALIGN(4); +- .preinit_array : { +- PROVIDE (__preinit_array_start = .); +- *(.preinit_array) +- PROVIDE (__preinit_array_end = .); +- } +- .init_array : { +- PROVIDE (__init_array_start = .); +- *(.init_array) +- PROVIDE (__init_array_end = .); +- } +- .fini_array : { +- PROVIDE (__fini_array_start = .); +- *(.fini_array) +- PROVIDE (__fini_array_end = .); +- } + .ctors : { + PROVIDE (__ctors_start = .); +- KEEP (*(SORT(.ctors.*))) +- KEEP (*(.ctors)) ++ KEEP (*(SORT(.preinit_array*))) ++ KEEP (*(SORT(.init_array*))) ++ KEEP (*(SORT(.ctors*))) + PROVIDE (__ctors_end = .); + } + .dtors : { + PROVIDE (__dtors_start = .); +- KEEP (*(SORT(.dtors.*))) +- KEEP (*(.dtors)) ++ KEEP (*(SORT(.fini_array*))) ++ KEEP (*(SORT(.dtors*))) + PROVIDE (__dtors_end = .); + } + +diff --git a/com32/modules/Makefile b/com32/modules/Makefile +index e9ce1d1..d8861c4 100644 +--- a/com32/modules/Makefile ++++ b/com32/modules/Makefile +@@ -19,11 +19,12 @@ topdir = ../.. + MAKEDIR = $(topdir)/mk + include $(MAKEDIR)/com32.mk + +-MODULES = chain.c32 config.c32 ethersel.c32 dmitest.c32 cpuidtest.c32 \ ++MODULES = chain.c32 config.c32 ethersel.c32 dmitest.c32 cpuidtest.c32 \ + disk.c32 pcitest.c32 elf.c32 linux.c32 reboot.c32 pmload.c32 \ + meminfo.c32 sdi.c32 sanboot.c32 ifcpu64.c32 vesainfo.c32 \ + kbdmap.c32 cmd.c32 vpdtest.c32 host.c32 ls.c32 gpxecmd.c32 \ +- ifcpu.c32 cpuid.c32 cat.c32 pwd.c32 ifplop.c32 zzjson.c32 whichsys.c32 ++ ifcpu.c32 cpuid.c32 cat.c32 pwd.c32 ifplop.c32 zzjson.c32 \ ++ whichsys.c32 + + TESTFILES = + +diff --git a/com32/tools/Makefile b/com32/tools/Makefile +index 7badabd..0161baf 100644 +--- a/com32/tools/Makefile ++++ b/com32/tools/Makefile +@@ -15,6 +15,8 @@ include $(MAKEDIR)/build.mk + + BINS = relocs + ++INCLUDES += -I./include ++ + all : $(BINS) + + relocs : relocs.o +diff --git a/com32/tools/include/tools/le_byteshift.h b/com32/tools/include/tools/le_byteshift.h +new file mode 100644 +index 0000000..c99d45a +--- /dev/null ++++ b/com32/tools/include/tools/le_byteshift.h +@@ -0,0 +1,70 @@ ++#ifndef _TOOLS_LE_BYTESHIFT_H ++#define _TOOLS_LE_BYTESHIFT_H ++ ++#include ++ ++static inline __u16 __get_unaligned_le16(const __u8 *p) ++{ ++ return p[0] | p[1] << 8; ++} ++ ++static inline __u32 __get_unaligned_le32(const __u8 *p) ++{ ++ return p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24; ++} ++ ++static inline __u64 __get_unaligned_le64(const __u8 *p) ++{ ++ return (__u64)__get_unaligned_le32(p + 4) << 32 | ++ __get_unaligned_le32(p); ++} ++ ++static inline void __put_unaligned_le16(__u16 val, __u8 *p) ++{ ++ *p++ = val; ++ *p++ = val >> 8; ++} ++ ++static inline void __put_unaligned_le32(__u32 val, __u8 *p) ++{ ++ __put_unaligned_le16(val >> 16, p + 2); ++ __put_unaligned_le16(val, p); ++} ++ ++static inline void __put_unaligned_le64(__u64 val, __u8 *p) ++{ ++ __put_unaligned_le32(val >> 32, p + 4); ++ __put_unaligned_le32(val, p); ++} ++ ++static inline __u16 get_unaligned_le16(const void *p) ++{ ++ return __get_unaligned_le16((const __u8 *)p); ++} ++ ++static inline __u32 get_unaligned_le32(const void *p) ++{ ++ return __get_unaligned_le32((const __u8 *)p); ++} ++ ++static inline __u64 get_unaligned_le64(const void *p) ++{ ++ return __get_unaligned_le64((const __u8 *)p); ++} ++ ++static inline void put_unaligned_le16(__u16 val, void *p) ++{ ++ __put_unaligned_le16(val, p); ++} ++ ++static inline void put_unaligned_le32(__u32 val, void *p) ++{ ++ __put_unaligned_le32(val, p); ++} ++ ++static inline void put_unaligned_le64(__u64 val, void *p) ++{ ++ __put_unaligned_le64(val, p); ++} ++ ++#endif /* _TOOLS_LE_BYTESHIFT_H */ +diff --git a/com32/tools/relocs.c b/com32/tools/relocs.c +index 2474206..86fc7c5 100644 +--- a/com32/tools/relocs.c ++++ b/com32/tools/relocs.c +@@ -13,12 +13,16 @@ + #define USE_BSD + #include + #include +-#include ++#include ++ ++static void die(char *fmt, ...); + + #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) + static Elf32_Ehdr ehdr; + static unsigned long reloc_count, reloc_idx; + static unsigned long *relocs; ++static unsigned long reloc16_count, reloc16_idx; ++static unsigned long *relocs16; + + struct section { + Elf32_Shdr shdr; +@@ -29,60 +33,87 @@ struct section { + }; + static struct section *secs; + +-static void die(char *fmt, ...) +-{ +- va_list ap; +- va_start(ap, fmt); +- vfprintf(stderr, fmt, ap); +- va_end(ap); +- exit(1); +-} ++enum symtype { ++ S_ABS, ++ S_REL, ++ S_SEG, ++ S_LIN, ++ S_NSYMTYPES ++}; + ++static const char * const sym_regex_kernel[S_NSYMTYPES] = { + /* + * Following symbols have been audited. Don't warn user about + * absolute relocations present w.r.t these symbols. + */ ++ [S_ABS] = ++ "^(__.*_len|__.*_dwords)$", + +-/* True absolute relocations */ ++/* ++ * These symbols are known to be relative, even if the linker marks them ++ * as absolute (typically defined outside any section in the linker script.) ++ */ ++ [S_REL] = ++ "^(__.*_start|__.*_end|_end|_[se](text|data))$", ++}; + +-static const char safe_abs_regex[] = +-"^(__.*_len|__.*_dwords)$"; +-static regex_t safe_abs_regex_c; + +-static int is_safe_abs_reloc(const char *sym_name) +-{ +- return !regexec(&safe_abs_regex_c, sym_name, 0, NULL, 0); +-} ++static const char * const sym_regex_realmode[S_NSYMTYPES] = { ++/* ++ * These are 16-bit segment symbols when compiling 16-bit code. ++ */ ++ [S_SEG] = ++ "^real_mode_seg$", + +-/* These are relative even though the linker marks them absolute */ ++/* ++ * These are offsets belonging to segments, as opposed to linear addresses, ++ * when compiling 16-bit code. ++ */ ++ [S_LIN] = ++ "^pa_", ++}; + +-static const char safe_rel_regex[] = +-"^(__.*_start|__.*_end|_end|_[se](text|data))$"; +-static regex_t safe_rel_regex_c; ++static const char * const *sym_regex; + +-static int is_safe_rel_reloc(const char *sym_name) ++static regex_t sym_regex_c[S_NSYMTYPES]; ++static int is_reloc(enum symtype type, const char *sym_name) + { +- return !regexec(&safe_rel_regex_c, sym_name, 0, NULL, 0); ++ return sym_regex[type] && ++ !regexec(&sym_regex_c[type], sym_name, 0, NULL, 0); + } + +-static void regex_init(void) ++static void regex_init(int use_real_mode) + { +- char errbuf[128]; +- int err; ++ char errbuf[128]; ++ int err; ++ int i; + +- err = regcomp(&safe_abs_regex_c, safe_abs_regex, +- REG_EXTENDED|REG_NOSUB); +- if (err) { +- regerror(err, &safe_abs_regex_c, errbuf, sizeof errbuf); +- die("%s", errbuf); +- } ++ if (use_real_mode) ++ sym_regex = sym_regex_realmode; ++ else ++ sym_regex = sym_regex_kernel; + +- err = regcomp(&safe_rel_regex_c, safe_rel_regex, +- REG_EXTENDED|REG_NOSUB); +- if (err) { +- regerror(err, &safe_rel_regex_c, errbuf, sizeof errbuf); +- die("%s", errbuf); +- } ++ for (i = 0; i < S_NSYMTYPES; i++) { ++ if (!sym_regex[i]) ++ continue; ++ ++ err = regcomp(&sym_regex_c[i], sym_regex[i], ++ REG_EXTENDED|REG_NOSUB); ++ ++ if (err) { ++ regerror(err, &sym_regex_c[i], errbuf, sizeof errbuf); ++ die("%s", errbuf); ++ } ++ } ++} ++ ++static void die(char *fmt, ...) ++{ ++ va_list ap; ++ va_start(ap, fmt); ++ vfprintf(stderr, fmt, ap); ++ va_end(ap); ++ exit(1); + } + + static const char *sym_type(unsigned type) +@@ -153,13 +184,16 @@ static const char *rel_type(unsigned type) + REL_TYPE(R_386_RELATIVE), + REL_TYPE(R_386_GOTOFF), + REL_TYPE(R_386_GOTPC), ++ REL_TYPE(R_386_8), ++ REL_TYPE(R_386_PC8), ++ REL_TYPE(R_386_16), ++ REL_TYPE(R_386_PC16), + #undef REL_TYPE + }; +- const char *name = NULL; +- if (type < ARRAY_SIZE(type_name)) ++ const char *name = "unknown type rel type name"; ++ if (type < ARRAY_SIZE(type_name) && type_name[type]) { + name = type_name[type]; +- if (!name) +- name = "unknown"; ++ } + return name; + } + +@@ -189,7 +223,7 @@ static const char *sym_name(const char *sym_strtab, Elf32_Sym *sym) + name = sym_strtab + sym->st_name; + } + else { +- name = sec_name(secs[sym->st_shndx].shdr.sh_name); ++ name = sec_name(sym->st_shndx); + } + return name; + } +@@ -428,7 +462,7 @@ static void print_absolute_symbols(void) + printf("\n"); + } + +-static int print_absolute_relocs(FILE *f) ++static void print_absolute_relocs(void) + { + int i, printed = 0; + +@@ -472,17 +506,18 @@ static int print_absolute_relocs(FILE *f) + * Before warning check if this absolute symbol + * relocation is harmless. + */ +- if (is_safe_abs_reloc(name) || +- is_safe_rel_reloc(name)) ++ if (is_reloc(S_ABS, name) || is_reloc(S_REL, name)) + continue; + + if (!printed) { +- fprintf(f, "Unknown absolute relocations present\n"); +- fprintf(f, "Offset Info Type Sym.Value Sym.Name\n"); ++ printf("WARNING: Absolute relocations" ++ " present\n"); ++ printf("Offset Info Type Sym.Value " ++ "Sym.Name\n"); + printed = 1; + } + +- fprintf(f, "%08x %08x %10s %08x %s\n", ++ printf("%08x %08x %10s %08x %s\n", + rel->r_offset, + rel->r_info, + rel_type(ELF32_R_TYPE(rel->r_info)), +@@ -492,12 +527,11 @@ static int print_absolute_relocs(FILE *f) + } + + if (printed) +- fputc('\n', f); +- +- return printed; ++ printf("\n"); + } + +-static void walk_relocs(void (*visit)(Elf32_Rel *rel, Elf32_Sym *sym)) ++static void walk_relocs(void (*visit)(Elf32_Rel *rel, Elf32_Sym *sym), ++ int use_real_mode) + { + int i; + /* Walk through the relocations */ +@@ -522,31 +556,71 @@ static void walk_relocs(void (*visit)(Elf32_Rel *rel, Elf32_Sym *sym)) + Elf32_Rel *rel; + Elf32_Sym *sym; + unsigned r_type; ++ const char *symname; ++ int shn_abs; ++ + rel = &sec->reltab[j]; + sym = &sh_symtab[ELF32_R_SYM(rel->r_info)]; + r_type = ELF32_R_TYPE(rel->r_info); +- /* Don't visit relocations to absolute symbols */ +- if (sym->st_shndx == SHN_ABS && +- !is_safe_rel_reloc(sym_name(sym_strtab, sym))) +- continue; ++ ++ shn_abs = sym->st_shndx == SHN_ABS; + + switch (r_type) { + case R_386_NONE: + case R_386_PC32: ++ case R_386_PC16: ++ case R_386_PC8: + case R_386_GOTPC: + case R_386_GOTOFF: + case R_386_GOT32: + case R_386_PLT32: +- /* Relative relocations don't need to +- be adjusted */ ++ /* ++ * NONE can be ignored and and PC relative ++ * relocations don't need to be adjusted. ++ */ + break; ++ ++ case R_386_16: ++ symname = sym_name(sym_strtab, sym); ++ if (!use_real_mode) ++ goto bad; ++ if (shn_abs) { ++ if (is_reloc(S_ABS, symname)) ++ break; ++ else if (!is_reloc(S_SEG, symname)) ++ goto bad; ++ } else { ++ if (is_reloc(S_LIN, symname)) ++ goto bad; ++ else ++ break; ++ } ++ visit(rel, sym); ++ break; ++ + case R_386_32: +- /* Visit relocations that need adjustment */ ++ symname = sym_name(sym_strtab, sym); ++ if (shn_abs) { ++ if (is_reloc(S_ABS, symname)) ++ break; ++ else if (!is_reloc(S_REL, symname)) ++ goto bad; ++ } else { ++ if (use_real_mode && ++ !is_reloc(S_LIN, symname)) ++ break; ++ } + visit(rel, sym); + break; + default: + die("Unsupported relocation type: %s (%d)\n", + rel_type(r_type), r_type); ++ break; ++ bad: ++ symname = sym_name(sym_strtab, sym); ++ die("Invalid %s %s relocation: %s\n", ++ shn_abs ? "absolute" : "relative", ++ rel_type(r_type), symname); + } + } + } +@@ -554,8 +628,12 @@ static void walk_relocs(void (*visit)(Elf32_Rel *rel, Elf32_Sym *sym)) + + static void count_reloc(Elf32_Rel *rel, Elf32_Sym *sym) + { +- (void)rel; (void)sym; +- reloc_count += 1; ++ (void)sym; ++ ++ if (ELF32_R_TYPE(rel->r_info) == R_386_16) ++ reloc16_count++; ++ else ++ reloc_count++; + } + + static void collect_reloc(Elf32_Rel *rel, Elf32_Sym *sym) +@@ -563,7 +641,10 @@ static void collect_reloc(Elf32_Rel *rel, Elf32_Sym *sym) + (void)sym; + + /* Remember the address that needs to be adjusted. */ +- relocs[reloc_idx++] = rel->r_offset; ++ if (ELF32_R_TYPE(rel->r_info) == R_386_16) ++ relocs16[reloc16_idx++] = rel->r_offset; ++ else ++ relocs[reloc_idx++] = rel->r_offset; + } + + static int cmp_relocs(const void *va, const void *vb) +@@ -573,23 +654,41 @@ static int cmp_relocs(const void *va, const void *vb) + return (*a == *b)? 0 : (*a > *b)? 1 : -1; + } + +-static void emit_relocs(int as_text) ++static int write32(unsigned int v, FILE *f) ++{ ++ unsigned char buf[4]; ++ ++ put_unaligned_le32(v, buf); ++ return fwrite(buf, 1, 4, f) == 4 ? 0 : -1; ++} ++ ++static void emit_relocs(int as_text, int use_real_mode) + { + int i; + /* Count how many relocations I have and allocate space for them. */ + reloc_count = 0; +- walk_relocs(count_reloc); ++ walk_relocs(count_reloc, use_real_mode); + relocs = malloc(reloc_count * sizeof(relocs[0])); + if (!relocs) { + die("malloc of %d entries for relocs failed\n", + reloc_count); + } ++ ++ relocs16 = malloc(reloc16_count * sizeof(relocs[0])); ++ if (!relocs16) { ++ die("malloc of %d entries for relocs16 failed\n", ++ reloc16_count); ++ } + /* Collect up the relocations */ + reloc_idx = 0; +- walk_relocs(collect_reloc); ++ walk_relocs(collect_reloc, use_real_mode); ++ ++ if (reloc16_count && !use_real_mode) ++ die("Segment relocations found but --realmode not specified\n"); + + /* Order the relocations for more efficient processing */ + qsort(relocs, reloc_count, sizeof(relocs[0]), cmp_relocs); ++ qsort(relocs16, reloc16_count, sizeof(relocs16[0]), cmp_relocs); + + /* Print the relocations */ + if (as_text) { +@@ -598,61 +697,83 @@ static void emit_relocs(int as_text) + */ + printf(".section \".data.reloc\",\"a\"\n"); + printf(".balign 4\n"); +- for (i = 0; i < reloc_count; i++) { +- printf("\t .long 0x%08lx\n", relocs[i]); ++ if (use_real_mode) { ++ printf("\t.long %lu\n", reloc16_count); ++ for (i = 0; i < reloc16_count; i++) ++ printf("\t.long 0x%08lx\n", relocs16[i]); ++ printf("\t.long %lu\n", reloc_count); ++ for (i = 0; i < reloc_count; i++) { ++ printf("\t.long 0x%08lx\n", relocs[i]); ++ } ++ } else { ++ for (i = 0; i < reloc_count; i++) { ++ printf("\t.long 0x%08lx\n", relocs[i]); ++ } ++ /* Print a stop */ ++ printf("\t.long 0x%08lx\n", (unsigned long)0); + } ++ + printf("\n"); + } + else { +- unsigned char buf[4]; +- /* Now print each relocation */ +- for (i = 0; i < reloc_count; i++) { +- buf[0] = (relocs[i] >> 0) & 0xff; +- buf[1] = (relocs[i] >> 8) & 0xff; +- buf[2] = (relocs[i] >> 16) & 0xff; +- buf[3] = (relocs[i] >> 24) & 0xff; +- fwrite(buf, 4, 1, stdout); ++ if (use_real_mode) { ++ write32(reloc16_count, stdout); ++ for (i = 0; i < reloc16_count; i++) ++ write32(relocs16[i], stdout); ++ write32(reloc_count, stdout); ++ ++ /* Now print each relocation */ ++ for (i = 0; i < reloc_count; i++) ++ write32(relocs[i], stdout); ++ } else { ++ /* Now print each relocation */ ++ for (i = 0; i < reloc_count; i++) { ++ write32(relocs[i], stdout); ++ } ++ ++ /* Print a stop */ ++ write32(0, stdout); + } +- /* Print a stop */ +- memset(buf, 0, sizeof buf); +- fwrite(buf, 4, 1, stdout); + } + } + + static void usage(void) + { +- die("relocs [--abs-syms |--abs-relocs | --text] vmlinux\n"); ++ die("relocs [--abs-syms|--abs-relocs|--text|--realmode] vmlinux\n"); + } + + int main(int argc, char **argv) + { + int show_absolute_syms, show_absolute_relocs; +- int as_text; ++ int as_text, use_real_mode; + const char *fname; + FILE *fp; + int i; +- int err = 0; + + show_absolute_syms = 0; + show_absolute_relocs = 0; + as_text = 0; ++ use_real_mode = 0; + fname = NULL; + for (i = 1; i < argc; i++) { + char *arg = argv[i]; + if (*arg == '-') { +- if (strcmp(argv[1], "--abs-syms") == 0) { ++ if (strcmp(arg, "--abs-syms") == 0) { + show_absolute_syms = 1; + continue; + } +- +- if (strcmp(argv[1], "--abs-relocs") == 0) { ++ if (strcmp(arg, "--abs-relocs") == 0) { + show_absolute_relocs = 1; + continue; + } +- else if (strcmp(argv[1], "--text") == 0) { ++ if (strcmp(arg, "--text") == 0) { + as_text = 1; + continue; + } ++ if (strcmp(arg, "--realmode") == 0) { ++ use_real_mode = 1; ++ continue; ++ } + } + else if (!fname) { + fname = arg; +@@ -663,10 +784,7 @@ int main(int argc, char **argv) + if (!fname) { + usage(); + } +- +- +- regex_init(); +- ++ regex_init(use_real_mode); + fp = fopen(fname, "r"); + if (!fp) { + die("Cannot open %s: %s\n", +@@ -682,10 +800,9 @@ int main(int argc, char **argv) + return 0; + } + if (show_absolute_relocs) { +- print_absolute_relocs(stdout); ++ print_absolute_relocs(); + return 0; + } +- err = print_absolute_relocs(stderr); +- emit_relocs(as_text); +- return err; ++ emit_relocs(as_text, use_real_mode); ++ return 0; + } diff --git a/SOURCES/0003-Fixes-for-problems-discovered-by-coverity-scan.-8120.patch b/SOURCES/0003-Fixes-for-problems-discovered-by-coverity-scan.-8120.patch new file mode 100644 index 00000000..38ad1f43 --- /dev/null +++ b/SOURCES/0003-Fixes-for-problems-discovered-by-coverity-scan.-8120.patch @@ -0,0 +1,265 @@ +From a3655b7bf64b7e016602d0b2bec450d27575816e Mon Sep 17 00:00:00 2001 +From: Peter Jones +Date: Mon, 15 Oct 2012 13:12:53 -0400 +Subject: [PATCH 3/4] Fixes for problems discovered by coverity scan. + +Related: rhbz#1085434 + +Signed-off-by: Peter Jones +--- + extlinux/main.c | 9 ++++++++- + libfat/fat.h | 9 +++++++-- + libinstaller/advio.c | 17 +++++++++-------- + libinstaller/syslxcom.c | 8 ++++++++ + libinstaller/syslxint.h | 10 +++++++--- + linux/syslinux.c | 3 --- + mtools/syslinux.c | 1 + + utils/Makefile | 2 +- + utils/isohybrid.c | 20 ++++++++++++++------ + 9 files changed, 55 insertions(+), 24 deletions(-) + +diff --git a/extlinux/main.c b/extlinux/main.c +index e574051..a461533 100755 +--- a/extlinux/main.c ++++ b/extlinux/main.c +@@ -292,7 +292,12 @@ int patch_file_and_bootblock(int fd, const char *dir, int devfd) + nsect = (boot_image_len + SECTOR_SIZE - 1) >> SECTOR_SHIFT; + nsect += 2; /* Two sectors for the ADV */ + sectp = alloca(sizeof(sector_t) * nsect); +- if (fs_type == EXT2 || fs_type == VFAT) { ++ if (sectp == NULL) { ++ perror("alloca"); ++ exit(1); ++ } ++ memset(sectp, '\0', sizeof(sector_t) * nsect); ++ if (fd >= 0 && (fs_type == EXT2 || fs_type == VFAT)) { + if (sectmap(fd, sectp, nsect)) { + perror("bmap"); + exit(1); +@@ -423,6 +428,8 @@ int ext2_fat_install_file(const char *path, int devfd, struct stat *rst) + + /* Map the file, and patch the initial sector accordingly */ + modbytes = patch_file_and_bootblock(fd, path, devfd); ++ if (modbytes < 0) ++ goto bail; + + /* Write the patch area again - this relies on the file being + overwritten in place! */ +diff --git a/libfat/fat.h b/libfat/fat.h +index b4e32f7..acafdb6 100644 +--- a/libfat/fat.h ++++ b/libfat/fat.h +@@ -23,8 +23,13 @@ + + /* The poor excuse FAT has for a superblock -- in the boot sector */ + struct fat_bootsect { +- le8_t bsJump[3]; /* Jump to code */ +- char bsOemName[8]; /* Formatting program */ ++ union { ++ struct { ++ uint8_t bsJump[3]; /* Jump to code */ ++ char bsOemName[8]; /* Formatting program */ ++ }; ++ uint8_t bsHead[11]; ++ }; + le16_t bsBytesPerSec; /* Bytes/sector */ + le8_t bsSecPerClust; /* Sectors/cluster */ + le16_t bsResSectors; /* Reserved sectors */ +diff --git a/libinstaller/advio.c b/libinstaller/advio.c +index 56f607d..01894f2 100644 +--- a/libinstaller/advio.c ++++ b/libinstaller/advio.c +@@ -135,15 +135,16 @@ int write_adv(const char *path, const char *cfg) + xst.st_dev != st.st_dev || xst.st_size != st.st_size) { + fprintf(stderr, "%s: race condition on write\n", file); + err = -2; ++ } else { ++ /* Write our own version ... */ ++ if (xpwrite(fd, syslinux_adv, 2 * ADV_SIZE, ++ st.st_size - 2 * ADV_SIZE) != 2 * ADV_SIZE) { ++ err = -1; ++ } ++ ++ sync(); ++ set_attributes(fd); + } +- /* Write our own version ... */ +- if (xpwrite(fd, syslinux_adv, 2 * ADV_SIZE, +- st.st_size - 2 * ADV_SIZE) != 2 * ADV_SIZE) { +- err = -1; +- } +- +- sync(); +- set_attributes(fd); + } + } + +diff --git a/libinstaller/syslxcom.c b/libinstaller/syslxcom.c +index a6a8339..dae81bc 100644 +--- a/libinstaller/syslxcom.c ++++ b/libinstaller/syslxcom.c +@@ -87,6 +87,9 @@ ssize_t xpwrite(int fd, const void *buf, size_t count, off_t offset) + ssize_t rv; + ssize_t done = 0; + ++ if (fd < 0) ++ die(strerror(EBADF)); ++ + while (count) { + rv = pwrite(fd, bufp, count, offset); + if (rv == 0) { +@@ -279,6 +282,11 @@ static int sectmap_fib(int fd, sector_t *sectors, int nsectors) + */ + int sectmap(int fd, sector_t *sectors, int nsectors) + { ++ if (fd < 0) { ++ errno = EBADF; ++ return -1; ++ } ++ + if (!sectmap_fie(fd, sectors, nsectors)) + return 0; + +diff --git a/libinstaller/syslxint.h b/libinstaller/syslxint.h +index 7c9da51..8d39f74 100644 +--- a/libinstaller/syslxint.h ++++ b/libinstaller/syslxint.h +@@ -193,8 +193,13 @@ struct syslinux_extent { + + /* FAT bootsector format, also used by other disk-based derivatives */ + struct boot_sector { +- uint8_t bsJump[3]; +- char bsOemName[8]; ++ union { ++ struct { ++ uint8_t bsJump[3]; ++ char bsOemName[8]; ++ }; ++ uint8_t bsHead[11]; ++ }; + uint16_t bsBytesPerSec; + uint8_t bsSecPerClust; + uint16_t bsResSectors; +@@ -241,7 +246,6 @@ struct boot_sector { + uint16_t bsSignature; + } __attribute__ ((packed)); + +-#define bsHead bsJump + #define bsHeadLen offsetof(struct boot_sector, bsBytesPerSec) + #define bsCode bs32.Code /* The common safe choice */ + #define bsCodeLen (offsetof(struct boot_sector, bsSignature) - \ +diff --git a/linux/syslinux.c b/linux/syslinux.c +index c7a9ecc..6e23a7a 100755 +--- a/linux/syslinux.c ++++ b/linux/syslinux.c +@@ -335,9 +335,6 @@ int main(int argc, char *argv[]) + snprintf(mntname, sizeof mntname, "syslinux.mnt.%lu.%d", + (unsigned long)mypid, i); + +- if (lstat(mntname, &dst) != -1 || errno != ENOENT) +- continue; +- + rv = mkdir(mntname, 0000); + + if (rv == -1) { +diff --git a/mtools/syslinux.c b/mtools/syslinux.c +index ac189c6..4bec0e3 100755 +--- a/mtools/syslinux.c ++++ b/mtools/syslinux.c +@@ -208,6 +208,7 @@ int main(int argc, char *argv[]) + !mtools_conf) + die_err(tmpdir); + ++ umask(077); + mtc_fd = mkstemp(mtools_conf); + if (mtc_fd < 0 || !(mtc = fdopen(mtc_fd, "w"))) + die_err(mtools_conf); +diff --git a/utils/Makefile b/utils/Makefile +index 44cb54f..4fabe04 100644 +--- a/utils/Makefile ++++ b/utils/Makefile +@@ -51,7 +51,7 @@ isohdpfx.c: $(ISOHDPFX) isohdpfxarray.pl + $(PERL) isohdpfxarray.pl $(ISOHDPFX) > $@ + + isohybrid: isohybrid.o isohdpfx.o +- $(CC) $(LDFLAGS) -luuid -o $@ $^ ++ $(CC) $(LDFLAGS) -fshort-wchar -luuid -o $@ $^ + + gethostip: gethostip.o + $(CC) $(LDFLAGS) -o $@ $^ +diff --git a/utils/isohybrid.c b/utils/isohybrid.c +index ac04bfd..865c114 100644 +--- a/utils/isohybrid.c ++++ b/utils/isohybrid.c +@@ -357,6 +357,8 @@ check_option(int argc, char *argv[]) + case ':': + errx(1, "option `-%c' takes an argument", optopt); + ++ printh(); ++ exit(0); + default: + case '?': + if (optopt) +@@ -618,7 +620,7 @@ initialise_mbr(uint8_t *mbr) + bsect = (offset % sector) + 1; + bcyle = offset / (head * sector); + +- bsect += (bcyle & 0x300) >> 2; ++ bsect += bcyle >> 2; + bcyle &= 0xFF; + + ehead = head - 1; +@@ -792,7 +794,7 @@ initialise_gpt(uint8_t *gpt, uint32_t current, uint32_t alternate, int primary) + memcpy(part->partTypeGUID, basic_partition, sizeof(uuid_t)); + part->firstLBA = lendian_64(0); + part->lastLBA = lendian_64(psize); +- memcpy(part->name, "ISOHybrid ISO", 28); ++ memcpy(part->name, L"ISOHybrid ISO", 28); + + gpt += sizeof(struct gpt_part_header); + part++; +@@ -801,7 +803,7 @@ initialise_gpt(uint8_t *gpt, uint32_t current, uint32_t alternate, int primary) + memcpy(part->partTypeGUID, basic_partition, sizeof(uuid_t)); + part->firstLBA = lendian_64(efi_lba * 4); + part->lastLBA = lendian_64(part->firstLBA + efi_count - 1); +- memcpy(part->name, "ISOHybrid", 20); ++ memcpy(part->name, L"ISOHybrid", 20); + + gpt += sizeof(struct gpt_part_header); + +@@ -814,7 +816,7 @@ initialise_gpt(uint8_t *gpt, uint32_t current, uint32_t alternate, int primary) + memcpy(part->partTypeGUID, hfs_partition, sizeof(uuid_t)); + part->firstLBA = lendian_64(mac_lba * 4); + part->lastLBA = lendian_64(part->firstLBA + mac_count - 1); +- memcpy(part->name, "ISOHybrid", 20); ++ memcpy(part->name, L"ISOHybrid", 20); + + part--; + } +@@ -891,7 +893,11 @@ main(int argc, char *argv[]) + size_t orig_gpt_size, free_space, gpt_size; + struct iso_primary_descriptor descriptor; + +- prog = strcpy(alloca(strlen(argv[0]) + 1), argv[0]); ++ prog = alloca(strlen(argv[0]) + 1); ++ if (!prog) ++ err(1, ""); ++ strcpy(prog, argv[0]); ++ + i = check_option(argc, argv); + argc -= i; + argv += i; +@@ -1097,7 +1103,9 @@ main(int argc, char *argv[]) + + initialise_apm(buf, APM_OFFSET); + +- fseek(fp, APM_OFFSET, SEEK_SET); ++ if (fseek(fp, APM_OFFSET, SEEK_SET)) ++ err(1, "%s: seek error - 7", argv[0]); ++ + fwrite(buf, sizeof(char), apm_size, fp); + } + +-- +1.9.3 + diff --git a/SOURCES/0004-Make-some-more-mingw-paths-work.patch b/SOURCES/0004-Make-some-more-mingw-paths-work.patch new file mode 100644 index 00000000..5cde519f --- /dev/null +++ b/SOURCES/0004-Make-some-more-mingw-paths-work.patch @@ -0,0 +1,42 @@ +From 9336f2aff579aa591b75bb4be59451d4b3dd283f Mon Sep 17 00:00:00 2001 +From: Peter Jones +Date: Mon, 7 Apr 2014 09:57:17 -0400 +Subject: [PATCH 4/4] Make some more mingw paths work. + +Related: rhbz#1085434 + +--- + win32/find-mingw32.sh | 4 +++- + win64/find-mingw64.sh | 1 + + 2 files changed, 4 insertions(+), 1 deletion(-) + +diff --git a/win32/find-mingw32.sh b/win32/find-mingw32.sh +index f79949c..ed8408f 100755 +--- a/win32/find-mingw32.sh ++++ b/win32/find-mingw32.sh +@@ -20,7 +20,9 @@ for prefix in \ + i386-mingw32msvc- \ + i486-mingw32msvc- \ + i586-mingw32msvc- \ +- i686-mingw32msvc-; do ++ i686-mingw32msvc- \ ++ i686-w64-mingw32- \ ++ ; do + if "${prefix}${cc}" -v > /dev/null 2>&1; then + echo "$prefix" + exit 0 +diff --git a/win64/find-mingw64.sh b/win64/find-mingw64.sh +index c45db56..4c2cce2 100755 +--- a/win64/find-mingw64.sh ++++ b/win64/find-mingw64.sh +@@ -20,6 +20,7 @@ for prefix in \ + amd64-mingw64msvc- \ + amd64-mingw32- \ + amd64-mingw32msvc- \ ++ x86_64-w64-mingw32- \ + ; do + if "${prefix}${cc}" -v > /dev/null 2>&1; then + echo "$prefix" +-- +1.9.0 + diff --git a/SOURCES/0005-Save-Dell-BIOS-chunk-in-PXELINUX.patch b/SOURCES/0005-Save-Dell-BIOS-chunk-in-PXELINUX.patch new file mode 100644 index 00000000..01eea468 --- /dev/null +++ b/SOURCES/0005-Save-Dell-BIOS-chunk-in-PXELINUX.patch @@ -0,0 +1,88 @@ +From e1db3e675ae4ccbeea5de9f4b74a618e42eac1a3 Mon Sep 17 00:00:00 2001 +From: Nick Bertrand +Date: Tue, 31 Jul 2012 19:00:05 -0700 +Subject: [PATCH] Save Dell BIOS chunk in PXELINUX + +Our site has many Dell OptiPlex 790s, all of which are unable to use the +'localboot' PXELINUX option as they either hang at 'Booting from local disk...' +or immediately reboot depending on which SYSLINUX version is used. Many people +have suggested using chain.c32 to chain load the local disk as a workaround, +but this causes problems with Windows 7 BitLocker as it detects the chain load +and forces the user to enter the recovery key. While searching for another +option I determined that the problem seems to stem from the BIOS storing some +information in the memory range 0x47CC-0x47FF, which is overwritten when +PXELINUX loads. I couldn't figure out a clean way to avoid that memory region +as it falls in the middle of the 4.x bss16 region, so I decided to create a +copy of it instead. By copying that information out of the way during PXELINUX +initialization and copying it back before returning control via 'localboot 0', +the computer successfully boots to the local disk. + +Some additional info: + +BIOS revision: A13 +PXE versions: Intel Boot Agent GE v1.3.81, Intel Boot Agent PXE Base Code (PXE-2.1 build 089) +Versions of SYSLINUX affected: 3.83, 4.03, 4.04, 4.05, possibly others +Resulting symptom for localboot option vs SYSLINUX version: + + localboot 0 localboot -1 +3.83 Reboot Reboot +4.03 Reboot Reboot +4.04 Hang Reboot +4.05 Hang Reboot + +This patch does not fix the reboot issue when using 'localboot -1'. I believe +this patch should also help those with OptiPlex 990s, but I don't have one to +test with to confirm. + +Below is a patch against commit 0a0e0e41cad93cd16c323cf16f40264a21eedd6c of +the git.kernel.org/pub/scm/boot/syslinux/syslinux.git repository. + +-- +--- + core/pxelinux.asm | 18 ++++++++++++++++++ + 1 file changed, 18 insertions(+) + +diff --git a/core/pxelinux.asm b/core/pxelinux.asm +index e8818a6..b58ed2a 100644 +--- a/core/pxelinux.asm ++++ b/core/pxelinux.asm +@@ -132,6 +132,13 @@ _start1: + mov ds,ax + mov es,ax + ++ ; Copy chunk of memory used by Dell BIOS on OptiPlex 790s ++ ; Allows control to return to PXE Boot Agent for localboot ++ mov esi,47cch ++ mov edi,DellBIOSChunk ++ mov ecx,13 ++ rep movsd ++ + %if 0 ; debugging code only... not intended for production use + ; Clobber the stack segment, to test for specific pathologies + mov di,STACK_BASE +@@ -289,6 +296,14 @@ local_boot: + ; Restore the environment we were called with + pm_call reset_pxe + call cleanup_hardware ++ ++ ; Copy Dell BIOS chunk back into place ++ cld ++ mov esi,DellBIOSChunk ++ mov edi,47cch ++ mov ecx,13 ++ rep movsd ++ + lss sp,[InitStack] + pop gs + pop fs +@@ -564,3 +579,6 @@ IPInfo: + .ServerIP resd 1 + .GatewayIP resd 1 + .Netmask resd 1 ++ ++ section .earlybss ++DellBIOSChunk resd 13 ; 52 bytes to store Dell BIOS chunk +-- +2.5.0 + + diff --git a/SOURCES/syslinux-4.05-avoid-ext2_fs.h.patch b/SOURCES/syslinux-4.05-avoid-ext2_fs.h.patch new file mode 100644 index 00000000..9a166eef --- /dev/null +++ b/SOURCES/syslinux-4.05-avoid-ext2_fs.h.patch @@ -0,0 +1,965 @@ +From a1006762fa6f98750bb77d76dd992cb8ea9f9c99 Mon Sep 17 00:00:00 2001 +From: "H. Peter Anvin" +Date: Mon, 26 Mar 2012 22:51:09 -0700 +Subject: [PATCH] libinstaller: Avoid using + +Don't use if we can avoid it. + +The ioctl constants have been globalized and moved to . +Use a private copy of ext2_fs.h from e2fsprogs with the ioctl +constants removed for the data structures. + +Do at least attempt backward compatibility for old kernel headers, but +no real hope of proper operation there... + +Signed-off-by: H. Peter Anvin +--- + libinstaller/ext2fs/ext2_fs.h | 856 ++++++++++++++++++++++++++++++++++++++++++ + libinstaller/linuxioctl.h | 29 +- + libinstaller/syslxcom.c | 12 +- + 3 files changed, 886 insertions(+), 11 deletions(-) + create mode 100644 libinstaller/ext2fs/ext2_fs.h + +diff -urpN syslinux-4.05/libinstaller/ext2fs/ext2_fs.h.ext2 syslinux-4.05/libinstaller/ext2fs/ext2_fs.h +--- syslinux-4.05/libinstaller/ext2fs/ext2_fs.h.ext2 2012-08-06 09:48:43.797645032 -0400 ++++ syslinux-4.05/libinstaller/ext2fs/ext2_fs.h 2012-08-06 09:48:43.797645032 -0400 +@@ -0,0 +1,856 @@ ++/* ++ * linux/include/linux/ext2_fs.h ++ * ++ * Copyright (C) 1992, 1993, 1994, 1995 ++ * Remy Card (card@masi.ibp.fr) ++ * Laboratoire MASI - Institut Blaise Pascal ++ * Universite Pierre et Marie Curie (Paris VI) ++ * ++ * from ++ * ++ * linux/include/linux/minix_fs.h ++ * ++ * Copyright (C) 1991, 1992 Linus Torvalds ++ */ ++ ++#ifndef _EXT2FS_EXT2_FS_H ++#define _EXT2FS_EXT2_FS_H ++ ++#include ++ ++/* ++ * The second extended filesystem constants/structures ++ */ ++ ++/* ++ * Define EXT2FS_DEBUG to produce debug messages ++ */ ++#undef EXT2FS_DEBUG ++ ++/* ++ * Define EXT2_PREALLOCATE to preallocate data blocks for expanding files ++ */ ++#define EXT2_PREALLOCATE ++#define EXT2_DEFAULT_PREALLOC_BLOCKS 8 ++ ++/* ++ * The second extended file system version ++ */ ++#define EXT2FS_DATE "95/08/09" ++#define EXT2FS_VERSION "0.5b" ++ ++/* ++ * Special inode numbers ++ */ ++#define EXT2_BAD_INO 1 /* Bad blocks inode */ ++#define EXT2_ROOT_INO 2 /* Root inode */ ++#define EXT4_USR_QUOTA_INO 3 /* User quota inode */ ++#define EXT4_GRP_QUOTA_INO 4 /* Group quota inode */ ++#define EXT2_BOOT_LOADER_INO 5 /* Boot loader inode */ ++#define EXT2_UNDEL_DIR_INO 6 /* Undelete directory inode */ ++#define EXT2_RESIZE_INO 7 /* Reserved group descriptors inode */ ++#define EXT2_JOURNAL_INO 8 /* Journal inode */ ++#define EXT2_EXCLUDE_INO 9 /* The "exclude" inode, for snapshots */ ++#define EXT4_REPLICA_INO 10 /* Used by non-upstream feature */ ++ ++/* First non-reserved inode for old ext2 filesystems */ ++#define EXT2_GOOD_OLD_FIRST_INO 11 ++ ++/* ++ * The second extended file system magic number ++ */ ++#define EXT2_SUPER_MAGIC 0xEF53 ++ ++#ifdef __KERNEL__ ++#define EXT2_SB(sb) (&((sb)->u.ext2_sb)) ++#else ++/* Assume that user mode programs are passing in an ext2fs superblock, not ++ * a kernel struct super_block. This will allow us to call the feature-test ++ * macros from user land. */ ++#define EXT2_SB(sb) (sb) ++#endif ++ ++/* ++ * Maximal count of links to a file ++ */ ++#define EXT2_LINK_MAX 65000 ++ ++/* ++ * Macro-instructions used to manage several block sizes ++ */ ++#define EXT2_MIN_BLOCK_LOG_SIZE 10 /* 1024 */ ++#define EXT2_MAX_BLOCK_LOG_SIZE 16 /* 65536 */ ++#define EXT2_MIN_BLOCK_SIZE (1 << EXT2_MIN_BLOCK_LOG_SIZE) ++#define EXT2_MAX_BLOCK_SIZE (1 << EXT2_MAX_BLOCK_LOG_SIZE) ++#ifdef __KERNEL__ ++#define EXT2_BLOCK_SIZE(s) ((s)->s_blocksize) ++#define EXT2_BLOCK_SIZE_BITS(s) ((s)->s_blocksize_bits) ++#define EXT2_ADDR_PER_BLOCK_BITS(s) (EXT2_SB(s)->addr_per_block_bits) ++#define EXT2_INODE_SIZE(s) (EXT2_SB(s)->s_inode_size) ++#define EXT2_FIRST_INO(s) (EXT2_SB(s)->s_first_ino) ++#else ++#define EXT2_BLOCK_SIZE(s) (EXT2_MIN_BLOCK_SIZE << (s)->s_log_block_size) ++#define EXT2_BLOCK_SIZE_BITS(s) ((s)->s_log_block_size + 10) ++#define EXT2_INODE_SIZE(s) (((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? \ ++ EXT2_GOOD_OLD_INODE_SIZE : (s)->s_inode_size) ++#define EXT2_FIRST_INO(s) (((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? \ ++ EXT2_GOOD_OLD_FIRST_INO : (s)->s_first_ino) ++#endif ++#define EXT2_ADDR_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) / sizeof(__u32)) ++ ++/* ++ * Macro-instructions used to manage allocation clusters ++ */ ++#define EXT2_MIN_CLUSTER_LOG_SIZE EXT2_MIN_BLOCK_LOG_SIZE ++#define EXT2_MAX_CLUSTER_LOG_SIZE 29 /* 512MB */ ++#define EXT2_MIN_CLUSTER_SIZE EXT2_MIN_BLOCK_SIZE ++#define EXT2_MAX_CLUSTER_SIZE (1 << EXT2_MAX_CLUSTER_LOG_SIZE) ++#define EXT2_CLUSTER_SIZE(s) (EXT2_MIN_BLOCK_SIZE << \ ++ (s)->s_log_cluster_size) ++#define EXT2_CLUSTER_SIZE_BITS(s) ((s)->s_log_cluster_size + 10) ++ ++/* ++ * Macro-instructions used to manage fragments ++ * ++ * Note: for backwards compatibility only, for the dump program. ++ * Ext2/3/4 will never support fragments.... ++ */ ++#define EXT2_MIN_FRAG_SIZE EXT2_MIN_BLOCK_SIZE ++#define EXT2_MAX_FRAG_SIZE EXT2_MAX_BLOCK_SIZE ++#define EXT2_MIN_FRAG_LOG_SIZE EXT2_MIN_BLOCK_LOG_SIZE ++#define EXT2_FRAG_SIZE(s) EXT2_BLOCK_SIZE(s) ++#define EXT2_FRAGS_PER_BLOCK(s) 1 ++ ++/* ++ * ACL structures ++ */ ++struct ext2_acl_header /* Header of Access Control Lists */ ++{ ++ __u32 aclh_size; ++ __u32 aclh_file_count; ++ __u32 aclh_acle_count; ++ __u32 aclh_first_acle; ++}; ++ ++struct ext2_acl_entry /* Access Control List Entry */ ++{ ++ __u32 acle_size; ++ __u16 acle_perms; /* Access permissions */ ++ __u16 acle_type; /* Type of entry */ ++ __u16 acle_tag; /* User or group identity */ ++ __u16 acle_pad1; ++ __u32 acle_next; /* Pointer on next entry for the */ ++ /* same inode or on next free entry */ ++}; ++ ++/* ++ * Structure of a blocks group descriptor ++ */ ++struct ext2_group_desc ++{ ++ __u32 bg_block_bitmap; /* Blocks bitmap block */ ++ __u32 bg_inode_bitmap; /* Inodes bitmap block */ ++ __u32 bg_inode_table; /* Inodes table block */ ++ __u16 bg_free_blocks_count; /* Free blocks count */ ++ __u16 bg_free_inodes_count; /* Free inodes count */ ++ __u16 bg_used_dirs_count; /* Directories count */ ++ __u16 bg_flags; ++ __u32 bg_exclude_bitmap_lo; /* Exclude bitmap for snapshots */ ++ __u16 bg_block_bitmap_csum_lo;/* crc32c(s_uuid+grp_num+bitmap) LSB */ ++ __u16 bg_inode_bitmap_csum_lo;/* crc32c(s_uuid+grp_num+bitmap) LSB */ ++ __u16 bg_itable_unused; /* Unused inodes count */ ++ __u16 bg_checksum; /* crc16(s_uuid+grouo_num+group_desc)*/ ++}; ++ ++/* ++ * Structure of a blocks group descriptor ++ */ ++struct ext4_group_desc ++{ ++ __u32 bg_block_bitmap; /* Blocks bitmap block */ ++ __u32 bg_inode_bitmap; /* Inodes bitmap block */ ++ __u32 bg_inode_table; /* Inodes table block */ ++ __u16 bg_free_blocks_count; /* Free blocks count */ ++ __u16 bg_free_inodes_count; /* Free inodes count */ ++ __u16 bg_used_dirs_count; /* Directories count */ ++ __u16 bg_flags; /* EXT4_BG_flags (INODE_UNINIT, etc) */ ++ __u32 bg_exclude_bitmap_lo; /* Exclude bitmap for snapshots */ ++ __u16 bg_block_bitmap_csum_lo;/* crc32c(s_uuid+grp_num+bitmap) LSB */ ++ __u16 bg_inode_bitmap_csum_lo;/* crc32c(s_uuid+grp_num+bitmap) LSB */ ++ __u16 bg_itable_unused; /* Unused inodes count */ ++ __u16 bg_checksum; /* crc16(sb_uuid+group+desc) */ ++ __u32 bg_block_bitmap_hi; /* Blocks bitmap block MSB */ ++ __u32 bg_inode_bitmap_hi; /* Inodes bitmap block MSB */ ++ __u32 bg_inode_table_hi; /* Inodes table block MSB */ ++ __u16 bg_free_blocks_count_hi;/* Free blocks count MSB */ ++ __u16 bg_free_inodes_count_hi;/* Free inodes count MSB */ ++ __u16 bg_used_dirs_count_hi; /* Directories count MSB */ ++ __u16 bg_itable_unused_hi; /* Unused inodes count MSB */ ++ __u32 bg_exclude_bitmap_hi; /* Exclude bitmap block MSB */ ++ __u16 bg_block_bitmap_csum_hi;/* crc32c(s_uuid+grp_num+bitmap) MSB */ ++ __u16 bg_inode_bitmap_csum_hi;/* crc32c(s_uuid+grp_num+bitmap) MSB */ ++ __u32 bg_reserved; ++}; ++ ++#define EXT2_BG_INODE_UNINIT 0x0001 /* Inode table/bitmap not initialized */ ++#define EXT2_BG_BLOCK_UNINIT 0x0002 /* Block bitmap not initialized */ ++#define EXT2_BG_INODE_ZEROED 0x0004 /* On-disk itable initialized to zero */ ++ ++/* ++ * Data structures used by the directory indexing feature ++ * ++ * Note: all of the multibyte integer fields are little endian. ++ */ ++ ++/* ++ * Note: dx_root_info is laid out so that if it should somehow get ++ * overlaid by a dirent the two low bits of the hash version will be ++ * zero. Therefore, the hash version mod 4 should never be 0. ++ * Sincerely, the paranoia department. ++ */ ++struct ext2_dx_root_info { ++ __u32 reserved_zero; ++ __u8 hash_version; /* 0 now, 1 at release */ ++ __u8 info_length; /* 8 */ ++ __u8 indirect_levels; ++ __u8 unused_flags; ++}; ++ ++#define EXT2_HASH_LEGACY 0 ++#define EXT2_HASH_HALF_MD4 1 ++#define EXT2_HASH_TEA 2 ++#define EXT2_HASH_LEGACY_UNSIGNED 3 /* reserved for userspace lib */ ++#define EXT2_HASH_HALF_MD4_UNSIGNED 4 /* reserved for userspace lib */ ++#define EXT2_HASH_TEA_UNSIGNED 5 /* reserved for userspace lib */ ++ ++#define EXT2_HASH_FLAG_INCOMPAT 0x1 ++ ++struct ext2_dx_entry { ++ __u32 hash; ++ __u32 block; ++}; ++ ++struct ext2_dx_countlimit { ++ __u16 limit; ++ __u16 count; ++}; ++ ++ ++/* ++ * Macro-instructions used to manage group descriptors ++ */ ++#define EXT2_MIN_DESC_SIZE 32 ++#define EXT2_MIN_DESC_SIZE_64BIT 64 ++#define EXT2_MAX_DESC_SIZE EXT2_MIN_BLOCK_SIZE ++#define EXT2_DESC_SIZE(s) \ ++ ((EXT2_SB(s)->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) ? \ ++ (s)->s_desc_size : EXT2_MIN_DESC_SIZE) ++ ++#define EXT2_BLOCKS_PER_GROUP(s) (EXT2_SB(s)->s_blocks_per_group) ++#define EXT2_INODES_PER_GROUP(s) (EXT2_SB(s)->s_inodes_per_group) ++#define EXT2_CLUSTERS_PER_GROUP(s) (EXT2_SB(s)->s_clusters_per_group) ++#define EXT2_INODES_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s)/EXT2_INODE_SIZE(s)) ++/* limits imposed by 16-bit value gd_free_{blocks,inode}_count */ ++#define EXT2_MAX_BLOCKS_PER_GROUP(s) ((((unsigned) 1 << 16) - 8) * \ ++ (EXT2_CLUSTER_SIZE(s) / \ ++ EXT2_BLOCK_SIZE(s))) ++#define EXT2_MAX_CLUSTERS_PER_GROUP(s) (((unsigned) 1 << 16) - 8) ++#define EXT2_MAX_INODES_PER_GROUP(s) (((unsigned) 1 << 16) - \ ++ EXT2_INODES_PER_BLOCK(s)) ++#ifdef __KERNEL__ ++#define EXT2_DESC_PER_BLOCK(s) (EXT2_SB(s)->s_desc_per_block) ++#define EXT2_DESC_PER_BLOCK_BITS(s) (EXT2_SB(s)->s_desc_per_block_bits) ++#else ++#define EXT2_DESC_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) / EXT2_DESC_SIZE(s)) ++#endif ++ ++/* ++ * Constants relative to the data blocks ++ */ ++#define EXT2_NDIR_BLOCKS 12 ++#define EXT2_IND_BLOCK EXT2_NDIR_BLOCKS ++#define EXT2_DIND_BLOCK (EXT2_IND_BLOCK + 1) ++#define EXT2_TIND_BLOCK (EXT2_DIND_BLOCK + 1) ++#define EXT2_N_BLOCKS (EXT2_TIND_BLOCK + 1) ++ ++/* ++ * Inode flags ++ */ ++#define EXT2_SECRM_FL 0x00000001 /* Secure deletion */ ++#define EXT2_UNRM_FL 0x00000002 /* Undelete */ ++#define EXT2_COMPR_FL 0x00000004 /* Compress file */ ++#define EXT2_SYNC_FL 0x00000008 /* Synchronous updates */ ++#define EXT2_IMMUTABLE_FL 0x00000010 /* Immutable file */ ++#define EXT2_APPEND_FL 0x00000020 /* writes to file may only append */ ++#define EXT2_NODUMP_FL 0x00000040 /* do not dump file */ ++#define EXT2_NOATIME_FL 0x00000080 /* do not update atime */ ++/* Reserved for compression usage... */ ++#define EXT2_DIRTY_FL 0x00000100 ++#define EXT2_COMPRBLK_FL 0x00000200 /* One or more compressed clusters */ ++#define EXT2_NOCOMPR_FL 0x00000400 /* Access raw compressed data */ ++#define EXT2_ECOMPR_FL 0x00000800 /* Compression error */ ++/* End compression flags --- maybe not all used */ ++#define EXT2_BTREE_FL 0x00001000 /* btree format dir */ ++#define EXT2_INDEX_FL 0x00001000 /* hash-indexed directory */ ++#define EXT2_IMAGIC_FL 0x00002000 ++#define EXT3_JOURNAL_DATA_FL 0x00004000 /* file data should be journaled */ ++#define EXT2_NOTAIL_FL 0x00008000 /* file tail should not be merged */ ++#define EXT2_DIRSYNC_FL 0x00010000 /* Synchronous directory modifications */ ++#define EXT2_TOPDIR_FL 0x00020000 /* Top of directory hierarchies*/ ++#define EXT4_HUGE_FILE_FL 0x00040000 /* Set to each huge file */ ++#define EXT4_EXTENTS_FL 0x00080000 /* Inode uses extents */ ++#define EXT4_EA_INODE_FL 0x00200000 /* Inode used for large EA */ ++/* EXT4_EOFBLOCKS_FL 0x00400000 was here */ ++#define EXT4_SNAPFILE_FL 0x01000000 /* Inode is a snapshot */ ++#define EXT4_SNAPFILE_DELETED_FL 0x04000000 /* Snapshot is being deleted */ ++#define EXT4_SNAPFILE_SHRUNK_FL 0x08000000 /* Snapshot shrink has completed */ ++#define EXT2_RESERVED_FL 0x80000000 /* reserved for ext2 lib */ ++ ++#define EXT2_FL_USER_VISIBLE 0x004BDFFF /* User visible flags */ ++#define EXT2_FL_USER_MODIFIABLE 0x004B80FF /* User modifiable flags */ ++ ++/* ++ * ioctl commands ++ */ ++ ++/* Used for online resize */ ++struct ext2_new_group_input { ++ __u32 group; /* Group number for this data */ ++ __u32 block_bitmap; /* Absolute block number of block bitmap */ ++ __u32 inode_bitmap; /* Absolute block number of inode bitmap */ ++ __u32 inode_table; /* Absolute block number of inode table start */ ++ __u32 blocks_count; /* Total number of blocks in this group */ ++ __u16 reserved_blocks; /* Number of reserved blocks in this group */ ++ __u16 unused; /* Number of reserved GDT blocks in group */ ++}; ++ ++struct ext4_new_group_input { ++ __u32 group; /* Group number for this data */ ++ __u64 block_bitmap; /* Absolute block number of block bitmap */ ++ __u64 inode_bitmap; /* Absolute block number of inode bitmap */ ++ __u64 inode_table; /* Absolute block number of inode table start */ ++ __u32 blocks_count; /* Total number of blocks in this group */ ++ __u16 reserved_blocks; /* Number of reserved blocks in this group */ ++ __u16 unused; ++}; ++ ++#ifdef __GNU__ /* Needed for the Hurd */ ++#define _IOT_ext2_new_group_input _IOT (_IOTS(__u32), 5, _IOTS(__u16), 2, 0, 0) ++#endif ++ ++#define EXT2_IOC_GETFLAGS _IOR('f', 1, long) ++#define EXT2_IOC_SETFLAGS _IOW('f', 2, long) ++#define EXT2_IOC_GETVERSION _IOR('v', 1, long) ++#define EXT2_IOC_SETVERSION _IOW('v', 2, long) ++#define EXT2_IOC_GETVERSION_NEW _IOR('f', 3, long) ++#define EXT2_IOC_SETVERSION_NEW _IOW('f', 4, long) ++#define EXT2_IOC_GROUP_EXTEND _IOW('f', 7, unsigned long) ++#define EXT2_IOC_GROUP_ADD _IOW('f', 8,struct ext2_new_group_input) ++#define EXT4_IOC_GROUP_ADD _IOW('f', 8,struct ext4_new_group_input) ++#define EXT4_IOC_RESIZE_FS _IOW('f', 16, __u64) ++ ++/* ++ * Structure of an inode on the disk ++ */ ++struct ext2_inode { ++ __u16 i_mode; /* File mode */ ++ __u16 i_uid; /* Low 16 bits of Owner Uid */ ++ __u32 i_size; /* Size in bytes */ ++ __u32 i_atime; /* Access time */ ++ __u32 i_ctime; /* Inode change time */ ++ __u32 i_mtime; /* Modification time */ ++ __u32 i_dtime; /* Deletion Time */ ++ __u16 i_gid; /* Low 16 bits of Group Id */ ++ __u16 i_links_count; /* Links count */ ++ __u32 i_blocks; /* Blocks count */ ++ __u32 i_flags; /* File flags */ ++ union { ++ struct { ++ __u32 l_i_version; /* was l_i_reserved1 */ ++ } linux1; ++ struct { ++ __u32 h_i_translator; ++ } hurd1; ++ } osd1; /* OS dependent 1 */ ++ __u32 i_block[EXT2_N_BLOCKS];/* Pointers to blocks */ ++ __u32 i_generation; /* File version (for NFS) */ ++ __u32 i_file_acl; /* File ACL */ ++ __u32 i_size_high; /* Formerly i_dir_acl, directory ACL */ ++ __u32 i_faddr; /* Fragment address */ ++ union { ++ struct { ++ __u16 l_i_blocks_hi; ++ __u16 l_i_file_acl_high; ++ __u16 l_i_uid_high; /* these 2 fields */ ++ __u16 l_i_gid_high; /* were reserved2[0] */ ++ __u16 l_i_checksum_lo; /* crc32c(uuid+inum+inode) */ ++ __u16 l_i_reserved; ++ } linux2; ++ struct { ++ __u8 h_i_frag; /* Fragment number */ ++ __u8 h_i_fsize; /* Fragment size */ ++ __u16 h_i_mode_high; ++ __u16 h_i_uid_high; ++ __u16 h_i_gid_high; ++ __u32 h_i_author; ++ } hurd2; ++ } osd2; /* OS dependent 2 */ ++}; ++ ++/* ++ * Permanent part of an large inode on the disk ++ */ ++struct ext2_inode_large { ++ __u16 i_mode; /* File mode */ ++ __u16 i_uid; /* Low 16 bits of Owner Uid */ ++ __u32 i_size; /* Size in bytes */ ++ __u32 i_atime; /* Access time */ ++ __u32 i_ctime; /* Inode Change time */ ++ __u32 i_mtime; /* Modification time */ ++ __u32 i_dtime; /* Deletion Time */ ++ __u16 i_gid; /* Low 16 bits of Group Id */ ++ __u16 i_links_count; /* Links count */ ++ __u32 i_blocks; /* Blocks count */ ++ __u32 i_flags; /* File flags */ ++ union { ++ struct { ++ __u32 l_i_version; /* was l_i_reserved1 */ ++ } linux1; ++ struct { ++ __u32 h_i_translator; ++ } hurd1; ++ } osd1; /* OS dependent 1 */ ++ __u32 i_block[EXT2_N_BLOCKS];/* Pointers to blocks */ ++ __u32 i_generation; /* File version (for NFS) */ ++ __u32 i_file_acl; /* File ACL */ ++ __u32 i_size_high; /* Formerly i_dir_acl, directory ACL */ ++ __u32 i_faddr; /* Fragment address */ ++ union { ++ struct { ++ __u16 l_i_blocks_hi; ++ __u16 l_i_file_acl_high; ++ __u16 l_i_uid_high; /* these 2 fields */ ++ __u16 l_i_gid_high; /* were reserved2[0] */ ++ __u16 l_i_checksum_lo; /* crc32c(uuid+inum+inode) */ ++ __u16 l_i_reserved; ++ } linux2; ++ struct { ++ __u8 h_i_frag; /* Fragment number */ ++ __u8 h_i_fsize; /* Fragment size */ ++ __u16 h_i_mode_high; ++ __u16 h_i_uid_high; ++ __u16 h_i_gid_high; ++ __u32 h_i_author; ++ } hurd2; ++ } osd2; /* OS dependent 2 */ ++ __u16 i_extra_isize; ++ __u16 i_checksum_hi; /* crc32c(uuid+inum+inode) */ ++ __u32 i_ctime_extra; /* extra Change time (nsec << 2 | epoch) */ ++ __u32 i_mtime_extra; /* extra Modification time (nsec << 2 | epoch) */ ++ __u32 i_atime_extra; /* extra Access time (nsec << 2 | epoch) */ ++ __u32 i_crtime; /* File creation time */ ++ __u32 i_crtime_extra; /* extra File creation time (nsec << 2 | epoch)*/ ++ __u32 i_version_hi; /* high 32 bits for 64-bit version */ ++}; ++ ++#define i_dir_acl i_size_high ++ ++#if defined(__KERNEL__) || defined(__linux__) ++#define i_reserved1 osd1.linux1.l_i_reserved1 ++#define i_frag osd2.linux2.l_i_frag ++#define i_fsize osd2.linux2.l_i_fsize ++#define i_uid_low i_uid ++#define i_gid_low i_gid ++#define i_uid_high osd2.linux2.l_i_uid_high ++#define i_gid_high osd2.linux2.l_i_gid_high ++#else ++#if defined(__GNU__) ++ ++#define i_translator osd1.hurd1.h_i_translator ++#define i_frag osd2.hurd2.h_i_frag; ++#define i_fsize osd2.hurd2.h_i_fsize; ++#define i_uid_high osd2.hurd2.h_i_uid_high ++#define i_gid_high osd2.hurd2.h_i_gid_high ++#define i_author osd2.hurd2.h_i_author ++ ++#endif /* __GNU__ */ ++#endif /* defined(__KERNEL__) || defined(__linux__) */ ++ ++#define inode_uid(inode) ((inode).i_uid | (inode).osd2.linux2.l_i_uid_high << 16) ++#define inode_gid(inode) ((inode).i_gid | (inode).osd2.linux2.l_i_gid_high << 16) ++#define ext2fs_set_i_uid_high(inode,x) ((inode).osd2.linux2.l_i_uid_high = (x)) ++#define ext2fs_set_i_gid_high(inode,x) ((inode).osd2.linux2.l_i_gid_high = (x)) ++ ++/* ++ * File system states ++ */ ++#define EXT2_VALID_FS 0x0001 /* Unmounted cleanly */ ++#define EXT2_ERROR_FS 0x0002 /* Errors detected */ ++#define EXT3_ORPHAN_FS 0x0004 /* Orphans being recovered */ ++ ++/* ++ * Misc. filesystem flags ++ */ ++#define EXT2_FLAGS_SIGNED_HASH 0x0001 /* Signed dirhash in use */ ++#define EXT2_FLAGS_UNSIGNED_HASH 0x0002 /* Unsigned dirhash in use */ ++#define EXT2_FLAGS_TEST_FILESYS 0x0004 /* OK for use on development code */ ++#define EXT2_FLAGS_IS_SNAPSHOT 0x0010 /* This is a snapshot image */ ++#define EXT2_FLAGS_FIX_SNAPSHOT 0x0020 /* Snapshot inodes corrupted */ ++#define EXT2_FLAGS_FIX_EXCLUDE 0x0040 /* Exclude bitmaps corrupted */ ++ ++/* ++ * Mount flags ++ */ ++#define EXT2_MOUNT_CHECK 0x0001 /* Do mount-time checks */ ++#define EXT2_MOUNT_GRPID 0x0004 /* Create files with directory's group */ ++#define EXT2_MOUNT_DEBUG 0x0008 /* Some debugging messages */ ++#define EXT2_MOUNT_ERRORS_CONT 0x0010 /* Continue on errors */ ++#define EXT2_MOUNT_ERRORS_RO 0x0020 /* Remount fs ro on errors */ ++#define EXT2_MOUNT_ERRORS_PANIC 0x0040 /* Panic on errors */ ++#define EXT2_MOUNT_MINIX_DF 0x0080 /* Mimics the Minix statfs */ ++#define EXT2_MOUNT_NO_UID32 0x0200 /* Disable 32-bit UIDs */ ++ ++#define clear_opt(o, opt) o &= ~EXT2_MOUNT_##opt ++#define set_opt(o, opt) o |= EXT2_MOUNT_##opt ++#define test_opt(sb, opt) (EXT2_SB(sb)->s_mount_opt & \ ++ EXT2_MOUNT_##opt) ++/* ++ * Maximal mount counts between two filesystem checks ++ */ ++#define EXT2_DFL_MAX_MNT_COUNT 20 /* Allow 20 mounts */ ++#define EXT2_DFL_CHECKINTERVAL 0 /* Don't use interval check */ ++ ++/* ++ * Behaviour when detecting errors ++ */ ++#define EXT2_ERRORS_CONTINUE 1 /* Continue execution */ ++#define EXT2_ERRORS_RO 2 /* Remount fs read-only */ ++#define EXT2_ERRORS_PANIC 3 /* Panic */ ++#define EXT2_ERRORS_DEFAULT EXT2_ERRORS_CONTINUE ++ ++#if (__GNUC__ >= 4) ++#define ext4_offsetof(TYPE,MEMBER) __builtin_offsetof(TYPE,MEMBER) ++#else ++#define ext4_offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) ++#endif ++ ++/* ++ * Structure of the super block ++ */ ++struct ext2_super_block { ++ __u32 s_inodes_count; /* Inodes count */ ++ __u32 s_blocks_count; /* Blocks count */ ++ __u32 s_r_blocks_count; /* Reserved blocks count */ ++ __u32 s_free_blocks_count; /* Free blocks count */ ++ __u32 s_free_inodes_count; /* Free inodes count */ ++ __u32 s_first_data_block; /* First Data Block */ ++ __u32 s_log_block_size; /* Block size */ ++ __u32 s_log_cluster_size; /* Allocation cluster size */ ++ __u32 s_blocks_per_group; /* # Blocks per group */ ++ __u32 s_clusters_per_group; /* # Fragments per group */ ++ __u32 s_inodes_per_group; /* # Inodes per group */ ++ __u32 s_mtime; /* Mount time */ ++ __u32 s_wtime; /* Write time */ ++ __u16 s_mnt_count; /* Mount count */ ++ __s16 s_max_mnt_count; /* Maximal mount count */ ++ __u16 s_magic; /* Magic signature */ ++ __u16 s_state; /* File system state */ ++ __u16 s_errors; /* Behaviour when detecting errors */ ++ __u16 s_minor_rev_level; /* minor revision level */ ++ __u32 s_lastcheck; /* time of last check */ ++ __u32 s_checkinterval; /* max. time between checks */ ++ __u32 s_creator_os; /* OS */ ++ __u32 s_rev_level; /* Revision level */ ++ __u16 s_def_resuid; /* Default uid for reserved blocks */ ++ __u16 s_def_resgid; /* Default gid for reserved blocks */ ++ /* ++ * These fields are for EXT2_DYNAMIC_REV superblocks only. ++ * ++ * Note: the difference between the compatible feature set and ++ * the incompatible feature set is that if there is a bit set ++ * in the incompatible feature set that the kernel doesn't ++ * know about, it should refuse to mount the filesystem. ++ * ++ * e2fsck's requirements are more strict; if it doesn't know ++ * about a feature in either the compatible or incompatible ++ * feature set, it must abort and not try to meddle with ++ * things it doesn't understand... ++ */ ++ __u32 s_first_ino; /* First non-reserved inode */ ++ __u16 s_inode_size; /* size of inode structure */ ++ __u16 s_block_group_nr; /* block group # of this superblock */ ++ __u32 s_feature_compat; /* compatible feature set */ ++ __u32 s_feature_incompat; /* incompatible feature set */ ++ __u32 s_feature_ro_compat; /* readonly-compatible feature set */ ++ __u8 s_uuid[16]; /* 128-bit uuid for volume */ ++ char s_volume_name[16]; /* volume name */ ++ char s_last_mounted[64]; /* directory where last mounted */ ++ __u32 s_algorithm_usage_bitmap; /* For compression */ ++ /* ++ * Performance hints. Directory preallocation should only ++ * happen if the EXT2_FEATURE_COMPAT_DIR_PREALLOC flag is on. ++ */ ++ __u8 s_prealloc_blocks; /* Nr of blocks to try to preallocate*/ ++ __u8 s_prealloc_dir_blocks; /* Nr to preallocate for dirs */ ++ __u16 s_reserved_gdt_blocks; /* Per group table for online growth */ ++ /* ++ * Journaling support valid if EXT2_FEATURE_COMPAT_HAS_JOURNAL set. ++ */ ++ __u8 s_journal_uuid[16]; /* uuid of journal superblock */ ++ __u32 s_journal_inum; /* inode number of journal file */ ++ __u32 s_journal_dev; /* device number of journal file */ ++ __u32 s_last_orphan; /* start of list of inodes to delete */ ++ __u32 s_hash_seed[4]; /* HTREE hash seed */ ++ __u8 s_def_hash_version; /* Default hash version to use */ ++ __u8 s_jnl_backup_type; /* Default type of journal backup */ ++ __u16 s_desc_size; /* Group desc. size: INCOMPAT_64BIT */ ++ __u32 s_default_mount_opts; ++ __u32 s_first_meta_bg; /* First metablock group */ ++ __u32 s_mkfs_time; /* When the filesystem was created */ ++ __u32 s_jnl_blocks[17]; /* Backup of the journal inode */ ++ __u32 s_blocks_count_hi; /* Blocks count high 32bits */ ++ __u32 s_r_blocks_count_hi; /* Reserved blocks count high 32 bits*/ ++ __u32 s_free_blocks_hi; /* Free blocks count */ ++ __u16 s_min_extra_isize; /* All inodes have at least # bytes */ ++ __u16 s_want_extra_isize; /* New inodes should reserve # bytes */ ++ __u32 s_flags; /* Miscellaneous flags */ ++ __u16 s_raid_stride; /* RAID stride */ ++ __u16 s_mmp_update_interval; /* # seconds to wait in MMP checking */ ++ __u64 s_mmp_block; /* Block for multi-mount protection */ ++ __u32 s_raid_stripe_width; /* blocks on all data disks (N*stride)*/ ++ __u8 s_log_groups_per_flex; /* FLEX_BG group size */ ++ __u8 s_reserved_char_pad; ++ __u16 s_reserved_pad; /* Padding to next 32bits */ ++ __u64 s_kbytes_written; /* nr of lifetime kilobytes written */ ++ __u32 s_snapshot_inum; /* Inode number of active snapshot */ ++ __u32 s_snapshot_id; /* sequential ID of active snapshot */ ++ __u64 s_snapshot_r_blocks_count; /* reserved blocks for active ++ snapshot's future use */ ++ __u32 s_snapshot_list; /* inode number of the head of the on-disk snapshot list */ ++#define EXT4_S_ERR_START ext4_offsetof(struct ext2_super_block, s_error_count) ++ __u32 s_error_count; /* number of fs errors */ ++ __u32 s_first_error_time; /* first time an error happened */ ++ __u32 s_first_error_ino; /* inode involved in first error */ ++ __u64 s_first_error_block; /* block involved of first error */ ++ __u8 s_first_error_func[32]; /* function where the error happened */ ++ __u32 s_first_error_line; /* line number where error happened */ ++ __u32 s_last_error_time; /* most recent time of an error */ ++ __u32 s_last_error_ino; /* inode involved in last error */ ++ __u32 s_last_error_line; /* line number where error happened */ ++ __u64 s_last_error_block; /* block involved of last error */ ++ __u8 s_last_error_func[32]; /* function where the error happened */ ++#define EXT4_S_ERR_END ext4_offsetof(struct ext2_super_block, s_mount_opts) ++ __u8 s_mount_opts[64]; ++ __u32 s_usr_quota_inum; /* inode number of user quota file */ ++ __u32 s_grp_quota_inum; /* inode number of group quota file */ ++ __u32 s_overhead_blocks; /* overhead blocks/clusters in fs */ ++ __u32 s_reserved[108]; /* Padding to the end of the block */ ++ __u32 s_checksum; /* crc32c(superblock) */ ++}; ++ ++#define EXT4_S_ERR_LEN (EXT4_S_ERR_END - EXT4_S_ERR_START) ++ ++/* ++ * Codes for operating systems ++ */ ++#define EXT2_OS_LINUX 0 ++#define EXT2_OS_HURD 1 ++#define EXT2_OBSO_OS_MASIX 2 ++#define EXT2_OS_FREEBSD 3 ++#define EXT2_OS_LITES 4 ++ ++/* ++ * Revision levels ++ */ ++#define EXT2_GOOD_OLD_REV 0 /* The good old (original) format */ ++#define EXT2_DYNAMIC_REV 1 /* V2 format w/ dynamic inode sizes */ ++ ++#define EXT2_CURRENT_REV EXT2_GOOD_OLD_REV ++#define EXT2_MAX_SUPP_REV EXT2_DYNAMIC_REV ++ ++#define EXT2_GOOD_OLD_INODE_SIZE 128 ++ ++/* ++ * Journal inode backup types ++ */ ++#define EXT3_JNL_BACKUP_BLOCKS 1 ++ ++/* ++ * Feature set definitions ++ */ ++ ++#define EXT2_HAS_COMPAT_FEATURE(sb,mask) \ ++ ( EXT2_SB(sb)->s_feature_compat & (mask) ) ++#define EXT2_HAS_RO_COMPAT_FEATURE(sb,mask) \ ++ ( EXT2_SB(sb)->s_feature_ro_compat & (mask) ) ++#define EXT2_HAS_INCOMPAT_FEATURE(sb,mask) \ ++ ( EXT2_SB(sb)->s_feature_incompat & (mask) ) ++ ++#define EXT2_FEATURE_COMPAT_DIR_PREALLOC 0x0001 ++#define EXT2_FEATURE_COMPAT_IMAGIC_INODES 0x0002 ++#define EXT3_FEATURE_COMPAT_HAS_JOURNAL 0x0004 ++#define EXT2_FEATURE_COMPAT_EXT_ATTR 0x0008 ++#define EXT2_FEATURE_COMPAT_RESIZE_INODE 0x0010 ++#define EXT2_FEATURE_COMPAT_DIR_INDEX 0x0020 ++#define EXT2_FEATURE_COMPAT_LAZY_BG 0x0040 ++/* #define EXT2_FEATURE_COMPAT_EXCLUDE_INODE 0x0080 not used, legacy */ ++#define EXT2_FEATURE_COMPAT_EXCLUDE_BITMAP 0x0100 ++ ++ ++#define EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER 0x0001 ++#define EXT2_FEATURE_RO_COMPAT_LARGE_FILE 0x0002 ++/* #define EXT2_FEATURE_RO_COMPAT_BTREE_DIR 0x0004 not used */ ++#define EXT4_FEATURE_RO_COMPAT_HUGE_FILE 0x0008 ++#define EXT4_FEATURE_RO_COMPAT_GDT_CSUM 0x0010 ++#define EXT4_FEATURE_RO_COMPAT_DIR_NLINK 0x0020 ++#define EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE 0x0040 ++#define EXT4_FEATURE_RO_COMPAT_HAS_SNAPSHOT 0x0080 ++#define EXT4_FEATURE_RO_COMPAT_QUOTA 0x0100 ++#define EXT4_FEATURE_RO_COMPAT_BIGALLOC 0x0200 ++#define EXT4_FEATURE_RO_COMPAT_METADATA_CSUM 0x0400 ++#define EXT4_FEATURE_RO_COMPAT_REPLICA 0x0800 ++ ++#define EXT2_FEATURE_INCOMPAT_COMPRESSION 0x0001 ++#define EXT2_FEATURE_INCOMPAT_FILETYPE 0x0002 ++#define EXT3_FEATURE_INCOMPAT_RECOVER 0x0004 /* Needs recovery */ ++#define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV 0x0008 /* Journal device */ ++#define EXT2_FEATURE_INCOMPAT_META_BG 0x0010 ++#define EXT3_FEATURE_INCOMPAT_EXTENTS 0x0040 ++#define EXT4_FEATURE_INCOMPAT_64BIT 0x0080 ++#define EXT4_FEATURE_INCOMPAT_MMP 0x0100 ++#define EXT4_FEATURE_INCOMPAT_FLEX_BG 0x0200 ++#define EXT4_FEATURE_INCOMPAT_EA_INODE 0x0400 ++#define EXT4_FEATURE_INCOMPAT_DIRDATA 0x1000 ++ ++#define EXT2_FEATURE_COMPAT_SUPP 0 ++#define EXT2_FEATURE_INCOMPAT_SUPP (EXT2_FEATURE_INCOMPAT_FILETYPE| \ ++ EXT4_FEATURE_INCOMPAT_MMP) ++#define EXT2_FEATURE_RO_COMPAT_SUPP (EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER| \ ++ EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \ ++ EXT4_FEATURE_RO_COMPAT_DIR_NLINK| \ ++ EXT2_FEATURE_RO_COMPAT_BTREE_DIR) ++ ++/* ++ * Default values for user and/or group using reserved blocks ++ */ ++#define EXT2_DEF_RESUID 0 ++#define EXT2_DEF_RESGID 0 ++ ++/* ++ * Default mount options ++ */ ++#define EXT2_DEFM_DEBUG 0x0001 ++#define EXT2_DEFM_BSDGROUPS 0x0002 ++#define EXT2_DEFM_XATTR_USER 0x0004 ++#define EXT2_DEFM_ACL 0x0008 ++#define EXT2_DEFM_UID16 0x0010 ++#define EXT3_DEFM_JMODE 0x0060 ++#define EXT3_DEFM_JMODE_DATA 0x0020 ++#define EXT3_DEFM_JMODE_ORDERED 0x0040 ++#define EXT3_DEFM_JMODE_WBACK 0x0060 ++#define EXT4_DEFM_NOBARRIER 0x0100 ++#define EXT4_DEFM_BLOCK_VALIDITY 0x0200 ++#define EXT4_DEFM_DISCARD 0x0400 ++#define EXT4_DEFM_NODELALLOC 0x0800 ++ ++/* ++ * Structure of a directory entry ++ */ ++#define EXT2_NAME_LEN 255 ++ ++struct ext2_dir_entry { ++ __u32 inode; /* Inode number */ ++ __u16 rec_len; /* Directory entry length */ ++ __u16 name_len; /* Name length */ ++ char name[EXT2_NAME_LEN]; /* File name */ ++}; ++ ++/* ++ * The new version of the directory entry. Since EXT2 structures are ++ * stored in intel byte order, and the name_len field could never be ++ * bigger than 255 chars, it's safe to reclaim the extra byte for the ++ * file_type field. ++ */ ++struct ext2_dir_entry_2 { ++ __u32 inode; /* Inode number */ ++ __u16 rec_len; /* Directory entry length */ ++ __u8 name_len; /* Name length */ ++ __u8 file_type; ++ char name[EXT2_NAME_LEN]; /* File name */ ++}; ++ ++/* ++ * Ext2 directory file types. Only the low 3 bits are used. The ++ * other bits are reserved for now. ++ */ ++#define EXT2_FT_UNKNOWN 0 ++#define EXT2_FT_REG_FILE 1 ++#define EXT2_FT_DIR 2 ++#define EXT2_FT_CHRDEV 3 ++#define EXT2_FT_BLKDEV 4 ++#define EXT2_FT_FIFO 5 ++#define EXT2_FT_SOCK 6 ++#define EXT2_FT_SYMLINK 7 ++ ++#define EXT2_FT_MAX 8 ++ ++/* ++ * EXT2_DIR_PAD defines the directory entries boundaries ++ * ++ * NOTE: It must be a multiple of 4 ++ */ ++#define EXT2_DIR_PAD 4 ++#define EXT2_DIR_ROUND (EXT2_DIR_PAD - 1) ++#define EXT2_DIR_REC_LEN(name_len) (((name_len) + 8 + EXT2_DIR_ROUND) & \ ++ ~EXT2_DIR_ROUND) ++ ++/* ++ * This structure is used for multiple mount protection. It is written ++ * into the block number saved in the s_mmp_block field in the superblock. ++ * Programs that check MMP should assume that if SEQ_FSCK (or any unknown ++ * code above SEQ_MAX) is present then it is NOT safe to use the filesystem, ++ * regardless of how old the timestamp is. ++ * ++ * The timestamp in the MMP structure will be updated by e2fsck at some ++ * arbitary intervals (start of passes, after every few groups of inodes ++ * in pass1 and pass1b). There is no guarantee that e2fsck is updating ++ * the MMP block in a timely manner, and the updates it does are purely ++ * for the convenience of the sysadmin and not for automatic validation. ++ * ++ * Note: Only the mmp_seq value is used to determine whether the MMP block ++ * is being updated. The mmp_time, mmp_nodename, and mmp_bdevname ++ * fields are only for informational purposes for the administrator, ++ * due to clock skew between nodes and hostname HA service takeover. ++ */ ++#define EXT4_MMP_MAGIC 0x004D4D50U /* ASCII for MMP */ ++#define EXT4_MMP_SEQ_CLEAN 0xFF4D4D50U /* mmp_seq value for clean unmount */ ++#define EXT4_MMP_SEQ_FSCK 0xE24D4D50U /* mmp_seq value when being fscked */ ++#define EXT4_MMP_SEQ_MAX 0xE24D4D4FU /* maximum valid mmp_seq value */ ++ ++struct mmp_struct { ++ __u32 mmp_magic; /* Magic number for MMP */ ++ __u32 mmp_seq; /* Sequence no. updated periodically */ ++ __u64 mmp_time; /* Time last updated */ ++ char mmp_nodename[64]; /* Node which last updated MMP block */ ++ char mmp_bdevname[32]; /* Bdev which last updated MMP block */ ++ __u16 mmp_check_interval; /* Changed mmp_check_interval */ ++ __u16 mmp_pad1; ++ __u32 mmp_pad2[227]; ++}; ++ ++/* ++ * Default interval for MMP update in seconds. ++ */ ++#define EXT4_MMP_UPDATE_INTERVAL 5 ++ ++/* ++ * Maximum interval for MMP update in seconds. ++ */ ++#define EXT4_MMP_MAX_UPDATE_INTERVAL 300 ++ ++/* ++ * Minimum interval for MMP checking in seconds. ++ */ ++#define EXT4_MMP_MIN_CHECK_INTERVAL 5 ++ ++#endif /* _EXT2FS_EXT2_FS_H */ +diff -urpN syslinux-4.05/libinstaller/linuxioctl.h.ext2 syslinux-4.05/libinstaller/linuxioctl.h +--- syslinux-4.05/libinstaller/linuxioctl.h.ext2 2011-12-09 13:28:17.000000000 -0500 ++++ syslinux-4.05/libinstaller/linuxioctl.h 2012-08-06 09:52:42.653335110 -0400 +@@ -9,17 +9,33 @@ + + #include + ++#ifdef __linux__ ++ + #define statfs _kernel_statfs /* HACK to deal with broken 2.4 distros */ + + #include /* Floppy geometry */ + #include /* Hard disk geometry */ + +-#include /* FIGETBSZ, FIBMAP, FS_IOC_FIEMAP */ ++#include /* FIGETBSZ, FIBMAP, FS_IOC_* */ + #include /* FAT_IOCTL_SET_ATTRIBUTES */ + + #undef SECTOR_SIZE /* Defined in msdos_fs.h for no good reason */ + #undef SECTOR_BITS +-#include /* EXT2_IOC_* */ ++ ++#ifndef FS_IOC_GETFLAGS ++/* Old kernel headers, these were once ext2-specific... */ ++# include /* EXT2_IOC_* */ ++ ++# define FS_IOC_GETFLAGS EXT2_IOC_GETFLAGS ++# define FS_IOC_SETFLAGS EXT2_IOC_SETFLAGS ++ ++# define FS_IMMUTABLE_FL EXT2_IMMUTABLE_FL ++ ++#else ++ ++# include ++ ++#endif + + #ifndef FAT_IOCTL_GET_ATTRIBUTES + # define FAT_IOCTL_GET_ATTRIBUTES _IOR('r', 0x10, __u32) +@@ -37,11 +53,13 @@ + + #undef statfs + +-#if defined(__linux__) && !defined(BLKGETSIZE64) ++#ifndef BLKGETSIZE64 + /* This takes a u64, but the size field says size_t. Someone screwed big. */ + # define BLKGETSIZE64 _IOR(0x12,114,size_t) + #endif + + #include + ++#endif /* __linux__ */ ++ + #endif /* LIBINSTALLER_LINUXIOCTL_H */ +diff -urpN syslinux-4.05/libinstaller/syslxcom.c.ext2 syslinux-4.05/libinstaller/syslxcom.c +--- syslinux-4.05/libinstaller/syslxcom.c.ext2 2011-12-09 13:28:17.000000000 -0500 ++++ syslinux-4.05/libinstaller/syslxcom.c 2012-08-06 09:48:43.797645032 -0400 +@@ -121,9 +121,9 @@ void clear_attributes(int fd) + { + int flags; + +- if (!ioctl(fd, EXT2_IOC_GETFLAGS, &flags)) { +- flags &= ~EXT2_IMMUTABLE_FL; +- ioctl(fd, EXT2_IOC_SETFLAGS, &flags); ++ if (!ioctl(fd, FS_IOC_GETFLAGS, &flags)) { ++ flags &= ~FS_IMMUTABLE_FL; ++ ioctl(fd, FS_IOC_SETFLAGS, &flags); + } + break; + } +@@ -151,9 +151,9 @@ void set_attributes(int fd) + { + int flags; + +- if (st.st_uid == 0 && !ioctl(fd, EXT2_IOC_GETFLAGS, &flags)) { +- flags |= EXT2_IMMUTABLE_FL; +- ioctl(fd, EXT2_IOC_SETFLAGS, &flags); ++ if (st.st_uid == 0 && !ioctl(fd, FS_IOC_GETFLAGS, &flags)) { ++ flags |= FS_IMMUTABLE_FL; ++ ioctl(fd, FS_IOC_SETFLAGS, &flags); + } + break; + } diff --git a/SOURCES/syslinux-4.05-man-pages.patch b/SOURCES/syslinux-4.05-man-pages.patch new file mode 100644 index 00000000..d150258b --- /dev/null +++ b/SOURCES/syslinux-4.05-man-pages.patch @@ -0,0 +1,118 @@ +From: Peter Jones +Subject: Improve documentation +Date: Mon Jan 20 14:12:34 2014 -0500 + +Resolves: rhbz#948852 + +diff -urpN syslinux-4.05/libinstaller/syslxopt.c.options syslinux-4.05/libinstaller/syslxopt.c +--- syslinux-4.05/libinstaller/syslxopt.c.options 2014-01-20 14:02:01.634201156 -0500 ++++ syslinux-4.05/libinstaller/syslxopt.c 2014-01-20 14:09:39.303778826 -0500 +@@ -102,11 +102,11 @@ void __attribute__ ((noreturn)) usage(in + fprintf(stderr, + " --install -i Install over the current bootsector\n" + " --update -U Update a previous installation\n" +- " --zip -z Force zipdrive geometry (-H 64 -S 32)\n" ++ " --zipdrive -z Force zipdrive geometry (-H 64 -S 32)\n" + " --sectors=# -S Force the number of sectors per track\n" + " --heads=# -H Force number of heads\n" + " --stupid -s Slow, safe and stupid mode\n" +- " --raid -r Fall back to the next device on boot failure\n" ++ " --raid-mode -r Fall back to the next device on boot failure\n" + " --once=... %s Execute a command once upon boot\n" + " --clear-once -O Clear the boot-once command\n" + " --reset-adv Reset auxilliary data\n", +diff -urpN syslinux-4.05/man/isohybrid.1.options syslinux-4.05/man/isohybrid.1 +--- syslinux-4.05/man/isohybrid.1.options 2014-01-20 14:10:08.950685806 -0500 ++++ syslinux-4.05/man/isohybrid.1 2014-01-20 14:10:01.468709289 -0500 +@@ -0,0 +1,61 @@ ++.TH isohybrid 1 "17 Jan 2014" "isohybrid" ++.SH "NAME" ++isohybrid \(em Post-process an ISO 9660 image generated with mkisofs or ++genisoimage to allow hybrid booting as a CD-ROM or as a hard disk. ++.SH "SYNOPSIS" ++.B isohybrid ++[\fBOPTIONS\fP] ++.I ++.SH "DESCRIPTION" ++.PP ++The \fBisohybrid\fR utility modifies a an ISO 9660 image generated with ++mkisofs, genisoimage, or compatible utilities, to be bootable as a CD-ROM or ++as a hard disk. ++.SH "OPTIONS" ++.TP ++\fB-h\fR \fI\fR\fN ++.br ++Number of default geometry heads ++.TP ++\fB-s\fR \fI\fR ++.br ++Number of default geometry sectors ++.TP ++\fB-e\fR \fI\fR, \fB--entry\fR \fI\fR ++Specify parititon entry number (1-4) ++.TP ++\fB-o\fR \fI\fR, \fB--offset\fR \fI\fR ++.br ++Specify partition offset (default 0) ++.TP ++\fB-t\fR \fI\fR, \fB--type\fR \fI\fR ++.br ++Specify MBR ID (default random) ++.TP ++\fB-u\fR, \fB--uefi\fB ++Build EFI bootable image ++.TP ++\fB-m\fR, \fB--mac\fB ++Add Apple File Protocol partition table support ++.TP ++\fB--forcehd0\fR ++Assume we are laoded as disk ID 0 ++.TP ++\fB--ctrlhd0\fR ++Assume disk ID 0 if the Ctrl key is pressed ++.TP ++\fB--partok\fR ++Allow booting from within a partition ++.TP ++\fB-?\fR, \fB--help\fR ++Display help ++.TP ++\fB-v\fR, \fB--verbose\fR ++Display verbose output ++.TP ++\fB-V\fR, \fB--version\fR ++Display version information ++ ++.SH "SEE ALSO" ++.PP ++\fBmkisofs\fR(1) +diff -urpN syslinux-4.05/man/memdiskfind.1.options syslinux-4.05/man/memdiskfind.1 +--- syslinux-4.05/man/memdiskfind.1.options 2014-01-20 14:10:30.474618196 -0500 ++++ syslinux-4.05/man/memdiskfind.1 2014-01-20 14:10:26.087632002 -0500 +@@ -0,0 +1,10 @@ ++.TH memdiskfind 1 "17 Jan 2014" "memdiskfind" ++.SH "NAME" ++memdiskfind \(em Simple utility to find a resident \fBmemdisk\fR instance. ++.SH "SYNOPSIS" ++.B memdiskfind ++.SH "DESCRIPTION" ++.PP ++The \fBmemdiskfind\fR utility searches memory for a \fBmemdisk\fR instance, ++and, if found, outputs the parameters needed to use the \fphram\fR driver in ++Linux to map it. +diff -urpN syslinux-4.05/man/syslinux.1.options syslinux-4.05/man/syslinux.1 +--- syslinux-4.05/man/syslinux.1.options 2014-01-20 14:01:00.005389882 -0500 ++++ syslinux-4.05/man/syslinux.1 2014-01-20 14:09:41.886770720 -0500 +@@ -83,6 +83,12 @@ Override the detected number of sectors + .TP + \fB\-z\fP, \fB\-\-zipdrive\fP + Assume zipdrive geometry (\fI\-\-heads 64 \-\-sectors 32). ++.TP ++\fB\-\-reset\-adv\fP ++Reset auxilliary data. ++.TP ++\fB\-M\fP, \fB\-\-menu\-save\fP ++Set the label to select as default on the next boot. + .SH FILES + .SS "Configuration file" + All the configurable defaults in \s-1SYSLINUX\s+1 can be changed by putting a diff --git a/SOURCES/syslinux-isohybrid-fix-mbr.patch b/SOURCES/syslinux-isohybrid-fix-mbr.patch new file mode 100644 index 00000000..974c70c3 --- /dev/null +++ b/SOURCES/syslinux-isohybrid-fix-mbr.patch @@ -0,0 +1,122 @@ +From: Matthew Garrett +Date: Wed Feb 15 12:05:29 2012 -0500 +Subject: isohybrid: Generate MBR even when in EFI mode + +Various EFI systems insist that there be no active flag in the pMBR in +order to parse the GPT. The only way around this is to also generate a +valid MBR - the firmware will then pick that up and use the system +partition provided there. In order to deal with other EFI "sanity" checks, +the partition type for the non-EFI partitions is set to 0 to skip the +firmware bailing because of overlapping partitions. + +diff --git a/utils/isohybrid.c b/utils/isohybrid.c +index 1dcbaa1..ac04bfd 100644 +--- a/utils/isohybrid.c ++++ b/utils/isohybrid.c +@@ -54,7 +54,7 @@ enum { VERBOSE = 1 , EFI = 2 , MAC = 4}; + uint16_t head = 64; /* 1 <= head <= 256 */ + uint8_t sector = 32; /* 1 <= sector <= 63 */ + +-uint8_t entry = 1; /* partition number: 1 <= entry <= 4 */ ++uint8_t entry = 0; /* partition number: 1 <= entry <= 4 */ + uint8_t offset = 0; /* partition offset: 0 <= offset <= 64 */ + uint16_t type = 0x17; /* partition type: 0 <= type <= 255 */ + uint32_t id = 0; /* MBR: 0 <= id <= 0xFFFFFFFF(4294967296) */ +@@ -300,6 +300,8 @@ check_option(int argc, char *argv[]) + entry = strtoul(optarg, &err, 0); + if (entry < 1 || entry > 4) + errx(1, "invalid entry: `%s', 1 <= entry <= 4", optarg); ++ if (mode & MAC || mode & EFI) ++ errx(1, "setting an entry is unsupported with EFI or Mac"); + break; + + case 'o': +@@ -334,10 +336,14 @@ check_option(int argc, char *argv[]) + + case 'u': + mode |= EFI; ++ if (entry) ++ errx(1, "setting an entry is unsupported with EFI or Mac"); + break; + + case 'm': + mode |= MAC; ++ if (entry) ++ errx(1, "setting an entry is unsupported with EFI or Mac"); + break; + + case 'v': +@@ -581,6 +587,12 @@ initialise_mbr(uint8_t *mbr) + memcpy(mbr, afp_header, sizeof(afp_header)); + } + ++ if (!entry) ++ entry = 1; ++ ++ if (mode & EFI) ++ type = 0; ++ + mbr += MBRSIZE; /* offset 432 */ + + tmp = lendian_int(de_lba * 4); +@@ -633,6 +645,40 @@ initialise_mbr(uint8_t *mbr) + tmp = lendian_int(psize); + memcpy(&mbr[12], &tmp, sizeof(tmp)); + } ++ if (i == 2 && (mode & EFI)) ++ { ++ mbr[0] = 0x0; ++ mbr[1] = 0xfe; ++ mbr[2] = 0xff; ++ mbr[3] = 0xff; ++ mbr[4] = 0xef; ++ mbr[5] = 0xfe; ++ mbr[6] = 0xff; ++ mbr[7] = 0xff; ++ ++ tmp = lendian_int(efi_lba * 4); ++ memcpy(&mbr[8], &tmp, sizeof(tmp)); ++ ++ tmp = lendian_int(efi_count); ++ memcpy(&mbr[12], &tmp, sizeof(tmp)); ++ } ++ if (i == 3 && (mode & MAC)) ++ { ++ mbr[0] = 0x0; ++ mbr[1] = 0xfe; ++ mbr[2] = 0xff; ++ mbr[3] = 0xff; ++ mbr[4] = 0x0; ++ mbr[5] = 0xfe; ++ mbr[6] = 0xff; ++ mbr[7] = 0xff; ++ ++ tmp = lendian_int(mac_lba * 4); ++ memcpy(&mbr[8], &tmp, sizeof(tmp)); ++ ++ tmp = lendian_int(mac_count); ++ memcpy(&mbr[12], &tmp, sizeof(tmp)); ++ } + mbr += 16; + } + mbr[0] = 0x55; +@@ -908,8 +954,7 @@ main(int argc, char *argv[]) + if (!read_efi_section(buf)) { + buf += 32; + if (!read_efi_catalogue(buf, &efi_count, &efi_lba) && efi_lba) { +- offset = 1; +- type = 0xee; ++ offset = 0; + } else { + errx(1, "%s: invalid efi catalogue", argv[0]); + } +@@ -925,8 +970,7 @@ main(int argc, char *argv[]) + if (!read_efi_section(buf)) { + buf += 32; + if (!read_efi_catalogue(buf, &mac_count, &mac_lba) && mac_lba) { +- offset = 1; +- type = 0xee; ++ offset = 0; + } else { + errx(1, "%s: invalid efi catalogue", argv[0]); + } diff --git a/SPECS/syslinux.spec b/SPECS/syslinux.spec new file mode 100644 index 00000000..88beb5f0 --- /dev/null +++ b/SPECS/syslinux.spec @@ -0,0 +1,255 @@ +Summary: Simple kernel loader which boots from a FAT filesystem +Name: syslinux +Version: 4.05 +%define tarball_version 4.05 +Release: 13%{?dist} +License: GPLv2+ +Group: Applications/System +URL: http://syslinux.zytor.com/wiki/index.php/The_Syslinux_Project +Source0: http://www.kernel.org/pub/linux/utils/boot/syslinux/%{name}-%{tarball_version}.tar.bz2 +ExclusiveArch: x86_64 +Buildroot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n) +BuildRequires: nasm >= 0.98.38-1, perl, netpbm-progs, git +BuildRequires: libuuid-devel +BuildRequires: /usr/include/gnu/stubs-32.h +BuildRequires: cpio, findutils +%ifarch x86_64 +Requires: mtools, libc.so.6()(64bit), libuuid +%endif + +Patch0001: syslinux-isohybrid-fix-mbr.patch +Patch0002: syslinux-4.05-avoid-ext2_fs.h.patch +Patch0003: syslinux-4.05-man-pages.patch +Patch0006: 0003-Fixes-for-problems-discovered-by-coverity-scan.-8120.patch +Patch0007: 0004-Make-some-more-mingw-paths-work.patch +Patch0008: 0001-Don-t-use-strict-aliasing-because-not-everything-her.patch +Patch0009: 0001-relocs-Move-stop-to-the-end.patch +Patch0010: 0005-Save-Dell-BIOS-chunk-in-PXELINUX.patch + +%description +SYSLINUX is a suite of bootloaders, currently supporting DOS FAT +filesystems, Linux ext2/ext3 filesystems (EXTLINUX), PXE network boots +(PXELINUX), or ISO 9660 CD-ROMs (ISOLINUX). + +%package perl +Summary: Syslinux tools written in perl +Group: Applications/System + +%description perl +Syslinux tools written in perl + +%package extlinux +Summary: The EXTLINUX bootloader, for booting the local system. +Group: System/Boot +Requires: syslinux + +%description extlinux +The EXTLINUX bootloader, for booting the local system, as well as all +the SYSLINUX/PXELINUX modules in /boot. + +%package devel +Summary: Headers and libraries for syslinux development. +Group: Development/Libraries + +%description devel +Headers and libraries for syslinux development. + +%package tftpboot +Summary: SYSLINUX modules in /var/lib/tftpboot, available for network booting +Group: Applications/Internet +ExclusiveArch: x86_64 +Requires: syslinux + +%description tftpboot +All the SYSLINUX/PXELINUX modules directly available for network +booting in the /var/lib/tftpboot directory. + +%prep +%setup -q -n syslinux-%{tarball_version} +git init +git config user.email "nobody@example.com" +git config user.name "RHEL Ninjas" +git add . +git commit -a -q -m "%{version} baseline." +git am %{patches} - - 4.05-13 +- Try to work around firmware bugs in the PXE stack. + Resolves: rhbz#1254615 + +* Fri Sep 26 2014 Peter Jones - 4.05-12 +- Toolchain changes between when this originally got built and 4.05-9 means + 4.05-9 - 4.05-11 don't actually work. + Related: rhbz#1085434 + +* Tue Sep 23 2014 Peter Jones - 4.05-11 +- Fix some rpmdiff problems. + Related: rhbz#1085434 + +* Tue Sep 23 2014 Peter Jones - 4.05-10 +- Fix some aliasing errors rpmdiff complains about. + Related: rhbz#1085434 + +* Tue Sep 02 2014 Peter Jones - 4.05-9 +- Try harder to build everything correctly. + Resolves: rhbz#1085434 + +* Thu Feb 27 2014 David Cantrell - 4.05-8 +- Only build for x86_64 + Resolves: rhbz#1070659 + +* Mon Jan 20 2014 Peter Jones - 4.05-7 +- Improve documentation. + Resolves: rhbz#948852 + +* Fri Dec 27 2013 Daniel Mach - 4.05-6 +- Mass rebuild 2013-12-27 + +* Fri Feb 15 2013 Fedora Release Engineering - 4.05-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_19_Mass_Rebuild + +* Mon Aug 06 2012 Peter Jones - 4.05-4 +- Fix build problem from kernel-headers' removeal of ext2_fs.h + (fix backported from as-yet-unreleased upstream version.) + +* Sat Jul 21 2012 Fedora Release Engineering - 4.05-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_18_Mass_Rebuild + +* Wed Apr 18 2012 Michael Schwendt - 4.05-2 +- Remove old Obsoletes/Provides for syslinux-devel as such a subpkg + was introduced with 3.83-2 (#756733). + +* Wed Feb 15 2012 Matthew Garrett - 4.05-1 +- New upstream release +- syslinux-isohybrid-fix-mbr.patch: generate a full MBR for UEFI images + +* Sat Jan 14 2012 Fedora Release Engineering - 4.02-6 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_17_Mass_Rebuild + +* Wed Aug 24 2011 Matthew Garrett - 4.02-5 +- Add support for building Mac and GPT bootable hybrid images + +* Wed Feb 09 2011 Fedora Release Engineering - 4.02-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_15_Mass_Rebuild + +* Fri Aug 20 2010 Matt Domsch - 4.02-2 +- add perl subpackage, move perl apps there + +* Fri Aug 06 2010 Peter Jones - 4.02-2 +- Split out extlinux and tftpboot. +- remove duplicate syslinux/com32/ left in base package after 3.83-2 + +* Thu Aug 05 2010 Peter Jones - 4.02-1 +- Update to 4.02