From a109bb6d0eb936ac4e2a9f0ee46a269a58ec48ce Mon Sep 17 00:00:00 2001 From: root Date: Fri, 16 Nov 2012 11:52:02 +0000 Subject: fish --- master/debian/4k_sectors.patch | 1029 +++ master/debian/bash-completion_identifiers.patch | 45 + master/debian/branch_devmapper.patch | 286 + master/debian/branch_embed-sectors.patch | 247 + master/debian/branch_fuse.patch | 605 ++ master/debian/branch_longlinuxcmd.patch | 179 + master/debian/branch_parse-color.patch | 1310 +++ master/debian/branch_squash.patch | 694 ++ master/debian/btrfs_stat.patch | 36 + master/debian/core_in_fs.patch | 31 + master/debian/dirlen.patch | 19 + master/debian/disable_floppies.patch | 28 + master/debian/dpkg_version_comparison.patch | 30 + master/debian/efi_disk_cache.patch | 26 + master/debian/efiemu_fix.patch | 134 + master/debian/fat_uuid.patch | 25 + master/debian/gcc_4_6_space.patch | 33 + master/debian/gfxpayload_keep_default.patch | 38 + master/debian/gfxterm_background.patch | 69 + master/debian/grub.cfg_400.patch | 15 + master/debian/grub_legacy_0_based_partitions.patch | 43 + master/debian/handle_new_autotools.patch | 535 ++ master/debian/hurd.patch | 37 + master/debian/install_stage2_confusion.patch | 24 + master/debian/kfreebsd-9_ada_devices.patch | 71 + master/debian/kfreebsd_lvm.patch | 187 + master/debian/kfreebsd_mfi_devices.patch | 35 + master/debian/lazy_stat.patch | 73 + master/debian/lzo.patch | 8643 ++++++++++++++++++++ master/debian/mkconfig_gnumach.patch | 53 + master/debian/mkconfig_loopback.patch | 84 + master/debian/mkconfig_skip_dmcrypt.patch | 30 + master/debian/mkconfig_skip_readme.patch | 20 + master/debian/mkrescue_diet.patch | 54 + master/debian/mkrescue_efi_modules.patch | 22 + master/debian/no_libzfs.patch | 227 + master/debian/olpc_prefix_hack.patch | 50 + master/debian/partition_performance.patch | 36 + master/debian/probe_canonicalise.patch | 26 + master/debian/qemu_img_exists.patch | 18 + master/debian/series | 45 + master/debian/userland-part.patch | 149 + master/debian/xen_replace.patch | 64 + master/debian/xfs_invalid_bmap.patch | 188 + master/debian/zfs_packed_la_array.patch | 17 + master/debian/zfs_update.patch | 2415 ++++++ 46 files changed, 18025 insertions(+) create mode 100644 master/debian/4k_sectors.patch create mode 100644 master/debian/bash-completion_identifiers.patch create mode 100644 master/debian/branch_devmapper.patch create mode 100644 master/debian/branch_embed-sectors.patch create mode 100644 master/debian/branch_fuse.patch create mode 100644 master/debian/branch_longlinuxcmd.patch create mode 100644 master/debian/branch_parse-color.patch create mode 100644 master/debian/branch_squash.patch create mode 100644 master/debian/btrfs_stat.patch create mode 100644 master/debian/core_in_fs.patch create mode 100644 master/debian/dirlen.patch create mode 100644 master/debian/disable_floppies.patch create mode 100644 master/debian/dpkg_version_comparison.patch create mode 100644 master/debian/efi_disk_cache.patch create mode 100644 master/debian/efiemu_fix.patch create mode 100644 master/debian/fat_uuid.patch create mode 100644 master/debian/gcc_4_6_space.patch create mode 100644 master/debian/gfxpayload_keep_default.patch create mode 100644 master/debian/gfxterm_background.patch create mode 100644 master/debian/grub.cfg_400.patch create mode 100644 master/debian/grub_legacy_0_based_partitions.patch create mode 100644 master/debian/handle_new_autotools.patch create mode 100644 master/debian/hurd.patch create mode 100644 master/debian/install_stage2_confusion.patch create mode 100644 master/debian/kfreebsd-9_ada_devices.patch create mode 100644 master/debian/kfreebsd_lvm.patch create mode 100644 master/debian/kfreebsd_mfi_devices.patch create mode 100644 master/debian/lazy_stat.patch create mode 100644 master/debian/lzo.patch create mode 100644 master/debian/mkconfig_gnumach.patch create mode 100644 master/debian/mkconfig_loopback.patch create mode 100644 master/debian/mkconfig_skip_dmcrypt.patch create mode 100644 master/debian/mkconfig_skip_readme.patch create mode 100644 master/debian/mkrescue_diet.patch create mode 100644 master/debian/mkrescue_efi_modules.patch create mode 100644 master/debian/no_libzfs.patch create mode 100644 master/debian/olpc_prefix_hack.patch create mode 100644 master/debian/partition_performance.patch create mode 100644 master/debian/probe_canonicalise.patch create mode 100644 master/debian/qemu_img_exists.patch create mode 100644 master/debian/series create mode 100644 master/debian/userland-part.patch create mode 100644 master/debian/xen_replace.patch create mode 100644 master/debian/xfs_invalid_bmap.patch create mode 100644 master/debian/zfs_packed_la_array.patch create mode 100644 master/debian/zfs_update.patch (limited to 'master/debian') diff --git a/master/debian/4k_sectors.patch b/master/debian/4k_sectors.patch new file mode 100644 index 0000000..7281b3f --- /dev/null +++ b/master/debian/4k_sectors.patch @@ -0,0 +1,1029 @@ +Description: Support non-512B sectors and agglomerate reads +Author: Vladimir Serbinenko +Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3325 +Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3476 +Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3709 +Forwarded: not-needed +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3325 +Last-Update: 2012-04-02 + +Index: b/Makefile.util.def +=================================================================== +--- a/Makefile.util.def ++++ b/Makefile.util.def +@@ -34,6 +34,7 @@ + common_nodist = grub_script.tab.h; + + common = grub-core/commands/blocklist.c; ++ common = grub-core/commands/testload.c; + common = grub-core/commands/extcmd.c; + common = grub-core/commands/ls.c; + common = grub-core/disk/dmraid_nvidia.c; +Index: b/grub-core/disk/efi/efidisk.c +=================================================================== +--- a/grub-core/disk/efi/efidisk.c ++++ b/grub-core/disk/efi/efidisk.c +@@ -33,12 +33,10 @@ + grub_efi_device_path_t *device_path; + grub_efi_device_path_t *last_device_path; + grub_efi_block_io_t *block_io; +- grub_efi_disk_io_t *disk_io; + struct grub_efidisk_data *next; + }; + +-/* GUIDs. */ +-static grub_efi_guid_t disk_io_guid = GRUB_EFI_DISK_IO_GUID; ++/* GUID. */ + static grub_efi_guid_t block_io_guid = GRUB_EFI_BLOCK_IO_GUID; + + static struct grub_efidisk_data *fd_devices; +@@ -143,7 +141,7 @@ + struct grub_efidisk_data *devices = 0; + + /* Find handles which support the disk io interface. */ +- handles = grub_efi_locate_handle (GRUB_EFI_BY_PROTOCOL, &disk_io_guid, ++ handles = grub_efi_locate_handle (GRUB_EFI_BY_PROTOCOL, &block_io_guid, + 0, &num_handles); + if (! handles) + return 0; +@@ -155,7 +153,6 @@ + grub_efi_device_path_t *ldp; + struct grub_efidisk_data *d; + grub_efi_block_io_t *bio; +- grub_efi_disk_io_t *dio; + + dp = grub_efi_get_device_path (*handle); + if (! dp) +@@ -168,9 +165,7 @@ + + bio = grub_efi_open_protocol (*handle, &block_io_guid, + GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL); +- dio = grub_efi_open_protocol (*handle, &disk_io_guid, +- GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL); +- if (! bio || ! dio) ++ if (! bio) + /* This should not happen... Why? */ + continue; + +@@ -186,7 +181,6 @@ + d->device_path = dp; + d->last_device_path = ldp; + d->block_io = bio; +- d->disk_io = dio; + d->next = devices; + devices = d; + } +@@ -536,8 +530,13 @@ + and total sectors should be replaced with total blocks. */ + grub_dprintf ("efidisk", "m = %p, last block = %llx, block size = %x\n", + m, (unsigned long long) m->last_block, m->block_size); +- disk->total_sectors = (m->last_block +- * (m->block_size >> GRUB_DISK_SECTOR_BITS)); ++ disk->total_sectors = m->last_block; ++ if (m->block_size & (m->block_size - 1) || !m->block_size) ++ return grub_error (GRUB_ERR_IO, "invalid sector size %d", ++ m->block_size); ++ for (disk->log_sector_size = 0; ++ (1U << disk->log_sector_size) < m->block_size; ++ disk->log_sector_size++); + disk->data = d; + + grub_dprintf ("efidisk", "opening %s succeeded\n", name); +@@ -558,22 +557,20 @@ + { + /* For now, use the disk io interface rather than the block io's. */ + struct grub_efidisk_data *d; +- grub_efi_disk_io_t *dio; + grub_efi_block_io_t *bio; + grub_efi_status_t status; + + d = disk->data; +- dio = d->disk_io; + bio = d->block_io; + + grub_dprintf ("efidisk", + "reading 0x%lx sectors at the sector 0x%llx from %s\n", + (unsigned long) size, (unsigned long long) sector, disk->name); + +- status = efi_call_5 (dio->read, dio, bio->media->media_id, +- (grub_efi_uint64_t) sector << GRUB_DISK_SECTOR_BITS, +- (grub_efi_uintn_t) size << GRUB_DISK_SECTOR_BITS, +- buf); ++ status = efi_call_5 (bio->read_blocks, bio, bio->media->media_id, ++ (grub_efi_uint64_t) sector, ++ (grub_efi_uintn_t) size << disk->log_sector_size, ++ buf); + if (status != GRUB_EFI_SUCCESS) + return grub_error (GRUB_ERR_READ_ERROR, "efidisk read error"); + +@@ -586,21 +583,19 @@ + { + /* For now, use the disk io interface rather than the block io's. */ + struct grub_efidisk_data *d; +- grub_efi_disk_io_t *dio; + grub_efi_block_io_t *bio; + grub_efi_status_t status; + + d = disk->data; +- dio = d->disk_io; + bio = d->block_io; + + grub_dprintf ("efidisk", + "writing 0x%lx sectors at the sector 0x%llx to %s\n", + (unsigned long) size, (unsigned long long) sector, disk->name); + +- status = efi_call_5 (dio->write, dio, bio->media->media_id, +- (grub_efi_uint64_t) sector << GRUB_DISK_SECTOR_BITS, +- (grub_efi_uintn_t) size << GRUB_DISK_SECTOR_BITS, ++ status = efi_call_5 (bio->write_blocks, bio, bio->media->media_id, ++ (grub_efi_uint64_t) sector, ++ (grub_efi_uintn_t) size << disk->log_sector_size, + (void *) buf); + if (status != GRUB_EFI_SUCCESS) + return grub_error (GRUB_ERR_WRITE_ERROR, "efidisk write error"); +Index: b/grub-core/disk/i386/pc/biosdisk.c +=================================================================== +--- a/grub-core/disk/i386/pc/biosdisk.c ++++ b/grub-core/disk/i386/pc/biosdisk.c +@@ -340,7 +340,8 @@ + if ((cd_drive) && (drive == cd_drive)) + { + data->flags = GRUB_BIOSDISK_FLAG_LBA | GRUB_BIOSDISK_FLAG_CDROM; +- data->sectors = 32; ++ data->sectors = 8; ++ disk->log_sector_size = 11; + /* TODO: get the correct size. */ + total_sectors = GRUB_DISK_SIZE_UNKNOWN; + } +@@ -349,6 +350,8 @@ + /* HDD */ + int version; + ++ disk->log_sector_size = 9; ++ + version = grub_biosdisk_check_int13_extensions (drive); + if (version) + { +@@ -369,6 +372,15 @@ + correctly but returns zero. So if it is zero, compute + it by C/H/S returned by the LBA BIOS call. */ + total_sectors = drp->cylinders * drp->heads * drp->sectors; ++ if (drp->bytes_per_sector ++ && !(drp->bytes_per_sector & (drp->bytes_per_sector - 1)) ++ && drp->bytes_per_sector >= 512 ++ && drp->bytes_per_sector <= 16384) ++ { ++ for (disk->log_sector_size = 0; ++ (1 << disk->log_sector_size) < drp->bytes_per_sector; ++ disk->log_sector_size++); ++ } + } + } + } +@@ -431,7 +443,7 @@ + + dap = (struct grub_biosdisk_dap *) (GRUB_MEMORY_MACHINE_SCRATCH_ADDR + + (data->sectors +- << GRUB_DISK_SECTOR_BITS)); ++ << disk->log_sector_size)); + dap->length = sizeof (*dap); + dap->reserved = 0; + dap->blocks = size; +@@ -445,9 +457,6 @@ + if (cmd) + return grub_error (GRUB_ERR_WRITE_ERROR, "can\'t write to cdrom"); + +- dap->blocks = ALIGN_UP (dap->blocks, 4) >> 2; +- dap->block >>= 2; +- + for (i = 0; i < GRUB_BIOSDISK_CDROM_RETRY_COUNT; i++) + if (! grub_biosdisk_rw_int13_extensions (0x42, data->drive, dap)) + break; +@@ -503,19 +512,21 @@ + + /* Return the number of sectors which can be read safely at a time. */ + static grub_size_t +-get_safe_sectors (grub_disk_addr_t sector, grub_uint32_t sectors) ++get_safe_sectors (grub_disk_t disk, grub_disk_addr_t sector) + { + grub_size_t size; +- grub_uint32_t offset; ++ grub_uint64_t offset; ++ struct grub_biosdisk_data *data = disk->data; ++ grub_uint32_t sectors = data->sectors; + + /* OFFSET = SECTOR % SECTORS */ +- grub_divmod64 (sector, sectors, &offset); ++ grub_divmod64_full (sector, sectors, &offset); + + size = sectors - offset; + + /* Limit the max to 0x7f because of Phoenix EDD. */ +- if (size > 0x7f) +- size = 0x7f; ++ if (size > ((0x7fU << GRUB_DISK_SECTOR_BITS) >> disk->log_sector_size)) ++ size = ((0x7fU << GRUB_DISK_SECTOR_BITS) >> disk->log_sector_size); + + return size; + } +@@ -524,21 +535,11 @@ + grub_biosdisk_read (grub_disk_t disk, grub_disk_addr_t sector, + grub_size_t size, char *buf) + { +- struct grub_biosdisk_data *data = disk->data; +- + while (size) + { + grub_size_t len; +- grub_size_t cdoff = 0; + +- len = get_safe_sectors (sector, data->sectors); +- +- if (data->flags & GRUB_BIOSDISK_FLAG_CDROM) +- { +- cdoff = (sector & 3) << GRUB_DISK_SECTOR_BITS; +- len = ALIGN_UP (sector + len, 4) - (sector & ~3); +- sector &= ~3; +- } ++ len = get_safe_sectors (disk, sector); + + if (len > size) + len = size; +@@ -547,9 +548,10 @@ + GRUB_MEMORY_MACHINE_SCRATCH_SEG)) + return grub_errno; + +- grub_memcpy (buf, (void *) (GRUB_MEMORY_MACHINE_SCRATCH_ADDR + cdoff), +- len << GRUB_DISK_SECTOR_BITS); +- buf += len << GRUB_DISK_SECTOR_BITS; ++ grub_memcpy (buf, (void *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR, ++ len << disk->log_sector_size); ++ ++ buf += len << disk->log_sector_size; + sector += len; + size -= len; + } +@@ -570,18 +572,18 @@ + { + grub_size_t len; + +- len = get_safe_sectors (sector, data->sectors); ++ len = get_safe_sectors (disk, sector); + if (len > size) + len = size; + + grub_memcpy ((void *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR, buf, +- len << GRUB_DISK_SECTOR_BITS); ++ len << disk->log_sector_size); + + if (grub_biosdisk_rw (GRUB_BIOSDISK_WRITE, disk, sector, len, + GRUB_MEMORY_MACHINE_SCRATCH_SEG)) + return grub_errno; + +- buf += len << GRUB_DISK_SECTOR_BITS; ++ buf += len << disk->log_sector_size; + sector += len; + size -= len; + } +Index: b/grub-core/disk/scsi.c +=================================================================== +--- a/grub-core/disk/scsi.c ++++ b/grub-core/disk/scsi.c +@@ -465,15 +465,20 @@ + return err; + } + +- /* SCSI blocks can be something else than 512, although GRUB +- wants 512 byte blocks. */ +- disk->total_sectors = ((grub_uint64_t)scsi->size +- * (grub_uint64_t)scsi->blocksize) +- >> GRUB_DISK_SECTOR_BITS; ++ disk->total_sectors = scsi->size; ++ if (scsi->blocksize & (scsi->blocksize - 1) || !scsi->blocksize) ++ { ++ grub_free (scsi); ++ return grub_error (GRUB_ERR_IO, "invalid sector size %d", ++ scsi->blocksize); ++ } ++ for (disk->log_sector_size = 0; ++ (1 << disk->log_sector_size) < scsi->blocksize; ++ disk->log_sector_size++); + + grub_dprintf ("scsi", "blocks=%u, blocksize=%u\n", + scsi->size, scsi->blocksize); +- grub_dprintf ("scsi", "Disk total 512 sectors = %llu\n", ++ grub_dprintf ("scsi", "Disk total sectors = %llu\n", + (unsigned long long) disk->total_sectors); + + return GRUB_ERR_NONE; +@@ -503,25 +508,6 @@ + + scsi = disk->data; + +- /* SCSI sectors are variable in size. GRUB uses 512 byte +- sectors. */ +- if (scsi->blocksize != GRUB_DISK_SECTOR_SIZE) +- { +- unsigned spb = scsi->blocksize >> GRUB_DISK_SECTOR_BITS; +- if (spb == 0 || (scsi->blocksize & (GRUB_DISK_SECTOR_SIZE - 1)) != 0) +- return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, +- "unsupported SCSI block size"); +- +- grub_uint32_t sector_mod = 0; +- sector = grub_divmod64 (sector, spb, §or_mod); +- +- if (! (sector_mod == 0 && size % spb == 0)) +- return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, +- "unaligned SCSI read not supported"); +- +- size /= spb; +- } +- + /* Depending on the type, select a read function. */ + switch (scsi->devtype) + { +Index: b/grub-core/kern/disk.c +=================================================================== +--- a/grub-core/kern/disk.c ++++ b/grub-core/kern/disk.c +@@ -247,6 +247,7 @@ + disk = (grub_disk_t) grub_zalloc (sizeof (*disk)); + if (! disk) + return 0; ++ disk->log_sector_size = GRUB_DISK_SECTOR_BITS; + + p = find_part_sep (name); + if (p) +@@ -266,7 +267,6 @@ + if (! disk->name) + goto fail; + +- + for (dev = grub_disk_dev_list; dev; dev = dev->next) + { + if ((dev->open) (raw, disk) == GRUB_ERR_NONE) +@@ -282,6 +282,14 @@ + grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no such disk"); + goto fail; + } ++ if (disk->log_sector_size > GRUB_DISK_CACHE_BITS + GRUB_DISK_SECTOR_BITS ++ || disk->log_sector_size < GRUB_DISK_SECTOR_BITS) ++ { ++ grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, ++ "sector sizes of %d bytes aren't supported yet", ++ (1 << disk->log_sector_size)); ++ goto fail; ++ } + + disk->dev = dev; + +@@ -373,21 +381,113 @@ + *sector += start; + } + +- if (disk->total_sectors <= *sector +- || ((*offset + size + GRUB_DISK_SECTOR_SIZE - 1) +- >> GRUB_DISK_SECTOR_BITS) > disk->total_sectors - *sector) ++ if (disk->total_sectors != GRUB_DISK_SIZE_UNKNOWN ++ && ((disk->total_sectors << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS)) <= *sector ++ || ((*offset + size + GRUB_DISK_SECTOR_SIZE - 1) ++ >> GRUB_DISK_SECTOR_BITS) > (disk->total_sectors ++ << (disk->log_sector_size ++ - GRUB_DISK_SECTOR_BITS)) - *sector)) + return grub_error (GRUB_ERR_OUT_OF_RANGE, "out of disk"); + + return GRUB_ERR_NONE; + } + ++static inline grub_disk_addr_t ++transform_sector (grub_disk_t disk, grub_disk_addr_t sector) ++{ ++ return sector >> (disk->log_sector_size - GRUB_DISK_SECTOR_BITS); ++} ++ ++/* Small read (less than cache size and not pass across cache unit boundaries). ++ sector is already adjusted and is divisible by cache unit size. ++ */ ++static grub_err_t ++grub_disk_read_small (grub_disk_t disk, grub_disk_addr_t sector, ++ grub_off_t offset, grub_size_t size, void *buf) ++{ ++ char *data; ++ char *tmp_buf; ++ ++ /* Fetch the cache. */ ++ data = grub_disk_cache_fetch (disk->dev->id, disk->id, sector); ++ if (data) ++ { ++ /* Just copy it! */ ++ grub_memcpy (buf, data + offset, size); ++ grub_disk_cache_unlock (disk->dev->id, disk->id, sector); ++ return GRUB_ERR_NONE; ++ } ++ ++ /* Allocate a temporary buffer. */ ++ tmp_buf = grub_malloc (GRUB_DISK_SECTOR_SIZE << GRUB_DISK_CACHE_BITS); ++ if (! tmp_buf) ++ return grub_errno; ++ ++ /* Otherwise read data from the disk actually. */ ++ if (disk->total_sectors == GRUB_DISK_SIZE_UNKNOWN ++ || sector + GRUB_DISK_CACHE_SIZE ++ < (disk->total_sectors << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS))) ++ { ++ grub_err_t err; ++ err = (disk->dev->read) (disk, transform_sector (disk, sector), ++ 1 << (GRUB_DISK_CACHE_BITS ++ + GRUB_DISK_SECTOR_BITS ++ - disk->log_sector_size), tmp_buf); ++ if (!err) ++ { ++ /* Copy it and store it in the disk cache. */ ++ grub_memcpy (buf, tmp_buf + offset, size); ++ grub_disk_cache_store (disk->dev->id, disk->id, ++ sector, tmp_buf); ++ grub_free (tmp_buf); ++ return GRUB_ERR_NONE; ++ } ++ } ++ ++ grub_free (tmp_buf); ++ grub_errno = GRUB_ERR_NONE; ++ ++ { ++ /* Uggh... Failed. Instead, just read necessary data. */ ++ unsigned num; ++ grub_disk_addr_t aligned_sector; ++ ++ sector += (offset >> GRUB_DISK_SECTOR_BITS); ++ offset &= ((1 << GRUB_DISK_SECTOR_BITS) - 1); ++ aligned_sector = (sector & ~((1 << (disk->log_sector_size ++ - GRUB_DISK_SECTOR_BITS)) ++ - 1)); ++ offset += ((sector - aligned_sector) << GRUB_DISK_SECTOR_BITS); ++ num = ((size + offset + (1 << (disk->log_sector_size)) ++ - 1) >> (disk->log_sector_size)); ++ ++ tmp_buf = grub_malloc (num << disk->log_sector_size); ++ if (!tmp_buf) ++ return grub_errno; ++ ++ if ((disk->dev->read) (disk, transform_sector (disk, aligned_sector), ++ num, tmp_buf)) ++ { ++ grub_error_push (); ++ grub_dprintf ("disk", "%s read failed\n", disk->name); ++ grub_error_pop (); ++ grub_free (tmp_buf); ++ return grub_errno; ++ } ++ grub_memcpy (buf, tmp_buf + offset, size); ++ grub_free (tmp_buf); ++ return GRUB_ERR_NONE; ++ } ++} ++ + /* Read data from the disk. */ + grub_err_t + grub_disk_read (grub_disk_t disk, grub_disk_addr_t sector, + grub_off_t offset, grub_size_t size, void *buf) + { +- char *tmp_buf; +- unsigned real_offset; ++ grub_off_t real_offset; ++ grub_disk_addr_t real_sector; ++ grub_size_t real_size; + + /* First of all, check if the region is within the disk. */ + if (grub_disk_adjust_range (disk, §or, &offset, size) != GRUB_ERR_NONE) +@@ -399,126 +499,126 @@ + return grub_errno; + } + ++ real_sector = sector; + real_offset = offset; ++ real_size = size; + +- /* Allocate a temporary buffer. */ +- tmp_buf = grub_malloc (GRUB_DISK_SECTOR_SIZE << GRUB_DISK_CACHE_BITS); +- if (! tmp_buf) +- return grub_errno; +- +- /* Until SIZE is zero... */ +- while (size) ++ /* First read until first cache boundary. */ ++ if (offset || (sector & (GRUB_DISK_CACHE_SIZE - 1))) + { +- char *data; + grub_disk_addr_t start_sector; +- grub_size_t len; + grub_size_t pos; ++ grub_err_t err; ++ grub_size_t len; + +- /* For reading bulk data. */ + start_sector = sector & ~(GRUB_DISK_CACHE_SIZE - 1); + pos = (sector - start_sector) << GRUB_DISK_SECTOR_BITS; + len = ((GRUB_DISK_SECTOR_SIZE << GRUB_DISK_CACHE_BITS) +- - pos - real_offset); ++ - pos - offset); + if (len > size) + len = size; ++ err = grub_disk_read_small (disk, start_sector, ++ offset + pos, len, buf); ++ if (err) ++ return err; ++ buf = (char *) buf + len; ++ size -= len; ++ offset += len; ++ sector += (offset >> GRUB_DISK_SECTOR_BITS); ++ offset &= ((1 << GRUB_DISK_SECTOR_BITS) - 1); ++ } + +- /* Fetch the cache. */ +- data = grub_disk_cache_fetch (disk->dev->id, disk->id, start_sector); +- if (data) ++ /* Until SIZE is zero... */ ++ while (size >= (GRUB_DISK_CACHE_SIZE << GRUB_DISK_SECTOR_BITS)) ++ { ++ char *data = NULL; ++ grub_disk_addr_t agglomerate; ++ grub_err_t err; ++ ++ /* agglomerate read until we find a first cached entry. */ ++ for (agglomerate = 0; agglomerate ++ < (size >> (GRUB_DISK_SECTOR_BITS + GRUB_DISK_CACHE_BITS)); ++ agglomerate++) + { +- /* Just copy it! */ +- grub_memcpy (buf, data + pos + real_offset, len); +- grub_disk_cache_unlock (disk->dev->id, disk->id, start_sector); ++ data = grub_disk_cache_fetch (disk->dev->id, disk->id, ++ sector + (agglomerate ++ << GRUB_DISK_CACHE_BITS)); ++ if (data) ++ break; + } +- else ++ ++ if (data) + { +- /* Otherwise read data from the disk actually. */ +- if (start_sector + GRUB_DISK_CACHE_SIZE > disk->total_sectors +- || (disk->dev->read) (disk, start_sector, +- GRUB_DISK_CACHE_SIZE, tmp_buf) +- != GRUB_ERR_NONE) +- { +- /* Uggh... Failed. Instead, just read necessary data. */ +- unsigned num; +- char *p; +- +- grub_errno = GRUB_ERR_NONE; +- +- num = ((size + real_offset + GRUB_DISK_SECTOR_SIZE - 1) +- >> GRUB_DISK_SECTOR_BITS); +- +- p = grub_realloc (tmp_buf, num << GRUB_DISK_SECTOR_BITS); +- if (!p) +- goto finish; +- +- tmp_buf = p; +- +- if ((disk->dev->read) (disk, sector, num, tmp_buf)) +- { +- grub_error_push (); +- grub_dprintf ("disk", "%s read failed\n", disk->name); +- grub_error_pop (); +- goto finish; +- } +- +- grub_memcpy (buf, tmp_buf + real_offset, size); +- +- /* Call the read hook, if any. */ +- if (disk->read_hook) +- while (size) +- { +- grub_size_t to_read = (size > GRUB_DISK_SECTOR_SIZE) ? GRUB_DISK_SECTOR_SIZE : size; +- (disk->read_hook) (sector, real_offset, +- to_read); +- if (grub_errno != GRUB_ERR_NONE) +- goto finish; +- +- sector++; +- size -= to_read - real_offset; +- real_offset = 0; +- } ++ grub_memcpy ((char *) buf ++ + (agglomerate << (GRUB_DISK_CACHE_BITS ++ + GRUB_DISK_SECTOR_BITS)), ++ data, GRUB_DISK_CACHE_SIZE << GRUB_DISK_SECTOR_BITS); ++ grub_disk_cache_unlock (disk->dev->id, disk->id, ++ sector + (agglomerate ++ << GRUB_DISK_CACHE_BITS)); ++ } + +- /* This must be the end. */ +- goto finish; +- } ++ if (agglomerate) ++ { ++ grub_disk_addr_t i; + +- /* Copy it and store it in the disk cache. */ +- grub_memcpy (buf, tmp_buf + pos + real_offset, len); +- grub_disk_cache_store (disk->dev->id, disk->id, +- start_sector, tmp_buf); ++ err = (disk->dev->read) (disk, transform_sector (disk, sector), ++ agglomerate << (GRUB_DISK_CACHE_BITS ++ + GRUB_DISK_SECTOR_BITS ++ - disk->log_sector_size), ++ buf); ++ if (err) ++ return err; ++ ++ for (i = 0; i < agglomerate; i ++) ++ grub_disk_cache_store (disk->dev->id, disk->id, ++ sector + (i << GRUB_DISK_CACHE_BITS), ++ (char *) buf ++ + (i << (GRUB_DISK_CACHE_BITS ++ + GRUB_DISK_SECTOR_BITS))); ++ ++ sector += agglomerate << GRUB_DISK_CACHE_BITS; ++ size -= agglomerate << (GRUB_DISK_CACHE_BITS + GRUB_DISK_SECTOR_BITS); ++ buf = (char *) buf ++ + (agglomerate << (GRUB_DISK_CACHE_BITS + GRUB_DISK_SECTOR_BITS)); + } + +- /* Call the read hook, if any. */ +- if (disk->read_hook) ++ if (data) + { +- grub_disk_addr_t s = sector; +- grub_size_t l = len; +- +- while (l) +- { +- (disk->read_hook) (s, real_offset, +- ((l > GRUB_DISK_SECTOR_SIZE) +- ? GRUB_DISK_SECTOR_SIZE +- : l)); +- +- if (l < GRUB_DISK_SECTOR_SIZE - real_offset) +- break; +- +- s++; +- l -= GRUB_DISK_SECTOR_SIZE - real_offset; +- real_offset = 0; +- } ++ sector += GRUB_DISK_CACHE_SIZE; ++ buf = (char *) buf + (GRUB_DISK_CACHE_SIZE << GRUB_DISK_SECTOR_BITS); ++ size -= (GRUB_DISK_CACHE_SIZE << GRUB_DISK_SECTOR_BITS); + } ++ } + +- sector = start_sector + GRUB_DISK_CACHE_SIZE; +- buf = (char *) buf + len; +- size -= len; +- real_offset = 0; ++ /* And now read the last part. */ ++ if (size) ++ { ++ grub_err_t err; ++ err = grub_disk_read_small (disk, sector, 0, size, buf); ++ if (err) ++ return err; + } + +- finish: ++ /* Call the read hook, if any. */ ++ if (disk->read_hook) ++ { ++ grub_disk_addr_t s = real_sector; ++ grub_size_t l = real_size; ++ grub_off_t o = real_offset; + +- grub_free (tmp_buf); ++ while (l) ++ { ++ grub_size_t cl; ++ cl = GRUB_DISK_SECTOR_SIZE - o; ++ if (cl > l) ++ cl = l; ++ (disk->read_hook) (s, o, cl); ++ s++; ++ l -= cl; ++ o = 0; ++ } ++ } + + return grub_errno; + } +@@ -528,25 +628,31 @@ + grub_off_t offset, grub_size_t size, const void *buf) + { + unsigned real_offset; ++ grub_disk_addr_t aligned_sector; + + grub_dprintf ("disk", "Writing `%s'...\n", disk->name); + + if (grub_disk_adjust_range (disk, §or, &offset, size) != GRUB_ERR_NONE) + return -1; + +- real_offset = offset; ++ aligned_sector = (sector & ~((1 << (disk->log_sector_size ++ - GRUB_DISK_SECTOR_BITS)) - 1)); ++ real_offset = offset + ((sector - aligned_sector) << GRUB_DISK_SECTOR_BITS); ++ sector = aligned_sector; + + while (size) + { +- if (real_offset != 0 || (size < GRUB_DISK_SECTOR_SIZE && size != 0)) ++ if (real_offset != 0 || (size < (1U << disk->log_sector_size) ++ && size != 0)) + { +- char tmp_buf[GRUB_DISK_SECTOR_SIZE]; ++ char tmp_buf[1 << disk->log_sector_size]; + grub_size_t len; + grub_partition_t part; + + part = disk->partition; + disk->partition = 0; +- if (grub_disk_read (disk, sector, 0, GRUB_DISK_SECTOR_SIZE, tmp_buf) ++ if (grub_disk_read (disk, sector, ++ 0, (1 << disk->log_sector_size), tmp_buf) + != GRUB_ERR_NONE) + { + disk->partition = part; +@@ -554,7 +660,7 @@ + } + disk->partition = part; + +- len = GRUB_DISK_SECTOR_SIZE - real_offset; ++ len = (1 << disk->log_sector_size) - real_offset; + if (len > size) + len = size; + +@@ -565,7 +671,7 @@ + if ((disk->dev->write) (disk, sector, 1, tmp_buf) != GRUB_ERR_NONE) + goto finish; + +- sector++; ++ sector += (1 << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS)); + buf = (char *) buf + len; + size -= len; + real_offset = 0; +@@ -575,8 +681,8 @@ + grub_size_t len; + grub_size_t n; + +- len = size & ~(GRUB_DISK_SECTOR_SIZE - 1); +- n = size >> GRUB_DISK_SECTOR_BITS; ++ len = size & ~((1 << disk->log_sector_size) - 1); ++ n = size >> disk->log_sector_size; + + if ((disk->dev->write) (disk, sector, n, buf) != GRUB_ERR_NONE) + goto finish; +@@ -599,6 +705,8 @@ + { + if (disk->partition) + return grub_partition_get_len (disk->partition); ++ else if (disk->total_sectors != GRUB_DISK_SIZE_UNKNOWN) ++ return disk->total_sectors << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS); + else +- return disk->total_sectors; ++ return GRUB_DISK_SIZE_UNKNOWN; + } +Index: b/grub-core/kern/emu/hostdisk.c +=================================================================== +--- a/grub-core/kern/emu/hostdisk.c ++++ b/grub-core/kern/emu/hostdisk.c +@@ -43,6 +43,7 @@ + + #ifdef __linux__ + # include /* ioctl */ ++# include + # if !defined(__GLIBC__) || \ + ((__GLIBC__ < 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ < 1))) + /* Maybe libc doesn't have large file support. */ +@@ -267,6 +268,7 @@ + # else + unsigned long long nr; + # endif ++ int sector_size; + int fd; + + fd = open (map[drive].device, O_RDONLY); +@@ -299,16 +301,32 @@ + goto fail; + } + ++# if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) ++ if (ioctl (fd, DIOCGSECTORSIZE, §or_size)) ++# else ++ if (ioctl (fd, BLKSSZGET, §or_size)) ++# endif ++ { ++ close (fd); ++ goto fail; ++ } ++ + close (fd); + ++ if (sector_size & (sector_size - 1) || !sector_size) ++ goto fail; ++ for (disk->log_sector_size = 0; ++ (1 << disk->log_sector_size) < sector_size; ++ disk->log_sector_size++); ++ + # if defined (__APPLE__) + disk->total_sectors = nr; + # elif defined(__NetBSD__) + disk->total_sectors = label.d_secperunit; + # else +- disk->total_sectors = nr / 512; ++ disk->total_sectors = nr >> disk->log_sector_size; + +- if (nr % 512) ++ if (nr & ((1 << disk->log_sector_size) - 1)) + grub_util_error ("unaligned device size"); + # endif + +@@ -325,7 +343,7 @@ + if (stat (map[drive].device, &st) < 0) + return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "cannot stat `%s'", map[drive].device); + +- disk->total_sectors = st.st_size >> GRUB_DISK_SECTOR_BITS; ++ disk->total_sectors = st.st_size >> disk->log_sector_size; + + grub_util_info ("the size of %s is %lu", name, disk->total_sectors); + +@@ -798,7 +816,7 @@ + _syscall5 (int, _llseek, uint, filedes, ulong, hi, ulong, lo, + loff_t *, res, uint, wh); + +- offset = (loff_t) sector << GRUB_DISK_SECTOR_BITS; ++ offset = (loff_t) sector << disk->log_sector_size; + if (_llseek (fd, offset >> 32, offset & 0xffffffff, &result, SEEK_SET)) + { + grub_error (GRUB_ERR_BAD_DEVICE, "cannot seek `%s'", map[disk->id].device); +@@ -808,7 +826,7 @@ + } + #else + { +- off_t offset = (off_t) sector << GRUB_DISK_SECTOR_BITS; ++ off_t offset = (off_t) sector << disk->log_sector_size; + + if (lseek (fd, offset, SEEK_SET) != offset) + { +@@ -908,19 +926,20 @@ + sectors that are read together with the MBR in one read. It + should only remap the MBR, so we split the read in two + parts. -jochen */ +- if (nread (fd, buf, GRUB_DISK_SECTOR_SIZE) != GRUB_DISK_SECTOR_SIZE) ++ if (nread (fd, buf, (1 << disk->log_sector_size)) ++ != (1 << disk->log_sector_size)) + { + grub_error (GRUB_ERR_READ_ERROR, "cannot read `%s'", map[disk->id].device); + return grub_errno; + } + +- buf += GRUB_DISK_SECTOR_SIZE; ++ buf += (1 << disk->log_sector_size); + size--; + } + #endif /* __linux__ */ + +- if (nread (fd, buf, size << GRUB_DISK_SECTOR_BITS) +- != (ssize_t) (size << GRUB_DISK_SECTOR_BITS)) ++ if (nread (fd, buf, size << disk->log_sector_size) ++ != (ssize_t) (size << disk->log_sector_size)) + grub_error (GRUB_ERR_READ_ERROR, "cannot read from `%s'", map[disk->id].device); + + return grub_errno; +@@ -953,8 +972,8 @@ + if (fd < 0) + return grub_errno; + +- if (nwrite (fd, buf, size << GRUB_DISK_SECTOR_BITS) +- != (ssize_t) (size << GRUB_DISK_SECTOR_BITS)) ++ if (nwrite (fd, buf, size << disk->log_sector_size) ++ != (ssize_t) (size << disk->log_sector_size)) + grub_error (GRUB_ERR_WRITE_ERROR, "cannot write to `%s'", map[disk->id].device); + + return grub_errno; +Index: b/grub-core/partmap/msdos.c +=================================================================== +--- a/grub-core/partmap/msdos.c ++++ b/grub-core/partmap/msdos.c +@@ -152,8 +152,11 @@ + { + e = mbr.entries + p.index; + +- p.start = p.offset + grub_le_to_cpu32 (e->start) - delta; +- p.len = grub_le_to_cpu32 (e->length); ++ p.start = p.offset ++ + (grub_le_to_cpu32 (e->start) ++ << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS)) - delta; ++ p.len = grub_le_to_cpu32 (e->length) ++ << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS); + p.msdostype = e->type; + + grub_dprintf ("partition", +@@ -188,7 +191,9 @@ + + if (grub_msdos_partition_is_extended (e->type)) + { +- p.offset = ext_offset + grub_le_to_cpu32 (e->start); ++ p.offset = ext_offset ++ + (grub_le_to_cpu32 (e->start) ++ << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS)); + if (! ext_offset) + ext_offset = p.offset; + +@@ -267,8 +272,11 @@ + e = mbr.entries + i; + + if (!grub_msdos_partition_is_empty (e->type) +- && end > offset + grub_le_to_cpu32 (e->start)) +- end = offset + grub_le_to_cpu32 (e->start); ++ && end > offset ++ + (grub_le_to_cpu32 (e->start) ++ << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS))) ++ end = offset + (grub_le_to_cpu32 (e->start) ++ << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS)); + + /* If this is a GPT partition, this MBR is just a dummy. */ + if (e->type == GRUB_PC_PARTITION_TYPE_GPT_DISK && i == 0) +@@ -282,7 +290,9 @@ + + if (grub_msdos_partition_is_extended (e->type)) + { +- offset = ext_offset + grub_le_to_cpu32 (e->start); ++ offset = ext_offset ++ + (grub_le_to_cpu32 (e->start) ++ << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS)); + if (! ext_offset) + ext_offset = offset; + +Index: b/include/grub/disk.h +=================================================================== +--- a/include/grub/disk.h ++++ b/include/grub/disk.h +@@ -100,6 +100,9 @@ + /* The total number of sectors. */ + grub_uint64_t total_sectors; + ++ /* Logarithm of sector size. */ ++ unsigned int log_sector_size; ++ + /* The id used by the disk cache manager. */ + unsigned long id; + +@@ -132,9 +135,10 @@ + /* The maximum number of disk caches. */ + #define GRUB_DISK_CACHE_NUM 1021 + +-/* The size of a disk cache in sector units. */ +-#define GRUB_DISK_CACHE_SIZE 8 +-#define GRUB_DISK_CACHE_BITS 3 ++/* The size of a disk cache in 512B units. Must be at least as big as the ++ largest supported sector size, currently 16K. */ ++#define GRUB_DISK_CACHE_BITS 6 ++#define GRUB_DISK_CACHE_SIZE (1 << GRUB_DISK_CACHE_BITS) + + /* Return value of grub_disk_get_size() in case disk size is unknown. */ + #define GRUB_DISK_SIZE_UNKNOWN 0xffffffffffffffffULL +Index: b/util/grub-fstest.c +=================================================================== +--- a/util/grub-fstest.c ++++ b/util/grub-fstest.c +@@ -60,6 +60,7 @@ + #define CMD_HEX 4 + #define CMD_CRC 6 + #define CMD_BLOCKLIST 7 ++#define CMD_TESTLOAD 8 + + #define BUF_SIZE 32256 + +@@ -333,6 +334,9 @@ + case CMD_BLOCKLIST: + execute_command ("blocklist", n, args); + grub_printf ("\n"); ++ case CMD_TESTLOAD: ++ execute_command ("testload", n, args); ++ grub_printf ("\n"); + } + + for (i = 0; i < num_disks; i++) +@@ -488,6 +492,11 @@ + cmd = CMD_BLOCKLIST; + nparm = 1; + } ++ else if (!grub_strcmp (arg, "testload")) ++ { ++ cmd = CMD_TESTLOAD; ++ nparm = 1; ++ } + else + { + fprintf (stderr, _("Invalid command %s.\n"), arg); diff --git a/master/debian/bash-completion_identifiers.patch b/master/debian/bash-completion_identifiers.patch new file mode 100644 index 0000000..814c101 --- /dev/null +++ b/master/debian/bash-completion_identifiers.patch @@ -0,0 +1,45 @@ +Description: Fix incorrect identifiers in bash-completion +Author: Andreas Born +Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3426 +Last-Update: 2012-03-05 + +Index: b/util/bash-completion.d/grub-completion.bash.in +=================================================================== +--- a/util/bash-completion.d/grub-completion.bash.in ++++ b/util/bash-completion.d/grub-completion.bash.in +@@ -402,7 +402,7 @@ + # + # grub-mkpasswd-pbkdf2 + # +-_grub_mkpasswd-pbkdf2 () { ++_grub_mkpasswd_pbkdf2 () { + local cur + + COMPREPLY=() +@@ -417,7 +417,7 @@ + } + __grub_mkpasswd_pbkdf2_program=$( echo grub-mkpasswd-pbkdf2 | sed "@program_transform_name@" ) + have ${__grub_mkpasswd_pbkdf2_program} && \ +- complete -F _grub_mkpasswd-pbkdf2 -o filenames ${__grub_mkpasswd_pbkdf2_program} ++ complete -F _grub_mkpasswd_pbkdf2 -o filenames ${__grub_mkpasswd_pbkdf2_program} + unset __grub_mkpasswd_pbkdf2_program + + +@@ -462,7 +462,7 @@ + # + # grub-script-check + # +-_grub_script-check () { ++_grub_script_check () { + local cur + + COMPREPLY=() +@@ -477,7 +477,7 @@ + } + __grub_script_check_program=$( echo grub-script-check | sed "@program_transform_name@" ) + have ${__grub_script_check_program} && \ +- complete -F _grub_script-check -o filenames ${__grub_script_check_program} ++ complete -F _grub_script_check -o filenames ${__grub_script_check_program} + + + # Local variables: diff --git a/master/debian/branch_devmapper.patch b/master/debian/branch_devmapper.patch new file mode 100644 index 0000000..1911a0b --- /dev/null +++ b/master/debian/branch_devmapper.patch @@ -0,0 +1,286 @@ +Description: Support for partitioned loop devices; improved devmapper support +Author: Vladimir Serbinenko +Origin: upstream, http://bzr.sv.gnu.org/r/grub/branches/devmapper/ +Forwarded: not-needed +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3302 +Last-Update: 2011-05-19 + +Index: b/grub-core/kern/emu/getroot.c +=================================================================== +--- a/grub-core/kern/emu/getroot.c ++++ b/grub-core/kern/emu/getroot.c +@@ -34,6 +34,10 @@ + #include + #include + ++#ifdef HAVE_DEVICE_MAPPER ++# include ++#endif ++ + #ifdef __GNU__ + #include + #include +@@ -634,32 +638,65 @@ + } + + static int +-grub_util_is_dmraid (const char *os_dev) ++grub_util_is_lvm (const char *os_dev) + { +- if (! strncmp (os_dev, "/dev/mapper/nvidia_", 19)) +- return 1; +- else if (! strncmp (os_dev, "/dev/mapper/isw_", 16)) +- return 1; +- else if (! strncmp (os_dev, "/dev/mapper/hpt37x_", 19)) +- return 1; +- else if (! strncmp (os_dev, "/dev/mapper/hpt45x_", 19)) +- return 1; +- else if (! strncmp (os_dev, "/dev/mapper/via_", 16)) +- return 1; +- else if (! strncmp (os_dev, "/dev/mapper/lsi_", 16)) +- return 1; +- else if (! strncmp (os_dev, "/dev/mapper/pdc_", 16)) +- return 1; +- else if (! strncmp (os_dev, "/dev/mapper/jmicron_", 20)) +- return 1; +- else if (! strncmp (os_dev, "/dev/mapper/asr_", 16)) +- return 1; +- else if (! strncmp (os_dev, "/dev/mapper/sil_", 16)) +- return 1; +- else if (! strncmp (os_dev, "/dev/mapper/ddf1_", 17)) +- return 1; ++ if ((strncmp ("/dev/mapper/", os_dev, 12) != 0)) ++ return 0; ++ ++#ifdef HAVE_DEVICE_MAPPER ++ { ++ struct dm_tree *tree; ++ uint32_t maj, min; ++ struct dm_tree_node *node = NULL; ++ const char *node_uuid; ++ struct stat st; + +- return 0; ++ if (stat (os_dev, &st) < 0) ++ return 0; ++ ++ tree = dm_tree_create (); ++ if (! tree) ++ { ++ grub_printf ("Failed to create tree\n"); ++ grub_dprintf ("hostdisk", "dm_tree_create failed\n"); ++ return 0; ++ } ++ ++ maj = major (st.st_rdev); ++ min = minor (st.st_rdev); ++ ++ if (! dm_tree_add_dev (tree, maj, min)) ++ { ++ grub_dprintf ("hostdisk", "dm_tree_add_dev failed\n"); ++ dm_tree_free (tree); ++ return 0; ++ } ++ ++ node = dm_tree_find_node (tree, maj, min); ++ if (! node) ++ { ++ grub_dprintf ("hostdisk", "dm_tree_find_node failed\n"); ++ dm_tree_free (tree); ++ return 0; ++ } ++ node_uuid = dm_tree_node_get_uuid (node); ++ if (! node_uuid) ++ { ++ grub_dprintf ("hostdisk", "%s has no DM uuid\n", os_dev); ++ dm_tree_free (tree); ++ return 0; ++ } ++ if (strncmp (node_uuid, "LVM-", 4) != 0) ++ { ++ dm_tree_free (tree); ++ return 0; ++ } ++ dm_tree_free (tree); ++ return 1; ++ } ++#else ++ return 1; ++#endif /* HAVE_DEVICE_MAPPER */ + } + + int +@@ -671,13 +708,11 @@ + return GRUB_DEV_ABSTRACTION_NONE; + + /* Check for LVM. */ +- if (!strncmp (os_dev, "/dev/mapper/", 12) +- && ! grub_util_is_dmraid (os_dev) +- && strncmp (os_dev, "/dev/mapper/mpath", 17) != 0) ++ if (grub_util_is_lvm (os_dev)) + return GRUB_DEV_ABSTRACTION_LVM; + + /* Check for RAID. */ +- if (!strncmp (os_dev, "/dev/md", 7)) ++ if (!strncmp (os_dev, "/dev/md", 7) && ! grub_util_device_is_mapped (os_dev)) + return GRUB_DEV_ABSTRACTION_RAID; + #endif + +Index: b/grub-core/kern/emu/hostdisk.c +=================================================================== +--- a/grub-core/kern/emu/hostdisk.c ++++ b/grub-core/kern/emu/hostdisk.c +@@ -24,6 +24,7 @@ + #include + #include + #include ++#include + #include + #include + #include +@@ -331,18 +332,23 @@ + return GRUB_ERR_NONE; + } + +-#ifdef HAVE_DEVICE_MAPPER +-static int +-device_is_mapped (const char *dev) ++int ++grub_util_device_is_mapped (const char *dev) + { ++#ifdef HAVE_DEVICE_MAPPER + struct stat st; + ++ if (!grub_device_mapper_supported ()) ++ return 0; ++ + if (stat (dev, &st) < 0) + return 0; + + return dm_is_dm_major (major (st.st_rdev)); +-} ++#else ++ return 0; + #endif /* HAVE_DEVICE_MAPPER */ ++} + + #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__) + /* FIXME: geom actually gives us the whole container hierarchy. +@@ -418,7 +424,7 @@ + # endif /* !defined(HAVE_DIOCGDINFO) */ + + # ifdef HAVE_DEVICE_MAPPER +- if (grub_device_mapper_supported () && device_is_mapped (dev)) { ++ if (grub_util_device_is_mapped (dev)) { + struct dm_task *task = NULL; + grub_uint64_t start, length; + char *target_type, *params, *space; +@@ -1161,6 +1167,54 @@ + return ret; + } + ++#ifdef HAVE_DEVICE_MAPPER ++static int ++grub_util_get_dm_node_linear_info (const char *dev, ++ int *maj, int *min) ++{ ++ struct dm_task *dmt; ++ void *next = NULL; ++ uint64_t length, start; ++ char *target, *params; ++ char *ptr; ++ int major, minor; ++ ++ dmt = dm_task_create(DM_DEVICE_TABLE); ++ if (!dmt) ++ return 0; ++ ++ if (!dm_task_set_name(dmt, dev)) ++ return 0; ++ dm_task_no_open_count(dmt); ++ if (!dm_task_run(dmt)) ++ return 0; ++ next = dm_get_next_target(dmt, next, &start, &length, ++ &target, ¶ms); ++ if (grub_strcmp (target, "linear") != 0) ++ return 0; ++ major = grub_strtoul (params, &ptr, 10); ++ if (grub_errno) ++ { ++ grub_errno = GRUB_ERR_NONE; ++ return 0; ++ } ++ if (*ptr != ':') ++ return 0; ++ ptr++; ++ minor = grub_strtoul (ptr, 0, 10); ++ if (grub_errno) ++ { ++ grub_errno = GRUB_ERR_NONE; ++ return 0; ++ } ++ if (maj) ++ *maj = major; ++ if (min) ++ *min = minor; ++ return 1; ++} ++#endif ++ + static char * + convert_system_partition_to_system_disk (const char *os_dev, struct stat *st) + { +@@ -1337,9 +1391,39 @@ + node = NULL; + goto devmapper_out; + } +- else if (strncmp (node_uuid, "DMRAID-", 7) != 0) ++ if (strncmp (node_uuid, "LVM-", 4) == 0) + { ++ grub_dprintf ("hostdisk", "%s is an LVM\n", path); ++ node = NULL; ++ goto devmapper_out; ++ } ++ if (strncmp (node_uuid, "mpath-", 6) == 0) ++ { ++ /* Multipath partitions have partN-mpath-* UUIDs, and are ++ linear mappings so are handled by ++ grub_util_get_dm_node_linear_info. Multipath disks are not ++ linear mappings and must be handled specially. */ ++ grub_dprintf ("hostdisk", "%s is a multipath disk\n", path); ++ mapper_name = dm_tree_node_get_name (node); ++ goto devmapper_out; ++ } ++ if (strncmp (node_uuid, "DMRAID-", 7) != 0) ++ { ++ int major, minor; ++ const char *node_name; + grub_dprintf ("hostdisk", "%s is not DM-RAID\n", path); ++ ++ if ((node_name = dm_tree_node_get_name (node)) ++ && grub_util_get_dm_node_linear_info (node_name, ++ &major, &minor)) ++ { ++ if (tree) ++ dm_tree_free (tree); ++ free (path); ++ char *ret = grub_find_device (NULL, (major << 8) | minor); ++ return ret; ++ } ++ + node = NULL; + goto devmapper_out; + } +Index: b/include/grub/emu/misc.h +=================================================================== +--- a/include/grub/emu/misc.h ++++ b/include/grub/emu/misc.h +@@ -54,6 +54,8 @@ + + char *grub_make_system_path_relative_to_its_root (const char *path) + __attribute__ ((warn_unused_result)); ++int ++grub_util_device_is_mapped (const char *dev); + + void * EXPORT_FUNC(xmalloc) (grub_size_t size) __attribute__ ((warn_unused_result)); + void * EXPORT_FUNC(xrealloc) (void *ptr, grub_size_t size) __attribute__ ((warn_unused_result)); diff --git a/master/debian/branch_embed-sectors.patch b/master/debian/branch_embed-sectors.patch new file mode 100644 index 0000000..9b16423 --- /dev/null +++ b/master/debian/branch_embed-sectors.patch @@ -0,0 +1,247 @@ +Description: Detect other software using embedding area + When embedding the core image in a post-MBR gap, check for and avoid + sectors matching any of the signatures in embed_signatures. +Author: Colin Watson +Origin: upstream, http://bzr.sv.gnu.org/r/grub/branches/embed-sectors/ +Forwarded: http://lists.gnu.org/archive/html/grub-devel/2010-08/msg00137.html +Last-Update: 2011-04-21 + +Index: b/ChangeLog.embed-sectors +=================================================================== +--- /dev/null ++++ b/ChangeLog.embed-sectors +@@ -0,0 +1,12 @@ ++2011-03-14 Colin Watson ++ ++ * include/grub/partition.h (grub_partition_map): Change prototype of ++ embed to take a maximum value for nsectors. ++ * grub-core/partmap/msdos.c (embed_signatures): New array. ++ (pc_partition_map_embed): Check for and avoid sectors matching any ++ of the signatures in embed_signatures, up to max_nsectors. ++ * grub-core/partmap/gpt.c (gpt_partition_map_embed): Restrict ++ returned sector map to max_nsectors. ++ * util/grub-setup.c (setup): Allow for the embedding area being ++ split into multiple blocklists. Tell dest_partmap->embed the ++ maximum number of sectors we care about. +Index: b/grub-core/partmap/gpt.c +=================================================================== +--- a/grub-core/partmap/gpt.c ++++ b/grub-core/partmap/gpt.c +@@ -127,6 +127,7 @@ + #ifdef GRUB_UTIL + static grub_err_t + gpt_partition_map_embed (struct grub_disk *disk, unsigned int *nsectors, ++ unsigned int max_nsectors, + grub_embed_type_t embed_type, + grub_disk_addr_t **sectors) + { +@@ -176,6 +177,8 @@ + " embedding won't be possible!"); + + *nsectors = len; ++ if (*nsectors > max_nsectors) ++ *nsectors = max_nsectors; + *sectors = grub_malloc (*nsectors * sizeof (**sectors)); + if (!*sectors) + return grub_errno; +Index: b/grub-core/partmap/msdos.c +=================================================================== +--- a/grub-core/partmap/msdos.c ++++ b/grub-core/partmap/msdos.c +@@ -29,6 +29,66 @@ + static struct grub_partition_map grub_msdos_partition_map; + + ++#ifdef GRUB_UTIL ++#include ++ ++struct embed_signature ++{ ++ const char *name; ++ const char *signature; ++ int signature_len; ++ enum { TYPE_SOFTWARE, TYPE_RAID } type; ++}; ++ ++const char message_warn[][200] = { ++ [TYPE_RAID] = "Sector %llu is already in use by %s; avoiding it. " ++ "Please ask the manufacturer not to store data in MBR gap", ++ [TYPE_SOFTWARE] = "Sector %llu is already in use by %s; avoiding it. " ++ "This software may cause boot or other problems in " ++ "future. Please ask its authors not to store data " ++ "in the boot track" ++}; ++ ++ ++/* Signatures of other software that may be using sectors in the embedding ++ area. */ ++struct embed_signature embed_signatures[] = ++ { ++ { ++ .name = "ZISD", ++ .signature = "ZISD", ++ .signature_len = 4, ++ .type = TYPE_SOFTWARE ++ }, ++ { ++ .name = "FlexNet", ++ .signature = "\xd4\x41\xa0\xf5\x03\x00\x03\x00", ++ .signature_len = 8, ++ .type = TYPE_SOFTWARE ++ }, ++ { ++ .name = "FlexNet", ++ .signature = "\xd8\x41\xa0\xf5\x02\x00\x02\x00", ++ .signature_len = 8, ++ .type = TYPE_SOFTWARE ++ }, ++ { ++ /* from Ryan Perkins */ ++ .name = "HP Backup and Recovery Manager (?)", ++ .signature = "\x70\x8a\x5d\x46\x35\xc5\x1b\x93" ++ "\xae\x3d\x86\xfd\xb1\x55\x3e\xe0", ++ .signature_len = 16, ++ .type = TYPE_SOFTWARE ++ }, ++ { ++ .name = "HighPoint RAID controller", ++ .signature = "ycgl", ++ .signature_len = 4, ++ .type = TYPE_RAID ++ } ++ }; ++#endif ++ + grub_err_t + grub_partition_msdos_iterate (grub_disk_t disk, + int (*hook) (grub_disk_t disk, +@@ -148,6 +208,7 @@ + #ifdef GRUB_UTIL + static grub_err_t + pc_partition_map_embed (struct grub_disk *disk, unsigned int *nsectors, ++ unsigned int max_nsectors, + grub_embed_type_t embed_type, + grub_disk_addr_t **sectors) + { +@@ -236,13 +297,65 @@ + + if (end >= *nsectors + 2) + { +- unsigned i; ++ unsigned i, j; ++ char *embed_signature_check; ++ unsigned int orig_nsectors, avail_nsectors; ++ ++ orig_nsectors = *nsectors; + *nsectors = end - 2; ++ avail_nsectors = *nsectors; ++ if (*nsectors > max_nsectors) ++ *nsectors = max_nsectors; + *sectors = grub_malloc (*nsectors * sizeof (**sectors)); + if (!*sectors) + return grub_errno; + for (i = 0; i < *nsectors; i++) + (*sectors)[i] = 1 + i; ++ ++ /* Check for software that is already using parts of the embedding ++ * area. ++ */ ++ embed_signature_check = grub_malloc (GRUB_DISK_SECTOR_SIZE); ++ for (i = 0; i < *nsectors; i++) ++ { ++ if (grub_disk_read (disk, (*sectors)[i], 0, GRUB_DISK_SECTOR_SIZE, ++ embed_signature_check)) ++ continue; ++ ++ for (j = 0; j < ARRAY_SIZE (embed_signatures); j++) ++ if (! grub_memcmp (embed_signatures[j].signature, ++ embed_signature_check, ++ embed_signatures[j].signature_len)) ++ break; ++ if (j == ARRAY_SIZE (embed_signatures)) ++ continue; ++ grub_util_warn (message_warn[embed_signatures[j].type], ++ (*sectors)[i], embed_signatures[j].name); ++ avail_nsectors--; ++ if (avail_nsectors < *nsectors) ++ *nsectors = avail_nsectors; ++ ++ /* Avoid this sector. */ ++ for (j = i; j < *nsectors; j++) ++ (*sectors)[j]++; ++ ++ /* Have we run out of space? */ ++ if (avail_nsectors < orig_nsectors) ++ break; ++ ++ /* Make sure to check the next sector. */ ++ i--; ++ } ++ grub_free (embed_signature_check); ++ ++ if (*nsectors < orig_nsectors) ++ return grub_error (GRUB_ERR_OUT_OF_RANGE, ++ "Other software is using the embedding area, and " ++ "there is not enough room for core.img. Such " ++ "software is often trying to store data in a way " ++ "that avoids detection. We recommend you " ++ "investigate."); ++ + return GRUB_ERR_NONE; + } + +Index: b/include/grub/partition.h +=================================================================== +--- a/include/grub/partition.h ++++ b/include/grub/partition.h +@@ -49,6 +49,7 @@ + #ifdef GRUB_UTIL + /* Determine sectors available for embedding. */ + grub_err_t (*embed) (struct grub_disk *disk, unsigned int *nsectors, ++ unsigned int max_nsectors, + grub_embed_type_t embed_type, + grub_disk_addr_t **sectors); + #endif +Index: b/util/grub-setup.c +=================================================================== +--- a/util/grub-setup.c ++++ b/util/grub-setup.c +@@ -428,10 +428,8 @@ + } + + nsec = core_sectors; +- err = dest_partmap->embed (dest_dev->disk, &nsec, ++ err = dest_partmap->embed (dest_dev->disk, &nsec, 2 * core_sectors, + GRUB_EMBED_PCBIOS, §ors); +- if (nsec > 2 * core_sectors) +- nsec = 2 * core_sectors; + + if (err) + { +@@ -460,6 +458,13 @@ + save_blocklists (sectors[i] + grub_partition_get_start (container), + 0, GRUB_DISK_SECTOR_SIZE); + ++ /* Make sure that the last blocklist is a terminator. */ ++ if (block == first_block) ++ block--; ++ block->start = 0; ++ block->len = 0; ++ block->segment = 0; ++ + write_rootdev (core_img, root_dev, boot_img, first_sector); + + core_img = realloc (core_img, nsec * GRUB_DISK_SECTOR_SIZE); +@@ -476,12 +481,6 @@ + nsec * GRUB_DISK_SECTOR_SIZE + - core_size); + +- /* Make sure that the second blocklist is a terminator. */ +- block = first_block - 1; +- block->start = 0; +- block->len = 0; +- block->segment = 0; +- + /* Write the core image onto the disk. */ + for (i = 0; i < nsec; i++) + grub_disk_write (dest_dev->disk, sectors[i], 0, diff --git a/master/debian/branch_fuse.patch b/master/debian/branch_fuse.patch new file mode 100644 index 0000000..1f5a22d --- /dev/null +++ b/master/debian/branch_fuse.patch @@ -0,0 +1,605 @@ +Description: Add grub-mount utility +Author: Vladimir Serbinenko +Origin: upstream, http://bzr.sv.gnu.org/r/grub/branches/fuse/ +Forwarded: http://lists.gnu.org/archive/html/grub-devel/2011-01/msg00056.html +Last-Update: 2011-07-10 + +--- a/Makefile.util.def ++++ b/Makefile.util.def +@@ -216,6 +216,21 @@ + }; + + program = { ++ name = grub-mount; ++ mansection = 1; ++ common_nodist = grub_fstest_init.c; ++ common = util/grub-mount.c; ++ common = grub-core/kern/emu/hostfs.c; ++ common = grub-core/disk/host.c; ++ ++ ldadd = libgrubmods.a; ++ ldadd = libgrubkern.a; ++ ldadd = grub-core/gnulib/libgnu.a; ++ ldadd = '$(LIBINTL) $(LIBDEVMAPPER) $(LIBZFS) $(LIBNVPAIR) -lfuse'; ++ condition = COND_GRUB_MOUNT; ++}; ++ ++program = { + name = grub-mkfont; + mansection = 1; + common = util/grub-mkfont.c; +--- a/configure.ac ++++ b/configure.ac +@@ -856,6 +856,37 @@ + AC_SUBST([freetype_cflags]) + AC_SUBST([freetype_libs]) + ++AC_ARG_ENABLE([grub-mount], ++ [AS_HELP_STRING([--enable-grub-mount], ++ [build and install the `grub-mount' utility (default=guessed)])]) ++if test x"$enable_grub_mount" = xno ; then ++ grub_mount_excuse="explicitly disabled" ++fi ++ ++if test x"$grub_mount_excuse" = x ; then ++ AC_CHECK_LIB([fuse], [fuse_main_real], [], ++ [grub_mount_excuse="need FUSE library"]) ++fi ++ ++if test x"$grub_mount_excuse" = x ; then ++ # Check for fuse headers. ++ SAVED_CPPFLAGS="$CPPFLAGS" ++ CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=64 -DFUSE_USE_VERSION=26" ++ AC_CHECK_HEADERS([fuse/fuse.h], [], ++ [grub_mount_excuse=["need FUSE headers"]]) ++ CPPFLAGS="$SAVED_CPPFLAGS" ++fi ++ ++if test x"$enable_grub_mount" = xyes && test x"$grub_mount_excuse" != x ; then ++ AC_MSG_ERROR([grub-mount was explicitly requested but can't be compiled]) ++fi ++if test x"$grub_mount_excuse" = x ; then ++enable_grub_mount=yes ++else ++enable_grub_mount=no ++fi ++AC_SUBST([enable_grub_mount]) ++ + AC_ARG_ENABLE([device-mapper], + [AS_HELP_STRING([--enable-device-mapper], + [enable Linux device-mapper support (default=guessed)])]) +@@ -967,6 +998,7 @@ + AM_CONDITIONAL([COND_GRUB_EMU_SDL], [test x$enable_grub_emu_sdl = xyes]) + AM_CONDITIONAL([COND_GRUB_EMU_PCI], [test x$enable_grub_emu_pci = xyes]) + AM_CONDITIONAL([COND_GRUB_MKFONT], [test x$enable_grub_mkfont = xyes]) ++AM_CONDITIONAL([COND_GRUB_MOUNT], [test x$enable_grub_mount = xyes]) + AM_CONDITIONAL([COND_HAVE_FONT_SOURCE], [test x$FONT_SOURCE != x]) + AM_CONDITIONAL([COND_GRUB_PE2ELF], [test x$TARGET_OBJ2ELF != x]) + AM_CONDITIONAL([COND_APPLE_CC], [test x$TARGET_APPLE_CC = x1]) +@@ -1043,5 +1075,10 @@ + else + echo grub-mkfont: No "($grub_mkfont_excuse)" + fi ++if [ x"$grub_mount_excuse" = x ]; then ++echo grub-mount: Yes ++else ++echo grub-mount: No "($grub_mount_excuse)" ++fi + echo "*******************************************************" + ] +--- /dev/null ++++ b/docs/man/grub-mount.h2m +@@ -0,0 +1,2 @@ ++[NAME] ++grub-mount \- export GRUB filesystem with FUSE +--- /dev/null ++++ b/util/grub-mount.c +@@ -0,0 +1,508 @@ ++/* grub-mount.c - FUSE driver for filesystems that GRUB understands */ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2008,2009,2010 Free Software Foundation, Inc. ++ * ++ * GRUB 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, either version 3 of the License, or ++ * (at your option) any later version. ++ * ++ * GRUB is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with GRUB. If not, see . ++ */ ++#define FUSE_USE_VERSION 26 ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include ++#include ++#include ++#include ++ ++#include "progname.h" ++#include "argp.h" ++ ++static char *root = NULL; ++grub_device_t dev = NULL; ++grub_fs_t fs = NULL; ++static char **images = NULL; ++static char *debug_str = NULL; ++static char **fuse_args = NULL; ++static int fuse_argc = 0; ++static int num_disks = 0; ++ ++static grub_err_t ++execute_command (char *name, int n, char **args) ++{ ++ grub_command_t cmd; ++ ++ cmd = grub_command_find (name); ++ if (! cmd) ++ grub_util_error (_("can\'t find command %s"), name); ++ ++ return (cmd->func) (cmd, n, args); ++} ++ ++/* Translate GRUB error numbers into OS error numbers. Print any unexpected ++ errors. */ ++static int ++translate_error (void) ++{ ++ int ret; ++ ++ switch (grub_errno) ++ { ++ case GRUB_ERR_NONE: ++ ret = 0; ++ break; ++ ++ case GRUB_ERR_OUT_OF_MEMORY: ++ grub_print_error (); ++ ret = -ENOMEM; ++ break; ++ ++ case GRUB_ERR_BAD_FILE_TYPE: ++ /* This could also be EISDIR. Take a guess. */ ++ ret = -ENOTDIR; ++ break; ++ ++ case GRUB_ERR_FILE_NOT_FOUND: ++ ret = -ENOENT; ++ break; ++ ++ case GRUB_ERR_FILE_READ_ERROR: ++ case GRUB_ERR_READ_ERROR: ++ case GRUB_ERR_IO: ++ grub_print_error (); ++ ret = -EIO; ++ break; ++ ++ case GRUB_ERR_SYMLINK_LOOP: ++ ret = -ELOOP; ++ break; ++ ++ default: ++ grub_print_error (); ++ ret = -EINVAL; ++ break; ++ } ++ ++ /* Any previous errors were handled. */ ++ grub_errno = GRUB_ERR_NONE; ++ ++ return ret; ++} ++ ++static int ++fuse_getattr (const char *path, struct stat *st) ++{ ++ char *filename, *pathname, *path2; ++ const char *pathname_t; ++ struct grub_dirhook_info file_info; ++ int file_exists = 0; ++ ++ /* A hook for iterating directories. */ ++ auto int find_file (const char *cur_filename, ++ const struct grub_dirhook_info *info); ++ int find_file (const char *cur_filename, ++ const struct grub_dirhook_info *info) ++ { ++ if ((info->case_insensitive ? grub_strcasecmp (cur_filename, filename) ++ : grub_strcmp (cur_filename, filename)) == 0) ++ { ++ file_info = *info; ++ file_exists = 1; ++ return 1; ++ } ++ return 0; ++ } ++ ++ if (path[0] == '/' && path[1] == 0) ++ { ++ st->st_dev = 0; ++ st->st_ino = 0; ++ st->st_mode = 0555 | S_IFDIR; ++ st->st_uid = 0; ++ st->st_gid = 0; ++ st->st_rdev = 0; ++ st->st_size = 0; ++ st->st_blksize = 512; ++ st->st_blocks = (st->st_blksize + 511) >> 9; ++ st->st_atime = st->st_mtime = st->st_ctime = 0; ++ return 0; ++ } ++ ++ file_exists = 0; ++ ++ pathname_t = grub_strchr (path, ')'); ++ if (! pathname_t) ++ pathname_t = path; ++ else ++ pathname_t++; ++ pathname = xstrdup (pathname_t); ++ ++ /* Remove trailing '/'. */ ++ while (*pathname && pathname[grub_strlen (pathname) - 1] == '/') ++ pathname[grub_strlen (pathname) - 1] = 0; ++ ++ /* Split into path and filename. */ ++ filename = grub_strrchr (pathname, '/'); ++ if (! filename) ++ { ++ path2 = grub_strdup ("/"); ++ filename = pathname; ++ } ++ else ++ { ++ filename++; ++ path2 = grub_strdup (pathname); ++ path2[filename - pathname] = 0; ++ } ++ ++ /* It's the whole device. */ ++ (fs->dir) (dev, path2, find_file); ++ ++ grub_free (path2); ++ if (!file_exists) ++ { ++ grub_errno = GRUB_ERR_NONE; ++ return -ENOENT; ++ } ++ st->st_dev = 0; ++ st->st_ino = 0; ++ st->st_mode = file_info.dir ? (0555 | S_IFDIR) : (0444 | S_IFREG); ++ st->st_uid = 0; ++ st->st_gid = 0; ++ st->st_rdev = 0; ++ if (!file_info.dir) ++ { ++ grub_file_t file; ++ file = grub_file_open (path); ++ if (! file) ++ return translate_error (); ++ st->st_size = file->size; ++ grub_file_close (file); ++ } ++ else ++ st->st_size = 0; ++ st->st_blksize = 512; ++ st->st_blocks = (st->st_size + 511) >> 9; ++ st->st_atime = st->st_mtime = st->st_ctime = file_info.mtimeset ++ ? file_info.mtime : 0; ++ grub_errno = GRUB_ERR_NONE; ++ return 0; ++} ++ ++static int ++fuse_opendir (const char *path, struct fuse_file_info *fi) ++{ ++ return 0; ++} ++ ++/* FIXME */ ++static grub_file_t files[65536]; ++static int first_fd = 1; ++ ++static int ++fuse_open (const char *path, struct fuse_file_info *fi __attribute__ ((unused))) ++{ ++ grub_file_t file; ++ file = grub_file_open (path); ++ if (! file) ++ return translate_error (); ++ files[first_fd++] = file; ++ fi->fh = first_fd; ++ files[first_fd++] = file; ++ grub_errno = GRUB_ERR_NONE; ++ return 0; ++} ++ ++static int ++fuse_read (const char *path, char *buf, size_t sz, off_t off, ++ struct fuse_file_info *fi) ++{ ++ grub_file_t file = files[fi->fh]; ++ grub_ssize_t size; ++ ++ if (off > file->size) ++ return -EINVAL; ++ ++ file->offset = off; ++ ++ size = grub_file_read (file, buf, sz); ++ if (size < 0) ++ return translate_error (); ++ else ++ { ++ grub_errno = GRUB_ERR_NONE; ++ return size; ++ } ++} ++ ++static int ++fuse_release (const char *path, struct fuse_file_info *fi) ++{ ++ grub_file_close (files[fi->fh]); ++ files[fi->fh] = NULL; ++ grub_errno = GRUB_ERR_NONE; ++ return 0; ++} ++ ++static int ++fuse_readdir (const char *path, void *buf, ++ fuse_fill_dir_t fill, off_t off, struct fuse_file_info *fi) ++{ ++ char *pathname; ++ ++ auto int call_fill (const char *filename, ++ const struct grub_dirhook_info *info); ++ int call_fill (const char *filename, const struct grub_dirhook_info *info) ++ { ++ fill (buf, filename, NULL, 0); ++ return 0; ++ } ++ ++ pathname = xstrdup (path); ++ ++ /* Remove trailing '/'. */ ++ while (pathname [0] && pathname[1] ++ && pathname[grub_strlen (pathname) - 1] == '/') ++ pathname[grub_strlen (pathname) - 1] = 0; ++ ++ (fs->dir) (dev, pathname, call_fill); ++ free (pathname); ++ grub_errno = GRUB_ERR_NONE; ++ return 0; ++} ++ ++struct fuse_operations grub_opers = { ++ .getattr = fuse_getattr, ++ .open = fuse_open, ++ .release = fuse_release, ++ .opendir = fuse_opendir, ++ .readdir = fuse_readdir, ++ .read = fuse_read ++}; ++ ++static grub_err_t ++fuse_init (void) ++{ ++ int i; ++ ++ for (i = 0; i < num_disks; i++) ++ { ++ char *argv[2]; ++ char *host_file; ++ char *loop_name; ++ loop_name = grub_xasprintf ("loop%d", i); ++ if (!loop_name) ++ grub_util_error (grub_errmsg); ++ ++ host_file = grub_xasprintf ("(host)%s", images[i]); ++ if (!host_file) ++ grub_util_error (grub_errmsg); ++ ++ argv[0] = loop_name; ++ argv[1] = host_file; ++ ++ if (execute_command ("loopback", 2, argv)) ++ grub_util_error (_("loopback command fails")); ++ ++ grub_free (loop_name); ++ grub_free (host_file); ++ } ++ ++ grub_lvm_fini (); ++ grub_mdraid09_fini (); ++ grub_mdraid1x_fini (); ++ grub_raid_fini (); ++ grub_raid_init (); ++ grub_mdraid09_init (); ++ grub_mdraid1x_init (); ++ grub_lvm_init (); ++ ++ dev = grub_device_open (0); ++ if (! dev) ++ return grub_errno; ++ ++ fs = grub_fs_probe (dev); ++ if (! fs) ++ { ++ grub_device_close (dev); ++ return grub_errno; ++ } ++ ++ fuse_main (fuse_argc, fuse_args, &grub_opers, NULL); ++ ++ for (i = 0; i < num_disks; i++) ++ { ++ char *argv[2]; ++ char *loop_name; ++ ++ loop_name = grub_xasprintf ("loop%d", i); ++ if (!loop_name) ++ grub_util_error (grub_errmsg); ++ ++ argv[0] = "-d"; ++ argv[1] = loop_name; ++ ++ execute_command ("loopback", 2, argv); ++ ++ grub_free (loop_name); ++ } ++ ++ return GRUB_ERR_NONE; ++} ++ ++static struct argp_option options[] = { ++ {"root", 'r', N_("DEVICE_NAME"), 0, N_("Set root device."), 2}, ++ {"debug", 'd', "S", 0, N_("Set debug environment variable."), 2}, ++ {"verbose", 'v', NULL, OPTION_ARG_OPTIONAL, N_("Print verbose messages."), 2}, ++ {0, 0, 0, 0, 0, 0} ++}; ++ ++/* Print the version information. */ ++static void ++print_version (FILE *stream, struct argp_state *state) ++{ ++ fprintf (stream, "%s (%s) %s\n", program_name, PACKAGE_NAME, PACKAGE_VERSION); ++} ++void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version; ++ ++error_t ++argp_parser (int key, char *arg, struct argp_state *state) ++{ ++ char *p; ++ ++ switch (key) ++ { ++ case 'r': ++ root = arg; ++ return 0; ++ ++ case 'd': ++ debug_str = arg; ++ return 0; ++ ++ case 'v': ++ verbosity++; ++ return 0; ++ ++ case ARGP_KEY_ARG: ++ if (arg[0] != '-') ++ break; ++ ++ default: ++ if (!arg) ++ return 0; ++ ++ fuse_args = xrealloc (fuse_args, (fuse_argc + 1) * sizeof (fuse_args[0])); ++ fuse_args[fuse_argc] = xstrdup (arg); ++ fuse_argc++; ++ return 0; ++ } ++ ++ if (arg[0] != '/') ++ { ++ fprintf (stderr, "%s", _("Must use absolute path.\n")); ++ argp_usage (state); ++ } ++ images = xrealloc (images, (num_disks + 1) * sizeof (images[0])); ++ images[num_disks] = xstrdup (arg); ++ num_disks++; ++ ++ return 0; ++} ++ ++struct argp argp = { ++ options, argp_parser, N_("IMAGE1 [IMAGE2 ...] MOUNTPOINT"), ++ N_("Debug tool for filesystem driver."), ++ NULL, NULL, NULL ++}; ++ ++int ++main (int argc, char *argv[]) ++{ ++ char *default_root, *alloc_root; ++ ++ set_program_name (argv[0]); ++ ++ grub_util_init_nls (); ++ ++ fuse_args = xrealloc (fuse_args, (fuse_argc + 2) * sizeof (fuse_args[0])); ++ fuse_args[fuse_argc] = xstrdup (argv[0]); ++ fuse_argc++; ++ /* Run single-threaded. */ ++ fuse_args[fuse_argc] = xstrdup ("-s"); ++ fuse_argc++; ++ ++ argp_parse (&argp, argc, argv, 0, 0, 0); ++ ++ if (num_disks < 2) ++ grub_util_error ("need an image and mountpoint"); ++ fuse_args = xrealloc (fuse_args, (fuse_argc + 2) * sizeof (fuse_args[0])); ++ fuse_args[fuse_argc] = images[num_disks - 1]; ++ fuse_argc++; ++ num_disks--; ++ fuse_args[fuse_argc] = NULL; ++ ++ /* Initialize all modules. */ ++ grub_init_all (); ++ ++ if (debug_str) ++ grub_env_set ("debug", debug_str); ++ ++ default_root = (num_disks == 1) ? "loop0" : "md0"; ++ alloc_root = 0; ++ if (root) ++ { ++ if ((*root >= '0') && (*root <= '9')) ++ { ++ alloc_root = xmalloc (strlen (default_root) + strlen (root) + 2); ++ ++ sprintf (alloc_root, "%s,%s", default_root, root); ++ root = alloc_root; ++ } ++ } ++ else ++ root = default_root; ++ ++ grub_env_set ("root", root); ++ ++ if (alloc_root) ++ free (alloc_root); ++ ++ /* Do it. */ ++ fuse_init (); ++ if (grub_errno) ++ { ++ grub_print_error (); ++ return 1; ++ } ++ ++ /* Free resources. */ ++ grub_fini_all (); ++ ++ return 0; ++} diff --git a/master/debian/branch_longlinuxcmd.patch b/master/debian/branch_longlinuxcmd.patch new file mode 100644 index 0000000..f7a048f --- /dev/null +++ b/master/debian/branch_longlinuxcmd.patch @@ -0,0 +1,179 @@ +Description: Support long Linux command lines +Author: Vladimir Serbinenko +Origin: upstream, http://bzr.sv.gnu.org/r/grub/branches/longlinuxcmd/ +Forwarded: not-needed +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3303 +Last-Update: 2011-05-19 + +Index: b/grub-core/loader/i386/linux.c +=================================================================== +--- a/grub-core/loader/i386/linux.c ++++ b/grub-core/loader/i386/linux.c +@@ -57,7 +57,6 @@ + #endif + + #define GRUB_LINUX_CL_OFFSET 0x1000 +-#define GRUB_LINUX_CL_END_OFFSET 0x2000 + + static grub_dl_t my_mod; + +@@ -74,6 +73,7 @@ + static grub_uint32_t initrd_pages; + static struct grub_relocator *relocator = NULL; + static void *efi_mmap_buf; ++static grub_size_t maximal_cmdline_size; + #ifdef GRUB_MACHINE_EFI + static grub_efi_uintn_t efi_mmap_size; + #else +@@ -189,7 +189,7 @@ + grub_err_t err; + + /* Make sure that each size is aligned to a page boundary. */ +- real_size = GRUB_LINUX_CL_END_OFFSET; ++ real_size = GRUB_LINUX_CL_OFFSET + maximal_cmdline_size; + prot_size = page_align (prot_size); + mmap_size = find_mmap_size (); + +@@ -662,6 +662,14 @@ + goto fail; + } + ++ if (grub_le_to_cpu16 (lh.version) >= 0x0206) ++ maximal_cmdline_size = grub_le_to_cpu32 (lh.cmdline_size) + 1; ++ else ++ maximal_cmdline_size = 256; ++ ++ if (maximal_cmdline_size < 128) ++ maximal_cmdline_size = 128; ++ + setup_sects = lh.setup_sects; + + /* If SETUP_SECTS is not set, set it to the default (4). */ +@@ -675,7 +683,7 @@ + goto fail; + + params = (struct linux_kernel_params *) real_mode_mem; +- grub_memset (params, 0, GRUB_LINUX_CL_END_OFFSET); ++ grub_memset (params, 0, GRUB_LINUX_CL_OFFSET + maximal_cmdline_size); + grub_memcpy (¶ms->setup_sects, &lh.setup_sects, sizeof (lh) - 0x1F1); + + params->ps_mouse = params->padding10 = 0; +@@ -870,7 +878,7 @@ + grub_create_loader_cmdline (argc, argv, + (char *)real_mode_mem + GRUB_LINUX_CL_OFFSET + + sizeof (LINUX_IMAGE) - 1, +- GRUB_LINUX_CL_END_OFFSET - GRUB_LINUX_CL_OFFSET ++ maximal_cmdline_size + - (sizeof (LINUX_IMAGE) - 1)); + + len = prot_size; +Index: b/grub-core/loader/i386/pc/linux.c +=================================================================== +--- a/grub-core/loader/i386/pc/linux.c ++++ b/grub-core/loader/i386/pc/linux.c +@@ -39,7 +39,6 @@ + GRUB_MOD_LICENSE ("GPLv3+"); + + #define GRUB_LINUX_CL_OFFSET 0x9000 +-#define GRUB_LINUX_CL_END_OFFSET 0x90FF + + static grub_dl_t my_mod; + +@@ -49,6 +48,7 @@ + static grub_addr_t grub_linux_real_target; + static char *grub_linux_real_chunk; + static grub_size_t grub_linux16_prot_size; ++static grub_size_t maximal_cmdline_size; + + static grub_err_t + grub_linux16_boot (void) +@@ -128,15 +128,20 @@ + setup_sects = lh.setup_sects; + linux_mem_size = 0; + ++ maximal_cmdline_size = 256; ++ + if (lh.header == grub_cpu_to_le32 (GRUB_LINUX_MAGIC_SIGNATURE) + && grub_le_to_cpu16 (lh.version) >= 0x0200) + { + grub_linux_is_bzimage = (lh.loadflags & GRUB_LINUX_FLAG_BIG_KERNEL); + lh.type_of_loader = GRUB_LINUX_BOOT_LOADER_TYPE; + ++ if (grub_le_to_cpu16 (lh.version) >= 0x0206) ++ maximal_cmdline_size = grub_le_to_cpu32 (lh.cmdline_size) + 1; ++ + /* Put the real mode part at as a high location as possible. */ + grub_linux_real_target = grub_mmap_get_lower () +- - GRUB_LINUX_SETUP_MOVE_SIZE; ++ - (GRUB_LINUX_CL_OFFSET + maximal_cmdline_size); + /* But it must not exceed the traditional area. */ + if (grub_linux_real_target > GRUB_LINUX_OLD_REAL_MODE_ADDR) + grub_linux_real_target = GRUB_LINUX_OLD_REAL_MODE_ADDR; +@@ -153,7 +158,8 @@ + { + lh.cl_magic = grub_cpu_to_le16 (GRUB_LINUX_CL_MAGIC); + lh.cl_offset = grub_cpu_to_le16 (GRUB_LINUX_CL_OFFSET); +- lh.setup_move_size = grub_cpu_to_le16 (GRUB_LINUX_SETUP_MOVE_SIZE); ++ lh.setup_move_size = grub_cpu_to_le16 (GRUB_LINUX_CL_OFFSET ++ + maximal_cmdline_size); + } + } + else +@@ -185,12 +191,13 @@ + goto fail; + } + +- if (grub_linux_real_target + GRUB_LINUX_SETUP_MOVE_SIZE ++ if (grub_linux_real_target + GRUB_LINUX_CL_OFFSET + maximal_cmdline_size + > grub_mmap_get_lower ()) + { + grub_error (GRUB_ERR_OUT_OF_RANGE, + "too small lower memory (0x%x > 0x%x)", +- grub_linux_real_target + GRUB_LINUX_SETUP_MOVE_SIZE, ++ grub_linux_real_target + GRUB_LINUX_CL_OFFSET ++ + maximal_cmdline_size, + (int) grub_mmap_get_lower ()); + goto fail; + } +@@ -263,7 +270,8 @@ + grub_relocator_chunk_t ch; + err = grub_relocator_alloc_chunk_addr (relocator, &ch, + grub_linux_real_target, +- GRUB_LINUX_SETUP_MOVE_SIZE); ++ GRUB_LINUX_CL_OFFSET ++ + maximal_cmdline_size); + if (err) + return err; + grub_linux_real_chunk = get_virtual_current_address (ch); +@@ -294,7 +302,7 @@ + grub_create_loader_cmdline (argc, argv, + (char *)grub_linux_real_chunk + + GRUB_LINUX_CL_OFFSET + sizeof (LINUX_IMAGE) - 1, +- GRUB_LINUX_CL_END_OFFSET - GRUB_LINUX_CL_OFFSET ++ maximal_cmdline_size + - (sizeof (LINUX_IMAGE) - 1)); + + if (grub_linux_is_bzimage) +Index: b/include/grub/i386/linux.h +=================================================================== +--- a/include/grub/i386/linux.h ++++ b/include/grub/i386/linux.h +@@ -41,7 +41,6 @@ + #define GRUB_LINUX_VID_MODE_ASK 0xFFFD + #define GRUB_LINUX_VID_MODE_VESA_START 0x0300 + +-#define GRUB_LINUX_SETUP_MOVE_SIZE 0x9100 + #define GRUB_LINUX_CL_MAGIC 0xA33F + + #ifdef __x86_64__ +@@ -130,6 +129,10 @@ + grub_uint16_t pad1; /* Unused */ + grub_uint32_t cmd_line_ptr; /* Points to the kernel command line */ + grub_uint32_t initrd_addr_max; /* Highest address for initrd */ ++ grub_uint32_t kernel_alignment; ++ grub_uint8_t relocatable; ++ grub_uint8_t pad[3]; ++ grub_uint32_t cmdline_size; + } __attribute__ ((packed)); + + /* Boot parameters for Linux based on 2.6.12. This is used by the setup diff --git a/master/debian/branch_parse-color.patch b/master/debian/branch_parse-color.patch new file mode 100644 index 0000000..3d68937 --- /dev/null +++ b/master/debian/branch_parse-color.patch @@ -0,0 +1,1310 @@ +Description: Add a background_color command + Move gfxmenu color handling to video, so that gfxterm can use it too; add a + background_color command. +Author: Colin Watson +Origin: upstream, http://bzr.sv.gnu.org/r/grub/branches/parse-color/ +Forwarded: http://lists.gnu.org/archive/html/grub-devel/2010-12/msg00045.html +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3308 +Last-Update: 2011-05-19 + +Index: b/ChangeLog.parse-color +=================================================================== +--- /dev/null ++++ b/ChangeLog.parse-color +@@ -0,0 +1,44 @@ ++2010-12-23 Colin Watson ++ ++ Move gfxmenu color handling to video, so that gfxterm can use it ++ too. ++ ++ * grub-core/gfxmenu/named_colors.c: Move to ... ++ * grub-core/video/colors.c: ... here. Rename ++ grub_gui_get_named_color to grub_video_get_named_color. ++ * grub-core/gfxmenu/gui_string_util.c (my_isxdigit): Move to ... ++ * grub-core/video/colors.c (my_isxdigit): ... here. ++ * grub-core/gfxmenu/gui_string_util.c (parse_hex_color_component): ++ Move to ... ++ * grub-core/video/colors.c (parse_hex_color_component): ... here. ++ * grub-core/gfxmenu/gui_string_util.c (grub_gui_parse_color): Move ++ to ... ++ * grub-core/video/colors.c (grub_video_parse_color): ... here. ++ ++ * include/grub/gui.h (grub_gui_color_t): Move to ... ++ * include/grub/video.h (grub_video_rgba_color_t): ... here. ++ * include/grub/gui.h (grub_gui_color_rgb): Move to ... ++ * include/grub/video.h (grub_video_rgba_color_rgb): ... here. ++ * include/grub/gui.h (grub_gui_map_color): Move to ... ++ * include/grub/video.h (grub_video_map_rgba_color): ... here. ++ * include/grub/gui_string_util.h (grub_gui_get_named_color): Move ++ to ... ++ * include/grub/video.h (grub_video_get_named_color): ... here. ++ * include/grub/gui_string_util.h (grub_gui_parse_color): Move to ... ++ * include/grub/video.h (grub_video_parse_color): ... here. ++ ++ * grub-core/Makefile.core.def (kernel) [videoinkernel]: Add ++ video/colors.c. ++ (gfxmenu): Remove gfxmenu/named_colors.c. ++ (video) [videomodules]: Add video/colors.c. ++ ++ Add a background_color command. ++ ++ * grub-core/term/gfxterm.c (grub_gfxterm_background_color_cmd): New ++ function. ++ (GRUB_MOD_INIT): Register background_color command. ++ (GRUB_MOD_FINI): Unregister background_color command. ++ (redraw_screen_rect): Allow blend/replace of text layer to be ++ controlled independently from whether there is a background bitmap. ++ (grub_gfxterm_background_image_cmd): Change blend_text_bg when ++ changing bitmap. +Index: b/grub-core/Makefile.core.def +=================================================================== +--- a/grub-core/Makefile.core.def ++++ b/grub-core/Makefile.core.def +@@ -178,6 +178,7 @@ + videoinkernel = io/bufio.c; + videoinkernel = video/bitmap.c; + videoinkernel = video/bitmap_scale.c; ++ videoinkernel = video/colors.c; + videoinkernel = video/fb/fbblit.c; + videoinkernel = video/fb/fbfill.c; + videoinkernel = video/fb/fbutil.c; +@@ -1056,7 +1057,6 @@ + common = gfxmenu/gui_progress_bar.c; + common = gfxmenu/gui_util.c; + common = gfxmenu/gui_string_util.c; +- common = gfxmenu/named_colors.c; + }; + + module = { +@@ -1463,6 +1463,7 @@ + module = { + name = video; + common = video/video.c; ++ common = video/colors.c; + enable = videomodules; + }; + +Index: b/grub-core/gfxmenu/gui_label.c +=================================================================== +--- a/grub-core/gfxmenu/gui_label.c ++++ b/grub-core/gfxmenu/gui_label.c +@@ -48,7 +48,7 @@ + char *text; + char *template; + grub_font_t font; +- grub_gui_color_t color; ++ grub_video_rgba_color_t color; + int value; + enum align_mode align; + }; +@@ -107,7 +107,7 @@ + grub_gui_set_viewport (&self->bounds, &vpsave); + grub_font_draw_string (self->text, + self->font, +- grub_gui_map_color (self->color), ++ grub_video_map_rgba_color (self->color), + left_x, + grub_font_get_ascent (self->font)); + grub_gui_restore_viewport (&vpsave); +@@ -186,7 +186,7 @@ + } + else if (grub_strcmp (name, "color") == 0) + { +- grub_gui_parse_color (value, &self->color); ++ grub_video_parse_color (value, &self->color); + } + else if (grub_strcmp (name, "align") == 0) + { +Index: b/grub-core/gfxmenu/gui_list.c +=================================================================== +--- a/grub-core/gfxmenu/gui_list.c ++++ b/grub-core/gfxmenu/gui_list.c +@@ -41,9 +41,9 @@ + int item_spacing; + grub_font_t item_font; + grub_font_t selected_item_font; +- grub_gui_color_t item_color; ++ grub_video_rgba_color_t item_color; + int selected_item_color_set; +- grub_gui_color_t selected_item_color; ++ grub_video_rgba_color_t selected_item_color; + + int draw_scrollbar; + int need_to_recreate_scrollbar; +@@ -269,13 +269,13 @@ + (is_selected && self->selected_item_font + ? self->selected_item_font + : self->item_font); +- grub_gui_color_t text_color = ++ grub_video_rgba_color_t text_color = + ((is_selected && self->selected_item_color_set) + ? self->selected_item_color + : self->item_color); + grub_font_draw_string (item_title, + font, +- grub_gui_map_color (text_color), ++ grub_video_map_rgba_color (text_color), + sel_leftpad + self->icon_width + icon_text_space, + (item_top + (item_height - (ascent + descent)) + / 2 + ascent)); +@@ -431,7 +431,7 @@ + } + else if (grub_strcmp (name, "item_color") == 0) + { +- grub_gui_parse_color (value, &self->item_color); ++ grub_video_parse_color (value, &self->item_color); + } + else if (grub_strcmp (name, "selected_item_color") == 0) + { +@@ -441,7 +441,7 @@ + } + else + { +- if (grub_gui_parse_color (value, &self->selected_item_color) ++ if (grub_video_parse_color (value, &self->selected_item_color) + == GRUB_ERR_NONE) + self->selected_item_color_set = 1; + } +@@ -564,7 +564,7 @@ + { + list_impl_t self; + grub_font_t default_font; +- grub_gui_color_t default_fg_color; ++ grub_video_rgba_color_t default_fg_color; + + self = grub_zalloc (sizeof (*self)); + if (! self) +@@ -576,7 +576,7 @@ + self->visible = 1; + + default_font = grub_font_get ("Unknown Regular 16"); +- default_fg_color = grub_gui_color_rgb (0, 0, 0); ++ default_fg_color = grub_video_rgba_color_rgb (0, 0, 0); + + self->icon_width = 32; + self->icon_height = 32; +Index: b/grub-core/gfxmenu/gui_progress_bar.c +=================================================================== +--- a/grub-core/gfxmenu/gui_progress_bar.c ++++ b/grub-core/gfxmenu/gui_progress_bar.c +@@ -40,10 +40,10 @@ + int show_text; + char *template; + grub_font_t font; +- grub_gui_color_t text_color; +- grub_gui_color_t border_color; +- grub_gui_color_t bg_color; +- grub_gui_color_t fg_color; ++ grub_video_rgba_color_t text_color; ++ grub_video_rgba_color_t border_color; ++ grub_video_rgba_color_t bg_color; ++ grub_video_rgba_color_t fg_color; + + char *theme_dir; + int need_to_recreate_pixmaps; +@@ -109,7 +109,7 @@ + f.height = self->bounds.height - 2; + + /* Border. */ +- grub_video_fill_rect (grub_gui_map_color (self->border_color), ++ grub_video_fill_rect (grub_video_map_rgba_color (self->border_color), + f.x - 1, f.y - 1, + f.width + 2, f.height + 2); + +@@ -117,12 +117,12 @@ + int barwidth = (f.width + * (self->value - self->start) + / (self->end - self->start)); +- grub_video_fill_rect (grub_gui_map_color (self->bg_color), ++ grub_video_fill_rect (grub_video_map_rgba_color (self->bg_color), + f.x + barwidth, f.y, + f.width - barwidth, f.height); + + /* Bar foreground. */ +- grub_video_fill_rect (grub_gui_map_color (self->fg_color), ++ grub_video_fill_rect (grub_video_map_rgba_color (self->fg_color), + f.x, f.y, + barwidth, f.height); + } +@@ -161,7 +161,8 @@ + if (self->template) + { + grub_font_t font = self->font; +- grub_video_color_t text_color = grub_gui_map_color (self->text_color); ++ grub_video_color_t text_color = ++ grub_video_map_rgba_color (self->text_color); + int width = self->bounds.width; + int height = self->bounds.height; + char *text; +@@ -298,19 +299,19 @@ + } + else if (grub_strcmp (name, "text_color") == 0) + { +- grub_gui_parse_color (value, &self->text_color); ++ grub_video_parse_color (value, &self->text_color); + } + else if (grub_strcmp (name, "border_color") == 0) + { +- grub_gui_parse_color (value, &self->border_color); ++ grub_video_parse_color (value, &self->border_color); + } + else if (grub_strcmp (name, "bg_color") == 0) + { +- grub_gui_parse_color (value, &self->bg_color); ++ grub_video_parse_color (value, &self->bg_color); + } + else if (grub_strcmp (name, "fg_color") == 0) + { +- grub_gui_parse_color (value, &self->fg_color); ++ grub_video_parse_color (value, &self->fg_color); + } + else if (grub_strcmp (name, "bar_style") == 0) + { +@@ -379,9 +380,9 @@ + self->progress.component.ops = &progress_bar_ops; + self->visible = 1; + self->font = grub_font_get ("Unknown Regular 16"); +- grub_gui_color_t black = { .red = 0, .green = 0, .blue = 0, .alpha = 255 }; +- grub_gui_color_t gray = { .red = 128, .green = 128, .blue = 128, .alpha = 255 }; +- grub_gui_color_t lightgray = { .red = 200, .green = 200, .blue = 200, .alpha = 255 }; ++ grub_video_rgba_color_t black = { .red = 0, .green = 0, .blue = 0, .alpha = 255 }; ++ grub_video_rgba_color_t gray = { .red = 128, .green = 128, .blue = 128, .alpha = 255 }; ++ grub_video_rgba_color_t lightgray = { .red = 200, .green = 200, .blue = 200, .alpha = 255 }; + self->text_color = black; + self->border_color = black; + self->bg_color = gray; +Index: b/grub-core/gfxmenu/gui_string_util.c +=================================================================== +--- a/grub-core/gfxmenu/gui_string_util.c ++++ b/grub-core/gfxmenu/gui_string_util.c +@@ -204,124 +204,3 @@ + + return grub_new_substring (file_path, 0, last_slash + 1); + } +- +-static __inline int +-my_isxdigit (char c) +-{ +- return ((c >= '0' && c <= '9') +- || (c >= 'a' && c <= 'f') +- || (c >= 'A' && c <= 'F')); +-} +- +-static int +-parse_hex_color_component (const char *s, unsigned start, unsigned end) +-{ +- unsigned len; +- char buf[3]; +- +- len = end - start; +- /* Check the limits so we don't overrun the buffer. */ +- if (len < 1 || len > 2) +- return 0; +- +- if (len == 1) +- { +- buf[0] = s[start]; /* Get the first and only hex digit. */ +- buf[1] = buf[0]; /* Duplicate the hex digit. */ +- } +- else if (len == 2) +- { +- buf[0] = s[start]; +- buf[1] = s[start + 1]; +- } +- +- buf[2] = '\0'; +- +- return grub_strtoul (buf, 0, 16); +-} +- +-/* Parse a color string of the form "r, g, b", "#RGB", "#RGBA", +- "#RRGGBB", or "#RRGGBBAA". */ +-grub_err_t +-grub_gui_parse_color (const char *s, grub_gui_color_t *color) +-{ +- grub_gui_color_t c; +- +- /* Skip whitespace. */ +- while (*s && grub_isspace (*s)) +- s++; +- +- if (*s == '#') +- { +- /* HTML-style. Number if hex digits: +- [6] #RRGGBB [3] #RGB +- [8] #RRGGBBAA [4] #RGBA */ +- +- s++; /* Skip the '#'. */ +- /* Count the hexits to determine the format. */ +- int hexits = 0; +- const char *end = s; +- while (my_isxdigit (*end)) +- { +- end++; +- hexits++; +- } +- +- /* Parse the color components based on the format. */ +- if (hexits == 3 || hexits == 4) +- { +- c.red = parse_hex_color_component (s, 0, 1); +- c.green = parse_hex_color_component (s, 1, 2); +- c.blue = parse_hex_color_component (s, 2, 3); +- if (hexits == 4) +- c.alpha = parse_hex_color_component (s, 3, 4); +- else +- c.alpha = 255; +- } +- else if (hexits == 6 || hexits == 8) +- { +- c.red = parse_hex_color_component (s, 0, 2); +- c.green = parse_hex_color_component (s, 2, 4); +- c.blue = parse_hex_color_component (s, 4, 6); +- if (hexits == 8) +- c.alpha = parse_hex_color_component (s, 6, 8); +- else +- c.alpha = 255; +- } +- else +- return grub_error (GRUB_ERR_BAD_ARGUMENT, +- "invalid HTML-type color string `%s'", s); +- } +- else if (grub_isdigit (*s)) +- { +- /* Comma separated decimal values. */ +- c.red = grub_strtoul (s, 0, 0); +- if ((s = grub_strchr (s, ',')) == 0) +- return grub_error (GRUB_ERR_BAD_ARGUMENT, +- "missing 1st comma separator in color `%s'", s); +- s++; +- c.green = grub_strtoul (s, 0, 0); +- if ((s = grub_strchr (s, ',')) == 0) +- return grub_error (GRUB_ERR_BAD_ARGUMENT, +- "missing 2nd comma separator in color `%s'", s); +- s++; +- c.blue = grub_strtoul (s, 0, 0); +- if ((s = grub_strchr (s, ',')) == 0) +- c.alpha = 255; +- else +- { +- s++; +- c.alpha = grub_strtoul (s, 0, 0); +- } +- } +- else +- { +- if (! grub_gui_get_named_color (s, &c)) +- return grub_error (GRUB_ERR_BAD_ARGUMENT, +- "invalid named color `%s'", s); +- } +- +- if (grub_errno == GRUB_ERR_NONE) +- *color = c; +- return grub_errno; +-} +Index: b/grub-core/gfxmenu/named_colors.c +=================================================================== +--- a/grub-core/gfxmenu/named_colors.c ++++ /dev/null +@@ -1,209 +0,0 @@ +-/* named_colors.c - Named color values. */ +-/* +- * GRUB -- GRand Unified Bootloader +- * Copyright (C) 2008 Free Software Foundation, Inc. +- * +- * GRUB 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, either version 3 of the License, or +- * (at your option) any later version. +- * +- * GRUB is distributed in the hope that it will be useful, +- * but WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- * GNU General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with GRUB. If not, see . +- */ +- +-#include +-#include +-#include +-#include +- +-struct named_color +-{ +- const char *name; +- grub_gui_color_t color; +-}; +- +-/* +- Named color list generated from the list of SVG color keywords from +- , +- processed through the following Perl command: +- perl -ne 'chomp;split;print "{ \"$_[0]\", RGB_COLOR($_[2]) },\n"' +- */ +- +-#define RGB_COLOR(r,g,b) {.red = r, .green = g, .blue = b, .alpha = 255} +- +-static struct named_color named_colors[] = +-{ +- { "aliceblue", RGB_COLOR(240,248,255) }, +- { "antiquewhite", RGB_COLOR(250,235,215) }, +- { "aqua", RGB_COLOR(0,255,255) }, +- { "aquamarine", RGB_COLOR(127,255,212) }, +- { "azure", RGB_COLOR(240,255,255) }, +- { "beige", RGB_COLOR(245,245,220) }, +- { "bisque", RGB_COLOR(255,228,196) }, +- { "black", RGB_COLOR(0,0,0) }, +- { "blanchedalmond", RGB_COLOR(255,235,205) }, +- { "blue", RGB_COLOR(0,0,255) }, +- { "blueviolet", RGB_COLOR(138,43,226) }, +- { "brown", RGB_COLOR(165,42,42) }, +- { "burlywood", RGB_COLOR(222,184,135) }, +- { "cadetblue", RGB_COLOR(95,158,160) }, +- { "chartreuse", RGB_COLOR(127,255,0) }, +- { "chocolate", RGB_COLOR(210,105,30) }, +- { "coral", RGB_COLOR(255,127,80) }, +- { "cornflowerblue", RGB_COLOR(100,149,237) }, +- { "cornsilk", RGB_COLOR(255,248,220) }, +- { "crimson", RGB_COLOR(220,20,60) }, +- { "cyan", RGB_COLOR(0,255,255) }, +- { "darkblue", RGB_COLOR(0,0,139) }, +- { "darkcyan", RGB_COLOR(0,139,139) }, +- { "darkgoldenrod", RGB_COLOR(184,134,11) }, +- { "darkgray", RGB_COLOR(169,169,169) }, +- { "darkgreen", RGB_COLOR(0,100,0) }, +- { "darkgrey", RGB_COLOR(169,169,169) }, +- { "darkkhaki", RGB_COLOR(189,183,107) }, +- { "darkmagenta", RGB_COLOR(139,0,139) }, +- { "darkolivegreen", RGB_COLOR(85,107,47) }, +- { "darkorange", RGB_COLOR(255,140,0) }, +- { "darkorchid", RGB_COLOR(153,50,204) }, +- { "darkred", RGB_COLOR(139,0,0) }, +- { "darksalmon", RGB_COLOR(233,150,122) }, +- { "darkseagreen", RGB_COLOR(143,188,143) }, +- { "darkslateblue", RGB_COLOR(72,61,139) }, +- { "darkslategray", RGB_COLOR(47,79,79) }, +- { "darkslategrey", RGB_COLOR(47,79,79) }, +- { "darkturquoise", RGB_COLOR(0,206,209) }, +- { "darkviolet", RGB_COLOR(148,0,211) }, +- { "deeppink", RGB_COLOR(255,20,147) }, +- { "deepskyblue", RGB_COLOR(0,191,255) }, +- { "dimgray", RGB_COLOR(105,105,105) }, +- { "dimgrey", RGB_COLOR(105,105,105) }, +- { "dodgerblue", RGB_COLOR(30,144,255) }, +- { "firebrick", RGB_COLOR(178,34,34) }, +- { "floralwhite", RGB_COLOR(255,250,240) }, +- { "forestgreen", RGB_COLOR(34,139,34) }, +- { "fuchsia", RGB_COLOR(255,0,255) }, +- { "gainsboro", RGB_COLOR(220,220,220) }, +- { "ghostwhite", RGB_COLOR(248,248,255) }, +- { "gold", RGB_COLOR(255,215,0) }, +- { "goldenrod", RGB_COLOR(218,165,32) }, +- { "gray", RGB_COLOR(128,128,128) }, +- { "green", RGB_COLOR(0,128,0) }, +- { "greenyellow", RGB_COLOR(173,255,47) }, +- { "grey", RGB_COLOR(128,128,128) }, +- { "honeydew", RGB_COLOR(240,255,240) }, +- { "hotpink", RGB_COLOR(255,105,180) }, +- { "indianred", RGB_COLOR(205,92,92) }, +- { "indigo", RGB_COLOR(75,0,130) }, +- { "ivory", RGB_COLOR(255,255,240) }, +- { "khaki", RGB_COLOR(240,230,140) }, +- { "lavender", RGB_COLOR(230,230,250) }, +- { "lavenderblush", RGB_COLOR(255,240,245) }, +- { "lawngreen", RGB_COLOR(124,252,0) }, +- { "lemonchiffon", RGB_COLOR(255,250,205) }, +- { "lightblue", RGB_COLOR(173,216,230) }, +- { "lightcoral", RGB_COLOR(240,128,128) }, +- { "lightcyan", RGB_COLOR(224,255,255) }, +- { "lightgoldenrodyellow", RGB_COLOR(250,250,210) }, +- { "lightgray", RGB_COLOR(211,211,211) }, +- { "lightgreen", RGB_COLOR(144,238,144) }, +- { "lightgrey", RGB_COLOR(211,211,211) }, +- { "lightpink", RGB_COLOR(255,182,193) }, +- { "lightsalmon", RGB_COLOR(255,160,122) }, +- { "lightseagreen", RGB_COLOR(32,178,170) }, +- { "lightskyblue", RGB_COLOR(135,206,250) }, +- { "lightslategray", RGB_COLOR(119,136,153) }, +- { "lightslategrey", RGB_COLOR(119,136,153) }, +- { "lightsteelblue", RGB_COLOR(176,196,222) }, +- { "lightyellow", RGB_COLOR(255,255,224) }, +- { "lime", RGB_COLOR(0,255,0) }, +- { "limegreen", RGB_COLOR(50,205,50) }, +- { "linen", RGB_COLOR(250,240,230) }, +- { "magenta", RGB_COLOR(255,0,255) }, +- { "maroon", RGB_COLOR(128,0,0) }, +- { "mediumaquamarine", RGB_COLOR(102,205,170) }, +- { "mediumblue", RGB_COLOR(0,0,205) }, +- { "mediumorchid", RGB_COLOR(186,85,211) }, +- { "mediumpurple", RGB_COLOR(147,112,219) }, +- { "mediumseagreen", RGB_COLOR(60,179,113) }, +- { "mediumslateblue", RGB_COLOR(123,104,238) }, +- { "mediumspringgreen", RGB_COLOR(0,250,154) }, +- { "mediumturquoise", RGB_COLOR(72,209,204) }, +- { "mediumvioletred", RGB_COLOR(199,21,133) }, +- { "midnightblue", RGB_COLOR(25,25,112) }, +- { "mintcream", RGB_COLOR(245,255,250) }, +- { "mistyrose", RGB_COLOR(255,228,225) }, +- { "moccasin", RGB_COLOR(255,228,181) }, +- { "navajowhite", RGB_COLOR(255,222,173) }, +- { "navy", RGB_COLOR(0,0,128) }, +- { "oldlace", RGB_COLOR(253,245,230) }, +- { "olive", RGB_COLOR(128,128,0) }, +- { "olivedrab", RGB_COLOR(107,142,35) }, +- { "orange", RGB_COLOR(255,165,0) }, +- { "orangered", RGB_COLOR(255,69,0) }, +- { "orchid", RGB_COLOR(218,112,214) }, +- { "palegoldenrod", RGB_COLOR(238,232,170) }, +- { "palegreen", RGB_COLOR(152,251,152) }, +- { "paleturquoise", RGB_COLOR(175,238,238) }, +- { "palevioletred", RGB_COLOR(219,112,147) }, +- { "papayawhip", RGB_COLOR(255,239,213) }, +- { "peachpuff", RGB_COLOR(255,218,185) }, +- { "peru", RGB_COLOR(205,133,63) }, +- { "pink", RGB_COLOR(255,192,203) }, +- { "plum", RGB_COLOR(221,160,221) }, +- { "powderblue", RGB_COLOR(176,224,230) }, +- { "purple", RGB_COLOR(128,0,128) }, +- { "red", RGB_COLOR(255,0,0) }, +- { "rosybrown", RGB_COLOR(188,143,143) }, +- { "royalblue", RGB_COLOR(65,105,225) }, +- { "saddlebrown", RGB_COLOR(139,69,19) }, +- { "salmon", RGB_COLOR(250,128,114) }, +- { "sandybrown", RGB_COLOR(244,164,96) }, +- { "seagreen", RGB_COLOR(46,139,87) }, +- { "seashell", RGB_COLOR(255,245,238) }, +- { "sienna", RGB_COLOR(160,82,45) }, +- { "silver", RGB_COLOR(192,192,192) }, +- { "skyblue", RGB_COLOR(135,206,235) }, +- { "slateblue", RGB_COLOR(106,90,205) }, +- { "slategray", RGB_COLOR(112,128,144) }, +- { "slategrey", RGB_COLOR(112,128,144) }, +- { "snow", RGB_COLOR(255,250,250) }, +- { "springgreen", RGB_COLOR(0,255,127) }, +- { "steelblue", RGB_COLOR(70,130,180) }, +- { "tan", RGB_COLOR(210,180,140) }, +- { "teal", RGB_COLOR(0,128,128) }, +- { "thistle", RGB_COLOR(216,191,216) }, +- { "tomato", RGB_COLOR(255,99,71) }, +- { "turquoise", RGB_COLOR(64,224,208) }, +- { "violet", RGB_COLOR(238,130,238) }, +- { "wheat", RGB_COLOR(245,222,179) }, +- { "white", RGB_COLOR(255,255,255) }, +- { "whitesmoke", RGB_COLOR(245,245,245) }, +- { "yellow", RGB_COLOR(255,255,0) }, +- { "yellowgreen", RGB_COLOR(154,205,50) }, +- { 0, { 0, 0, 0, 0 } } /* Terminator. */ +-}; +- +-/* Get the color named NAME. If the color was found, returns 1 and +- stores the color into *COLOR. If the color was not found, returns 0 and +- does not modify *COLOR. */ +-int +-grub_gui_get_named_color (const char *name, +- grub_gui_color_t *color) +-{ +- int i; +- for (i = 0; named_colors[i].name; i++) +- { +- if (grub_strcmp (named_colors[i].name, name) == 0) +- { +- *color = named_colors[i].color; +- return 1; +- } +- } +- return 0; +-} +Index: b/grub-core/gfxmenu/theme_loader.c +=================================================================== +--- a/grub-core/gfxmenu/theme_loader.c ++++ b/grub-core/gfxmenu/theme_loader.c +@@ -135,11 +135,11 @@ + return grub_errno; + } + else if (! grub_strcmp ("title-color", name)) +- grub_gui_parse_color (value, &view->title_color); ++ grub_video_parse_color (value, &view->title_color); + else if (! grub_strcmp ("message-color", name)) +- grub_gui_parse_color (value, &view->message_color); ++ grub_video_parse_color (value, &view->message_color); + else if (! grub_strcmp ("message-bg-color", name)) +- grub_gui_parse_color (value, &view->message_bg_color); ++ grub_video_parse_color (value, &view->message_bg_color); + else if (! grub_strcmp ("desktop-image", name)) + { + struct grub_video_bitmap *raw_bitmap; +@@ -170,7 +170,7 @@ + view->desktop_image = scaled_bitmap; + } + else if (! grub_strcmp ("desktop-color", name)) +- grub_gui_parse_color (value, &view->desktop_color); ++ grub_video_parse_color (value, &view->desktop_color); + else if (! grub_strcmp ("terminal-box", name)) + { + grub_err_t err; +Index: b/grub-core/gfxmenu/view.c +=================================================================== +--- a/grub-core/gfxmenu/view.c ++++ b/grub-core/gfxmenu/view.c +@@ -50,8 +50,8 @@ + { + grub_gfxmenu_view_t view; + grub_font_t default_font; +- grub_gui_color_t default_fg_color; +- grub_gui_color_t default_bg_color; ++ grub_video_rgba_color_t default_fg_color; ++ grub_video_rgba_color_t default_bg_color; + + view = grub_malloc (sizeof (*view)); + if (! view) +@@ -63,8 +63,8 @@ + view->screen.height = height; + + default_font = grub_font_get ("Unknown Regular 16"); +- default_fg_color = grub_gui_color_rgb (0, 0, 0); +- default_bg_color = grub_gui_color_rgb (255, 255, 255); ++ default_fg_color = grub_video_rgba_color_rgb (0, 0, 0); ++ default_bg_color = grub_video_rgba_color_rgb (255, 255, 255); + + view->canvas = 0; + +@@ -131,7 +131,7 @@ + } + else + { +- grub_video_fill_rect (grub_gui_map_color (view->desktop_color), ++ grub_video_fill_rect (grub_video_map_rgba_color (view->desktop_color), + bounds->x, bounds->y, + bounds->width, bounds->height); + } +@@ -150,7 +150,7 @@ + int y = 40 + grub_font_get_ascent (view->title_font); + grub_font_draw_string (view->title_text, + view->title_font, +- grub_gui_map_color (view->title_color), ++ grub_video_map_rgba_color (view->title_color), + x, y); + } + +@@ -244,13 +244,13 @@ + return; + + grub_font_t font = view->message_font; +- grub_video_color_t color = grub_gui_map_color (view->message_color); ++ grub_video_color_t color = grub_video_map_rgba_color (view->message_color); + + /* Border. */ + grub_video_fill_rect (color, + f.x-1, f.y-1, f.width+2, f.height+2); + /* Fill. */ +- grub_video_fill_rect (grub_gui_map_color (view->message_bg_color), ++ grub_video_fill_rect (grub_video_map_rgba_color (view->message_bg_color), + f.x, f.y, f.width, f.height); + + /* Center the text. */ +Index: b/grub-core/term/gfxterm.c +=================================================================== +--- a/grub-core/term/gfxterm.c ++++ b/grub-core/term/gfxterm.c +@@ -130,6 +130,7 @@ + static unsigned int bitmap_width; + static unsigned int bitmap_height; + static struct grub_video_bitmap *bitmap; ++static int blend_text_bg; + + static struct grub_dirty_region dirty_region; + +@@ -476,26 +477,27 @@ + /* Render background layer. */ + grub_video_fill_rect (color, x, ty, width, h); + } +- +- /* Render text layer as blended. */ +- grub_video_blit_render_target (text_layer, GRUB_VIDEO_BLIT_BLEND, x, y, +- x - virtual_screen.offset_x, +- y - virtual_screen.offset_y, +- width, height); + } + else + { + /* Render background layer. */ + color = virtual_screen.bg_color_display; + grub_video_fill_rect (color, x, y, width, height); +- +- /* Render text layer as replaced (to get texts background color). */ +- grub_video_blit_render_target (text_layer, GRUB_VIDEO_BLIT_REPLACE, x, y, +- x - virtual_screen.offset_x, +- y - virtual_screen.offset_y, +- width, height); + } + ++ if (blend_text_bg) ++ /* Render text layer as blended. */ ++ grub_video_blit_render_target (text_layer, GRUB_VIDEO_BLIT_BLEND, x, y, ++ x - virtual_screen.offset_x, ++ y - virtual_screen.offset_y, ++ width, height); ++ else ++ /* Render text layer as replaced (to get texts background color). */ ++ grub_video_blit_render_target (text_layer, GRUB_VIDEO_BLIT_REPLACE, x, y, ++ x - virtual_screen.offset_x, ++ y - virtual_screen.offset_y, ++ width, height); ++ + /* Restore saved viewport. */ + grub_video_set_viewport (saved_view.x, saved_view.y, + saved_view.width, saved_view.height); +@@ -1127,6 +1129,7 @@ + { + grub_video_bitmap_destroy (bitmap); + bitmap = 0; ++ blend_text_bg = 0; + + /* Mark whole screen as dirty. */ + dirty_region_add (0, 0, window.width, window.height); +@@ -1166,6 +1169,8 @@ + /* If bitmap was loaded correctly, display it. */ + if (bitmap) + { ++ blend_text_bg = 1; ++ + /* Determine bitmap dimensions. */ + bitmap_width = grub_video_bitmap_get_width (bitmap); + bitmap_height = grub_video_bitmap_get_height (bitmap); +@@ -1180,6 +1185,48 @@ + return grub_errno; + } + ++static grub_err_t ++grub_gfxterm_background_color_cmd (grub_command_t cmd __attribute__ ((unused)), ++ int argc, char **args) ++{ ++ grub_video_rgba_color_t color; ++ struct grub_video_render_target *old_target; ++ ++ if (argc != 1) ++ return grub_error (GRUB_ERR_BAD_ARGUMENT, "missing operand"); ++ ++ /* Check that we have video adapter active. */ ++ if (grub_video_get_info (NULL) != GRUB_ERR_NONE) ++ return grub_errno; ++ ++ if (grub_video_parse_color (args[0], &color) != GRUB_ERR_NONE) ++ return grub_errno; ++ ++ /* Destroy existing background bitmap if loaded. */ ++ if (bitmap) ++ { ++ grub_video_bitmap_destroy (bitmap); ++ bitmap = 0; ++ ++ /* Mark whole screen as dirty. */ ++ dirty_region_add (0, 0, window.width, window.height); ++ } ++ ++ /* Set the background and border colors. The background color needs to be ++ compatible with the text layer. */ ++ grub_video_get_active_render_target (&old_target); ++ grub_video_set_active_render_target (text_layer); ++ virtual_screen.bg_color = grub_video_map_rgba_color (color); ++ grub_video_set_active_render_target (old_target); ++ virtual_screen.bg_color_display = grub_video_map_rgba_color (color); ++ blend_text_bg = 1; ++ ++ /* Mark whole screen as dirty. */ ++ dirty_region_add (0, 0, window.width, window.height); ++ ++ return GRUB_ERR_NONE; ++} ++ + static struct grub_term_output grub_video_term = + { + .name = "gfxterm", +@@ -1201,6 +1248,7 @@ + }; + + static grub_extcmd_t background_image_cmd_handle; ++static grub_command_t background_color_cmd_handle; + + GRUB_MOD_INIT(gfxterm) + { +@@ -1211,10 +1259,16 @@ + N_("[-m (stretch|normal)] FILE"), + N_("Load background image for active terminal."), + background_image_cmd_options); ++ background_color_cmd_handle = ++ grub_register_command ("background_color", ++ grub_gfxterm_background_color_cmd, ++ N_("COLOR"), ++ N_("Set background color for active terminal.")); + } + + GRUB_MOD_FINI(gfxterm) + { ++ grub_unregister_command (background_color_cmd_handle); + grub_unregister_extcmd (background_image_cmd_handle); + grub_term_unregister_output (&grub_video_term); + } +Index: b/include/grub/gfxmenu_view.h +=================================================================== +--- a/include/grub/gfxmenu_view.h ++++ b/include/grub/gfxmenu_view.h +@@ -87,11 +87,11 @@ + grub_font_t title_font; + grub_font_t message_font; + char *terminal_font_name; +- grub_gui_color_t title_color; +- grub_gui_color_t message_color; +- grub_gui_color_t message_bg_color; ++ grub_video_rgba_color_t title_color; ++ grub_video_rgba_color_t message_color; ++ grub_video_rgba_color_t message_bg_color; + struct grub_video_bitmap *desktop_image; +- grub_gui_color_t desktop_color; ++ grub_video_rgba_color_t desktop_color; + grub_gfxmenu_box_t terminal_box; + char *title_text; + char *progress_message_text; +Index: b/include/grub/gui.h +=================================================================== +--- a/include/grub/gui.h ++++ b/include/grub/gui.h +@@ -31,16 +31,6 @@ + status changes. */ + #define GRUB_GFXMENU_TIMEOUT_COMPONENT_ID "__timeout__" + +-/* A representation of a color. Unlike grub_video_color_t, this +- representation is independent of any video mode specifics. */ +-typedef struct grub_gui_color +-{ +- grub_uint8_t red; +- grub_uint8_t green; +- grub_uint8_t blue; +- grub_uint8_t alpha; +-} grub_gui_color_t; +- + typedef struct grub_gui_component *grub_gui_component_t; + typedef struct grub_gui_container *grub_gui_container_t; + typedef struct grub_gui_list *grub_gui_list_t; +@@ -242,23 +232,6 @@ + r->height); + } + +-static __inline grub_gui_color_t +-grub_gui_color_rgb (int r, int g, int b) +-{ +- grub_gui_color_t c; +- c.red = r; +- c.green = g; +- c.blue = b; +- c.alpha = 255; +- return c; +-} +- +-static __inline grub_video_color_t +-grub_gui_map_color (grub_gui_color_t c) +-{ +- return grub_video_map_rgba (c.red, c.green, c.blue, c.alpha); +-} +- + static inline int + grub_video_have_common_points (const grub_video_rect_t *a, + const grub_video_rect_t *b) +Index: b/include/grub/gui_string_util.h +=================================================================== +--- a/include/grub/gui_string_util.h ++++ b/include/grub/gui_string_util.h +@@ -30,8 +30,4 @@ + + char *grub_get_dirname (const char *file_path); + +-int grub_gui_get_named_color (const char *name, grub_gui_color_t *color); +- +-grub_err_t grub_gui_parse_color (const char *s, grub_gui_color_t *color); +- + #endif /* GRUB_GUI_STRING_UTIL_HEADER */ +Index: b/include/grub/video.h +=================================================================== +--- a/include/grub/video.h ++++ b/include/grub/video.h +@@ -27,6 +27,15 @@ + specific coding format. */ + typedef grub_uint32_t grub_video_color_t; + ++/* Video color in hardware independent format. */ ++typedef struct grub_video_rgba_color ++{ ++ grub_uint8_t red; ++ grub_uint8_t green; ++ grub_uint8_t blue; ++ grub_uint8_t alpha; ++} grub_video_rgba_color_t; ++ + /* This structure is driver specific and should not be accessed directly by + outside code. */ + struct grub_video_render_target; +@@ -428,4 +437,27 @@ + + grub_video_driver_id_t EXPORT_FUNC (grub_video_get_driver_id) (void); + ++static __inline grub_video_rgba_color_t ++grub_video_rgba_color_rgb (int r, int g, int b) ++{ ++ grub_video_rgba_color_t c; ++ c.red = r; ++ c.green = g; ++ c.blue = b; ++ c.alpha = 255; ++ return c; ++} ++ ++static __inline grub_video_color_t ++grub_video_map_rgba_color (grub_video_rgba_color_t c) ++{ ++ return grub_video_map_rgba (c.red, c.green, c.blue, c.alpha); ++} ++ ++int EXPORT_FUNC (grub_video_get_named_color) (const char *name, ++ grub_video_rgba_color_t *color); ++ ++grub_err_t EXPORT_FUNC (grub_video_parse_color) (const char *s, ++ grub_video_rgba_color_t *color); ++ + #endif /* ! GRUB_VIDEO_HEADER */ +Index: b/grub-core/video/colors.c +=================================================================== +--- /dev/null ++++ b/grub-core/video/colors.c +@@ -0,0 +1,330 @@ ++/* named_colors.c - Named color values. */ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2008 Free Software Foundation, Inc. ++ * ++ * GRUB 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, either version 3 of the License, or ++ * (at your option) any later version. ++ * ++ * GRUB is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with GRUB. If not, see . ++ */ ++ ++#include ++#include ++#include ++#include ++ ++struct named_color ++{ ++ const char *name; ++ grub_video_rgba_color_t color; ++}; ++ ++/* ++ Named color list generated from the list of SVG color keywords from ++ , ++ processed through the following Perl command: ++ perl -ne 'chomp;split;print "{ \"$_[0]\", RGB_COLOR($_[2]) },\n"' ++ */ ++ ++#define RGB_COLOR(r,g,b) {.red = r, .green = g, .blue = b, .alpha = 255} ++ ++static struct named_color named_colors[] = ++{ ++ { "aliceblue", RGB_COLOR(240,248,255) }, ++ { "antiquewhite", RGB_COLOR(250,235,215) }, ++ { "aqua", RGB_COLOR(0,255,255) }, ++ { "aquamarine", RGB_COLOR(127,255,212) }, ++ { "azure", RGB_COLOR(240,255,255) }, ++ { "beige", RGB_COLOR(245,245,220) }, ++ { "bisque", RGB_COLOR(255,228,196) }, ++ { "black", RGB_COLOR(0,0,0) }, ++ { "blanchedalmond", RGB_COLOR(255,235,205) }, ++ { "blue", RGB_COLOR(0,0,255) }, ++ { "blueviolet", RGB_COLOR(138,43,226) }, ++ { "brown", RGB_COLOR(165,42,42) }, ++ { "burlywood", RGB_COLOR(222,184,135) }, ++ { "cadetblue", RGB_COLOR(95,158,160) }, ++ { "chartreuse", RGB_COLOR(127,255,0) }, ++ { "chocolate", RGB_COLOR(210,105,30) }, ++ { "coral", RGB_COLOR(255,127,80) }, ++ { "cornflowerblue", RGB_COLOR(100,149,237) }, ++ { "cornsilk", RGB_COLOR(255,248,220) }, ++ { "crimson", RGB_COLOR(220,20,60) }, ++ { "cyan", RGB_COLOR(0,255,255) }, ++ { "darkblue", RGB_COLOR(0,0,139) }, ++ { "darkcyan", RGB_COLOR(0,139,139) }, ++ { "darkgoldenrod", RGB_COLOR(184,134,11) }, ++ { "darkgray", RGB_COLOR(169,169,169) }, ++ { "darkgreen", RGB_COLOR(0,100,0) }, ++ { "darkgrey", RGB_COLOR(169,169,169) }, ++ { "darkkhaki", RGB_COLOR(189,183,107) }, ++ { "darkmagenta", RGB_COLOR(139,0,139) }, ++ { "darkolivegreen", RGB_COLOR(85,107,47) }, ++ { "darkorange", RGB_COLOR(255,140,0) }, ++ { "darkorchid", RGB_COLOR(153,50,204) }, ++ { "darkred", RGB_COLOR(139,0,0) }, ++ { "darksalmon", RGB_COLOR(233,150,122) }, ++ { "darkseagreen", RGB_COLOR(143,188,143) }, ++ { "darkslateblue", RGB_COLOR(72,61,139) }, ++ { "darkslategray", RGB_COLOR(47,79,79) }, ++ { "darkslategrey", RGB_COLOR(47,79,79) }, ++ { "darkturquoise", RGB_COLOR(0,206,209) }, ++ { "darkviolet", RGB_COLOR(148,0,211) }, ++ { "deeppink", RGB_COLOR(255,20,147) }, ++ { "deepskyblue", RGB_COLOR(0,191,255) }, ++ { "dimgray", RGB_COLOR(105,105,105) }, ++ { "dimgrey", RGB_COLOR(105,105,105) }, ++ { "dodgerblue", RGB_COLOR(30,144,255) }, ++ { "firebrick", RGB_COLOR(178,34,34) }, ++ { "floralwhite", RGB_COLOR(255,250,240) }, ++ { "forestgreen", RGB_COLOR(34,139,34) }, ++ { "fuchsia", RGB_COLOR(255,0,255) }, ++ { "gainsboro", RGB_COLOR(220,220,220) }, ++ { "ghostwhite", RGB_COLOR(248,248,255) }, ++ { "gold", RGB_COLOR(255,215,0) }, ++ { "goldenrod", RGB_COLOR(218,165,32) }, ++ { "gray", RGB_COLOR(128,128,128) }, ++ { "green", RGB_COLOR(0,128,0) }, ++ { "greenyellow", RGB_COLOR(173,255,47) }, ++ { "grey", RGB_COLOR(128,128,128) }, ++ { "honeydew", RGB_COLOR(240,255,240) }, ++ { "hotpink", RGB_COLOR(255,105,180) }, ++ { "indianred", RGB_COLOR(205,92,92) }, ++ { "indigo", RGB_COLOR(75,0,130) }, ++ { "ivory", RGB_COLOR(255,255,240) }, ++ { "khaki", RGB_COLOR(240,230,140) }, ++ { "lavender", RGB_COLOR(230,230,250) }, ++ { "lavenderblush", RGB_COLOR(255,240,245) }, ++ { "lawngreen", RGB_COLOR(124,252,0) }, ++ { "lemonchiffon", RGB_COLOR(255,250,205) }, ++ { "lightblue", RGB_COLOR(173,216,230) }, ++ { "lightcoral", RGB_COLOR(240,128,128) }, ++ { "lightcyan", RGB_COLOR(224,255,255) }, ++ { "lightgoldenrodyellow", RGB_COLOR(250,250,210) }, ++ { "lightgray", RGB_COLOR(211,211,211) }, ++ { "lightgreen", RGB_COLOR(144,238,144) }, ++ { "lightgrey", RGB_COLOR(211,211,211) }, ++ { "lightpink", RGB_COLOR(255,182,193) }, ++ { "lightsalmon", RGB_COLOR(255,160,122) }, ++ { "lightseagreen", RGB_COLOR(32,178,170) }, ++ { "lightskyblue", RGB_COLOR(135,206,250) }, ++ { "lightslategray", RGB_COLOR(119,136,153) }, ++ { "lightslategrey", RGB_COLOR(119,136,153) }, ++ { "lightsteelblue", RGB_COLOR(176,196,222) }, ++ { "lightyellow", RGB_COLOR(255,255,224) }, ++ { "lime", RGB_COLOR(0,255,0) }, ++ { "limegreen", RGB_COLOR(50,205,50) }, ++ { "linen", RGB_COLOR(250,240,230) }, ++ { "magenta", RGB_COLOR(255,0,255) }, ++ { "maroon", RGB_COLOR(128,0,0) }, ++ { "mediumaquamarine", RGB_COLOR(102,205,170) }, ++ { "mediumblue", RGB_COLOR(0,0,205) }, ++ { "mediumorchid", RGB_COLOR(186,85,211) }, ++ { "mediumpurple", RGB_COLOR(147,112,219) }, ++ { "mediumseagreen", RGB_COLOR(60,179,113) }, ++ { "mediumslateblue", RGB_COLOR(123,104,238) }, ++ { "mediumspringgreen", RGB_COLOR(0,250,154) }, ++ { "mediumturquoise", RGB_COLOR(72,209,204) }, ++ { "mediumvioletred", RGB_COLOR(199,21,133) }, ++ { "midnightblue", RGB_COLOR(25,25,112) }, ++ { "mintcream", RGB_COLOR(245,255,250) }, ++ { "mistyrose", RGB_COLOR(255,228,225) }, ++ { "moccasin", RGB_COLOR(255,228,181) }, ++ { "navajowhite", RGB_COLOR(255,222,173) }, ++ { "navy", RGB_COLOR(0,0,128) }, ++ { "oldlace", RGB_COLOR(253,245,230) }, ++ { "olive", RGB_COLOR(128,128,0) }, ++ { "olivedrab", RGB_COLOR(107,142,35) }, ++ { "orange", RGB_COLOR(255,165,0) }, ++ { "orangered", RGB_COLOR(255,69,0) }, ++ { "orchid", RGB_COLOR(218,112,214) }, ++ { "palegoldenrod", RGB_COLOR(238,232,170) }, ++ { "palegreen", RGB_COLOR(152,251,152) }, ++ { "paleturquoise", RGB_COLOR(175,238,238) }, ++ { "palevioletred", RGB_COLOR(219,112,147) }, ++ { "papayawhip", RGB_COLOR(255,239,213) }, ++ { "peachpuff", RGB_COLOR(255,218,185) }, ++ { "peru", RGB_COLOR(205,133,63) }, ++ { "pink", RGB_COLOR(255,192,203) }, ++ { "plum", RGB_COLOR(221,160,221) }, ++ { "powderblue", RGB_COLOR(176,224,230) }, ++ { "purple", RGB_COLOR(128,0,128) }, ++ { "red", RGB_COLOR(255,0,0) }, ++ { "rosybrown", RGB_COLOR(188,143,143) }, ++ { "royalblue", RGB_COLOR(65,105,225) }, ++ { "saddlebrown", RGB_COLOR(139,69,19) }, ++ { "salmon", RGB_COLOR(250,128,114) }, ++ { "sandybrown", RGB_COLOR(244,164,96) }, ++ { "seagreen", RGB_COLOR(46,139,87) }, ++ { "seashell", RGB_COLOR(255,245,238) }, ++ { "sienna", RGB_COLOR(160,82,45) }, ++ { "silver", RGB_COLOR(192,192,192) }, ++ { "skyblue", RGB_COLOR(135,206,235) }, ++ { "slateblue", RGB_COLOR(106,90,205) }, ++ { "slategray", RGB_COLOR(112,128,144) }, ++ { "slategrey", RGB_COLOR(112,128,144) }, ++ { "snow", RGB_COLOR(255,250,250) }, ++ { "springgreen", RGB_COLOR(0,255,127) }, ++ { "steelblue", RGB_COLOR(70,130,180) }, ++ { "tan", RGB_COLOR(210,180,140) }, ++ { "teal", RGB_COLOR(0,128,128) }, ++ { "thistle", RGB_COLOR(216,191,216) }, ++ { "tomato", RGB_COLOR(255,99,71) }, ++ { "turquoise", RGB_COLOR(64,224,208) }, ++ { "violet", RGB_COLOR(238,130,238) }, ++ { "wheat", RGB_COLOR(245,222,179) }, ++ { "white", RGB_COLOR(255,255,255) }, ++ { "whitesmoke", RGB_COLOR(245,245,245) }, ++ { "yellow", RGB_COLOR(255,255,0) }, ++ { "yellowgreen", RGB_COLOR(154,205,50) }, ++ { 0, { 0, 0, 0, 0 } } /* Terminator. */ ++}; ++ ++/* Get the color named NAME. If the color was found, returns 1 and ++ stores the color into *COLOR. If the color was not found, returns 0 and ++ does not modify *COLOR. */ ++int ++grub_video_get_named_color (const char *name, ++ grub_video_rgba_color_t *color) ++{ ++ int i; ++ for (i = 0; named_colors[i].name; i++) ++ { ++ if (grub_strcmp (named_colors[i].name, name) == 0) ++ { ++ *color = named_colors[i].color; ++ return 1; ++ } ++ } ++ return 0; ++} ++ ++static __inline int ++my_isxdigit (char c) ++{ ++ return ((c >= '0' && c <= '9') ++ || (c >= 'a' && c <= 'f') ++ || (c >= 'A' && c <= 'F')); ++} ++ ++static int ++parse_hex_color_component (const char *s, unsigned start, unsigned end) ++{ ++ unsigned len; ++ char buf[3]; ++ ++ len = end - start; ++ /* Check the limits so we don't overrun the buffer. */ ++ if (len < 1 || len > 2) ++ return 0; ++ ++ if (len == 1) ++ { ++ buf[0] = s[start]; /* Get the first and only hex digit. */ ++ buf[1] = buf[0]; /* Duplicate the hex digit. */ ++ } ++ else if (len == 2) ++ { ++ buf[0] = s[start]; ++ buf[1] = s[start + 1]; ++ } ++ ++ buf[2] = '\0'; ++ ++ return grub_strtoul (buf, 0, 16); ++} ++ ++/* Parse a color string of the form "r, g, b", "#RGB", "#RGBA", ++ "#RRGGBB", or "#RRGGBBAA". */ ++grub_err_t ++grub_video_parse_color (const char *s, grub_video_rgba_color_t *color) ++{ ++ grub_video_rgba_color_t c; ++ ++ /* Skip whitespace. */ ++ while (*s && grub_isspace (*s)) ++ s++; ++ ++ if (*s == '#') ++ { ++ /* HTML-style. Number if hex digits: ++ [6] #RRGGBB [3] #RGB ++ [8] #RRGGBBAA [4] #RGBA */ ++ ++ s++; /* Skip the '#'. */ ++ /* Count the hexits to determine the format. */ ++ int hexits = 0; ++ const char *end = s; ++ while (my_isxdigit (*end)) ++ { ++ end++; ++ hexits++; ++ } ++ ++ /* Parse the color components based on the format. */ ++ if (hexits == 3 || hexits == 4) ++ { ++ c.red = parse_hex_color_component (s, 0, 1); ++ c.green = parse_hex_color_component (s, 1, 2); ++ c.blue = parse_hex_color_component (s, 2, 3); ++ if (hexits == 4) ++ c.alpha = parse_hex_color_component (s, 3, 4); ++ else ++ c.alpha = 255; ++ } ++ else if (hexits == 6 || hexits == 8) ++ { ++ c.red = parse_hex_color_component (s, 0, 2); ++ c.green = parse_hex_color_component (s, 2, 4); ++ c.blue = parse_hex_color_component (s, 4, 6); ++ if (hexits == 8) ++ c.alpha = parse_hex_color_component (s, 6, 8); ++ else ++ c.alpha = 255; ++ } ++ else ++ return grub_error (GRUB_ERR_BAD_ARGUMENT, ++ "invalid HTML-type color string `%s'", s); ++ } ++ else if (grub_isdigit (*s)) ++ { ++ /* Comma separated decimal values. */ ++ c.red = grub_strtoul (s, 0, 0); ++ if ((s = grub_strchr (s, ',')) == 0) ++ return grub_error (GRUB_ERR_BAD_ARGUMENT, ++ "missing 1st comma separator in color `%s'", s); ++ s++; ++ c.green = grub_strtoul (s, 0, 0); ++ if ((s = grub_strchr (s, ',')) == 0) ++ return grub_error (GRUB_ERR_BAD_ARGUMENT, ++ "missing 2nd comma separator in color `%s'", s); ++ s++; ++ c.blue = grub_strtoul (s, 0, 0); ++ if ((s = grub_strchr (s, ',')) == 0) ++ c.alpha = 255; ++ else ++ { ++ s++; ++ c.alpha = grub_strtoul (s, 0, 0); ++ } ++ } ++ else ++ { ++ if (! grub_video_get_named_color (s, &c)) ++ return grub_error (GRUB_ERR_BAD_ARGUMENT, ++ "invalid named color `%s'", s); ++ } ++ ++ if (grub_errno == GRUB_ERR_NONE) ++ *color = c; ++ return grub_errno; ++} diff --git a/master/debian/branch_squash.patch b/master/debian/branch_squash.patch new file mode 100644 index 0000000..594d03c --- /dev/null +++ b/master/debian/branch_squash.patch @@ -0,0 +1,694 @@ +Description: Add squashfs 4 support +Author: Vladimir Serbinenko +Origin: upstream, http://bzr.sv.gnu.org/r/grub/branches/squash/ +Forwarded: not-needed +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3278 +Last-Update: 2011-05-19 + +Index: b/Makefile.util.def +=================================================================== +--- a/Makefile.util.def ++++ b/Makefile.util.def +@@ -65,6 +65,7 @@ + common = grub-core/fs/ntfscomp.c; + common = grub-core/fs/reiserfs.c; + common = grub-core/fs/sfs.c; ++ common = grub-core/fs/squash4.c; + common = grub-core/fs/tar.c; + common = grub-core/fs/udf.c; + common = grub-core/fs/ufs2.c; +Index: b/grub-core/Makefile.core.def +=================================================================== +--- a/grub-core/Makefile.core.def ++++ b/grub-core/Makefile.core.def +@@ -985,6 +985,11 @@ + }; + + module = { ++ name = squash4; ++ common = fs/squash4.c; ++}; ++ ++module = { + name = tar; + common = fs/tar.c; + }; +Index: b/grub-core/fs/squash4.c +=================================================================== +--- /dev/null ++++ b/grub-core/fs/squash4.c +@@ -0,0 +1,548 @@ ++/* squash4.c - SquashFS */ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2010 Free Software Foundation, Inc. ++ * ++ * GRUB 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, either version 3 of the License, or ++ * (at your option) any later version. ++ * ++ * GRUB is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with GRUB. If not, see . ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++GRUB_MOD_LICENSE ("GPLv3+"); ++ ++/* ++ object format Pointed by ++ superblock RAW Fixed offset (0) ++ data RAW ? Fixed offset (60) ++ inode table Chunk superblock ++ dir table Chunk superblock ++ fragment table Chunk unk1 ++ unk1 RAW, Chunk superblock ++ unk2 RAW superblock ++ UID/GID Chunk exttblptr ++ exttblptr RAW superblock ++ ++ UID/GID table is the array ot uint32_t ++ unk1 contains pointer to unk3 followed by some chunk. ++ unk2 containts one uint64_t ++*/ ++ ++struct grub_squash_super ++{ ++ grub_uint32_t magic; ++#define SQUASH_MAGIC 0x73717368 ++ grub_uint32_t dummy1; ++ grub_uint32_t creation_time; ++ grub_uint32_t dummy2; ++ grub_uint64_t dummy3; ++ grub_uint8_t flags; ++#define SQUASH_FLAG_UNCOMPRESSED_INODES 1 ++#define SQUASH_FLAG_UNCOMPRESSED_DATA 2 ++#define SQUASH_FLAG_UNCOMPRESSED_FRAGMENTS 8 ++ grub_uint8_t dummy4[7]; ++ grub_uint16_t root_ino_offset; ++ grub_uint32_t root_ino_chunk; ++ grub_uint16_t dummy5; ++ grub_uint64_t total_size; ++ grub_uint64_t exttbloffset; ++ grub_uint64_t dummy6; ++ grub_uint64_t inodeoffset; ++ grub_uint64_t diroffset; ++ grub_uint64_t unk1offset; ++ grub_uint64_t unk2offset; ++} __attribute__ ((packed)); ++ ++ ++/* Chunk-based */ ++struct grub_squash_inode ++{ ++ /* Same values as direlem types. */ ++ grub_uint16_t type; ++ grub_uint16_t dummy[3]; ++ grub_uint32_t mtime; ++ union ++ { ++ struct { ++ grub_uint32_t dummy; ++ grub_uint32_t chunk; ++ grub_uint32_t fragment; ++ grub_uint32_t offset; ++ grub_uint32_t size; ++ } __attribute__ ((packed)) file; ++ struct { ++ grub_uint32_t dummy1; ++ grub_uint32_t chunk; ++ grub_uint32_t dummy2; ++ grub_uint16_t size; ++ grub_uint32_t offset; ++ grub_uint16_t dummy3; ++ } __attribute__ ((packed)) dir; ++ struct { ++ grub_uint64_t dummy; ++ grub_uint32_t namelen; ++ char name[0]; ++ } __attribute__ ((packed)) symlink; ++ } __attribute__ ((packed)); ++} __attribute__ ((packed)); ++ ++/* Chunk-based. */ ++struct grub_squash_dirent_header ++{ ++ /* Actually the value is the number of elements - 1. */ ++ grub_uint32_t nelems; ++ grub_uint64_t ino_chunk; ++} __attribute__ ((packed)); ++ ++struct grub_squash_dirent ++{ ++ grub_uint16_t ino_offset; ++ grub_uint16_t dummy; ++ grub_uint16_t type; ++#define SQUASH_TYPE_DIR 1 ++#define SQUASH_TYPE_REGULAR 2 ++#define SQUASH_TYPE_SYMLINK 3 ++ /* Actually the value is the length of name - 1. */ ++ grub_uint16_t namelen; ++ char name[0]; ++} __attribute__ ((packed)); ++ ++struct grub_squash_frag_desc ++{ ++ grub_uint64_t offset; ++ grub_uint64_t dummy; ++} __attribute__ ((packed)); ++ ++#define SQUASH_CHUNK_SIZE 0x2000 ++#define SQUASH_CHUNK_FLAGS 0x8000 ++#define SQUASH_CHUNK_UNCOMPRESSED 0x8000 ++ ++struct grub_squash_data ++{ ++ grub_disk_t disk; ++ struct grub_squash_super sb; ++ struct grub_squash_inode ino; ++ grub_uint64_t fragments; ++}; ++ ++struct grub_fshelp_node ++{ ++ struct grub_squash_data *data; ++ struct grub_squash_inode ino; ++ grub_uint32_t ino_chunk; ++ grub_uint16_t ino_offset; ++}; ++ ++static grub_err_t ++read_chunk (grub_disk_t disk, void *buf, grub_size_t len, ++ grub_uint64_t chunk, grub_off_t offset) ++{ ++ grub_uint64_t chunk_start; ++ chunk_start = grub_le_to_cpu64 (chunk); ++ while (len > 0) ++ { ++ grub_uint64_t csize; ++ grub_uint16_t d; ++ grub_err_t err; ++ while (1) ++ { ++ err = grub_disk_read (disk, chunk_start >> GRUB_DISK_SECTOR_BITS, ++ chunk_start & (GRUB_DISK_SECTOR_SIZE - 1), ++ sizeof (d), &d); ++ if (err) ++ return err; ++ if (offset < SQUASH_CHUNK_SIZE) ++ break; ++ offset -= SQUASH_CHUNK_SIZE; ++ chunk_start += 2 + (grub_le_to_cpu16 (d) & ~SQUASH_CHUNK_FLAGS); ++ } ++ ++ csize = SQUASH_CHUNK_SIZE - offset; ++ if (csize > len) ++ csize = len; ++ ++ if (grub_le_to_cpu16 (d) & SQUASH_CHUNK_UNCOMPRESSED) ++ { ++ grub_disk_addr_t a = chunk_start + 2 + offset; ++ err = grub_disk_read (disk, (a >> GRUB_DISK_SECTOR_BITS), ++ a & (GRUB_DISK_SECTOR_SIZE - 1), ++ csize, buf); ++ if (err) ++ return err; ++ } ++ else ++ { ++ char *tmp; ++ grub_size_t bsize = grub_le_to_cpu16 (d) & ~SQUASH_CHUNK_FLAGS; ++ grub_disk_addr_t a = chunk_start + 2; ++ tmp = grub_malloc (bsize); ++ if (!tmp) ++ return grub_errno; ++ /* FIXME: buffer uncompressed data. */ ++ err = grub_disk_read (disk, (a >> GRUB_DISK_SECTOR_BITS), ++ a & (GRUB_DISK_SECTOR_SIZE - 1), ++ bsize, tmp); ++ if (err) ++ { ++ grub_free (tmp); ++ return err; ++ } ++ ++ if (grub_zlib_decompress (tmp, bsize, offset, ++ buf, csize) < 0) ++ { ++ grub_free (tmp); ++ return grub_errno; ++ } ++ grub_free (tmp); ++ } ++ len -= csize; ++ offset += csize; ++ buf = (char *) buf + csize; ++ } ++ return GRUB_ERR_NONE; ++} ++ ++static struct grub_squash_data * ++squash_mount (grub_disk_t disk) ++{ ++ struct grub_squash_super sb; ++ grub_err_t err; ++ struct grub_squash_data *data; ++ grub_uint64_t frag; ++ ++ err = grub_disk_read (disk, 0, 0, sizeof (sb), &sb); ++ if (grub_errno == GRUB_ERR_OUT_OF_RANGE) ++ grub_error (GRUB_ERR_BAD_FS, "not a squash4"); ++ if (err) ++ return NULL; ++ if (grub_le_to_cpu32 (sb.magic) != SQUASH_MAGIC) ++ { ++ grub_error (GRUB_ERR_BAD_FS, "not squash4"); ++ return NULL; ++ } ++ ++ err = grub_disk_read (disk, grub_le_to_cpu32 (sb.unk1offset) ++ >> GRUB_DISK_SECTOR_BITS, ++ grub_le_to_cpu32 (sb.unk1offset) ++ & (GRUB_DISK_SECTOR_SIZE - 1), sizeof (frag), &frag); ++ if (grub_errno == GRUB_ERR_OUT_OF_RANGE) ++ grub_error (GRUB_ERR_BAD_FS, "not a squash4"); ++ if (err) ++ return NULL; ++ ++ data = grub_malloc (sizeof (*data)); ++ if (!data) ++ return NULL; ++ data->sb = sb; ++ data->disk = disk; ++ data->fragments = frag; ++ ++ return data; ++} ++ ++static char * ++grub_squash_read_symlink (grub_fshelp_node_t node) ++{ ++ char *ret; ++ grub_err_t err; ++ ret = grub_malloc (grub_le_to_cpu32 (node->ino.symlink.namelen) + 1); ++ ++ err = read_chunk (node->data->disk, ret, ++ grub_le_to_cpu32 (node->ino.symlink.namelen), ++ grub_le_to_cpu64 (node->data->sb.inodeoffset) ++ + node->ino_chunk, ++ node->ino_offset + (node->ino.symlink.name ++ - (char *) &node->ino)); ++ if (err) ++ { ++ grub_free (ret); ++ return NULL; ++ } ++ ret[grub_le_to_cpu32 (node->ino.symlink.namelen)] = 0; ++ return ret; ++} ++ ++static int ++grub_squash_iterate_dir (grub_fshelp_node_t dir, ++ int NESTED_FUNC_ATTR ++ (*hook) (const char *filename, ++ enum grub_fshelp_filetype filetype, ++ grub_fshelp_node_t node)) ++{ ++ grub_uint32_t off = grub_le_to_cpu16 (dir->ino.dir.offset); ++ grub_uint32_t endoff; ++ unsigned i; ++ ++ /* FIXME: why - 3 ? */ ++ endoff = grub_le_to_cpu32 (dir->ino.dir.size) + off - 3; ++ ++ while (off < endoff) ++ { ++ struct grub_squash_dirent_header dh; ++ grub_err_t err; ++ ++ err = read_chunk (dir->data->disk, &dh, sizeof (dh), ++ grub_le_to_cpu64 (dir->data->sb.diroffset) ++ + grub_le_to_cpu32 (dir->ino.dir.chunk), off); ++ if (err) ++ return 0; ++ off += sizeof (dh); ++ for (i = 0; i < (unsigned) grub_le_to_cpu16 (dh.nelems) + 1; i++) ++ { ++ char *buf; ++ int r; ++ struct grub_fshelp_node *node; ++ enum grub_fshelp_filetype filetype = GRUB_FSHELP_REG; ++ struct grub_squash_dirent di; ++ struct grub_squash_inode ino; ++ ++ err = read_chunk (dir->data->disk, &di, sizeof (di), ++ grub_le_to_cpu64 (dir->data->sb.diroffset) ++ + grub_le_to_cpu32 (dir->ino.dir.chunk), off); ++ if (err) ++ return 0; ++ off += sizeof (di); ++ ++ err = read_chunk (dir->data->disk, &ino, sizeof (ino), ++ grub_le_to_cpu64 (dir->data->sb.inodeoffset) ++ + grub_le_to_cpu32 (dh.ino_chunk), ++ grub_cpu_to_le16 (di.ino_offset)); ++ if (err) ++ return 0; ++ ++ buf = grub_malloc (grub_le_to_cpu16 (di.namelen) + 2); ++ if (!buf) ++ return 0; ++ err = read_chunk (dir->data->disk, buf, ++ grub_le_to_cpu16 (di.namelen) + 1, ++ grub_le_to_cpu64 (dir->data->sb.diroffset) ++ + grub_le_to_cpu32 (dir->ino.dir.chunk), off); ++ if (err) ++ return 0; ++ ++ off += grub_le_to_cpu16 (di.namelen) + 1; ++ buf[grub_le_to_cpu16 (di.namelen) + 1] = 0; ++ if (grub_le_to_cpu16 (di.type) == SQUASH_TYPE_DIR) ++ filetype = GRUB_FSHELP_DIR; ++ if (grub_le_to_cpu16 (di.type) == SQUASH_TYPE_SYMLINK) ++ filetype = GRUB_FSHELP_SYMLINK; ++ ++ node = grub_malloc (sizeof (*node)); ++ if (! node) ++ return 0; ++ *node = *dir; ++ node->ino = ino; ++ node->ino_chunk = grub_le_to_cpu32 (dh.ino_chunk); ++ node->ino_offset = grub_le_to_cpu16 (di.ino_offset); ++ ++ r = hook (buf, filetype, node); ++ ++ grub_free (buf); ++ if (r) ++ return r; ++ } ++ } ++ return 0; ++} ++ ++static grub_err_t ++make_root_node (struct grub_squash_data *data, struct grub_fshelp_node *root) ++{ ++ grub_memset (root, 0, sizeof (*root)); ++ root->data = data; ++ ++ return read_chunk (data->disk, &root->ino, sizeof (root->ino), ++ grub_le_to_cpu64 (data->sb.inodeoffset) ++ + grub_le_to_cpu16 (data->sb.root_ino_chunk), ++ grub_cpu_to_le16 (data->sb.root_ino_offset)); ++} ++ ++static grub_err_t ++grub_squash_dir (grub_device_t device, const char *path, ++ int (*hook) (const char *filename, ++ const struct grub_dirhook_info *info)) ++{ ++ auto int NESTED_FUNC_ATTR iterate (const char *filename, ++ enum grub_fshelp_filetype filetype, ++ grub_fshelp_node_t node); ++ ++ int NESTED_FUNC_ATTR iterate (const char *filename, ++ enum grub_fshelp_filetype filetype, ++ grub_fshelp_node_t node) ++ { ++ struct grub_dirhook_info info; ++ grub_memset (&info, 0, sizeof (info)); ++ info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR); ++ info.mtimeset = 1; ++ info.mtime = grub_le_to_cpu32 (node->ino.mtime); ++ return hook (filename, &info); ++ } ++ ++ struct grub_squash_data *data = 0; ++ struct grub_fshelp_node *fdiro = 0; ++ struct grub_fshelp_node root; ++ grub_err_t err; ++ ++ data = squash_mount (device->disk); ++ if (! data) ++ return grub_errno; ++ ++ err = make_root_node (data, &root); ++ if (err) ++ return err; ++ ++ grub_fshelp_find_file (path, &root, &fdiro, grub_squash_iterate_dir, ++ grub_squash_read_symlink, GRUB_FSHELP_DIR); ++ if (!grub_errno) ++ grub_squash_iterate_dir (fdiro, iterate); ++ ++ grub_free (data); ++ ++ return grub_errno; ++} ++ ++static grub_err_t ++grub_squash_open (struct grub_file *file, const char *name) ++{ ++ struct grub_squash_data *data = 0; ++ struct grub_fshelp_node *fdiro = 0; ++ struct grub_fshelp_node root; ++ grub_err_t err; ++ ++ data = squash_mount (file->device->disk); ++ if (! data) ++ return grub_errno; ++ ++ err = make_root_node (data, &root); ++ if (err) ++ return err; ++ ++ grub_fshelp_find_file (name, &root, &fdiro, grub_squash_iterate_dir, ++ grub_squash_read_symlink, GRUB_FSHELP_REG); ++ if (grub_errno) ++ { ++ grub_free (data); ++ return grub_errno; ++ } ++ ++ file->data = data; ++ data->ino = fdiro->ino; ++ file->size = grub_le_to_cpu32 (fdiro->ino.file.size); ++ ++ return GRUB_ERR_NONE; ++} ++ ++static grub_ssize_t ++grub_squash_read_data (struct grub_squash_data *data, ++ grub_disk_t disk, const struct grub_squash_inode *ino, ++ grub_off_t off, char *buf, grub_size_t len) ++{ ++ grub_err_t err; ++ grub_uint64_t a, b; ++ int compressed = 0; ++ ++ if (grub_le_to_cpu16 (ino->file.fragment) == 0xffff) ++ { ++ if (grub_le_to_cpu32 (ino->file.chunk)) ++ a = grub_le_to_cpu32 (ino->file.chunk); ++ else ++ a = sizeof (struct grub_squash_super); ++ compressed = !(data->sb.flags & SQUASH_FLAG_UNCOMPRESSED_DATA); ++ } ++ else ++ { ++ struct grub_squash_frag_desc frag; ++ err = read_chunk (disk, &frag, sizeof (frag), ++ data->fragments, sizeof (frag) ++ * grub_le_to_cpu16 (ino->file.fragment)); ++ if (err) ++ return -1; ++ a = grub_le_to_cpu64 (frag.offset) + grub_le_to_cpu32 (ino->file.chunk); ++ compressed = !(data->sb.flags & SQUASH_FLAG_UNCOMPRESSED_FRAGMENTS); ++ } ++ ++ b = grub_le_to_cpu32 (data->ino.file.offset) + off; ++ ++ /* FIXME: cache uncompressed chunks. */ ++ if (compressed) ++ err = grub_zlib_disk_read (disk, a, b, buf, len); ++ else ++ err = grub_disk_read (disk, (a + b) >> GRUB_DISK_SECTOR_BITS, ++ (a + b) & (GRUB_DISK_SECTOR_SIZE - 1), len, buf); ++ if (err) ++ return -1; ++ return len; ++} ++ ++static grub_ssize_t ++grub_squash_read (grub_file_t file, char *buf, grub_size_t len) ++{ ++ struct grub_squash_data *data = file->data; ++ ++ return grub_squash_read_data (data, file->device->disk, &data->ino, ++ file->offset, buf, len); ++} ++ ++static grub_err_t ++grub_squash_close (grub_file_t file) ++{ ++ grub_free (file->data); ++ return GRUB_ERR_NONE; ++} ++ ++static grub_err_t ++grub_squash_mtime (grub_device_t dev, grub_int32_t *tm) ++{ ++ struct grub_squash_data *data = 0; ++ ++ data = squash_mount (dev->disk); ++ if (! data) ++ return grub_errno; ++ *tm = grub_le_to_cpu32 (data->sb.creation_time); ++ grub_free (data); ++ return GRUB_ERR_NONE; ++} ++ ++static struct grub_fs grub_squash_fs = ++ { ++ .name = "squash4", ++ .dir = grub_squash_dir, ++ .open = grub_squash_open, ++ .read = grub_squash_read, ++ .close = grub_squash_close, ++ .mtime = grub_squash_mtime, ++#ifdef GRUB_UTIL ++ .reserved_first_sector = 0, ++#endif ++ .next = 0 ++ }; ++ ++GRUB_MOD_INIT(squash4) ++{ ++ grub_fs_register (&grub_squash_fs); ++} ++ ++GRUB_MOD_FINI(squash4) ++{ ++ grub_fs_unregister (&grub_squash_fs); ++} ++ +Index: b/grub-core/io/gzio.c +=================================================================== +--- a/grub-core/io/gzio.c ++++ b/grub-core/io/gzio.c +@@ -41,6 +41,7 @@ + #include + #include + #include ++#include + #include + + GRUB_MOD_LICENSE ("GPLv3+"); +@@ -64,6 +65,9 @@ + /* If input is in memory following fields are used instead of file. */ + grub_size_t mem_input_size, mem_input_off; + grub_uint8_t *mem_input; ++ grub_disk_addr_t disk_input_off; ++ grub_disk_addr_t disk_input_start; ++ grub_disk_t disk_input; + /* The offset at which the data starts in the underlying file. */ + grub_off_t data_offset; + /* The type of current block. */ +@@ -384,8 +388,21 @@ + return 0; + } + +- if (grub_file_tell (gzio->file) == (grub_off_t) gzio->data_offset +- || gzio->inbuf_d == INBUFSIZ) ++ if (gzio->disk_input && (gzio->disk_input_off == gzio->data_offset ++ || gzio->inbuf_d == INBUFSIZ)) ++ { ++ grub_disk_addr_t d = gzio->disk_input_start + gzio->disk_input_off; ++ gzio->inbuf_d = 0; ++ grub_disk_read (gzio->disk_input, ++ d >> GRUB_DISK_SECTOR_BITS, ++ d & (GRUB_DISK_SECTOR_SIZE - 1), ++ INBUFSIZ, gzio->inbuf); ++ gzio->disk_input_off += INBUFSIZ; ++ } ++ ++ if (gzio->file && (grub_file_tell (gzio->file) ++ == (grub_off_t) gzio->data_offset ++ || gzio->inbuf_d == INBUFSIZ)) + { + gzio->inbuf_d = 0; + grub_file_read (gzio->file, gzio->inbuf, INBUFSIZ); +@@ -403,8 +420,10 @@ + grub_error (GRUB_ERR_OUT_OF_RANGE, + "attempt to seek outside of the file"); + else +- gzio->mem_input_off = gzio->data_offset; ++ gzio->mem_input_off = off; + } ++ else if (gzio->disk_input) ++ gzio->disk_input_off = off; + else + grub_file_seek (gzio->file, off); + } +@@ -1298,6 +1317,34 @@ + return ret; + } + ++grub_err_t ++grub_zlib_disk_read (grub_disk_t disk, grub_disk_addr_t zlibstart, ++ grub_off_t off, char *outbuf, grub_size_t outsize) ++{ ++ grub_gzio_t gzio = 0; ++ grub_ssize_t ret; ++ ++ gzio = grub_zalloc (sizeof (*gzio)); ++ if (! gzio) ++ return -1; ++ ++ gzio->disk_input_off = 0; ++ gzio->disk_input_start = zlibstart; ++ gzio->disk_input = disk; ++ ++ if (!test_zlib_header (gzio)) ++ { ++ grub_free (gzio); ++ return -1; ++ } ++ ++ ret = grub_gzio_read_real (gzio, off, outbuf, outsize); ++ grub_free (gzio); ++ ++ /* FIXME: Check Adler. */ ++ return ret < 0 ? grub_errno : GRUB_ERR_NONE; ++} ++ + + + static struct grub_fs grub_gzio_fs = +Index: b/include/grub/deflate.h +=================================================================== +--- a/include/grub/deflate.h ++++ b/include/grub/deflate.h +@@ -23,4 +23,8 @@ + grub_zlib_decompress (char *inbuf, grub_size_t insize, grub_off_t off, + char *outbuf, grub_size_t outsize); + ++grub_err_t ++grub_zlib_disk_read (grub_disk_t disk, grub_disk_addr_t zlibstart, ++ grub_off_t off, char *outbuf, grub_size_t outsize); ++ + #endif diff --git a/master/debian/btrfs_stat.patch b/master/debian/btrfs_stat.patch new file mode 100644 index 0000000..7e162e6 --- /dev/null +++ b/master/debian/btrfs_stat.patch @@ -0,0 +1,36 @@ +Description: Cope with btrfs / inside an encrypted block device + If / is inside an encrypted block device, then grub-probe can't tell what + its filesystem type is. Work around this. +Author: alexeagar@gmail.com +Bug-Ubuntu: https://bugs.launchpad.net/bugs/757631 +Forwarded: no +Last-Update: 2011-06-15 + +Index: b/util/grub.d/10_linux.in +=================================================================== +--- a/util/grub.d/10_linux.in ++++ b/util/grub.d/10_linux.in +@@ -56,7 +56,8 @@ + LINUX_ROOT_DEVICE=UUID=${GRUB_DEVICE_UUID} + fi + +-if [ "x`${grub_probe} --device ${GRUB_DEVICE} --target=fs 2>/dev/null || true`" = xbtrfs ]; then ++if [ "x`${grub_probe} --device ${GRUB_DEVICE} --target=fs 2>/dev/null || true`" = xbtrfs ] \ ++ || [ "x`stat -f --printf=%T /`" = xbtrfs ]; then + rootsubvol="`make_system_path_relative_to_its_root /`" + rootsubvol="${rootsubvol#/}" + if [ "x${rootsubvol}" != x ]; then +Index: b/util/grub.d/20_linux_xen.in +=================================================================== +--- a/util/grub.d/20_linux_xen.in ++++ b/util/grub.d/20_linux_xen.in +@@ -56,7 +56,8 @@ + LINUX_ROOT_DEVICE=UUID=${GRUB_DEVICE_UUID} + fi + +-if [ "x`${grub_probe} --device ${GRUB_DEVICE} --target=fs 2>/dev/null || true`" = xbtrfs ]; then ++if [ "x`${grub_probe} --device ${GRUB_DEVICE} --target=fs 2>/dev/null || true`" = xbtrfs ] \ ++ || [ "x`stat -f --printf=%T /`" = xbtrfs ]; then + rootsubvol="`make_system_path_relative_to_its_root /`" + rootsubvol="${rootsubvol#/}" + if [ "x${rootsubvol}" != x ]; then diff --git a/master/debian/core_in_fs.patch b/master/debian/core_in_fs.patch new file mode 100644 index 0000000..7b597ea --- /dev/null +++ b/master/debian/core_in_fs.patch @@ -0,0 +1,31 @@ +Index: b/util/grub-setup.c +=================================================================== +--- a/util/grub-setup.c ++++ b/util/grub-setup.c +@@ -76,6 +76,7 @@ + + #define DEFAULT_BOOT_FILE "boot.img" + #define DEFAULT_CORE_FILE "core.img" ++#define CORE_IMG_IN_FS "setup_left_core_image_in_filesystem" + + #ifdef GRUB_MACHINE_SPARC64 + #define grub_target_to_host16(x) grub_be_to_cpu16(x) +@@ -489,6 +490,8 @@ + + grub_free (sectors); + ++ unlink (DEFAULT_DIRECTORY "/" CORE_IMG_IN_FS); ++ + goto finish; + } + #endif +@@ -514,6 +517,9 @@ + /* The core image must be put on a filesystem unfortunately. */ + grub_util_info ("will leave the core image on the filesystem"); + ++ fp = fopen (DEFAULT_DIRECTORY "/" CORE_IMG_IN_FS, "w"); ++ fclose (fp); ++ + /* Make sure that GRUB reads the identical image as the OS. */ + tmp_img = xmalloc (core_size); + core_path_dev_full = grub_util_get_path (dir, core_file); diff --git a/master/debian/dirlen.patch b/master/debian/dirlen.patch new file mode 100644 index 0000000..1268456 --- /dev/null +++ b/master/debian/dirlen.patch @@ -0,0 +1,19 @@ +Description: Ignore entries with direct.inode = 0. +Author: Samuel Thibault +Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3749 +Forwarded: not-needed +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3749 +Last-Update: 2012-06-08 + +--- a/grub-core/fs/ext2.c 2012-01-14 10:30:43 +0000 ++++ b/grub-core/fs/ext2.c 2012-01-14 10:55:20 +0000 +@@ -685,7 +685,7 @@ grub_ext2_iterate_dir (grub_fshelp_node_ + if (dirent.direntlen == 0) + return 0; + +- if (dirent.namelen != 0) ++ if (dirent.inode != 0 && dirent.namelen != 0) + { + char filename[dirent.namelen + 1]; + struct grub_fshelp_node *fdiro; + diff --git a/master/debian/disable_floppies.patch b/master/debian/disable_floppies.patch new file mode 100644 index 0000000..6bb2862 --- /dev/null +++ b/master/debian/disable_floppies.patch @@ -0,0 +1,28 @@ + +Author: Robert Millan + +An ugly kludge. Should this be merged upstream? + +Index: b/grub-core/kern/emu/hostdisk.c +=================================================================== +--- a/grub-core/kern/emu/hostdisk.c ++++ b/grub-core/kern/emu/hostdisk.c +@@ -1077,6 +1077,18 @@ + continue; + } + ++ if (! strncmp (p, "/dev/fd", sizeof ("/dev/fd") - 1)) ++ { ++ char *q = p + sizeof ("/dev/fd") - 1; ++ if (*q >= '0' && *q <= '9') ++ { ++ free (map[drive].drive); ++ map[drive].drive = NULL; ++ grub_util_info ("`%s' looks like a floppy drive, skipping", p); ++ continue; ++ } ++ } ++ + #ifdef __linux__ + /* On Linux, the devfs uses symbolic links horribly, and that + confuses the interface very much, so use realpath to expand diff --git a/master/debian/dpkg_version_comparison.patch b/master/debian/dpkg_version_comparison.patch new file mode 100644 index 0000000..6b23c61 --- /dev/null +++ b/master/debian/dpkg_version_comparison.patch @@ -0,0 +1,30 @@ +Description: Improve handling of Debian kernel version numbers +Author: Robert Millan +Forwarded: not-needed +Last-Update: 2011-04-21 + +Index: b/util/grub-mkconfig_lib.in +=================================================================== +--- a/util/grub-mkconfig_lib.in ++++ b/util/grub-mkconfig_lib.in +@@ -172,8 +172,9 @@ + + version_test_gt () + { +- local a="`echo "$1" | sed -e "s/[^-]*-//"`" +- local b="`echo "$2" | sed -e "s/[^-]*-//"`" ++ local sedexp="s/[^-]*-//;s/[._-]\(pre\|rc\|test\|git\|old\|trunk\)/~\1/g" ++ local a="`echo "$1" | sed -e "$sedexp"`" ++ local b="`echo "$2" | sed -e "$sedexp"`" + local cmp=gt + if [ "x$b" = "x" ] ; then + return 0 +@@ -183,7 +184,7 @@ + *.old:*) a="`echo -n "$a" | sed -e 's/\.old$//'`" ; cmp=gt ;; + *:*.old) b="`echo -n "$b" | sed -e 's/\.old$//'`" ; cmp=ge ;; + esac +- version_test_numeric "$a" "$cmp" "$b" ++ dpkg --compare-versions "$a" $cmp "$b" + return "$?" + } + diff --git a/master/debian/efi_disk_cache.patch b/master/debian/efi_disk_cache.patch new file mode 100644 index 0000000..478e144 --- /dev/null +++ b/master/debian/efi_disk_cache.patch @@ -0,0 +1,26 @@ +Description: Bump the values of GRUB_DISK_CACHE_SIZE and GRUB_DISK_CACHE_BITS + on EFI systems (and only on EFI sytems) to dramatically reduce the load times + for vmlinux and initrd. Forwarding this isn't required as upstream trunk + has completely rewritten how this all works. +Author: Adam Conrad +Origin: other, http://blog.fpmurphy.com/2010/03/grub2-efi-support.html +Bug-Ubuntu: https://bugs.launchpad.net/ubuntu/+source/grub2/+bug/944347 +Forwarded: not-needed +Last-Update: 2012-03-05 + +Index: b/include/grub/disk.h +=================================================================== +--- a/include/grub/disk.h ++++ b/include/grub/disk.h +@@ -137,7 +137,11 @@ + + /* The size of a disk cache in 512B units. Must be at least as big as the + largest supported sector size, currently 16K. */ ++#ifdef GRUB_MACHINE_EFI ++#define GRUB_DISK_CACHE_BITS 10 ++#else + #define GRUB_DISK_CACHE_BITS 6 ++#endif + #define GRUB_DISK_CACHE_SIZE (1 << GRUB_DISK_CACHE_BITS) + + /* Return value of grub_disk_get_size() in case disk size is unknown. */ diff --git a/master/debian/efiemu_fix.patch b/master/debian/efiemu_fix.patch new file mode 100644 index 0000000..5dba671 --- /dev/null +++ b/master/debian/efiemu_fix.patch @@ -0,0 +1,134 @@ +Description: Fix efiemu + Without this, lzo.patch causes efiemu not to be built. +Author: Vladimir Serbinenko +Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3740 +Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/4066 +Forwarded: not-needed +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3740 +Last-Update: 2012-03-19 + +Index: b/configure.ac +=================================================================== +--- a/configure.ac ++++ b/configure.ac +@@ -479,6 +479,42 @@ + esac + AC_MSG_RESULT([$TARGET_OBJ2ELF]) + ++ ++AC_ARG_ENABLE([efiemu], ++ [AS_HELP_STRING([--enable-efiemu], ++ [build and install the efiemu runtimes (default=guessed)])]) ++if test x"$enable_efiemu" = xno ; then ++ efiemu_excuse="explicitly disabled" ++fi ++if test x"$target_cpu" != xi386 ; then ++ efiemu_excuse="only available on i386" ++fi ++if test x"$platform" = xefi ; then ++ efiemu_excuse="not available on efi" ++fi ++if test x"$efiemu_excuse" = x ; then ++ AC_CACHE_CHECK([whether options required for efiemu work], grub_cv_cc_efiemu, [ ++ SAVED_CFLAGS="$CFLAGS" ++ CFLAGS="$CFLAGS -m64 -mcmodel=large -mno-red-zone -nostdlib" ++ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])], ++ [grub_cv_cc_efiemu=yes], ++ [grub_cv_cc_efiemu=no]) ++ CFLAGS="$SAVED_CFLAGS" ++ ]) ++ if test x$grub_cv_cc_efiemu = xno; then ++ efiemu_excuse="cannot compile with -m64 -mcmodel=large -mno-red-zone -nostdlib" ++ fi ++fi ++if test x"$enable_efiemu" = xyes && test x"$efiemu_excuse" != x ; then ++ AC_MSG_ERROR([efiemu runtime was explicitly requested but can't be compiled]) ++fi ++if test x"$efiemu_excuse" = x ; then ++enable_efiemu=yes ++else ++enable_efiemu=no ++fi ++AC_SUBST([enable_efiemu]) ++ + if test "x$target_m32" = x1; then + # Force 32-bit mode. + TARGET_CFLAGS="$TARGET_CFLAGS -m32" +@@ -638,39 +674,6 @@ + grub_I386_ASM_ADDR32 + fi + +-AC_ARG_ENABLE([efiemu], +- [AS_HELP_STRING([--enable-efiemu], +- [build and install the efiemu runtimes (default=guessed)])]) +-if test x"$enable_efiemu" = xno ; then +- efiemu_excuse="explicitly disabled" +-fi +-if test x"$target_cpu" != xi386 ; then +- efiemu_excuse="only available on i386" +-fi +-if test x"$platform" = xefi ; then +- efiemu_excuse="not available on efi" +-fi +-if test x"$efiemu_excuse" = x ; then +- AC_CACHE_CHECK([whether options required for efiemu work], grub_cv_cc_efiemu, [ +- CFLAGS="$CFLAGS -m64 -mcmodel=large -mno-red-zone -nostdlib" +- AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])], +- [grub_cv_cc_efiemu=yes], +- [grub_cv_cc_efiemu=no]) +- ]) +- if test x$grub_cv_cc_efiemu = xno; then +- efiemu_excuse="cannot compile with -m64 -mcmodel=large -mno-red-zone -nostdlib" +- fi +-fi +-if test x"$enable_efiemu" = xyes && test x"$efiemu_excuse" != x ; then +- AC_MSG_ERROR([efiemu runtime was explicitly requested but can't be compiled]) +-fi +-if test x"$efiemu_excuse" = x ; then +-enable_efiemu=yes +-else +-enable_efiemu=no +-fi +-AC_SUBST([enable_efiemu]) +- + if test "$platform" != emu; then + AC_CACHE_CHECK([whether -nostdinc -isystem works], [grub_cv_cc_isystem], [ + SAVED_CPPFLAGS="$CPPFLAGS" +Index: b/grub-core/efiemu/runtime/efiemu.c +=================================================================== +--- a/grub-core/efiemu/runtime/efiemu.c ++++ b/grub-core/efiemu/runtime/efiemu.c +@@ -21,6 +21,12 @@ + As it emulates only runtime serviceit isn't able + to chainload EFI bootloader on non-EFI system (TODO) */ + ++#ifdef __i386__ ++#include ++#else ++#include ++#endif ++ + #include + #include + #include +@@ -369,16 +375,16 @@ + switch (cur_relloc->size) + { + case 8: +- *((grub_uint64_t *) UINT_TO_PTR (cur_relloc->addr)) += corr; ++ *((grub_uint64_t *) (grub_addr_t) cur_relloc->addr) += corr; + break; + case 4: +- *((grub_uint32_t *) UINT_TO_PTR (cur_relloc->addr)) += corr; ++ *((grub_uint32_t *) (grub_addr_t) cur_relloc->addr) += corr; + break; + case 2: +- *((grub_uint16_t *) UINT_TO_PTR (cur_relloc->addr)) += corr; ++ *((grub_uint16_t *) (grub_addr_t) cur_relloc->addr) += corr; + break; + case 1: +- *((grub_uint8_t *) UINT_TO_PTR (cur_relloc->addr)) += corr; ++ *((grub_uint8_t *) (grub_addr_t) cur_relloc->addr) += corr; + break; + } + } diff --git a/master/debian/fat_uuid.patch b/master/debian/fat_uuid.patch new file mode 100644 index 0000000..b7c0a46 --- /dev/null +++ b/master/debian/fat_uuid.patch @@ -0,0 +1,25 @@ +Description: Make FAT UUID uppercase to match Linux +Author: Vladimir Serbinenko +Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3482 +Bug-Ubuntu: https://bugs.launchpad.net/bugs/948716 +Forwarded: not-needed +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3482 +Last-Update: 2012-03-19 + +Index: b/grub-core/fs/fat.c +=================================================================== +--- a/grub-core/fs/fat.c ++++ b/grub-core/fs/fat.c +@@ -836,9 +836,12 @@ + data = grub_fat_mount (disk); + if (data) + { ++ char *ptr; + *uuid = grub_xasprintf ("%04x-%04x", + (grub_uint16_t) (data->uuid >> 16), + (grub_uint16_t) data->uuid); ++ for (ptr = *uuid; ptr && *ptr; ptr++) ++ *ptr = grub_toupper (*ptr); + } + else + *uuid = NULL; diff --git a/master/debian/gcc_4_6_space.patch b/master/debian/gcc_4_6_space.patch new file mode 100644 index 0000000..7aaa536 --- /dev/null +++ b/master/debian/gcc_4_6_space.patch @@ -0,0 +1,33 @@ +Description: Build with -fno-asynchronous-unwind-tables to save space +Author: Vladimir Serbinenko +Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3589 +Last-Update: 2012-03-06 + +Index: b/configure.ac +=================================================================== +--- a/configure.ac ++++ b/configure.ac +@@ -415,6 +415,23 @@ + fi + fi + ++# By default, GCC 4.6 generates .eh_frame sections containing unwind ++# information in some cases where it previously did not. GRUB doesn't need ++# these and they just use up vital space. Restore the old compiler ++# behaviour. ++AC_CACHE_CHECK([whether -fno-asynchronous-unwind-tables works], [grub_cv_cc_fno_asynchronous_unwind_tables], [ ++ SAVE_CFLAGS="$CFLAGS" ++ CFLAGS="$CFLAGS -fno-dwarf2-cfi-asm" ++ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])], ++ [grub_cv_cc_fno_asynchronous_unwind_tables=yes], ++ [grub_cv_cc_fno_asynchronous_unwind_tables=no]) ++ CFLAGS="$SAVE_CFLAGS" ++]) ++ ++if test "x$grub_cv_cc_fno_asynchronous_unwind_tables" = xyes; then ++ TARGET_CFLAGS="$TARGET_CFLAGS -fno-asynchronous-unwind-tables" ++fi ++ + grub_apple_target_cc + if test x$grub_cv_apple_target_cc = xyes ; then + TARGET_CPPFLAGS="$TARGET_CPPFLAGS -DAPPLE_CC=1" diff --git a/master/debian/gfxpayload_keep_default.patch b/master/debian/gfxpayload_keep_default.patch new file mode 100644 index 0000000..43cfb6f --- /dev/null +++ b/master/debian/gfxpayload_keep_default.patch @@ -0,0 +1,38 @@ +Description: Disable gfxpayload=keep by default + Setting gfxpayload=keep has been known to cause efifb to be inappropriately + enabled. In any case, with the current Linux kernel the result of this + option is that early kernelspace will be unable to print anything to the + console, so (for example) if boot fails and you end up dumped to an + initramfs prompt, you won't be able to see anything on the screen. As such + it shouldn't be enabled by default in Debian, no matter what kernel options + are enabled. + . + gfxpayload=keep is a good idea but rather ahead of its time ... +Author: Colin Watson +Bug-Debian: http://bugs.debian.org/567245 +Forwarded: no +Last-Update: 2010-03-09 + +Index: b/util/grub.d/10_linux.in +=================================================================== +--- a/util/grub.d/10_linux.in ++++ b/util/grub.d/10_linux.in +@@ -77,17 +77,7 @@ + + # Use ELILO's generic "efifb" when it's known to be available. + # FIXME: We need an interface to select vesafb in case efifb can't be used. +- if [ "x$GRUB_GFXPAYLOAD_LINUX" = x ]; then +- cat << EOF +- load_video +-EOF +- if grep -qx "CONFIG_FB_EFI=y" "${config}" 2> /dev/null \ +- && grep -qx "CONFIG_VT_HW_CONSOLE_BINDING=y" "${config}" 2> /dev/null; then +- cat << EOF +- set gfxpayload=keep +-EOF +- fi +- else ++ if [ "x$GRUB_GFXPAYLOAD_LINUX" != x ]; then + if [ "x$GRUB_GFXPAYLOAD_LINUX" != xtext ]; then + cat << EOF + load_video diff --git a/master/debian/gfxterm_background.patch b/master/debian/gfxterm_background.patch new file mode 100644 index 0000000..6fa0ff8 --- /dev/null +++ b/master/debian/gfxterm_background.patch @@ -0,0 +1,69 @@ +Description: Fix gfxterm background_color regression +Author: Colin Watson +Forwarded: http://lists.gnu.org/archive/html/grub-devel/2011-06/msg00085.html +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3368 +Last-Update: 2011-06-28 + +Index: b/grub-core/term/gfxterm.c +=================================================================== +--- a/grub-core/term/gfxterm.c ++++ b/grub-core/term/gfxterm.c +@@ -131,6 +131,7 @@ + static unsigned int bitmap_height; + static struct grub_video_bitmap *bitmap; + static int blend_text_bg; ++static grub_video_rgba_color_t default_bg_color = { 0, 0, 0, 0 }; + + static struct grub_dirty_region dirty_region; + +@@ -266,7 +267,8 @@ + + grub_video_set_active_render_target (render_target); + +- virtual_screen.bg_color_display = grub_video_map_rgba(0, 0, 0, 0); ++ virtual_screen.bg_color_display = ++ grub_video_map_rgba_color (default_bg_color); + + /* Clear out text buffer. */ + for (i = 0; i < virtual_screen.columns * virtual_screen.rows; i++) +@@ -338,8 +340,8 @@ + double_redraw = mode_info.mode_type & GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED + && !(mode_info.mode_type & GRUB_VIDEO_MODE_TYPE_UPDATING_SWAP); + +- /* Make sure screen is black. */ +- color = grub_video_map_rgb (0, 0, 0); ++ /* Make sure screen is set to the default background color. */ ++ color = grub_video_map_rgba_color (default_bg_color); + grub_video_fill_rect (color, 0, 0, mode_info.width, mode_info.height); + if (double_redraw) + { +@@ -1189,7 +1191,6 @@ + grub_gfxterm_background_color_cmd (grub_command_t cmd __attribute__ ((unused)), + int argc, char **args) + { +- grub_video_rgba_color_t color; + struct grub_video_render_target *old_target; + + if (argc != 1) +@@ -1199,7 +1200,7 @@ + if (grub_video_get_info (NULL) != GRUB_ERR_NONE) + return grub_errno; + +- if (grub_video_parse_color (args[0], &color) != GRUB_ERR_NONE) ++ if (grub_video_parse_color (args[0], &default_bg_color) != GRUB_ERR_NONE) + return grub_errno; + + /* Destroy existing background bitmap if loaded. */ +@@ -1216,9 +1217,10 @@ + compatible with the text layer. */ + grub_video_get_active_render_target (&old_target); + grub_video_set_active_render_target (text_layer); +- virtual_screen.bg_color = grub_video_map_rgba_color (color); ++ virtual_screen.bg_color = grub_video_map_rgba_color (default_bg_color); + grub_video_set_active_render_target (old_target); +- virtual_screen.bg_color_display = grub_video_map_rgba_color (color); ++ virtual_screen.bg_color_display = ++ grub_video_map_rgba_color (default_bg_color); + blend_text_bg = 1; + + /* Mark whole screen as dirty. */ diff --git a/master/debian/grub.cfg_400.patch b/master/debian/grub.cfg_400.patch new file mode 100644 index 0000000..1ac8d44 --- /dev/null +++ b/master/debian/grub.cfg_400.patch @@ -0,0 +1,15 @@ +Index: b/util/grub-mkconfig.in +=================================================================== +--- a/util/grub-mkconfig.in ++++ b/util/grub-mkconfig.in +@@ -293,6 +293,10 @@ + esac + done + ++if [ "x${grub_cfg}" != "x" ] && ! grep "^password " ${grub_cfg}.new >/dev/null; then ++ chmod 444 ${grub_cfg}.new || true ++fi ++ + if test "x${grub_cfg}" != "x" ; then + if ! ${grub_script_check} ${grub_cfg}.new; then + echo "Syntax errors are detected in generated GRUB config file." >&2 diff --git a/master/debian/grub_legacy_0_based_partitions.patch b/master/debian/grub_legacy_0_based_partitions.patch new file mode 100644 index 0000000..f245434 --- /dev/null +++ b/master/debian/grub_legacy_0_based_partitions.patch @@ -0,0 +1,43 @@ +Index: b/grub-core/kern/emu/hostdisk.c +=================================================================== +--- a/grub-core/kern/emu/hostdisk.c ++++ b/grub-core/kern/emu/hostdisk.c +@@ -1131,7 +1131,7 @@ + char *bsd_part_str = NULL; + + if (dos_part >= 0) +- dos_part_str = xasprintf (",%d", dos_part + 1); ++ dos_part_str = xasprintf (",%d", dos_part + (getenv ("GRUB_LEGACY_0_BASED_PARTITIONS") ? 0 : 1)); + + if (bsd_part >= 0) + bsd_part_str = xasprintf (",%d", bsd_part + 1); +@@ -1619,6 +1619,29 @@ + + if (start == part_start) + { ++ if (getenv ("GRUB_LEGACY_0_BASED_PARTITIONS")) ++ { ++ int dos_part, bsd_part; ++ char *fullname, *comma; ++ ++ if (partition->parent) ++ { ++ dos_part = partition->parent->number; ++ bsd_part = partition->number; ++ } ++ else ++ { ++ dos_part = partition->number; ++ bsd_part = -1; ++ } ++ ++ fullname = make_device_name (drive, dos_part, bsd_part); ++ comma = strchr (fullname, ','); ++ partname = comma ? xstrdup (comma + 1) : NULL; ++ free (fullname); ++ return 1; ++ } ++ + partname = grub_partition_get_name (partition); + return 1; + } diff --git a/master/debian/handle_new_autotools.patch b/master/debian/handle_new_autotools.patch new file mode 100644 index 0000000..91f72b4 --- /dev/null +++ b/master/debian/handle_new_autotools.patch @@ -0,0 +1,535 @@ +Description: Handle new autotools, and add some missing quotes in the process + Backported by Colin Watson; I modified this to keep update-grub_lib in + place until such time as we upgrade to a newer upstream snapshot. +Author: Vladimir Serbinenko +Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3766 +Last-Update: 2012-01-31 + +Index: b/Makefile.am +=================================================================== +--- a/Makefile.am ++++ b/Makefile.am +@@ -101,8 +101,8 @@ + # Install config.h into platformdir + platform_HEADERS = config.h + +-pkglib_DATA += grub-mkconfig_lib +-pkglib_DATA += update-grub_lib ++pkgdata_DATA += grub-mkconfig_lib ++pkgdata_DATA += update-grub_lib + + + if COND_i386_coreboot +Index: b/conf/Makefile.common +=================================================================== +--- a/conf/Makefile.common ++++ b/conf/Makefile.common +@@ -137,7 +137,7 @@ + + man_MANS = + noinst_DATA = +-pkglib_DATA = ++pkgdata_DATA = + bin_SCRIPTS = + sbin_SCRIPTS = + bin_PROGRAMS = +@@ -147,7 +147,6 @@ + grubconf_DATA = + check_PROGRAMS = + noinst_SCRIPTS = +-pkglib_SCRIPTS = + noinst_PROGRAMS = + grubconf_SCRIPTS = + noinst_LIBRARIES = +Index: b/tests/util/grub-shell-tester.in +=================================================================== +--- a/tests/util/grub-shell-tester.in ++++ b/tests/util/grub-shell-tester.in +@@ -19,18 +19,17 @@ + # Initialize some variables. + transform="@program_transform_name@" + +-prefix=@prefix@ +-exec_prefix=@exec_prefix@ +-bindir=@bindir@ +-libdir=@libdir@ +-builddir=@builddir@ ++prefix="@prefix@" ++exec_prefix="@exec_prefix@" ++datarootdir="@datarootdir@" ++builddir="@builddir@" + PACKAGE_NAME=@PACKAGE_NAME@ + PACKAGE_TARNAME=@PACKAGE_TARNAME@ + PACKAGE_VERSION=@PACKAGE_VERSION@ + target_cpu=@target_cpu@ + + # Force build directory components +-PATH=${builddir}:$PATH ++PATH="${builddir}:$PATH" + export PATH + + # Usage: usage +@@ -85,23 +84,23 @@ + if [ "x${source}" = x ] ; then + tmpfile=`mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` || exit 1 + while read REPLY; do +- echo $REPLY >> ${tmpfile} ++ echo $REPLY >> "${tmpfile}" + done +- source=${tmpfile} ++ source="${tmpfile}" + fi + + outfile1=`mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` || exit 1 +-@builddir@/grub-shell --qemu-opts="${qemuopts}" --modules=${modules} ${source} >${outfile1} ++"@builddir@/grub-shell" --qemu-opts="${qemuopts}" --modules=${modules} "${source}" >"${outfile1}" + + outfile2=`mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` || exit 1 +-bash ${source} >${outfile2} ++bash "${source}" >"${outfile2}" + +-if ! diff -q ${outfile1} ${outfile2} >/dev/null ++if ! diff -q "${outfile1}" "${outfile2}" >/dev/null + then + echo "${source}: GRUB and BASH outputs did not match (see diff -u ${outfile1} ${outfile2})" + status=1 + else +- rm -f ${outfile1} ${outfile2} ++ rm -f "${outfile1}" "${outfile2}" + fi + + exit $status +Index: b/tests/util/grub-shell.in +=================================================================== +--- a/tests/util/grub-shell.in ++++ b/tests/util/grub-shell.in +@@ -19,11 +19,10 @@ + # Initialize some variables. + transform="@program_transform_name@" + +-prefix=@prefix@ +-exec_prefix=@exec_prefix@ +-bindir=@bindir@ +-libdir=@libdir@ +-builddir=@builddir@ ++prefix="@prefix@" ++exec_prefix="@exec_prefix@" ++datarootdir="@datarootdir@" ++builddir="@builddir@" + PACKAGE_NAME=@PACKAGE_NAME@ + PACKAGE_TARNAME=@PACKAGE_TARNAME@ + PACKAGE_VERSION=@PACKAGE_VERSION@ +@@ -31,7 +30,7 @@ + platform=@platform@ + + # Force build directory components +-PATH=${builddir}:$PATH ++PATH="${builddir}:$PATH" + export PATH + + # Usage: usage +@@ -140,9 +139,9 @@ + + isofile=`mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` || exit 1 + if [ x$boot != xnet ]; then +- sh @builddir@/grub-mkrescue --grub-mkimage=${builddir}/grub-mkimage --output=${isofile} --override-directory=${builddir}/grub-core \ ++ sh "@builddir@/grub-mkrescue" "--grub-mkimage=${builddir}/grub-mkimage" "--output=${isofile}" "--override-directory=${builddir}/grub-core" \ + --rom-directory="${rom_directory}" \ +- /boot/grub/grub.cfg=${cfgfile} /boot/grub/testcase.cfg=${source} \ ++ "/boot/grub/grub.cfg=${cfgfile}" "/boot/grub/testcase.cfg=${source}" \ + ${files} >/dev/null 2>&1 + fi + if [ x$boot = xhd ]; then +@@ -173,12 +172,12 @@ + + if [ x$boot = xnet ]; then + netdir=`mktemp -d "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` || exit 1 +- sh @builddir@/grub-mknetdir --grub-mkimage=${builddir}/grub-mkimage --override-directory=${builddir}/grub-core --net-directory=$netdir +- cp ${cfgfile} $netdir/boot/grub/grub.cfg +- cp ${source} $netdir/boot/grub/testcase.cfg +- ${qemu} ${qemuopts} -nographic -serial file:/dev/stdout -monitor file:/dev/null -boot n -net user,tftp=$netdir,bootfile=/boot/grub/$target_cpu-$platform/core.0 -net nic | cat | tr -d "\r" ++ sh "@builddir@/grub-mknetdir" "--grub-mkimage=${builddir}/grub-mkimage" "--override-directory=${builddir}/grub-core" "--net-directory=$netdir" ++ cp "${cfgfile}" "$netdir/boot/grub/grub.cfg" ++ cp "${source}" "$netdir/boot/grub/testcase.cfg" ++ "${qemu}" ${qemuopts} -nographic -serial file:/dev/stdout -monitor file:/dev/null -boot n -net "user,tftp=$netdir,bootfile=/boot/grub/$target_cpu-$platform/core.0" -net nic | cat | tr -d "\r" + else +- ${qemu} ${qemuopts} -nographic -serial file:/dev/stdout -monitor file:/dev/null -${device} ${isofile} ${bootdev} | cat | tr -d "\r" ++ "${qemu}" ${qemuopts} -nographic -serial file:/dev/stdout -monitor file:/dev/null -${device} ${isofile} ${bootdev} | cat | tr -d "\r" + fi + rm -f "${isofile}" "${imgfile}" + rm -rf "${rom_directory}" +Index: b/util/grub-install.in +=================================================================== +--- a/util/grub-install.in ++++ b/util/grub-install.in +@@ -21,6 +21,7 @@ + + prefix="@prefix@" + exec_prefix="@exec_prefix@" ++datarootdir="@datarootdir@" + sbindir="@sbindir@" + bindir="@bindir@" + libdir="@libdir@" +@@ -32,6 +33,7 @@ + platform=@platform@ + host_os=@host_os@ + pkglibdir="${libdir}/`echo ${PACKAGE_TARNAME}/${target_cpu}-${platform} | sed ${transform}`" ++datadir="@datadir@" + localedir="@datadir@/locale" + + self="`basename $0`" +Index: b/util/grub-mkconfig.in +=================================================================== +--- a/util/grub-mkconfig.in ++++ b/util/grub-mkconfig.in +@@ -18,26 +18,27 @@ + # along with GRUB. If not, see . + + transform="@program_transform_name@" +- +-prefix=@prefix@ +-exec_prefix=@exec_prefix@ +-sbindir=@sbindir@ +-bindir=@bindir@ +-libdir=@libdir@ +-sysconfdir=@sysconfdir@ ++prefix="@prefix@" ++exec_prefix="@exec_prefix@" ++datarootdir="@datarootdir@" ++ ++prefix="@prefix@" ++exec_prefix="@exec_prefix@" ++sbindir="@sbindir@" ++bindir="@bindir@" ++sysconfdir="@sysconfdir@" + PACKAGE_NAME=@PACKAGE_NAME@ + PACKAGE_VERSION=@PACKAGE_VERSION@ + host_os=@host_os@ +-datarootdir=@datarootdir@ +-datadir=@datadir@ +-pkgdatadir=${datadir}/`echo @PACKAGE_TARNAME@ | sed "${transform}"` ++datadir="@datadir@" ++pkgdatadir="${datadir}/`echo @PACKAGE_TARNAME@ | sed "${transform}"`" + grub_cfg="" +-grub_mkconfig_dir=${sysconfdir}/grub.d ++grub_mkconfig_dir="${sysconfdir}"/grub.d + + self=`basename $0` + +-grub_mkdevicemap=${sbindir}/`echo grub-mkdevicemap | sed "${transform}"` +-grub_probe=${sbindir}/`echo grub-probe | sed "${transform}"` ++grub_mkdevicemap="${sbindir}/`echo grub-mkdevicemap | sed "${transform}"`" ++grub_probe="${sbindir}/`echo grub-probe | sed "${transform}"`" + grub_script_check="${bindir}/`echo grub-script-check | sed "${transform}"`" + + GRUB_PREFIX=`echo '/@bootdirname@/@grubdirname@' | sed "s,//*,/,g"` +@@ -95,7 +96,7 @@ + esac + done + +-. ${libdir}/grub/grub-mkconfig_lib ++. "${datadir}/grub/grub-mkconfig_lib" + + if [ "x$EUID" = "x" ] ; then + EUID=`id -u` +Index: b/util/grub-mknetdir.in +=================================================================== +--- a/util/grub-mknetdir.in ++++ b/util/grub-mknetdir.in +@@ -19,25 +19,23 @@ + # Initialize some variables. + transform="@program_transform_name@" + +-prefix=@prefix@ +-exec_prefix=@exec_prefix@ +-sbindir=@sbindir@ +-bindir=@bindir@ +-libdir=@libdir@ ++prefix="@prefix@" ++exec_prefix="@exec_prefix@" ++datarootdir="@datarootdir@" ++bindir="@bindir@" ++libdir="@libdir@" + PACKAGE_NAME=@PACKAGE_NAME@ + PACKAGE_TARNAME=@PACKAGE_TARNAME@ + PACKAGE_VERSION=@PACKAGE_VERSION@ + target_cpu=@target_cpu@ + platform=@platform@ + host_os=@host_os@ +-pkglibdir=${libdir}/`echo ${PACKAGE_TARNAME}/${target_cpu}-${platform} | sed ${transform}` +-localedir=@datadir@/locale + native_platform=@platform@ + pkglib_DATA="moddep.lst command.lst fs.lst partmap.lst parttool.lst handler.lst video.lst crypto.lst terminal.lst" + + self=`basename $0` + +-grub_mkimage=${bindir}/`echo grub-mkimage | sed ${transform}` ++grub_mkimage="${bindir}/`echo grub-mkimage | sed ${transform}`" + rootdir=/srv/tftp + grub_prefix=`echo /boot/grub | sed ${transform}` + modules= +@@ -48,7 +46,7 @@ + debug=no + debug_image= + subdir=`echo /boot/grub | sed ${transform}` +-pc_dir=${libdir}/$(echo ${PACKAGE_TARNAME} | sed ${transform})/i386-pc ++pc_dir="${libdir}/$(echo ${PACKAGE_TARNAME} | sed ${transform})/i386-pc" + + # Usage: usage + # Print the usage. +@@ -170,12 +168,12 @@ + config_opt= + mkdir -p "$grubdir" || exit 1 + +- for file in ${grubdir}/*.mod ${grubdir}/*.lst ${grubdir}/*.img ${grubdir}/efiemu??.o; do +- if test -f $file && [ "`basename $file`" != menu.lst ]; then +- rm -f $file || exit 1 ++ for file in "${grubdir}"/*.mod "${grubdir}"/*.lst "${grubdir}"/*.img "${grubdir}"/efiemu??.o; do ++ if test -f "$file" && [ "`basename $file`" != menu.lst ]; then ++ rm -f "$file" || exit 1 + fi + done +- for file in ${input_dir}/*.mod; do ++ for file in "${input_dir}"/*.mod; do + if test -f "$file"; then + cp -f "$file" "$grubdir/" + fi +@@ -213,7 +211,7 @@ + source ${subdir}/grub.cfg + EOF + +- $grub_mkimage ${config_opt} -d "${input_dir}" -O ${mkimage_target} --output=${grubdir}/core.$ext --prefix=$prefix $modules $netmodules || exit 1 ++ "$grub_mkimage" ${config_opt} -d "${input_dir}" -O ${mkimage_target} "--output=${grubdir}/core.$ext" "--prefix=$prefix" $modules $netmodules || exit 1 + echo "Netboot directory for ${platform} created. Configure your DHCP server to point to ${subdir}/${platform}/core.$ext" + } + +Index: b/util/grub-mkrescue.in +=================================================================== +--- a/util/grub-mkrescue.in ++++ b/util/grub-mkrescue.in +@@ -18,12 +18,14 @@ + # along with GRUB. If not, see . + + # Initialize some variables. ++ + transform="@program_transform_name@" + +-prefix=@prefix@ +-exec_prefix=@exec_prefix@ +-bindir=@bindir@ +-libdir=@libdir@ ++prefix="@prefix@" ++exec_prefix="@exec_prefix@" ++datarootdir="@datarootdir@" ++bindir="@bindir@" ++libdir="@libdir@" + PACKAGE_NAME=@PACKAGE_NAME@ + PACKAGE_TARNAME=@PACKAGE_TARNAME@ + PACKAGE_VERSION=@PACKAGE_VERSION@ +Index: b/util/grub.d/00_header.in +=================================================================== +--- a/util/grub.d/00_header.in ++++ b/util/grub.d/00_header.in +@@ -19,13 +19,13 @@ + + transform="@program_transform_name@" + +-prefix=@prefix@ +-exec_prefix=@exec_prefix@ +-libdir=@libdir@ ++prefix="@prefix@" ++exec_prefix="@exec_prefix@" ++datarootdir="@datarootdir@" + locale_dir=`echo ${GRUB_PREFIX}/locale | sed ${transform}` + grub_lang=`echo $LANG | cut -d . -f 1` + +-. ${libdir}/grub/grub-mkconfig_lib ++. "@datadir@/grub/grub-mkconfig_lib" + + # Do this as early as possible, since other commands might depend on it. + # (e.g. the `loadfont' command might need lvm or raid modules) +@@ -112,7 +112,7 @@ + done + + if [ "x$serial" = x1 ]; then +- if ! test -e ${GRUB_PREFIX}/serial.mod ; then ++ if ! test -e "${GRUB_PREFIX}/serial.mod" ; then + echo "Serial terminal not available on this platform." >&2 ; exit 1 + fi + +Index: b/util/grub.d/10_hurd.in +=================================================================== +--- a/util/grub.d/10_hurd.in ++++ b/util/grub.d/10_hurd.in +@@ -17,10 +17,10 @@ + # You should have received a copy of the GNU General Public License + # along with GRUB. If not, see . + +-prefix=@prefix@ +-exec_prefix=@exec_prefix@ +-libdir=@libdir@ +-. ${libdir}/grub/grub-mkconfig_lib ++prefix="@prefix@" ++exec_prefix="@exec_prefix@" ++datarootdir="@datarootdir@" ++. "@datadir@/grub/grub-mkconfig_lib" + + CLASS="--class gnu --class os" + +Index: b/util/grub.d/10_kfreebsd.in +=================================================================== +--- a/util/grub.d/10_kfreebsd.in ++++ b/util/grub.d/10_kfreebsd.in +@@ -17,14 +17,13 @@ + # You should have received a copy of the GNU General Public License + # along with GRUB. If not, see . + +-prefix=@prefix@ +-exec_prefix=@exec_prefix@ +-bindir=@bindir@ +-libdir=@libdir@ +-. ${libdir}/grub/grub-mkconfig_lib ++prefix="@prefix@" ++exec_prefix="@exec_prefix@" ++datarootdir="@datarootdir@" ++. "@datadir@/grub/grub-mkconfig_lib" + + export TEXTDOMAIN=@PACKAGE@ +-export TEXTDOMAINDIR=@localedir@ ++export TEXTDOMAINDIR="@localedir@" + + CLASS="--class os" + +Index: b/util/grub.d/10_linux.in +=================================================================== +--- a/util/grub.d/10_linux.in ++++ b/util/grub.d/10_linux.in +@@ -17,14 +17,14 @@ + # You should have received a copy of the GNU General Public License + # along with GRUB. If not, see . + +-prefix=@prefix@ +-exec_prefix=@exec_prefix@ +-bindir=@bindir@ +-libdir=@libdir@ +-. ${libdir}/grub/grub-mkconfig_lib ++prefix="@prefix@" ++exec_prefix="@exec_prefix@" ++datarootdir="@datarootdir@" ++ ++. "@datadir@/grub/grub-mkconfig_lib" + + export TEXTDOMAIN=@PACKAGE@ +-export TEXTDOMAINDIR=@localedir@ ++export TEXTDOMAINDIR="@localedir@" + + CLASS="--class gnu-linux --class gnu --class os" + +Index: b/util/grub.d/10_netbsd.in +=================================================================== +--- a/util/grub.d/10_netbsd.in ++++ b/util/grub.d/10_netbsd.in +@@ -17,14 +17,13 @@ + # You should have received a copy of the GNU General Public License + # along with GRUB. If not, see . + +-prefix=@prefix@ +-exec_prefix=@exec_prefix@ +-bindir=@bindir@ +-libdir=@libdir@ +-. ${libdir}/grub/grub-mkconfig_lib ++prefix="@prefix@" ++exec_prefix="@exec_prefix@" ++datarootdir="@datarootdir@" ++. "@datadir@/grub/grub-mkconfig_lib" + + export TEXTDOMAIN=@PACKAGE@ +-export TEXTDOMAINDIR=@localedir@ ++export TEXTDOMAINDIR="@localedir@" + + if [ "x${GRUB_DISTRIBUTOR}" = "x" ] ; then + OS="NetBSD" +Index: b/util/grub.d/10_windows.in +=================================================================== +--- a/util/grub.d/10_windows.in ++++ b/util/grub.d/10_windows.in +@@ -17,10 +17,11 @@ + # You should have received a copy of the GNU General Public License + # along with GRUB. If not, see . + +-prefix=@prefix@ +-exec_prefix=@exec_prefix@ +-libdir=@libdir@ +-. ${libdir}/grub/grub-mkconfig_lib ++prefix="@prefix@" ++exec_prefix="@exec_prefix@" ++datarootdir="@datarootdir@" ++ ++. "@datadir@/grub/grub-mkconfig_lib" + + case "`uname 2>/dev/null`" in + CYGWIN*) ;; +Index: b/util/grub.d/20_linux_xen.in +=================================================================== +--- a/util/grub.d/20_linux_xen.in ++++ b/util/grub.d/20_linux_xen.in +@@ -17,14 +17,14 @@ + # You should have received a copy of the GNU General Public License + # along with GRUB. If not, see . + +-prefix=@prefix@ +-exec_prefix=@exec_prefix@ +-bindir=@bindir@ +-libdir=@libdir@ +-. ${libdir}/grub/grub-mkconfig_lib ++prefix="@prefix@" ++exec_prefix="@exec_prefix@" ++datarootdir="@datarootdir@" ++ ++. "@datadir@/grub/grub-mkconfig_lib" + + export TEXTDOMAIN=@PACKAGE@ +-export TEXTDOMAINDIR=@localedir@ ++export TEXTDOMAINDIR="@localedir@" + + CLASS="--class gnu-linux --class gnu --class os --class xen" + +Index: b/util/grub.d/30_os-prober.in +=================================================================== +--- a/util/grub.d/30_os-prober.in ++++ b/util/grub.d/30_os-prober.in +@@ -17,11 +17,11 @@ + # You should have received a copy of the GNU General Public License + # along with GRUB. If not, see . + +-prefix=@prefix@ +-exec_prefix=@exec_prefix@ +-libdir=@libdir@ ++prefix="@prefix@" ++exec_prefix="@exec_prefix@" ++datarootdir="@datarootdir@" + +-. ${libdir}/grub/grub-mkconfig_lib ++. "@datadir@/grub/grub-mkconfig_lib" + + if [ "x${GRUB_DISABLE_OS_PROBER}" = "xtrue" ]; then + exit 0 +Index: b/util/update-grub_lib.in +=================================================================== +--- a/util/update-grub_lib.in ++++ b/util/update-grub_lib.in +@@ -14,10 +14,10 @@ + # You should have received a copy of the GNU General Public License + # along with GRUB. If not, see . + +-prefix=@prefix@ +-exec_prefix=@exec_prefix@ +-libdir=@libdir@ ++prefix="@prefix@" ++exec_prefix="@exec_prefix@" ++datarootdir="@datarootdir@" + +-. ${libdir}/grub/grub-mkconfig_lib ++. "@datadir@/grub/grub-mkconfig_lib" + + grub_warn "update-grub_lib is deprecated, use grub-mkconfig_lib instead" diff --git a/master/debian/hurd.patch b/master/debian/hurd.patch new file mode 100644 index 0000000..cb04f13 --- /dev/null +++ b/master/debian/hurd.patch @@ -0,0 +1,37 @@ +Description: Fix hurd build by disabling zfs code. +Author: Samuel Thibault +Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/4237 +Forwarded: not-needed +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/4237 +Last-Update: 2012-06-08 + +--- a/grub-core/kern/emu/getroot.c 2012-04-21 14:49:56 +0000 ++++ b/grub-core/kern/emu/getroot.c 2012-04-22 19:02:55 +0000 +@@ -241,6 +241,8 @@ + + #endif /* __linux__ */ + ++#if !defined (__GNU__) ++ + static char * + find_device_from_pool (const char *poolname) + { +@@ -322,6 +323,8 @@ + return device; + } + ++#endif ++ + #ifdef __MINGW32__ + + char * +@@ -331,6 +331,8 @@ + return 0; + } + ++#elif defined (__GNU__) ++ + #elif ! defined(__CYGWIN__) + + char * + diff --git a/master/debian/install_stage2_confusion.patch b/master/debian/install_stage2_confusion.patch new file mode 100644 index 0000000..ff840ef --- /dev/null +++ b/master/debian/install_stage2_confusion.patch @@ -0,0 +1,24 @@ +Description: If GRUB Legacy is still around, tell packaging to ignore it +Author: Colin Watson +Bug-Debian: http://bugs.debian.org/586143 +Forwarded: not-needed +Last-Update: 2010-06-18 + +Index: b/util/grub-install.in +=================================================================== +--- a/util/grub-install.in ++++ b/util/grub-install.in +@@ -660,6 +660,13 @@ + fi + fi + ++# If vestiges of GRUB Legacy still exist, tell the Debian packaging that ++# they can ignore them. ++if test -z "$rootdir" && \ ++ test -e /boot/grub/stage2 && test -e /boot/grub/menu.lst; then ++ touch /boot/grub/grub2-installed ++fi ++ + echo "Installation finished. No error reported." + + # Bye. diff --git a/master/debian/kfreebsd-9_ada_devices.patch b/master/debian/kfreebsd-9_ada_devices.patch new file mode 100644 index 0000000..e1c22e4 --- /dev/null +++ b/master/debian/kfreebsd-9_ada_devices.patch @@ -0,0 +1,71 @@ +2011-06-16 Robert Millan + + Detect `ataraid' devices on GNU/kFreeBSD. Fix for ATA devices using + `ata' driver on kernel of FreeBSD 9. + + * util/deviceiter.c [__FreeBSD_kernel__] (get_ada_disk_name) + (get_ataraid_disk_name): New functions. + [__FreeBSD_kernel__] (grub_util_iterate_devices): Scan for ataraid + (/dev/ar[0-9]+) and ada (/dev/ada[0-9]+) devices using + get_ataraid_disk_name() and get_ada_disk_name(). + +=== modified file 'util/deviceiter.c' +--- a/util/deviceiter.c ++++ b/util/deviceiter.c +@@ -286,6 +286,20 @@ + #endif + } + ++#ifdef __FreeBSD_kernel__ ++static void ++get_ada_disk_name (char *name, int unit) ++{ ++ sprintf (name, "/dev/ada%d", unit); ++} ++ ++static void ++get_ataraid_disk_name (char *name, int unit) ++{ ++ sprintf (name, "/dev/ar%d", unit); ++} ++#endif ++ + #ifdef __linux__ + static void + get_virtio_disk_name (char *name, int unit) +@@ -620,6 +634,35 @@ + } + } + ++#ifdef __FreeBSD_kernel__ ++ /* IDE disks using ATA Direct Access driver. */ ++ if (get_kfreebsd_version () >= 800000) ++ for (i = 0; i < 96; i++) ++ { ++ char name[16]; ++ ++ get_ada_disk_name (name, i); ++ if (check_device_readable_unique (name)) ++ { ++ if (hook (name, 0)) ++ goto out; ++ } ++ } ++ ++ /* ATARAID disks. */ ++ for (i = 0; i < 8; i++) ++ { ++ char name[20]; ++ ++ get_ataraid_disk_name (name, i); ++ if (check_device_readable_unique (name)) ++ { ++ if (hook (name, 0)) ++ goto out; ++ } ++ } ++#endif ++ + #ifdef __linux__ + /* Virtio disks. */ + for (i = 0; i < 26; i++) diff --git a/master/debian/kfreebsd_lvm.patch b/master/debian/kfreebsd_lvm.patch new file mode 100644 index 0000000..8583cc9 --- /dev/null +++ b/master/debian/kfreebsd_lvm.patch @@ -0,0 +1,187 @@ +2011-10-09 Robert Millan + + LVM support for FreeBSD and GNU/kFreeBSD. + + * util/lvm.c (grub_util_lvm_isvolume): Enable on FreeBSD and + GNU/kFreeBSD. + (LVM_DEV_MAPPER_STRING): Move from here ... + * include/grub/util/lvm.h (LVM_DEV_MAPPER_STRING): ... to here. + * util/getroot.c: Include `'. + (grub_util_get_dev_abstraction): Enable + grub_util_biosdisk_is_present() on FreeBSD and GNU/kFreeBSD. + Check for LVM abstraction on FreeBSD and GNU/kFreeBSD. + (grub_util_get_grub_dev): Replace "/dev/mapper/" with + `LVM_DEV_MAPPER_STRING'. Enable LVM and mdRAID only on platforms that + support it. + * util/grub-setup.c (main): Check for LVM also on FreeBSD and + GNU/kFreeBSD. + * util/grub.d/10_kfreebsd.in: Load `geom_linux_lvm' kernel module + when LVM abstraction is required for ${GRUB_DEVICE}. + +--- a/grub-core/kern/emu/getroot.c ++++ b/grub-core/kern/emu/getroot.c +@@ -33,6 +33,7 @@ + #include + #include + #include ++#include + + #ifdef HAVE_DEVICE_MAPPER + # include +@@ -709,11 +710,13 @@ + int + grub_util_get_dev_abstraction (const char *os_dev __attribute__((unused))) + { +-#ifdef __linux__ ++#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) + /* User explicitly claims that this drive is visible by BIOS. */ + if (grub_util_biosdisk_is_present (os_dev)) + return GRUB_DEV_ABSTRACTION_NONE; ++#endif + ++#if defined(__linux__) + /* Check for LVM. */ + if (grub_util_is_lvm (os_dev)) + return GRUB_DEV_ABSTRACTION_LVM; +@@ -723,6 +726,12 @@ + return GRUB_DEV_ABSTRACTION_RAID; + #endif + ++#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) ++ /* Check for LVM. */ ++ if (!strncmp (os_dev, LVM_DEV_MAPPER_STRING, sizeof(LVM_DEV_MAPPER_STRING)-1)) ++ return GRUB_DEV_ABSTRACTION_LVM; ++#endif ++ + /* No abstraction found. */ + return GRUB_DEV_ABSTRACTION_NONE; + } +@@ -815,11 +824,12 @@ + + switch (grub_util_get_dev_abstraction (os_dev)) + { ++#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) + case GRUB_DEV_ABSTRACTION_LVM: + + { + unsigned short i, len; +- grub_size_t offset = sizeof ("/dev/mapper/") - 1; ++ grub_size_t offset = sizeof (LVM_DEV_MAPPER_STRING) - 1; + + len = strlen (os_dev) - offset + 1; + grub_dev = xmalloc (len); +@@ -833,7 +843,9 @@ + } + + break; ++#endif + ++#ifdef __linux__ + case GRUB_DEV_ABSTRACTION_RAID: + + if (os_dev[7] == '_' && os_dev[8] == 'd') +@@ -909,7 +921,6 @@ + else + grub_util_error ("unknown kind of RAID device `%s'", os_dev); + +-#ifdef __linux__ + { + char *mdadm_name = get_mdadm_uuid (os_dev); + struct stat st; +@@ -934,9 +945,8 @@ + free (mdadm_name); + } + } +-#endif /* __linux__ */ +- + break; ++#endif /* __linux__ */ + + default: /* GRUB_DEV_ABSTRACTION_NONE */ + grub_dev = grub_util_biosdisk_get_grub_dev (os_dev); +--- a/include/grub/util/lvm.h ++++ b/include/grub/util/lvm.h +@@ -20,7 +20,14 @@ + #ifndef GRUB_LVM_UTIL_HEADER + #define GRUB_LVM_UTIL_HEADER 1 + ++#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) ++ + #ifdef __linux__ ++#define LVM_DEV_MAPPER_STRING "/dev/mapper/" ++#else ++#define LVM_DEV_MAPPER_STRING "/dev/linux_lvm/" ++#endif ++ + int grub_util_lvm_isvolume (char *name); + #endif + +--- a/util/grub-setup.c ++++ b/util/grub-setup.c +@@ -959,10 +959,12 @@ + arguments.dir ? : DEFAULT_DIRECTORY); + } + +-#ifdef __linux__ ++#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) + if (grub_util_lvm_isvolume (root_dev)) + must_embed = 1; ++#endif + ++#ifdef __linux__ + if (root_dev[0] == 'm' && root_dev[1] == 'd' + && ((root_dev[2] >= '0' && root_dev[2] <= '9') || root_dev[2] == '/')) + { +--- a/util/grub.d/10_kfreebsd.in ++++ b/util/grub.d/10_kfreebsd.in +@@ -98,6 +98,23 @@ + + load_kfreebsd_module acpi true + ++ for abstraction in dummy $(grub-probe -t abstraction --device ${GRUB_DEVICE}) ; do ++ case $abstraction in ++ lvm) load_kfreebsd_module geom_linux_lvm false ;; ++ esac ++ done ++ ++ case "$(grub-probe -t abstraction --device ${GRUB_DEVICE})" in ++ lvm) ++ test -e "${module_dir}/geom_linux_lvm.ko" ++ ++ printf '%s\n' "${prepare_module_dir_cache}" ++ cat << EOF ++ kfreebsd_module_elf ${module_dir_rel}/geom_linux_lvm.ko ++EOF ++ ;; ++ esac ++ + case "${kfreebsd_fs}" in + zfs) + load_kfreebsd_module opensolaris false +--- a/util/lvm.c ++++ b/util/lvm.c +@@ -17,8 +17,7 @@ + * along with GRUB. If not, see . + */ + +-/* We only support LVM on Linux. */ +-#ifdef __linux__ ++#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) + #include + #include + #include +@@ -26,8 +25,6 @@ + #include + #include + +-#define LVM_DEV_MAPPER_STRING "/dev/mapper/" +- + int + grub_util_lvm_isvolume (char *name) + { +@@ -49,4 +46,4 @@ + return 1; + } + +-#endif /* ! __linux__ */ ++#endif diff --git a/master/debian/kfreebsd_mfi_devices.patch b/master/debian/kfreebsd_mfi_devices.patch new file mode 100644 index 0000000..6b0992e --- /dev/null +++ b/master/debian/kfreebsd_mfi_devices.patch @@ -0,0 +1,35 @@ +--- a/util/deviceiter.c ++++ b/util/deviceiter.c +@@ -298,6 +298,12 @@ + { + sprintf (name, "/dev/ar%d", unit); + } ++ ++static void ++get_mfi_disk_name (char *name, int unit) ++{ ++ sprintf (name, "/dev/mfid%d", unit); ++} + #endif + + #ifdef __linux__ +@@ -658,6 +664,19 @@ + if (check_device_readable_unique (name)) + { + if (hook (name, 0)) ++ goto out; ++ } ++ } ++ ++ /* LSI MegaRAID SAS. */ ++ for (i = 0; i < 32; i++) ++ { ++ char name[20]; ++ ++ get_mfi_disk_name (name, i); ++ if (check_device_readable_unique (name)) ++ { ++ if (hook (name, 0)) + goto out; + } + } diff --git a/master/debian/lazy_stat.patch b/master/debian/lazy_stat.patch new file mode 100644 index 0000000..b2cdfd2 --- /dev/null +++ b/master/debian/lazy_stat.patch @@ -0,0 +1,73 @@ +Description: Don't stat devices unless we have to +Author: Vladimir Serbinenko +Author: Colin Watson +Bug-Debian: http://bugs.debian.org/627587 +Forwarded: yes +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3318 +Last-Update: 2011-05-31 + +Index: b/grub-core/kern/emu/getroot.c +=================================================================== +--- a/grub-core/kern/emu/getroot.c ++++ b/grub-core/kern/emu/getroot.c +@@ -358,7 +358,7 @@ + + if (S_ISLNK (st.st_mode)) { + #ifdef __linux__ +- if (strcmp (dir, "mapper") == 0) { ++ if (strcmp (dir, "mapper") == 0 || strcmp (dir, "/dev/mapper") == 0) { + /* Follow symbolic links under /dev/mapper/; the canonical name + may be something like /dev/dm-0, but the names under + /dev/mapper/ are more human-readable and so we prefer them if +@@ -609,20 +609,27 @@ + + if (os_dev) + { +- if (stat (os_dev, &st) >= 0) +- dev = st.st_rdev; +- else +- grub_util_error ("cannot stat `%s'", os_dev); +- free (os_dev); ++ char *tmp = os_dev; ++ os_dev = canonicalize_file_name (os_dev); ++ free (tmp); + } +- else ++ ++ if (os_dev) + { +- if (stat (dir, &st) >= 0) +- dev = st.st_dev; +- else +- grub_util_error ("cannot stat `%s'", dir); ++ if (strncmp (os_dev, "/dev/dm-", sizeof ("/dev/dm-") - 1) != 0) ++ return os_dev; ++ if (stat (os_dev, &st) < 0) ++ grub_util_error ("cannot stat `%s'", os_dev); ++ free (os_dev); ++ dev = st.st_rdev; ++ return grub_find_device ("/dev/mapper", dev); + } + ++ if (stat (dir, &st) < 0) ++ grub_util_error ("cannot stat `%s'", dir); ++ ++ dev = st.st_dev; ++ + #ifdef __CYGWIN__ + /* Cygwin specific function. */ + os_dev = grub_find_device (dir, dev); +Index: b/grub-core/kern/emu/hostdisk.c +=================================================================== +--- a/grub-core/kern/emu/hostdisk.c ++++ b/grub-core/kern/emu/hostdisk.c +@@ -1420,7 +1420,8 @@ + if (tree) + dm_tree_free (tree); + free (path); +- char *ret = grub_find_device (NULL, (major << 8) | minor); ++ char *ret = grub_find_device ("/dev/mapper", ++ (major << 8) | minor); + return ret; + } + diff --git a/master/debian/lzo.patch b/master/debian/lzo.patch new file mode 100644 index 0000000..08be339 --- /dev/null +++ b/master/debian/lzo.patch @@ -0,0 +1,8643 @@ +Description: Add support for LZO compression in btrfs +Author: Szymon Janc +Author: Vladimir Serbinenko +Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3436 +Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3446 +Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3459 +Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3551 +Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3804 +Bug-Ubuntu: https://bugs.launchpad.net/bugs/727535 +Forwarded: not-needed +Last-Update: 2012-03-12 + +Index: b/Makefile.util.def +=================================================================== +--- a/Makefile.util.def ++++ b/Makefile.util.def +@@ -24,8 +24,8 @@ + + library = { + name = libgrubmods.a; +- cflags = '$(CFLAGS_GCRY)'; +- cppflags = '$(CPPFLAGS_GCRY)'; ++ cflags = '$(CFLAGS_GCRY) $(CFLAGS_POSIX) -Wno-undef'; ++ cppflags = '$(CPPFLAGS_GCRY) -I$(srcdir)/lib/posix_wrap -I$(top_srcdir)/grub-core/lib/minilzo -DMINILZO_HAVE_CONFIG_H'; + + common_nodist = grub_script.tab.c; + common_nodist = grub_script.yy.c; +@@ -85,6 +85,7 @@ + common = grub-core/lib/LzmaEnc.c; + common = grub-core/lib/pbkdf2.c; + common = grub-core/lib/crc.c; ++ common = grub-core/lib/adler32.c; + common = grub-core/normal/datetime.c; + common = grub-core/normal/misc.c; + common = grub-core/partmap/acorn.c; +@@ -101,6 +102,8 @@ + common = grub-core/script/script.c; + common = grub-core/script/argv.c; + common = grub-core/io/gzio.c; ++ common = grub-core/io/lzopio.c; ++ common = grub-core/lib/minilzo/minilzo.c; + }; + + program = { +Index: b/configure.ac +=================================================================== +--- a/configure.ac ++++ b/configure.ac +@@ -483,6 +483,7 @@ + # Force 32-bit mode. + TARGET_CFLAGS="$TARGET_CFLAGS -m32" + TARGET_CCASFLAGS="$TARGET_CCASFLAGS -m32" ++ TARGET_CPPFLAGS="$TARGET_CPPFLAGS -m32" + TARGET_LDFLAGS="$TARGET_LDFLAGS -m32" + TARGET_MODULE_FORMAT="elf32" + fi +@@ -491,6 +492,7 @@ + # Force 64-bit mode. + TARGET_CFLAGS="$TARGET_CFLAGS -m64" + TARGET_CCASFLAGS="$TARGET_CCASFLAGS -m64" ++ TARGET_CPPFLAGS="$TARGET_CPPFLAGS -m64" + TARGET_LDFLAGS="$TARGET_LDFLAGS -m64" + TARGET_MODULE_FORMAT="elf64" + fi +@@ -607,7 +609,7 @@ + fi + + # Check for libgcc symbols +-AC_CHECK_FUNCS(__bswapsi2 __bswapdi2 __ashldi3 __ashrdi3 __lshrdi3 __trampoline_setup __ucmpdi2 _restgpr_14_x) ++AC_CHECK_FUNCS(__bswapsi2 __bswapdi2 __ashldi3 __ashrdi3 __lshrdi3 __trampoline_setup __ucmpdi2 _restgpr_14_x __ctzdi2 __ctzsi2) + + if test "x$TARGET_APPLE_CC" = x1 ; then + CFLAGS="$TARGET_CFLAGS -nostdlib" +Index: b/grub-core/Makefile.core.def +=================================================================== +--- a/grub-core/Makefile.core.def ++++ b/grub-core/Makefile.core.def +@@ -908,6 +908,8 @@ + name = btrfs; + common = fs/btrfs.c; + common = lib/crc.c; ++ cflags = '$(CFLAGS_POSIX) -Wno-undef'; ++ cppflags = '-I$(srcdir)/lib/posix_wrap -I$(srcdir)/lib/minilzo -DMINILZO_HAVE_CONFIG_H'; + }; + + module = { +@@ -1509,6 +1511,14 @@ + }; + + module = { ++ name = lzopio; ++ common = io/lzopio.c; ++ common = lib/minilzo/minilzo.c; ++ cflags = '$(CFLAGS_POSIX) -Wno-undef'; ++ cppflags = '-I$(srcdir)/lib/posix_wrap -I$(srcdir)/lib/minilzo -DMINILZO_HAVE_CONFIG_H'; ++}; ++ ++module = { + name = testload; + common = commands/testload.c; + }; +@@ -1524,3 +1534,8 @@ + common = commands/keylayouts.c; + enable = videomodules; + }; ++ ++module = { ++ name = adler32; ++ common = lib/adler32.c; ++}; +Index: b/grub-core/fs/btrfs.c +=================================================================== +--- a/grub-core/fs/btrfs.c ++++ b/grub-core/fs/btrfs.c +@@ -26,11 +26,23 @@ + #include + #include + #include ++#include + + GRUB_MOD_LICENSE ("GPLv3+"); + + #define GRUB_BTRFS_SIGNATURE "_BHRfS_M" + ++/* From http://www.oberhumer.com/opensource/lzo/lzofaq.php ++ * LZO will expand incompressible data by a little amount. I still haven't ++ * computed the exact values, but I suggest using these formulas for ++ * a worst-case expansion calculation: ++ * ++ * output_block_size = input_block_size + (input_block_size / 16) + 64 + 3 ++ * */ ++#define GRUB_BTRFS_LZO_BLOCK_SIZE 4096 ++#define GRUB_BTRFS_LZO_BLOCK_MAX_CSIZE (GRUB_BTRFS_LZO_BLOCK_SIZE + \ ++ (GRUB_BTRFS_LZO_BLOCK_SIZE / 16) + 64 + 3) ++ + typedef grub_uint8_t grub_btrfs_checksum_t[0x20]; + typedef grub_uint16_t grub_btrfs_uuid_t[8]; + +@@ -41,7 +53,7 @@ + } __attribute__ ((packed)); + + struct grub_btrfs_superblock +-{ ++{ + grub_btrfs_checksum_t checksum; + grub_btrfs_uuid_t uuid; + grub_uint8_t dummy[0x10]; +@@ -160,7 +172,8 @@ + { + unsigned depth; + unsigned allocated; +- struct { ++ struct ++ { + grub_disk_addr_t addr; + unsigned iter; + unsigned maxiter; +@@ -179,7 +192,7 @@ + { + grub_int64_t sec; + grub_uint32_t nanosec; +-} __attribute__ ((aligned(4))); ++} __attribute__ ((aligned (4))); + + struct grub_btrfs_inode + { +@@ -215,12 +228,13 @@ + + #define GRUB_BTRFS_COMPRESSION_NONE 0 + #define GRUB_BTRFS_COMPRESSION_ZLIB 1 ++#define GRUB_BTRFS_COMPRESSION_LZO 2 + + #define GRUB_BTRFS_OBJECT_ID_CHUNK 0x100 + + static grub_disk_addr_t superblock_sectors[] = { 64 * 2, 64 * 1024 * 2, +- 256 * 1048576 * 2, +- 1048576ULL * 1048576ULL * 2 }; ++ 256 * 1048576 * 2, 1048576ULL * 1048576ULL * 2 ++}; + + static grub_err_t + grub_btrfs_read_logical (struct grub_btrfs_data *data, +@@ -283,7 +297,7 @@ + } + + static grub_err_t +-save_ref (struct grub_btrfs_leaf_descriptor *desc, ++save_ref (struct grub_btrfs_leaf_descriptor *desc, + grub_disk_addr_t addr, unsigned i, unsigned m, int l) + { + desc->depth++; +@@ -307,7 +321,7 @@ + static int + next (struct grub_btrfs_data *data, + struct grub_btrfs_leaf_descriptor *desc, +- grub_disk_addr_t *outaddr, grub_size_t *outsize, ++ grub_disk_addr_t * outaddr, grub_size_t * outsize, + struct grub_btrfs_key *key_out) + { + grub_err_t err; +@@ -330,17 +344,17 @@ + err = grub_btrfs_read_logical (data, desc->data[desc->depth - 1].iter + * sizeof (node) + + sizeof (struct btrfs_header) +- + desc->data[desc->depth - 1].addr, &node, +- sizeof (node)); ++ + desc->data[desc->depth - 1].addr, ++ &node, sizeof (node)); + if (err) + return -err; + +- err = grub_btrfs_read_logical (data, grub_le_to_cpu64 (node.addr), &head, +- sizeof (head)); ++ err = grub_btrfs_read_logical (data, grub_le_to_cpu64 (node.addr), ++ &head, sizeof (head)); + if (err) + return -err; + +- save_ref (desc, grub_le_to_cpu64 (node.addr), 0, ++ save_ref (desc, grub_le_to_cpu64 (node.addr), 0, + grub_le_to_cpu32 (head.nitems), !head.level); + } + err = grub_btrfs_read_logical (data, desc->data[desc->depth - 1].iter +@@ -354,12 +368,12 @@ + *outaddr = desc->data[desc->depth - 1].addr + sizeof (struct btrfs_header) + + grub_le_to_cpu32 (leaf.offset); + *key_out = leaf.key; +- return 1; ++ return 1; + } + + static grub_err_t + lower_bound (struct grub_btrfs_data *data, +- const struct grub_btrfs_key *key_in, ++ const struct grub_btrfs_key *key_in, + struct grub_btrfs_key *key_out, + grub_disk_addr_t root, + grub_disk_addr_t *outaddr, grub_size_t *outsize, +@@ -410,8 +424,9 @@ + grub_dprintf ("btrfs", + "internal node (depth %d) %" PRIxGRUB_UINT64_T + " %x %" PRIxGRUB_UINT64_T "\n", depth, +- node.key.object_id, node.key.type, node.key.offset); +- ++ node.key.object_id, node.key.type, ++ node.key.offset); ++ + if (key_cmp (&node.key, key_in) == 0) + { + err = GRUB_ERR_NONE; +@@ -433,7 +448,7 @@ + err = GRUB_ERR_NONE; + if (desc) + err = save_ref (desc, addr - sizeof (head), i - 1, +- grub_le_to_cpu32 (head.nitems), 0); ++ grub_le_to_cpu32 (head.nitems), 0); + if (err) + return err; + addr = grub_le_to_cpu64 (node_last.addr); +@@ -457,7 +472,7 @@ + &leaf, sizeof (leaf)); + if (err) + return err; +- ++ + grub_dprintf ("btrfs", + "leaf (depth %d) %" PRIxGRUB_UINT64_T + " %x %" PRIxGRUB_UINT64_T "\n", depth, +@@ -465,31 +480,31 @@ + + if (key_cmp (&leaf.key, key_in) == 0) + { +- grub_memcpy (key_out, &leaf.key, sizeof(*key_out)); ++ grub_memcpy (key_out, &leaf.key, sizeof (*key_out)); + *outsize = grub_le_to_cpu32 (leaf.size); + *outaddr = addr + grub_le_to_cpu32 (leaf.offset); + if (desc) + return save_ref (desc, addr - sizeof (head), i, + grub_le_to_cpu32 (head.nitems), 1); +- return GRUB_ERR_NONE; ++ return GRUB_ERR_NONE; + } +- ++ + if (key_cmp (&leaf.key, key_in) > 0) + break; +- ++ + have_last = 1; + leaf_last = leaf; + } + + if (have_last) + { +- grub_memcpy (key_out, &leaf_last.key, sizeof(*key_out)); ++ grub_memcpy (key_out, &leaf_last.key, sizeof (*key_out)); + *outsize = grub_le_to_cpu32 (leaf_last.size); + *outaddr = addr + grub_le_to_cpu32 (leaf_last.offset); + if (desc) + return save_ref (desc, addr - sizeof (head), i - 1, + grub_le_to_cpu32 (head.nitems), 1); +- return GRUB_ERR_NONE; ++ return GRUB_ERR_NONE; + } + *outsize = 0; + *outaddr = 0; +@@ -503,8 +518,7 @@ + } + + static grub_device_t +-find_device (struct grub_btrfs_data *data, grub_uint64_t id, +- int do_rescan) ++find_device (struct grub_btrfs_data *data, grub_uint64_t id, int do_rescan) + { + grub_device_t dev_found = NULL; + auto int hook (const char *name); +@@ -540,7 +554,7 @@ + grub_device_close (dev); + return 0; + } +- ++ + dev_found = dev; + return 1; + } +@@ -579,17 +593,16 @@ + } + + static grub_err_t +-grub_btrfs_read_logical (struct grub_btrfs_data *data, +- grub_disk_addr_t addr, ++grub_btrfs_read_logical (struct grub_btrfs_data *data, grub_disk_addr_t addr, + void *buf, grub_size_t size) + { + while (size > 0) + { + grub_uint8_t *ptr; + struct grub_btrfs_key *key; +- struct grub_btrfs_chunk_item *chunk; ++ struct grub_btrfs_chunk_item *chunk; + grub_uint64_t csize; +- grub_err_t err; ++ grub_err_t err = 0; + struct grub_btrfs_key key_out; + int challoc = 0; + grub_device_t dev; +@@ -597,15 +610,15 @@ + addr); + for (ptr = data->sblock.bootstrap_mapping; + ptr < data->sblock.bootstrap_mapping +- + sizeof (data->sblock.bootstrap_mapping) +- - sizeof (struct grub_btrfs_key); +- ) ++ + sizeof (data->sblock.bootstrap_mapping) ++ - sizeof (struct grub_btrfs_key);) + { + key = (struct grub_btrfs_key *) ptr; + if (key->type != GRUB_BTRFS_ITEM_TYPE_CHUNK) + break; + chunk = (struct grub_btrfs_chunk_item *) (key + 1); +- grub_dprintf ("btrfs", "%" PRIxGRUB_UINT64_T " %" PRIxGRUB_UINT64_T " \n", ++ grub_dprintf ("btrfs", ++ "%" PRIxGRUB_UINT64_T " %" PRIxGRUB_UINT64_T " \n", + grub_le_to_cpu64 (key->offset), + grub_le_to_cpu64 (chunk->size)); + if (grub_le_to_cpu64 (key->offset) <= addr +@@ -702,11 +715,11 @@ + middle = grub_divmod64 (off, + grub_le_to_cpu64 (chunk->stripe_length), + &low); +- ++ + high = grub_divmod64 (middle, grub_le_to_cpu16 (chunk->nstripes), + &stripen); +- stripe_offset = low + grub_le_to_cpu64 (chunk->stripe_length) +- * high; ++ stripe_offset = ++ low + grub_le_to_cpu64 (chunk->stripe_length) * high; + csize = grub_le_to_cpu64 (chunk->stripe_length) - low; + break; + } +@@ -717,7 +730,7 @@ + middle = grub_divmod64 (off, + grub_le_to_cpu64 (chunk->stripe_length), + &low); +- ++ + high = grub_divmod64 (middle, + grub_le_to_cpu16 (chunk->nsubstripes), + &stripen); +@@ -757,7 +770,8 @@ + paddr = stripe->offset + stripe_offset; + + grub_dprintf ("btrfs", "chunk 0x%" PRIxGRUB_UINT64_T +- "+0x%" PRIxGRUB_UINT64_T " (%d stripes (%d substripes) of %" ++ "+0x%" PRIxGRUB_UINT64_T ++ " (%d stripes (%d substripes) of %" + PRIxGRUB_UINT64_T ") stripe %" PRIxGRUB_UINT32_T + " maps to 0x%" PRIxGRUB_UINT64_T "\n", + grub_le_to_cpu64 (key->offset), +@@ -767,7 +781,7 @@ + grub_le_to_cpu64 (chunk->stripe_length), + stripen, stripe->offset); + grub_dprintf ("btrfs", "reading paddr 0x%" PRIxGRUB_UINT64_T +- " for laddr 0x%" PRIxGRUB_UINT64_T"\n", paddr, ++ " for laddr 0x%" PRIxGRUB_UINT64_T "\n", paddr, + addr); + + dev = find_device (data, stripe->device_id, j); +@@ -813,7 +827,7 @@ + } + + data = grub_zalloc (sizeof (*data)); +- if (! data) ++ if (!data) + return NULL; + + err = read_sblock (dev->disk, &data->sblock); +@@ -864,8 +878,7 @@ + key_in.type = GRUB_BTRFS_ITEM_TYPE_INODE_ITEM; + key_in.offset = 0; + +- err = lower_bound (data, &key_in, &key_out, tree, +- &elemaddr, &elemsize, NULL); ++ err = lower_bound (data, &key_in, &key_out, tree, &elemaddr, &elemsize, NULL); + if (err) + return err; + if (num != key_out.object_id +@@ -876,6 +889,76 @@ + } + + static grub_ssize_t ++grub_btrfs_lzo_decompress(char *ibuf, grub_size_t isize, grub_off_t off, ++ char *obuf, grub_size_t osize) ++{ ++ grub_uint32_t total_size, cblock_size, ret = 0; ++ unsigned char buf[GRUB_BTRFS_LZO_BLOCK_SIZE]; ++ ++ total_size = grub_le_to_cpu32 (grub_get_unaligned32 (ibuf)); ++ ibuf += sizeof (total_size); ++ ++ if (isize < total_size) ++ return -1; ++ ++ /* Jump forward to first block with requested data. */ ++ while (off >= GRUB_BTRFS_LZO_BLOCK_SIZE) ++ { ++ cblock_size = grub_le_to_cpu32 (grub_get_unaligned32 (ibuf)); ++ ibuf += sizeof (cblock_size); ++ ++ if (cblock_size > GRUB_BTRFS_LZO_BLOCK_MAX_CSIZE) ++ return -1; ++ ++ off -= GRUB_BTRFS_LZO_BLOCK_SIZE; ++ ibuf += cblock_size; ++ } ++ ++ while (osize > 0) ++ { ++ lzo_uint usize = GRUB_BTRFS_LZO_BLOCK_SIZE; ++ ++ cblock_size = grub_le_to_cpu32 (grub_get_unaligned32 (ibuf)); ++ ibuf += sizeof (cblock_size); ++ ++ if (cblock_size > GRUB_BTRFS_LZO_BLOCK_MAX_CSIZE) ++ return -1; ++ ++ /* Block partially filled with requested data. */ ++ if (off > 0 || osize < GRUB_BTRFS_LZO_BLOCK_SIZE) ++ { ++ grub_size_t to_copy = grub_min(osize, GRUB_BTRFS_LZO_BLOCK_SIZE - off); ++ ++ if (lzo1x_decompress_safe ((lzo_bytep)ibuf, cblock_size, buf, &usize, ++ NULL) != LZO_E_OK) ++ return -1; ++ ++ to_copy = grub_min(to_copy, usize); ++ grub_memcpy(obuf, buf + off, to_copy); ++ ++ osize -= to_copy; ++ ret += to_copy; ++ obuf += to_copy; ++ ibuf += cblock_size; ++ off = 0; ++ continue; ++ } ++ ++ /* Decompress whole block directly to output buffer. */ ++ if (lzo1x_decompress_safe ((lzo_bytep)ibuf, cblock_size, (lzo_bytep)obuf, ++ &usize, NULL) != LZO_E_OK) ++ return -1; ++ ++ osize -= usize; ++ ret += usize; ++ obuf += usize; ++ ibuf += cblock_size; ++ } ++ ++ return ret; ++} ++ ++static grub_ssize_t + grub_btrfs_extent_read (struct grub_btrfs_data *data, + grub_uint64_t ino, grub_uint64_t tree, + grub_off_t pos0, char *buf, grub_size_t len) +@@ -915,19 +998,17 @@ + if (!data->extent) + return grub_errno; + +- err = grub_btrfs_read_logical (data, elemaddr, +- data->extent, elemsize); ++ err = grub_btrfs_read_logical (data, elemaddr, data->extent, ++ elemsize); + if (err) + return err; + +- data->extend = data->extstart +- + grub_le_to_cpu64 (data->extent->size); ++ data->extend = data->extstart + grub_le_to_cpu64 (data->extent->size); + if (data->extent->type == GRUB_BTRFS_EXTENT_REGULAR + && (char *) &data->extent + elemsize +- >= (char *) &data->extent->filled +- + sizeof (data->extent->filled)) +- data->extend = data->extstart +- + grub_le_to_cpu64 (data->extent->filled); ++ >= (char *) &data->extent->filled + sizeof (data->extent->filled)) ++ data->extend = ++ data->extstart + grub_le_to_cpu64 (data->extent->filled); + + grub_dprintf ("btrfs", "extent 0x%" PRIxGRUB_UINT64_T "+0x%" + PRIxGRUB_UINT64_T " (0x%" +@@ -954,7 +1035,8 @@ + } + + if (data->extent->compression != GRUB_BTRFS_COMPRESSION_NONE +- && data->extent->compression != GRUB_BTRFS_COMPRESSION_ZLIB) ++ && data->extent->compression != GRUB_BTRFS_COMPRESSION_ZLIB ++ && data->extent->compression != GRUB_BTRFS_COMPRESSION_LZO) + { + grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, + "compression type 0x%x not supported", +@@ -964,8 +1046,7 @@ + + if (data->extent->encoding) + { +- grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, +- "encoding not supported"); ++ grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, "encoding not supported"); + return -1; + } + +@@ -981,6 +1062,15 @@ + != (grub_ssize_t) csize) + return -1; + } ++ else if (data->extent->compression == GRUB_BTRFS_COMPRESSION_LZO) ++ { ++ if (grub_btrfs_lzo_decompress(data->extent->inl, data->extsize - ++ ((grub_uint8_t *) data->extent->inl ++ - (grub_uint8_t *) data->extent), ++ extoff, buf, csize) ++ != (grub_ssize_t) csize) ++ return -1; ++ } + else + grub_memcpy (buf, data->extent->inl + extoff, csize); + break; +@@ -990,10 +1080,13 @@ + grub_memset (buf, 0, csize); + break; + } +- if (data->extent->compression == GRUB_BTRFS_COMPRESSION_ZLIB) ++ ++ if (data->extent->compression != GRUB_BTRFS_COMPRESSION_NONE) + { + char *tmp; + grub_uint64_t zsize; ++ grub_ssize_t ret; ++ + zsize = grub_le_to_cpu64 (data->extent->compressed_size); + tmp = grub_malloc (zsize); + if (!tmp) +@@ -1006,27 +1099,35 @@ + grub_free (tmp); + return -1; + } +- if (grub_zlib_decompress (tmp, zsize, extoff +- + grub_le_to_cpu64 (data->extent->offset), +- buf, csize) != (grub_ssize_t) csize) +- { +- grub_free (tmp); +- return -1; +- } ++ ++ if (data->extent->compression == GRUB_BTRFS_COMPRESSION_ZLIB) ++ ret = grub_zlib_decompress (tmp, zsize, extoff ++ + grub_le_to_cpu64 (data->extent->offset), ++ buf, csize); ++ else if (data->extent->compression == GRUB_BTRFS_COMPRESSION_LZO) ++ ret = grub_btrfs_lzo_decompress (tmp, zsize, extoff ++ + grub_le_to_cpu64 (data->extent->offset), ++ buf, csize); ++ else ++ ret = -1; ++ + grub_free (tmp); ++ ++ if (ret != (grub_ssize_t) csize) ++ return -1; ++ + break; + } + err = grub_btrfs_read_logical (data, + grub_le_to_cpu64 (data->extent->laddr) + + grub_le_to_cpu64 (data->extent->offset) +- + extoff, +- buf, csize); ++ + extoff, buf, csize); + if (err) + return -1; + break; + default: + grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, +- "unsupported extent type 0x%x", data->extent->type); ++ "unsupported extent type 0x%x", data->extent->type); + return -1; + } + buf += csize; +@@ -1089,9 +1190,9 @@ + + key->type = GRUB_BTRFS_ITEM_TYPE_DIR_ITEM; + key->offset = grub_cpu_to_le64 (~grub_getcrc32c (1, ctoken, ctokenlen)); +- +- err = lower_bound (data, key, &key_out, *tree, +- &elemaddr, &elemsize, NULL); ++ ++ err = lower_bound (data, key, &key_out, *tree, &elemaddr, &elemsize, ++ NULL); + if (err) + { + grub_free (direl); +@@ -1128,7 +1229,7 @@ + + for (cdirel = direl; + (grub_uint8_t *) cdirel - (grub_uint8_t *) direl +- < (grub_ssize_t) elemsize; ++ < (grub_ssize_t) elemsize; + cdirel = (void *) ((grub_uint8_t *) (direl + 1) + + grub_le_to_cpu16 (cdirel->n) + + grub_le_to_cpu16 (cdirel->m))) +@@ -1159,7 +1260,7 @@ + return grub_error (GRUB_ERR_SYMLINK_LOOP, + "too deep nesting of symlinks"); + } +- ++ + err = grub_btrfs_read_inode (data, &inode, + cdirel->key.object_id, *tree); + if (err) +@@ -1187,7 +1288,7 @@ + grub_free (tmp); + return grub_errno; + } +- grub_memcpy (tmp + grub_le_to_cpu64 (inode.size), path, ++ grub_memcpy (tmp + grub_le_to_cpu64 (inode.size), path, + grub_strlen (path) + 1); + grub_free (path_alloc); + path = path_alloc = tmp; +@@ -1225,8 +1326,7 @@ + grub_free (path_alloc); + return grub_error (GRUB_ERR_FILE_NOT_FOUND, "file not found"); + } +- err = grub_btrfs_read_logical (data, elemaddr, +- &ri, sizeof (ri)); ++ err = grub_btrfs_read_logical (data, elemaddr, &ri, sizeof (ri)); + if (err) + { + grub_free (direl); +@@ -1253,7 +1353,7 @@ + default: + grub_free (path_alloc); + grub_free (direl); +- return grub_error (GRUB_ERR_BAD_FS, "unrecognised object type 0x%x", ++ return grub_error (GRUB_ERR_BAD_FS, "unrecognised object type 0x%x", + cdirel->key.type); + } + } +@@ -1264,8 +1364,8 @@ + + static grub_err_t + grub_btrfs_dir (grub_device_t device, const char *path, +- int (*hook) (const char *filename, +- const struct grub_dirhook_info *info)) ++ int (*hook) (const char *filename, ++ const struct grub_dirhook_info *info)) + { + struct grub_btrfs_data *data = grub_btrfs_mount (device); + struct grub_btrfs_key key_in, key_out; +@@ -1286,10 +1386,9 @@ + if (err) + return err; + if (type != GRUB_BTRFS_DIR_ITEM_TYPE_DIRECTORY) +- return grub_error (GRUB_ERR_BAD_FILE_TYPE, "not a directory"); ++ return grub_error (GRUB_ERR_BAD_FILE_TYPE, "not a directory"); + +- err = lower_bound (data, &key_in, &key_out, tree, +- &elemaddr, &elemsize, &desc); ++ err = lower_bound (data, &key_in, &key_out, tree, &elemaddr, &elemsize, &desc); + if (err) + return err; + if (key_out.type != GRUB_BTRFS_ITEM_TYPE_DIR_ITEM +@@ -1329,7 +1428,7 @@ + + for (cdirel = direl; + (grub_uint8_t *) cdirel - (grub_uint8_t *) direl +- < (grub_ssize_t) elemsize; ++ < (grub_ssize_t) elemsize; + cdirel = (void *) ((grub_uint8_t *) (direl + 1) + + grub_le_to_cpu16 (cdirel->n) + + grub_le_to_cpu16 (cdirel->m))) +@@ -1358,7 +1457,7 @@ + } + while (r > 0); + +- out: ++out: + grub_free (direl); + + free_iterator (&desc); +@@ -1430,7 +1529,7 @@ + *uuid = NULL; + + data = grub_btrfs_mount (device); +- if (! data) ++ if (!data) + return grub_errno; + + *uuid = grub_xasprintf ("%04x%04x-%04x-%04x-%04x-%04x%04x%04x", +@@ -1456,7 +1555,7 @@ + *label = NULL; + + data = grub_btrfs_mount (device); +- if (! data) ++ if (!data) + return grub_errno; + + *label = grub_strndup (data->sblock.label, sizeof (data->sblock.label)); +@@ -1466,26 +1565,25 @@ + return grub_errno; + } + +-static struct grub_fs grub_btrfs_fs = +- { +- .name = "btrfs", +- .dir = grub_btrfs_dir, +- .open = grub_btrfs_open, +- .read = grub_btrfs_read, +- .close = grub_btrfs_close, +- .uuid = grub_btrfs_uuid, +- .label = grub_btrfs_label, ++static struct grub_fs grub_btrfs_fs = { ++ .name = "btrfs", ++ .dir = grub_btrfs_dir, ++ .open = grub_btrfs_open, ++ .read = grub_btrfs_read, ++ .close = grub_btrfs_close, ++ .uuid = grub_btrfs_uuid, ++ .label = grub_btrfs_label, + #ifdef GRUB_UTIL +- .reserved_first_sector = 1, ++ .reserved_first_sector = 1, + #endif +- }; ++}; + +-GRUB_MOD_INIT(btrfs) ++GRUB_MOD_INIT (btrfs) + { + grub_fs_register (&grub_btrfs_fs); + } + +-GRUB_MOD_FINI(btrfs) ++GRUB_MOD_FINI (btrfs) + { + grub_fs_unregister (&grub_btrfs_fs); + } +Index: b/grub-core/io/lzopio.c +=================================================================== +--- /dev/null ++++ b/grub-core/io/lzopio.c +@@ -0,0 +1,564 @@ ++/* lzopio.c - decompression support for lzop */ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2011 Free Software Foundation, Inc. ++ * ++ * GRUB 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, either version 3 of the License, or ++ * (at your option) any later version. ++ * ++ * GRUB is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with GRUB. If not, see . ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++GRUB_MOD_LICENSE ("GPLv3+"); ++ ++#define LZOP_MAGIC "\x89\x4c\x5a\x4f\x00\x0d\x0a\x1a\x0a" ++#define LZOP_MAGIC_SIZE 9 ++#define LZOP_CHECK_SIZE 4 ++#define LZOP_NEW_LIB 0x0940 ++ ++/* Header flags - copied from conf.h of LZOP source code. */ ++#define F_ADLER32_D 0x00000001L ++#define F_ADLER32_C 0x00000002L ++#define F_STDIN 0x00000004L ++#define F_STDOUT 0x00000008L ++#define F_NAME_DEFAULT 0x00000010L ++#define F_DOSISH 0x00000020L ++#define F_H_EXTRA_FIELD 0x00000040L ++#define F_H_GMTDIFF 0x00000080L ++#define F_CRC32_D 0x00000100L ++#define F_CRC32_C 0x00000200L ++#define F_MULTIPART 0x00000400L ++#define F_H_FILTER 0x00000800L ++#define F_H_CRC32 0x00001000L ++#define F_H_PATH 0x00002000L ++#define F_MASK 0x00003FFFL ++ ++struct block_header ++{ ++ grub_uint32_t usize; ++ grub_uint32_t csize; ++ grub_uint32_t ucheck; ++ grub_uint32_t ccheck; ++ unsigned char *cdata; ++ unsigned char *udata; ++}; ++ ++struct grub_lzopio ++{ ++ grub_file_t file; ++ int has_ccheck; ++ int has_ucheck; ++ const gcry_md_spec_t *ucheck_fun; ++ const gcry_md_spec_t *ccheck_fun; ++ grub_off_t saved_off; /* Rounded down to block boundary. */ ++ grub_off_t start_block_off; ++ struct block_header block; ++}; ++ ++typedef struct grub_lzopio *grub_lzopio_t; ++static struct grub_fs grub_lzopio_fs; ++ ++/* Some helper functions. On errors memory allocated by those function is free ++ * either on close() so no risk of leaks. This makes functions simpler. */ ++ ++/* Read block header from file, after successful exit file points to ++ * beginning of block data. */ ++static int ++read_block_header (struct grub_lzopio *lzopio) ++{ ++ lzopio->saved_off += lzopio->block.usize; ++ ++ /* Free cached block data if any. */ ++ grub_free (lzopio->block.udata); ++ grub_free (lzopio->block.cdata); ++ lzopio->block.udata = NULL; ++ lzopio->block.cdata = NULL; ++ ++ if (grub_file_read (lzopio->file, &lzopio->block.usize, ++ sizeof (lzopio->block.usize)) != ++ sizeof (lzopio->block.usize)) ++ return -1; ++ ++ lzopio->block.usize = grub_be_to_cpu32 (lzopio->block.usize); ++ ++ /* Last block has uncompressed data size == 0 and no other fields. */ ++ if (lzopio->block.usize == 0) ++ { ++ if (grub_file_tell (lzopio->file) == grub_file_size (lzopio->file)) ++ return 0; ++ else ++ return -1; ++ } ++ ++ /* Read compressed data block size. */ ++ if (grub_file_read (lzopio->file, &lzopio->block.csize, ++ sizeof (lzopio->block.csize)) != ++ sizeof (lzopio->block.csize)) ++ return -1; ++ ++ lzopio->block.csize = grub_be_to_cpu32 (lzopio->block.csize); ++ ++ /* Corrupted. */ ++ if (lzopio->block.csize > lzopio->block.usize) ++ return -1; ++ ++ /* Read checksum of uncompressed data. */ ++ if (lzopio->has_ucheck) ++ { ++ if (grub_file_read (lzopio->file, &lzopio->block.ucheck, ++ sizeof (lzopio->block.ucheck)) != ++ sizeof (lzopio->block.ucheck)) ++ return -1; ++ ++ lzopio->block.ucheck = grub_be_to_cpu32 (lzopio->block.ucheck); ++ } ++ ++ /* Read checksum of compressed data. */ ++ if (lzopio->has_ccheck) ++ { ++ /* Incompressible data block. */ ++ if (lzopio->block.csize == lzopio->block.usize) ++ { ++ lzopio->block.ccheck = lzopio->block.ucheck; ++ } ++ else ++ { ++ if (grub_file_read (lzopio->file, &lzopio->block.ccheck, ++ sizeof (lzopio->block.ccheck)) != ++ sizeof (lzopio->block.ccheck)) ++ return -1; ++ ++ lzopio->block.ccheck = grub_be_to_cpu32 (lzopio->block.ccheck); ++ } ++ } ++ ++ return 0; ++} ++ ++/* Read block data into memory. File must be set to beginning of block data. ++ * Can't be called on last block. */ ++static int ++read_block_data (struct grub_lzopio *lzopio) ++{ ++ lzopio->block.cdata = grub_malloc (lzopio->block.csize); ++ if (!lzopio->block.cdata) ++ return -1; ++ ++ if (grub_file_read (lzopio->file, lzopio->block.cdata, lzopio->block.csize) ++ != (grub_ssize_t) lzopio->block.csize) ++ return -1; ++ ++ if (lzopio->ccheck_fun) ++ { ++ grub_uint64_t context[(lzopio->ccheck_fun->contextsize + 7) / 8]; ++ ++ lzopio->ccheck_fun->init (context); ++ lzopio->ccheck_fun->write (context, lzopio->block.cdata, ++ lzopio->block.csize); ++ lzopio->ccheck_fun->final (context); ++ ++ if (grub_memcmp ++ (lzopio->ccheck_fun->read (context), &lzopio->block.ccheck, ++ sizeof (lzopio->block.ccheck)) != 0) ++ return -1; ++ } ++ ++ return 0; ++} ++ ++/* Read block data, uncompressed and also store it in memory. */ ++/* XXX Investigate possibility of in-place decompression to reduce memory ++ * footprint. Or try to uncompress directly to buf if possible. */ ++static int ++uncompress_block (struct grub_lzopio *lzopio) ++{ ++ lzo_uint usize = lzopio->block.usize; ++ ++ if (read_block_data (lzopio) < 0) ++ return -1; ++ ++ /* Incompressible data. */ ++ if (lzopio->block.csize == lzopio->block.usize) ++ { ++ lzopio->block.udata = lzopio->block.cdata; ++ lzopio->block.cdata = NULL; ++ } ++ else ++ { ++ lzopio->block.udata = grub_malloc (lzopio->block.usize); ++ if (!lzopio->block.udata) ++ return -1; ++ ++ if (lzo1x_decompress_safe (lzopio->block.cdata, lzopio->block.csize, ++ lzopio->block.udata, &usize, NULL) ++ != LZO_E_OK) ++ return -1; ++ ++ if (lzopio->ucheck_fun) ++ { ++ grub_uint64_t context[(lzopio->ucheck_fun->contextsize + 7) / 8]; ++ ++ lzopio->ucheck_fun->init (context); ++ lzopio->ucheck_fun->write (context, lzopio->block.udata, ++ lzopio->block.usize); ++ lzopio->ucheck_fun->final (context); ++ ++ if (grub_memcmp ++ (lzopio->ucheck_fun->read (context), &lzopio->block.ucheck, ++ sizeof (lzopio->block.ucheck)) != 0) ++ return -1; ++ } ++ ++ /* Compressed data can be free now. */ ++ grub_free (lzopio->block.cdata); ++ lzopio->block.cdata = NULL; ++ } ++ ++ return 0; ++} ++ ++/* Jump to next block and read its header. */ ++static int ++jump_block (struct grub_lzopio *lzopio) ++{ ++ /* only jump if block was not decompressed (and read from disk) */ ++ if (!lzopio->block.udata) ++ { ++ grub_off_t off = grub_file_tell (lzopio->file) + lzopio->block.csize; ++ ++ if (grub_file_seek (lzopio->file, off) == ((grub_off_t) - 1)) ++ return -1; ++ } ++ ++ return read_block_header (lzopio); ++} ++ ++static int ++calculate_uncompressed_size (grub_file_t file) ++{ ++ grub_lzopio_t lzopio = file->data; ++ grub_off_t usize_total = 0; ++ ++ if (read_block_header (lzopio) < 0) ++ return -1; ++ ++ /* FIXME: Don't do this for not easily seekable files. */ ++ while (lzopio->block.usize != 0) ++ { ++ usize_total += lzopio->block.usize; ++ ++ if (jump_block (lzopio) < 0) ++ return -1; ++ } ++ ++ file->size = usize_total; ++ ++ return 0; ++} ++ ++struct lzop_header ++{ ++ grub_uint8_t magic[LZOP_MAGIC_SIZE]; ++ grub_uint16_t lzop_version; ++ grub_uint16_t lib_version; ++ grub_uint16_t lib_version_ext; ++ grub_uint8_t method; ++ grub_uint8_t level; ++ grub_uint32_t flags; ++ /* grub_uint32_t filter; */ /* No filters support. Rarely used anyway. */ ++ grub_uint32_t mode; ++ grub_uint32_t mtime_lo; ++ grub_uint32_t mtime_hi; ++ grub_uint8_t name_len; ++} __attribute__ ((packed)); ++ ++static int ++test_header (grub_file_t file) ++{ ++ grub_lzopio_t lzopio = file->data; ++ struct lzop_header header; ++ grub_uint32_t flags, checksum; ++ const gcry_md_spec_t *hcheck; ++ grub_uint8_t *context = NULL; ++ grub_uint8_t *name = NULL; ++ ++ if (grub_file_read (lzopio->file, &header, sizeof (header)) != sizeof (header)) ++ { ++ grub_error (GRUB_ERR_BAD_FILE_TYPE, "no lzop magic found"); ++ return 0; ++ } ++ ++ if (grub_memcmp (header.magic, LZOP_MAGIC, LZOP_MAGIC_SIZE) != 0) ++ { ++ grub_error (GRUB_ERR_BAD_FILE_TYPE, "no lzop magic found"); ++ return 0; ++ } ++ ++ if (grub_be_to_cpu16(header.lib_version) < LZOP_NEW_LIB) ++ { ++ grub_error (GRUB_ERR_BAD_COMPRESSED_DATA, ++ "unsupported (too old) LZOP version"); ++ return 0; ++ } ++ ++ /* Too new version, should upgrade minilzo? */ ++ if (grub_be_to_cpu16 (header.lib_version_ext) > MINILZO_VERSION) ++ { ++ grub_error (GRUB_ERR_BAD_COMPRESSED_DATA, ++ "unsupported (too new) LZO version"); ++ return 0; ++ } ++ ++ flags = grub_be_to_cpu32 (header.flags); ++ ++ if (flags & F_CRC32_D) ++ { ++ lzopio->has_ucheck = 1; ++ lzopio->ucheck_fun = grub_crypto_lookup_md_by_name ("crc32"); ++ } ++ else if (flags & F_ADLER32_D) ++ { ++ lzopio->has_ucheck = 1; ++ lzopio->ucheck_fun = grub_crypto_lookup_md_by_name ("adler32"); ++ } ++ ++ if (flags & F_CRC32_C) ++ { ++ lzopio->has_ccheck = 1; ++ lzopio->ccheck_fun = grub_crypto_lookup_md_by_name ("crc32"); ++ } ++ else if (flags & F_ADLER32_C) ++ { ++ lzopio->has_ccheck = 1; ++ lzopio->ccheck_fun = grub_crypto_lookup_md_by_name ("adler32"); ++ } ++ ++ if (flags & F_H_CRC32) ++ hcheck = grub_crypto_lookup_md_by_name ("crc32"); ++ else ++ hcheck = grub_crypto_lookup_md_by_name ("adler32"); ++ ++ if (hcheck) { ++ context = grub_malloc(hcheck->contextsize); ++ if (! context) ++ return 0; ++ ++ hcheck->init(context); ++ ++ /* MAGIC is not included in check calculation. */ ++ hcheck->write(context, &header.lzop_version, sizeof(header)- LZOP_MAGIC_SIZE); ++ } ++ ++ if (header.name_len != 0) ++ { ++ name = grub_malloc (header.name_len); ++ if (! name) ++ { ++ grub_free (context); ++ return 0; ++ } ++ ++ if (grub_file_read (lzopio->file, name, header.name_len) != ++ header.name_len) ++ { ++ grub_free(name); ++ goto CORRUPTED; ++ } ++ ++ if (hcheck) ++ hcheck->write(context, name, header.name_len); ++ ++ grub_free(name); ++ } ++ ++ if (hcheck) ++ hcheck->final(context); ++ ++ if (grub_file_read (lzopio->file, &checksum, sizeof (checksum)) != ++ sizeof (checksum)) ++ goto CORRUPTED; ++ ++ if (hcheck) ++ { ++ checksum = grub_cpu_to_be32(checksum); ++ if (grub_memcmp (&checksum, hcheck->read(context), sizeof(checksum)) != 0) ++ goto CORRUPTED; ++ } ++ ++ lzopio->start_block_off = grub_file_tell (lzopio->file); ++ ++ if (calculate_uncompressed_size (file) < 0) ++ goto CORRUPTED; ++ ++ /* Get back to start block. */ ++ grub_file_seek (lzopio->file, lzopio->start_block_off); ++ ++ /* Read first block - grub_lzopio_read() expects valid block. */ ++ if (read_block_header (lzopio) < 0) ++ goto CORRUPTED; ++ ++ lzopio->saved_off = 0; ++ return 1; ++ ++CORRUPTED: ++ grub_error (GRUB_ERR_BAD_COMPRESSED_DATA, "lzop file corrupted"); ++ ++ grub_free(name); ++ ++ return 0; ++} ++ ++static grub_file_t ++grub_lzopio_open (grub_file_t io) ++{ ++ grub_file_t file; ++ grub_lzopio_t lzopio; ++ ++ file = (grub_file_t) grub_zalloc (sizeof (*file)); ++ if (!file) ++ return 0; ++ ++ lzopio = grub_zalloc (sizeof (*lzopio)); ++ if (!lzopio) ++ { ++ grub_free (file); ++ return 0; ++ } ++ ++ lzopio->file = io; ++ ++ file->device = io->device; ++ file->offset = 0; ++ file->data = lzopio; ++ file->read_hook = 0; ++ file->fs = &grub_lzopio_fs; ++ file->size = GRUB_FILE_SIZE_UNKNOWN; ++ file->not_easily_seekable = 1; ++ ++ if (grub_file_tell (lzopio->file) != 0) ++ grub_file_seek (lzopio->file, 0); ++ ++ if (!test_header (file)) ++ { ++ grub_errno = GRUB_ERR_NONE; ++ grub_file_seek (io, 0); ++ grub_free (lzopio); ++ grub_free (file); ++ ++ return io; ++ } ++ ++ return file; ++} ++ ++static grub_ssize_t ++grub_lzopio_read (grub_file_t file, char *buf, grub_size_t len) ++{ ++ grub_lzopio_t lzopio = file->data; ++ grub_ssize_t ret = 0; ++ grub_off_t off; ++ ++ /* Backward seek before last read block. */ ++ if (lzopio->saved_off > grub_file_tell (file)) ++ { ++ grub_file_seek (lzopio->file, lzopio->start_block_off); ++ ++ if (read_block_header (lzopio) < 0) ++ goto CORRUPTED; ++ ++ lzopio->saved_off = 0; ++ } ++ ++ /* Forward to first block with requested data. */ ++ while (lzopio->saved_off + lzopio->block.usize <= grub_file_tell (file)) ++ { ++ /* EOF, could be possible files with unknown size. */ ++ if (lzopio->block.usize == 0) ++ return 0; ++ ++ if (jump_block (lzopio) < 0) ++ goto CORRUPTED; ++ } ++ ++ off = grub_file_tell (file) - lzopio->saved_off; ++ ++ while (len != 0 && lzopio->block.usize != 0) ++ { ++ long to_copy; ++ ++ /* Block not decompressed yet. */ ++ if (!lzopio->block.udata && uncompress_block (lzopio) < 0) ++ goto CORRUPTED; ++ ++ /* Copy requested data into buffer. */ ++ to_copy = grub_min (lzopio->block.usize - off, len); ++ grub_memcpy (buf, lzopio->block.udata + off, to_copy); ++ ++ len -= to_copy; ++ buf += to_copy; ++ ret += to_copy; ++ off = 0; ++ ++ /* Read next block if needed. */ ++ if (len > 0 && read_block_header (lzopio) < 0) ++ goto CORRUPTED; ++ } ++ ++ return ret; ++ ++CORRUPTED: ++ grub_error (GRUB_ERR_BAD_COMPRESSED_DATA, "lzop file corrupted"); ++ return -1; ++} ++ ++/* Release everything, including the underlying file object. */ ++static grub_err_t ++grub_lzopio_close (grub_file_t file) ++{ ++ grub_lzopio_t lzopio = file->data; ++ ++ grub_file_close (lzopio->file); ++ grub_free (lzopio->block.cdata); ++ grub_free (lzopio->block.udata); ++ grub_free (lzopio); ++ ++ /* Device must not be closed twice. */ ++ file->device = 0; ++ return grub_errno; ++} ++ ++static struct grub_fs grub_lzopio_fs = { ++ .name = "lzopio", ++ .dir = 0, ++ .open = 0, ++ .read = grub_lzopio_read, ++ .close = grub_lzopio_close, ++ .label = 0, ++ .next = 0 ++}; ++ ++GRUB_MOD_INIT (lzopio) ++{ ++ grub_file_filter_register (GRUB_FILE_FILTER_LZOPIO, grub_lzopio_open); ++} ++ ++GRUB_MOD_FINI (lzopio) ++{ ++ grub_file_filter_unregister (GRUB_FILE_FILTER_LZOPIO); ++} +Index: b/grub-core/lib/adler32.c +=================================================================== +--- /dev/null ++++ b/grub-core/lib/adler32.c +@@ -0,0 +1,151 @@ ++/* adler32.c - adler32 check. */ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2011 Free Software Foundation, Inc. ++ * ++ * GRUB 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, either version 3 of the License, or ++ * (at your option) any later version. ++ * ++ * GRUB is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with GRUB. If not, see . ++ */ ++ ++#include ++#include ++#include ++ ++/* Based on adler32() from adler32.c of zlib-1.2.5 library. */ ++ ++#define BASE 65521UL ++#define NMAX 5552 ++ ++#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} ++#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); ++#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); ++#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); ++#define DO16(buf) DO8(buf,0); DO8(buf,8); ++ ++static grub_uint32_t ++update_adler32 (grub_uint32_t adler, const grub_uint8_t *buf, grub_size_t len) ++{ ++ unsigned long sum2; ++ unsigned int n; ++ ++ sum2 = (adler >> 16) & 0xffff; ++ adler &= 0xffff; ++ ++ if (len == 1) ++ { ++ adler += buf[0]; ++ if (adler >= BASE) ++ adler -= BASE; ++ sum2 += adler; ++ if (sum2 >= BASE) ++ sum2 -= BASE; ++ return adler | (sum2 << 16); ++ } ++ ++ if (len < 16) ++ { ++ while (len--) ++ { ++ adler += *buf++; ++ sum2 += adler; ++ } ++ if (adler >= BASE) ++ adler -= BASE; ++ sum2 %= BASE; ++ return adler | (sum2 << 16); ++ } ++ ++ while (len >= NMAX) ++ { ++ len -= NMAX; ++ n = NMAX / 16; ++ do ++ { ++ DO16 (buf); ++ buf += 16; ++ } ++ while (--n); ++ adler %= BASE; ++ sum2 %= BASE; ++ } ++ ++ if (len) ++ { ++ while (len >= 16) ++ { ++ len -= 16; ++ DO16 (buf); ++ buf += 16; ++ } ++ while (len--) ++ { ++ adler += *buf++; ++ sum2 += adler; ++ } ++ adler %= BASE; ++ sum2 %= BASE; ++ } ++ ++ return adler | (sum2 << 16); ++} ++ ++typedef struct ++{ ++ grub_uint32_t adler; ++} ++adler32_context; ++ ++static void ++adler32_init (void *context) ++{ ++ adler32_context *ctx = (adler32_context *) context; ++ ctx->adler = 1; ++} ++ ++static void ++adler32_write (void *context, const void *inbuf, grub_size_t inlen) ++{ ++ adler32_context *ctx = (adler32_context *) context; ++ if (!inbuf) ++ return; ++ ctx->adler = update_adler32 (ctx->adler, inbuf, inlen); ++} ++ ++static grub_uint8_t * ++adler32_read (void *context) ++{ ++ adler32_context *ctx = (adler32_context *) context; ++ return (grub_uint8_t *) &ctx->adler; ++} ++ ++static void ++adler32_final (void *context __attribute__ ((unused))) ++{ ++} ++ ++gcry_md_spec_t _gcry_digest_spec_adler32 = { ++ "ADLER32",0 , 0, 0 , 4, ++ adler32_init, adler32_write, adler32_final, adler32_read, ++ sizeof (adler32_context), ++ .blocksize = 64 ++}; ++ ++GRUB_MOD_INIT(adler32) ++{ ++ grub_md_register (&_gcry_digest_spec_adler32); ++} ++ ++GRUB_MOD_FINI(adler32) ++{ ++ grub_md_unregister (&_gcry_digest_spec_adler32); ++} +Index: b/grub-core/lib/minilzo/lzoconf.h +=================================================================== +--- /dev/null ++++ b/grub-core/lib/minilzo/lzoconf.h +@@ -0,0 +1,446 @@ ++/* lzoconf.h -- configuration of the LZO data compression library ++ ++ This file is part of the LZO real-time data compression library. ++ ++ Copyright (C) 2011 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2010 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2009 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer ++ All Rights Reserved. ++ ++ The LZO library 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; either version 2 of ++ the License, or (at your option) any later version. ++ ++ The LZO library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with the LZO library; see the file COPYING. ++ If not, write to the Free Software Foundation, Inc., ++ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ ++ Markus F.X.J. Oberhumer ++ ++ http://www.oberhumer.com/opensource/lzo/ ++ */ ++ ++ ++#ifndef __LZOCONF_H_INCLUDED ++#define __LZOCONF_H_INCLUDED 1 ++ ++#define LZO_VERSION 0x2050 ++#define LZO_VERSION_STRING "2.05" ++#define LZO_VERSION_DATE "Apr 23 2011" ++ ++/* internal Autoconf configuration file - only used when building LZO */ ++#if defined(LZO_HAVE_CONFIG_H) ++# include ++#endif ++#include ++#include ++ ++ ++/*********************************************************************** ++// LZO requires a conforming ++************************************************************************/ ++ ++#if !defined(CHAR_BIT) || (CHAR_BIT != 8) ++# error "invalid CHAR_BIT" ++#endif ++#if !defined(UCHAR_MAX) || !defined(UINT_MAX) || !defined(ULONG_MAX) ++# error "check your compiler installation" ++#endif ++#if (USHRT_MAX < 1) || (UINT_MAX < 1) || (ULONG_MAX < 1) ++# error "your limits.h macros are broken" ++#endif ++ ++/* get OS and architecture defines */ ++#ifndef __LZODEFS_H_INCLUDED ++#include "lzodefs.h" ++#endif ++ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++ ++/*********************************************************************** ++// some core defines ++************************************************************************/ ++ ++#if !defined(LZO_UINT32_C) ++# if (UINT_MAX < LZO_0xffffffffL) ++# define LZO_UINT32_C(c) c ## UL ++# else ++# define LZO_UINT32_C(c) ((c) + 0U) ++# endif ++#endif ++ ++/* memory checkers */ ++#if !defined(__LZO_CHECKER) ++# if defined(__BOUNDS_CHECKING_ON) ++# define __LZO_CHECKER 1 ++# elif defined(__CHECKER__) ++# define __LZO_CHECKER 1 ++# elif defined(__INSURE__) ++# define __LZO_CHECKER 1 ++# elif defined(__PURIFY__) ++# define __LZO_CHECKER 1 ++# endif ++#endif ++ ++ ++/*********************************************************************** ++// integral and pointer types ++************************************************************************/ ++ ++/* lzo_uint should match size_t */ ++#if !defined(LZO_UINT_MAX) ++# if defined(LZO_ABI_LLP64) /* WIN64 */ ++# if defined(LZO_OS_WIN64) ++ typedef unsigned __int64 lzo_uint; ++ typedef __int64 lzo_int; ++# else ++ typedef unsigned long long lzo_uint; ++ typedef long long lzo_int; ++# endif ++# define LZO_UINT_MAX 0xffffffffffffffffull ++# define LZO_INT_MAX 9223372036854775807LL ++# define LZO_INT_MIN (-1LL - LZO_INT_MAX) ++# elif defined(LZO_ABI_IP32L64) /* MIPS R5900 */ ++ typedef unsigned int lzo_uint; ++ typedef int lzo_int; ++# define LZO_UINT_MAX UINT_MAX ++# define LZO_INT_MAX INT_MAX ++# define LZO_INT_MIN INT_MIN ++# elif (ULONG_MAX >= LZO_0xffffffffL) ++ typedef unsigned long lzo_uint; ++ typedef long lzo_int; ++# define LZO_UINT_MAX ULONG_MAX ++# define LZO_INT_MAX LONG_MAX ++# define LZO_INT_MIN LONG_MIN ++# else ++# error "lzo_uint" ++# endif ++#endif ++ ++/* Integral types with 32 bits or more. */ ++#if !defined(LZO_UINT32_MAX) ++# if (UINT_MAX >= LZO_0xffffffffL) ++ typedef unsigned int lzo_uint32; ++ typedef int lzo_int32; ++# define LZO_UINT32_MAX UINT_MAX ++# define LZO_INT32_MAX INT_MAX ++# define LZO_INT32_MIN INT_MIN ++# elif (ULONG_MAX >= LZO_0xffffffffL) ++ typedef unsigned long lzo_uint32; ++ typedef long lzo_int32; ++# define LZO_UINT32_MAX ULONG_MAX ++# define LZO_INT32_MAX LONG_MAX ++# define LZO_INT32_MIN LONG_MIN ++# else ++# error "lzo_uint32" ++# endif ++#endif ++ ++/* Integral types with exactly 64 bits. */ ++#if !defined(LZO_UINT64_MAX) ++# if (LZO_UINT_MAX >= LZO_0xffffffffL) ++# if ((((LZO_UINT_MAX) >> 31) >> 31) == 3) ++# define lzo_uint64 lzo_uint ++# define lzo_int64 lzo_int ++# define LZO_UINT64_MAX LZO_UINT_MAX ++# define LZO_INT64_MAX LZO_INT_MAX ++# define LZO_INT64_MIN LZO_INT_MIN ++# endif ++# elif (ULONG_MAX >= LZO_0xffffffffL) ++# if ((((ULONG_MAX) >> 31) >> 31) == 3) ++ typedef unsigned long lzo_uint64; ++ typedef long lzo_int64; ++# define LZO_UINT64_MAX ULONG_MAX ++# define LZO_INT64_MAX LONG_MAX ++# define LZO_INT64_MIN LONG_MIN ++# endif ++# endif ++#endif ++ ++/* The larger type of lzo_uint and lzo_uint32. */ ++#if (LZO_UINT_MAX >= LZO_UINT32_MAX) ++# define lzo_xint lzo_uint ++#else ++# define lzo_xint lzo_uint32 ++#endif ++ ++/* Memory model that allows to access memory at offsets of lzo_uint. */ ++#if !defined(__LZO_MMODEL) ++# if (LZO_UINT_MAX <= UINT_MAX) ++# define __LZO_MMODEL /*empty*/ ++# elif defined(LZO_HAVE_MM_HUGE_PTR) ++# define __LZO_MMODEL_HUGE 1 ++# define __LZO_MMODEL __huge ++# else ++# define __LZO_MMODEL /*empty*/ ++# endif ++#endif ++ ++/* no typedef here because of const-pointer issues */ ++#define lzo_bytep unsigned char __LZO_MMODEL * ++#define lzo_charp char __LZO_MMODEL * ++#define lzo_voidp void __LZO_MMODEL * ++#define lzo_shortp short __LZO_MMODEL * ++#define lzo_ushortp unsigned short __LZO_MMODEL * ++#define lzo_uint32p lzo_uint32 __LZO_MMODEL * ++#define lzo_int32p lzo_int32 __LZO_MMODEL * ++#if defined(LZO_UINT64_MAX) ++#define lzo_uint64p lzo_uint64 __LZO_MMODEL * ++#define lzo_int64p lzo_int64 __LZO_MMODEL * ++#endif ++#define lzo_uintp lzo_uint __LZO_MMODEL * ++#define lzo_intp lzo_int __LZO_MMODEL * ++#define lzo_xintp lzo_xint __LZO_MMODEL * ++#define lzo_voidpp lzo_voidp __LZO_MMODEL * ++#define lzo_bytepp lzo_bytep __LZO_MMODEL * ++/* deprecated - use 'lzo_bytep' instead of 'lzo_byte *' */ ++#define lzo_byte unsigned char __LZO_MMODEL ++ ++typedef int lzo_bool; ++ ++ ++/*********************************************************************** ++// function types ++************************************************************************/ ++ ++/* name mangling */ ++#if !defined(__LZO_EXTERN_C) ++# ifdef __cplusplus ++# define __LZO_EXTERN_C extern "C" ++# else ++# define __LZO_EXTERN_C extern ++# endif ++#endif ++ ++/* calling convention */ ++#if !defined(__LZO_CDECL) ++# define __LZO_CDECL __lzo_cdecl ++#endif ++ ++/* DLL export information */ ++#if !defined(__LZO_EXPORT1) ++# define __LZO_EXPORT1 /*empty*/ ++#endif ++#if !defined(__LZO_EXPORT2) ++# define __LZO_EXPORT2 /*empty*/ ++#endif ++ ++/* __cdecl calling convention for public C and assembly functions */ ++#if !defined(LZO_PUBLIC) ++# define LZO_PUBLIC(_rettype) __LZO_EXPORT1 _rettype __LZO_EXPORT2 __LZO_CDECL ++#endif ++#if !defined(LZO_EXTERN) ++# define LZO_EXTERN(_rettype) __LZO_EXTERN_C LZO_PUBLIC(_rettype) ++#endif ++#if !defined(LZO_PRIVATE) ++# define LZO_PRIVATE(_rettype) static _rettype __LZO_CDECL ++#endif ++ ++/* function types */ ++typedef int ++(__LZO_CDECL *lzo_compress_t) ( const lzo_bytep src, lzo_uint src_len, ++ lzo_bytep dst, lzo_uintp dst_len, ++ lzo_voidp wrkmem ); ++ ++typedef int ++(__LZO_CDECL *lzo_decompress_t) ( const lzo_bytep src, lzo_uint src_len, ++ lzo_bytep dst, lzo_uintp dst_len, ++ lzo_voidp wrkmem ); ++ ++typedef int ++(__LZO_CDECL *lzo_optimize_t) ( lzo_bytep src, lzo_uint src_len, ++ lzo_bytep dst, lzo_uintp dst_len, ++ lzo_voidp wrkmem ); ++ ++typedef int ++(__LZO_CDECL *lzo_compress_dict_t)(const lzo_bytep src, lzo_uint src_len, ++ lzo_bytep dst, lzo_uintp dst_len, ++ lzo_voidp wrkmem, ++ const lzo_bytep dict, lzo_uint dict_len ); ++ ++typedef int ++(__LZO_CDECL *lzo_decompress_dict_t)(const lzo_bytep src, lzo_uint src_len, ++ lzo_bytep dst, lzo_uintp dst_len, ++ lzo_voidp wrkmem, ++ const lzo_bytep dict, lzo_uint dict_len ); ++ ++ ++/* Callback interface. Currently only the progress indicator ("nprogress") ++ * is used, but this may change in a future release. */ ++ ++struct lzo_callback_t; ++typedef struct lzo_callback_t lzo_callback_t; ++#define lzo_callback_p lzo_callback_t __LZO_MMODEL * ++ ++/* malloc & free function types */ ++typedef lzo_voidp (__LZO_CDECL *lzo_alloc_func_t) ++ (lzo_callback_p self, lzo_uint items, lzo_uint size); ++typedef void (__LZO_CDECL *lzo_free_func_t) ++ (lzo_callback_p self, lzo_voidp ptr); ++ ++/* a progress indicator callback function */ ++typedef void (__LZO_CDECL *lzo_progress_func_t) ++ (lzo_callback_p, lzo_uint, lzo_uint, int); ++ ++struct lzo_callback_t ++{ ++ /* custom allocators (set to 0 to disable) */ ++ lzo_alloc_func_t nalloc; /* [not used right now] */ ++ lzo_free_func_t nfree; /* [not used right now] */ ++ ++ /* a progress indicator callback function (set to 0 to disable) */ ++ lzo_progress_func_t nprogress; ++ ++ /* NOTE: the first parameter "self" of the nalloc/nfree/nprogress ++ * callbacks points back to this struct, so you are free to store ++ * some extra info in the following variables. */ ++ lzo_voidp user1; ++ lzo_xint user2; ++ lzo_xint user3; ++}; ++ ++ ++/*********************************************************************** ++// error codes and prototypes ++************************************************************************/ ++ ++/* Error codes for the compression/decompression functions. Negative ++ * values are errors, positive values will be used for special but ++ * normal events. ++ */ ++#define LZO_E_OK 0 ++#define LZO_E_ERROR (-1) ++#define LZO_E_OUT_OF_MEMORY (-2) /* [lzo_alloc_func_t failure] */ ++#define LZO_E_NOT_COMPRESSIBLE (-3) /* [not used right now] */ ++#define LZO_E_INPUT_OVERRUN (-4) ++#define LZO_E_OUTPUT_OVERRUN (-5) ++#define LZO_E_LOOKBEHIND_OVERRUN (-6) ++#define LZO_E_EOF_NOT_FOUND (-7) ++#define LZO_E_INPUT_NOT_CONSUMED (-8) ++#define LZO_E_NOT_YET_IMPLEMENTED (-9) /* [not used right now] */ ++#define LZO_E_INVALID_ARGUMENT (-10) ++ ++ ++#ifndef lzo_sizeof_dict_t ++# define lzo_sizeof_dict_t ((unsigned)sizeof(lzo_bytep)) ++#endif ++ ++/* lzo_init() should be the first function you call. ++ * Check the return code ! ++ * ++ * lzo_init() is a macro to allow checking that the library and the ++ * compiler's view of various types are consistent. ++ */ ++#define lzo_init() __lzo_init_v2(LZO_VERSION,(int)sizeof(short),(int)sizeof(int),\ ++ (int)sizeof(long),(int)sizeof(lzo_uint32),(int)sizeof(lzo_uint),\ ++ (int)lzo_sizeof_dict_t,(int)sizeof(char *),(int)sizeof(lzo_voidp),\ ++ (int)sizeof(lzo_callback_t)) ++LZO_EXTERN(int) __lzo_init_v2(unsigned,int,int,int,int,int,int,int,int,int); ++ ++/* version functions (useful for shared libraries) */ ++LZO_EXTERN(unsigned) lzo_version(void); ++LZO_EXTERN(const char *) lzo_version_string(void); ++LZO_EXTERN(const char *) lzo_version_date(void); ++LZO_EXTERN(const lzo_charp) _lzo_version_string(void); ++LZO_EXTERN(const lzo_charp) _lzo_version_date(void); ++ ++/* string functions */ ++LZO_EXTERN(int) ++ lzo_memcmp(const lzo_voidp a, const lzo_voidp b, lzo_uint len); ++LZO_EXTERN(lzo_voidp) ++ lzo_memcpy(lzo_voidp dst, const lzo_voidp src, lzo_uint len); ++LZO_EXTERN(lzo_voidp) ++ lzo_memmove(lzo_voidp dst, const lzo_voidp src, lzo_uint len); ++LZO_EXTERN(lzo_voidp) ++ lzo_memset(lzo_voidp buf, int c, lzo_uint len); ++ ++/* checksum functions */ ++LZO_EXTERN(lzo_uint32) ++ lzo_adler32(lzo_uint32 c, const lzo_bytep buf, lzo_uint len); ++LZO_EXTERN(lzo_uint32) ++ lzo_crc32(lzo_uint32 c, const lzo_bytep buf, lzo_uint len); ++LZO_EXTERN(const lzo_uint32p) ++ lzo_get_crc32_table(void); ++ ++/* misc. */ ++LZO_EXTERN(int) _lzo_config_check(void); ++typedef union { lzo_bytep p; lzo_uint u; } __lzo_pu_u; ++typedef union { lzo_bytep p; lzo_uint32 u32; } __lzo_pu32_u; ++typedef union { void *vp; lzo_bytep bp; lzo_uint u; lzo_uint32 u32; unsigned long l; } lzo_align_t; ++ ++/* align a char pointer on a boundary that is a multiple of 'size' */ ++LZO_EXTERN(unsigned) __lzo_align_gap(const lzo_voidp p, lzo_uint size); ++#define LZO_PTR_ALIGN_UP(p,size) \ ++ ((p) + (lzo_uint) __lzo_align_gap((const lzo_voidp)(p),(lzo_uint)(size))) ++ ++ ++/*********************************************************************** ++// deprecated macros - only for backward compatibility with LZO v1.xx ++************************************************************************/ ++ ++#if defined(LZO_CFG_COMPAT) ++ ++#define __LZOCONF_H 1 ++ ++#if defined(LZO_ARCH_I086) ++# define __LZO_i386 1 ++#elif defined(LZO_ARCH_I386) ++# define __LZO_i386 1 ++#endif ++ ++#if defined(LZO_OS_DOS16) ++# define __LZO_DOS 1 ++# define __LZO_DOS16 1 ++#elif defined(LZO_OS_DOS32) ++# define __LZO_DOS 1 ++#elif defined(LZO_OS_WIN16) ++# define __LZO_WIN 1 ++# define __LZO_WIN16 1 ++#elif defined(LZO_OS_WIN32) ++# define __LZO_WIN 1 ++#endif ++ ++#define __LZO_CMODEL /*empty*/ ++#define __LZO_DMODEL /*empty*/ ++#define __LZO_ENTRY __LZO_CDECL ++#define LZO_EXTERN_CDECL LZO_EXTERN ++#define LZO_ALIGN LZO_PTR_ALIGN_UP ++ ++#define lzo_compress_asm_t lzo_compress_t ++#define lzo_decompress_asm_t lzo_decompress_t ++ ++#endif /* LZO_CFG_COMPAT */ ++ ++ ++#ifdef __cplusplus ++} /* extern "C" */ ++#endif ++ ++#endif /* already included */ ++ ++ ++/* vim:set ts=4 et: */ +Index: b/grub-core/lib/minilzo/lzodefs.h +=================================================================== +--- /dev/null ++++ b/grub-core/lib/minilzo/lzodefs.h +@@ -0,0 +1,1852 @@ ++/* lzodefs.h -- architecture, OS and compiler specific defines ++ ++ This file is part of the LZO real-time data compression library. ++ ++ Copyright (C) 2011 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2010 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2009 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer ++ All Rights Reserved. ++ ++ The LZO library 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; either version 2 of ++ the License, or (at your option) any later version. ++ ++ The LZO library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with the LZO library; see the file COPYING. ++ If not, write to the Free Software Foundation, Inc., ++ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ ++ Markus F.X.J. Oberhumer ++ ++ http://www.oberhumer.com/opensource/lzo/ ++ */ ++ ++ ++#ifndef __LZODEFS_H_INCLUDED ++#define __LZODEFS_H_INCLUDED 1 ++ ++#if defined(__CYGWIN32__) && !defined(__CYGWIN__) ++# define __CYGWIN__ __CYGWIN32__ ++#endif ++#if defined(__IBMCPP__) && !defined(__IBMC__) ++# define __IBMC__ __IBMCPP__ ++#endif ++#if defined(__ICL) && defined(_WIN32) && !defined(__INTEL_COMPILER) ++# define __INTEL_COMPILER __ICL ++#endif ++#if 1 && defined(__INTERIX) && defined(__GNUC__) && !defined(_ALL_SOURCE) ++# define _ALL_SOURCE 1 ++#endif ++#if defined(__mips__) && defined(__R5900__) ++# if !defined(__LONG_MAX__) ++# define __LONG_MAX__ 9223372036854775807L ++# endif ++#endif ++#if defined(__INTEL_COMPILER) && defined(__linux__) ++# pragma warning(disable: 193) ++#endif ++#if defined(__KEIL__) && defined(__C166__) ++# pragma warning disable = 322 ++#elif 0 && defined(__C251__) ++# pragma warning disable = 322 ++#endif ++#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && !defined(__MWERKS__) ++# if (_MSC_VER >= 1300) ++# pragma warning(disable: 4668) ++# endif ++#endif ++#if 0 && defined(__WATCOMC__) ++# if (__WATCOMC__ >= 1050) && (__WATCOMC__ < 1060) ++# pragma warning 203 9 ++# endif ++#endif ++#if defined(__BORLANDC__) && defined(__MSDOS__) && !defined(__FLAT__) ++# pragma option -h ++#endif ++#if 0 ++#define LZO_0xffffL 0xfffful ++#define LZO_0xffffffffL 0xfffffffful ++#else ++#define LZO_0xffffL 65535ul ++#define LZO_0xffffffffL 4294967295ul ++#endif ++#if (LZO_0xffffL == LZO_0xffffffffL) ++# error "your preprocessor is broken 1" ++#endif ++#if (16ul * 16384ul != 262144ul) ++# error "your preprocessor is broken 2" ++#endif ++#if 0 ++#if (32767 >= 4294967295ul) ++# error "your preprocessor is broken 3" ++#endif ++#if (65535u >= 4294967295ul) ++# error "your preprocessor is broken 4" ++#endif ++#endif ++#if (UINT_MAX == LZO_0xffffL) ++#if defined(__ZTC__) && defined(__I86__) && !defined(__OS2__) ++# if !defined(MSDOS) ++# define MSDOS 1 ++# endif ++# if !defined(_MSDOS) ++# define _MSDOS 1 ++# endif ++#elif 0 && defined(__VERSION) && defined(MB_LEN_MAX) ++# if (__VERSION == 520) && (MB_LEN_MAX == 1) ++# if !defined(__AZTEC_C__) ++# define __AZTEC_C__ __VERSION ++# endif ++# if !defined(__DOS__) ++# define __DOS__ 1 ++# endif ++# endif ++#endif ++#endif ++#if defined(_MSC_VER) && defined(M_I86HM) && (UINT_MAX == LZO_0xffffL) ++# define ptrdiff_t long ++# define _PTRDIFF_T_DEFINED 1 ++#endif ++#if (UINT_MAX == LZO_0xffffL) ++# undef __LZO_RENAME_A ++# undef __LZO_RENAME_B ++# if defined(__AZTEC_C__) && defined(__DOS__) ++# define __LZO_RENAME_A 1 ++# elif defined(_MSC_VER) && defined(MSDOS) ++# if (_MSC_VER < 600) ++# define __LZO_RENAME_A 1 ++# elif (_MSC_VER < 700) ++# define __LZO_RENAME_B 1 ++# endif ++# elif defined(__TSC__) && defined(__OS2__) ++# define __LZO_RENAME_A 1 ++# elif defined(__MSDOS__) && defined(__TURBOC__) && (__TURBOC__ < 0x0410) ++# define __LZO_RENAME_A 1 ++# elif defined(__PACIFIC__) && defined(DOS) ++# if !defined(__far) ++# define __far far ++# endif ++# if !defined(__near) ++# define __near near ++# endif ++# endif ++# if defined(__LZO_RENAME_A) ++# if !defined(__cdecl) ++# define __cdecl cdecl ++# endif ++# if !defined(__far) ++# define __far far ++# endif ++# if !defined(__huge) ++# define __huge huge ++# endif ++# if !defined(__near) ++# define __near near ++# endif ++# if !defined(__pascal) ++# define __pascal pascal ++# endif ++# if !defined(__huge) ++# define __huge huge ++# endif ++# elif defined(__LZO_RENAME_B) ++# if !defined(__cdecl) ++# define __cdecl _cdecl ++# endif ++# if !defined(__far) ++# define __far _far ++# endif ++# if !defined(__huge) ++# define __huge _huge ++# endif ++# if !defined(__near) ++# define __near _near ++# endif ++# if !defined(__pascal) ++# define __pascal _pascal ++# endif ++# elif (defined(__PUREC__) || defined(__TURBOC__)) && defined(__TOS__) ++# if !defined(__cdecl) ++# define __cdecl cdecl ++# endif ++# if !defined(__pascal) ++# define __pascal pascal ++# endif ++# endif ++# undef __LZO_RENAME_A ++# undef __LZO_RENAME_B ++#endif ++#if (UINT_MAX == LZO_0xffffL) ++#if defined(__AZTEC_C__) && defined(__DOS__) ++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1 ++#elif defined(_MSC_VER) && defined(MSDOS) ++# if (_MSC_VER < 600) ++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1 ++# endif ++# if (_MSC_VER < 700) ++# define LZO_BROKEN_INTEGRAL_PROMOTION 1 ++# define LZO_BROKEN_SIZEOF 1 ++# endif ++#elif defined(__PACIFIC__) && defined(DOS) ++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1 ++#elif defined(__TURBOC__) && defined(__MSDOS__) ++# if (__TURBOC__ < 0x0150) ++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1 ++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1 ++# define LZO_BROKEN_INTEGRAL_PROMOTION 1 ++# endif ++# if (__TURBOC__ < 0x0200) ++# define LZO_BROKEN_SIZEOF 1 ++# endif ++# if (__TURBOC__ < 0x0400) && defined(__cplusplus) ++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1 ++# endif ++#elif (defined(__PUREC__) || defined(__TURBOC__)) && defined(__TOS__) ++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1 ++# define LZO_BROKEN_SIZEOF 1 ++#endif ++#endif ++#if defined(__WATCOMC__) && (__WATCOMC__ < 900) ++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1 ++#endif ++#if defined(_CRAY) && defined(_CRAY1) ++# define LZO_BROKEN_SIGNED_RIGHT_SHIFT 1 ++#endif ++#define LZO_PP_STRINGIZE(x) #x ++#define LZO_PP_MACRO_EXPAND(x) LZO_PP_STRINGIZE(x) ++#define LZO_PP_CONCAT2(a,b) a ## b ++#define LZO_PP_CONCAT3(a,b,c) a ## b ## c ++#define LZO_PP_CONCAT4(a,b,c,d) a ## b ## c ## d ++#define LZO_PP_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e ++#define LZO_PP_ECONCAT2(a,b) LZO_PP_CONCAT2(a,b) ++#define LZO_PP_ECONCAT3(a,b,c) LZO_PP_CONCAT3(a,b,c) ++#define LZO_PP_ECONCAT4(a,b,c,d) LZO_PP_CONCAT4(a,b,c,d) ++#define LZO_PP_ECONCAT5(a,b,c,d,e) LZO_PP_CONCAT5(a,b,c,d,e) ++#if 1 ++#define LZO_CPP_STRINGIZE(x) #x ++#define LZO_CPP_MACRO_EXPAND(x) LZO_CPP_STRINGIZE(x) ++#define LZO_CPP_CONCAT2(a,b) a ## b ++#define LZO_CPP_CONCAT3(a,b,c) a ## b ## c ++#define LZO_CPP_CONCAT4(a,b,c,d) a ## b ## c ## d ++#define LZO_CPP_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e ++#define LZO_CPP_ECONCAT2(a,b) LZO_CPP_CONCAT2(a,b) ++#define LZO_CPP_ECONCAT3(a,b,c) LZO_CPP_CONCAT3(a,b,c) ++#define LZO_CPP_ECONCAT4(a,b,c,d) LZO_CPP_CONCAT4(a,b,c,d) ++#define LZO_CPP_ECONCAT5(a,b,c,d,e) LZO_CPP_CONCAT5(a,b,c,d,e) ++#endif ++#define __LZO_MASK_GEN(o,b) (((((o) << ((b)-1)) - (o)) << 1) + (o)) ++#if 1 && defined(__cplusplus) ++# if !defined(__STDC_CONSTANT_MACROS) ++# define __STDC_CONSTANT_MACROS 1 ++# endif ++# if !defined(__STDC_LIMIT_MACROS) ++# define __STDC_LIMIT_MACROS 1 ++# endif ++#endif ++#if defined(__cplusplus) ++# define LZO_EXTERN_C extern "C" ++#else ++# define LZO_EXTERN_C extern ++#endif ++#if !defined(__LZO_OS_OVERRIDE) ++#if (LZO_OS_FREESTANDING) ++# define LZO_INFO_OS "freestanding" ++#elif (LZO_OS_EMBEDDED) ++# define LZO_INFO_OS "embedded" ++#elif 1 && defined(__IAR_SYSTEMS_ICC__) ++# define LZO_OS_EMBEDDED 1 ++# define LZO_INFO_OS "embedded" ++#elif defined(__CYGWIN__) && defined(__GNUC__) ++# define LZO_OS_CYGWIN 1 ++# define LZO_INFO_OS "cygwin" ++#elif defined(__EMX__) && defined(__GNUC__) ++# define LZO_OS_EMX 1 ++# define LZO_INFO_OS "emx" ++#elif defined(__BEOS__) ++# define LZO_OS_BEOS 1 ++# define LZO_INFO_OS "beos" ++#elif defined(__Lynx__) ++# define LZO_OS_LYNXOS 1 ++# define LZO_INFO_OS "lynxos" ++#elif defined(__OS400__) ++# define LZO_OS_OS400 1 ++# define LZO_INFO_OS "os400" ++#elif defined(__QNX__) ++# define LZO_OS_QNX 1 ++# define LZO_INFO_OS "qnx" ++#elif defined(__BORLANDC__) && defined(__DPMI32__) && (__BORLANDC__ >= 0x0460) ++# define LZO_OS_DOS32 1 ++# define LZO_INFO_OS "dos32" ++#elif defined(__BORLANDC__) && defined(__DPMI16__) ++# define LZO_OS_DOS16 1 ++# define LZO_INFO_OS "dos16" ++#elif defined(__ZTC__) && defined(DOS386) ++# define LZO_OS_DOS32 1 ++# define LZO_INFO_OS "dos32" ++#elif defined(__OS2__) || defined(__OS2V2__) ++# if (UINT_MAX == LZO_0xffffL) ++# define LZO_OS_OS216 1 ++# define LZO_INFO_OS "os216" ++# elif (UINT_MAX == LZO_0xffffffffL) ++# define LZO_OS_OS2 1 ++# define LZO_INFO_OS "os2" ++# else ++# error "check your limits.h header" ++# endif ++#elif defined(__WIN64__) || defined(_WIN64) || defined(WIN64) ++# define LZO_OS_WIN64 1 ++# define LZO_INFO_OS "win64" ++#elif defined(__WIN32__) || defined(_WIN32) || defined(WIN32) || defined(__WINDOWS_386__) ++# define LZO_OS_WIN32 1 ++# define LZO_INFO_OS "win32" ++#elif defined(__MWERKS__) && defined(__INTEL__) ++# define LZO_OS_WIN32 1 ++# define LZO_INFO_OS "win32" ++#elif defined(__WINDOWS__) || defined(_WINDOWS) || defined(_Windows) ++# if (UINT_MAX == LZO_0xffffL) ++# define LZO_OS_WIN16 1 ++# define LZO_INFO_OS "win16" ++# elif (UINT_MAX == LZO_0xffffffffL) ++# define LZO_OS_WIN32 1 ++# define LZO_INFO_OS "win32" ++# else ++# error "check your limits.h header" ++# endif ++#elif defined(__DOS__) || defined(__MSDOS__) || defined(_MSDOS) || defined(MSDOS) || (defined(__PACIFIC__) && defined(DOS)) ++# if (UINT_MAX == LZO_0xffffL) ++# define LZO_OS_DOS16 1 ++# define LZO_INFO_OS "dos16" ++# elif (UINT_MAX == LZO_0xffffffffL) ++# define LZO_OS_DOS32 1 ++# define LZO_INFO_OS "dos32" ++# else ++# error "check your limits.h header" ++# endif ++#elif defined(__WATCOMC__) ++# if defined(__NT__) && (UINT_MAX == LZO_0xffffL) ++# define LZO_OS_DOS16 1 ++# define LZO_INFO_OS "dos16" ++# elif defined(__NT__) && (__WATCOMC__ < 1100) ++# define LZO_OS_WIN32 1 ++# define LZO_INFO_OS "win32" ++# elif defined(__linux__) || defined(__LINUX__) ++# define LZO_OS_POSIX 1 ++# define LZO_INFO_OS "posix" ++# else ++# error "please specify a target using the -bt compiler option" ++# endif ++#elif defined(__palmos__) ++# define LZO_OS_PALMOS 1 ++# define LZO_INFO_OS "palmos" ++#elif defined(__TOS__) || defined(__atarist__) ++# define LZO_OS_TOS 1 ++# define LZO_INFO_OS "tos" ++#elif defined(macintosh) && !defined(__ppc__) ++# define LZO_OS_MACCLASSIC 1 ++# define LZO_INFO_OS "macclassic" ++#elif defined(__VMS) ++# define LZO_OS_VMS 1 ++# define LZO_INFO_OS "vms" ++#elif ((defined(__mips__) && defined(__R5900__)) || defined(__MIPS_PSX2__)) ++# define LZO_OS_CONSOLE 1 ++# define LZO_OS_CONSOLE_PS2 1 ++# define LZO_INFO_OS "console" ++# define LZO_INFO_OS_CONSOLE "ps2" ++#elif (defined(__mips__) && defined(__psp__)) ++# define LZO_OS_CONSOLE 1 ++# define LZO_OS_CONSOLE_PSP 1 ++# define LZO_INFO_OS "console" ++# define LZO_INFO_OS_CONSOLE "psp" ++#else ++# define LZO_OS_POSIX 1 ++# define LZO_INFO_OS "posix" ++#endif ++#if (LZO_OS_POSIX) ++# if defined(_AIX) || defined(__AIX__) || defined(__aix__) ++# define LZO_OS_POSIX_AIX 1 ++# define LZO_INFO_OS_POSIX "aix" ++# elif defined(__FreeBSD__) ++# define LZO_OS_POSIX_FREEBSD 1 ++# define LZO_INFO_OS_POSIX "freebsd" ++# elif defined(__hpux__) || defined(__hpux) ++# define LZO_OS_POSIX_HPUX 1 ++# define LZO_INFO_OS_POSIX "hpux" ++# elif defined(__INTERIX) ++# define LZO_OS_POSIX_INTERIX 1 ++# define LZO_INFO_OS_POSIX "interix" ++# elif defined(__IRIX__) || defined(__irix__) ++# define LZO_OS_POSIX_IRIX 1 ++# define LZO_INFO_OS_POSIX "irix" ++# elif defined(__linux__) || defined(__linux) || defined(__LINUX__) ++# define LZO_OS_POSIX_LINUX 1 ++# define LZO_INFO_OS_POSIX "linux" ++# elif defined(__APPLE__) || defined(__MACOS__) ++# define LZO_OS_POSIX_MACOSX 1 ++# define LZO_INFO_OS_POSIX "macosx" ++# elif defined(__minix__) || defined(__minix) ++# define LZO_OS_POSIX_MINIX 1 ++# define LZO_INFO_OS_POSIX "minix" ++# elif defined(__NetBSD__) ++# define LZO_OS_POSIX_NETBSD 1 ++# define LZO_INFO_OS_POSIX "netbsd" ++# elif defined(__OpenBSD__) ++# define LZO_OS_POSIX_OPENBSD 1 ++# define LZO_INFO_OS_POSIX "openbsd" ++# elif defined(__osf__) ++# define LZO_OS_POSIX_OSF 1 ++# define LZO_INFO_OS_POSIX "osf" ++# elif defined(__solaris__) || defined(__sun) ++# if defined(__SVR4) || defined(__svr4__) ++# define LZO_OS_POSIX_SOLARIS 1 ++# define LZO_INFO_OS_POSIX "solaris" ++# else ++# define LZO_OS_POSIX_SUNOS 1 ++# define LZO_INFO_OS_POSIX "sunos" ++# endif ++# elif defined(__ultrix__) || defined(__ultrix) ++# define LZO_OS_POSIX_ULTRIX 1 ++# define LZO_INFO_OS_POSIX "ultrix" ++# elif defined(_UNICOS) ++# define LZO_OS_POSIX_UNICOS 1 ++# define LZO_INFO_OS_POSIX "unicos" ++# else ++# define LZO_OS_POSIX_UNKNOWN 1 ++# define LZO_INFO_OS_POSIX "unknown" ++# endif ++#endif ++#endif ++#if (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16) ++# if (UINT_MAX != LZO_0xffffL) ++# error "this should not happen" ++# endif ++# if (ULONG_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++#endif ++#if (LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_WIN32 || LZO_OS_WIN64) ++# if (UINT_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++# if (ULONG_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++#endif ++#if defined(CIL) && defined(_GNUCC) && defined(__GNUC__) ++# define LZO_CC_CILLY 1 ++# define LZO_INFO_CC "Cilly" ++# if defined(__CILLY__) ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__CILLY__) ++# else ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif 0 && defined(SDCC) && defined(__VERSION__) && !defined(__GNUC__) ++# define LZO_CC_SDCC 1 ++# define LZO_INFO_CC "sdcc" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(SDCC) ++#elif defined(__PATHSCALE__) && defined(__PATHCC_PATCHLEVEL__) ++# define LZO_CC_PATHSCALE (__PATHCC__ * 0x10000L + __PATHCC_MINOR__ * 0x100 + __PATHCC_PATCHLEVEL__) ++# define LZO_INFO_CC "Pathscale C" ++# define LZO_INFO_CCVER __PATHSCALE__ ++#elif defined(__INTEL_COMPILER) ++# define LZO_CC_INTELC 1 ++# define LZO_INFO_CC "Intel C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__INTEL_COMPILER) ++# if defined(_WIN32) || defined(_WIN64) ++# define LZO_CC_SYNTAX_MSC 1 ++# else ++# define LZO_CC_SYNTAX_GNUC 1 ++# endif ++#elif defined(__POCC__) && defined(_WIN32) ++# define LZO_CC_PELLESC 1 ++# define LZO_INFO_CC "Pelles C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__POCC__) ++#elif defined(__clang__) && defined(__llvm__) && defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__VERSION__) ++# if defined(__GNUC_PATCHLEVEL__) ++# define LZO_CC_CLANG_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__) ++# else ++# define LZO_CC_CLANG_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100) ++# endif ++# if defined(__clang_major__) && defined(__clang_minor__) && defined(__clang_patchlevel__) ++# define LZO_CC_CLANG_CLANG (__clang_major__ * 0x10000L + __clang_minor__ * 0x100 + __clang_patchlevel__) ++# else ++# define LZO_CC_CLANG_CLANG 0x010000L ++# endif ++# define LZO_CC_CLANG LZO_CC_CLANG_GNUC ++# define LZO_INFO_CC "clang" ++# define LZO_INFO_CCVER __VERSION__ ++#elif defined(__llvm__) && defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__VERSION__) ++# if defined(__GNUC_PATCHLEVEL__) ++# define LZO_CC_LLVM_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__) ++# else ++# define LZO_CC_LLVM_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100) ++# endif ++# define LZO_CC_LLVM LZO_CC_LLVM_GNUC ++# define LZO_INFO_CC "llvm-gcc" ++# define LZO_INFO_CCVER __VERSION__ ++#elif defined(__GNUC__) && defined(__VERSION__) ++# if defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) ++# define LZO_CC_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__) ++# elif defined(__GNUC_MINOR__) ++# define LZO_CC_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100) ++# else ++# define LZO_CC_GNUC (__GNUC__ * 0x10000L) ++# endif ++# define LZO_INFO_CC "gcc" ++# define LZO_INFO_CCVER __VERSION__ ++#elif defined(__ACK__) && defined(_ACK) ++# define LZO_CC_ACK 1 ++# define LZO_INFO_CC "Amsterdam Compiler Kit C" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__AZTEC_C__) ++# define LZO_CC_AZTECC 1 ++# define LZO_INFO_CC "Aztec C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__AZTEC_C__) ++#elif defined(__CODEGEARC__) ++# define LZO_CC_CODEGEARC 1 ++# define LZO_INFO_CC "CodeGear C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__CODEGEARC__) ++#elif defined(__BORLANDC__) ++# define LZO_CC_BORLANDC 1 ++# define LZO_INFO_CC "Borland C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__BORLANDC__) ++#elif defined(_CRAYC) && defined(_RELEASE) ++# define LZO_CC_CRAYC 1 ++# define LZO_INFO_CC "Cray C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_RELEASE) ++#elif defined(__DMC__) && defined(__SC__) ++# define LZO_CC_DMC 1 ++# define LZO_INFO_CC "Digital Mars C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__DMC__) ++#elif defined(__DECC) ++# define LZO_CC_DECC 1 ++# define LZO_INFO_CC "DEC C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__DECC) ++#elif defined(__HIGHC__) ++# define LZO_CC_HIGHC 1 ++# define LZO_INFO_CC "MetaWare High C" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__IAR_SYSTEMS_ICC__) ++# define LZO_CC_IARC 1 ++# define LZO_INFO_CC "IAR C" ++# if defined(__VER__) ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__VER__) ++# else ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif defined(__IBMC__) ++# define LZO_CC_IBMC 1 ++# define LZO_INFO_CC "IBM C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__IBMC__) ++#elif defined(__KEIL__) && defined(__C166__) ++# define LZO_CC_KEILC 1 ++# define LZO_INFO_CC "Keil C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__C166__) ++#elif defined(__LCC__) && defined(_WIN32) && defined(__LCCOPTIMLEVEL) ++# define LZO_CC_LCCWIN32 1 ++# define LZO_INFO_CC "lcc-win32" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__LCC__) ++# define LZO_CC_LCC 1 ++# define LZO_INFO_CC "lcc" ++# if defined(__LCC_VERSION__) ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__LCC_VERSION__) ++# else ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif defined(_MSC_VER) ++# define LZO_CC_MSC 1 ++# define LZO_INFO_CC "Microsoft C" ++# if defined(_MSC_FULL_VER) ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_MSC_VER) "." LZO_PP_MACRO_EXPAND(_MSC_FULL_VER) ++# else ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_MSC_VER) ++# endif ++#elif defined(__MWERKS__) ++# define LZO_CC_MWERKS 1 ++# define LZO_INFO_CC "Metrowerks C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__MWERKS__) ++#elif (defined(__NDPC__) || defined(__NDPX__)) && defined(__i386) ++# define LZO_CC_NDPC 1 ++# define LZO_INFO_CC "Microway NDP C" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__PACIFIC__) ++# define LZO_CC_PACIFICC 1 ++# define LZO_INFO_CC "Pacific C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__PACIFIC__) ++#elif defined(__PGI) && (defined(__linux__) || defined(__WIN32__)) ++# define LZO_CC_PGI 1 ++# define LZO_INFO_CC "Portland Group PGI C" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__PUREC__) && defined(__TOS__) ++# define LZO_CC_PUREC 1 ++# define LZO_INFO_CC "Pure C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__PUREC__) ++#elif defined(__SC__) && defined(__ZTC__) ++# define LZO_CC_SYMANTECC 1 ++# define LZO_INFO_CC "Symantec C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SC__) ++#elif defined(__SUNPRO_C) ++# define LZO_INFO_CC "SunPro C" ++# if ((__SUNPRO_C)+0 > 0) ++# define LZO_CC_SUNPROC __SUNPRO_C ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SUNPRO_C) ++# else ++# define LZO_CC_SUNPROC 1 ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif defined(__SUNPRO_CC) ++# define LZO_INFO_CC "SunPro C" ++# if ((__SUNPRO_CC)+0 > 0) ++# define LZO_CC_SUNPROC __SUNPRO_CC ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SUNPRO_CC) ++# else ++# define LZO_CC_SUNPROC 1 ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif defined(__TINYC__) ++# define LZO_CC_TINYC 1 ++# define LZO_INFO_CC "Tiny C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TINYC__) ++#elif defined(__TSC__) ++# define LZO_CC_TOPSPEEDC 1 ++# define LZO_INFO_CC "TopSpeed C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TSC__) ++#elif defined(__WATCOMC__) ++# define LZO_CC_WATCOMC 1 ++# define LZO_INFO_CC "Watcom C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__WATCOMC__) ++#elif defined(__TURBOC__) ++# define LZO_CC_TURBOC 1 ++# define LZO_INFO_CC "Turbo C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TURBOC__) ++#elif defined(__ZTC__) ++# define LZO_CC_ZORTECHC 1 ++# define LZO_INFO_CC "Zortech C" ++# if (__ZTC__ == 0x310) ++# define LZO_INFO_CCVER "0x310" ++# else ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__ZTC__) ++# endif ++#else ++# define LZO_CC_UNKNOWN 1 ++# define LZO_INFO_CC "unknown" ++# define LZO_INFO_CCVER "unknown" ++#endif ++#if 0 && (LZO_CC_MSC && (_MSC_VER >= 1200)) && !defined(_MSC_FULL_VER) ++# error "LZO_CC_MSC: _MSC_FULL_VER is not defined" ++#endif ++#if !defined(__LZO_ARCH_OVERRIDE) && !(LZO_ARCH_GENERIC) && defined(_CRAY) ++# if (UINT_MAX > LZO_0xffffffffL) && defined(_CRAY) ++# if defined(_CRAYMPP) || defined(_CRAYT3D) || defined(_CRAYT3E) ++# define LZO_ARCH_CRAY_MPP 1 ++# elif defined(_CRAY1) ++# define LZO_ARCH_CRAY_PVP 1 ++# endif ++# endif ++#endif ++#if !defined(__LZO_ARCH_OVERRIDE) ++#if (LZO_ARCH_GENERIC) ++# define LZO_INFO_ARCH "generic" ++#elif (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16) ++# define LZO_ARCH_I086 1 ++# define LZO_ARCH_IA16 1 ++# define LZO_INFO_ARCH "i086" ++#elif defined(__alpha__) || defined(__alpha) || defined(_M_ALPHA) ++# define LZO_ARCH_ALPHA 1 ++# define LZO_INFO_ARCH "alpha" ++#elif (LZO_ARCH_CRAY_MPP) && (defined(_CRAYT3D) || defined(_CRAYT3E)) ++# define LZO_ARCH_ALPHA 1 ++# define LZO_INFO_ARCH "alpha" ++#elif defined(__amd64__) || defined(__x86_64__) || defined(_M_AMD64) ++# define LZO_ARCH_AMD64 1 ++# define LZO_INFO_ARCH "amd64" ++#elif defined(__thumb__) || (defined(_M_ARM) && defined(_M_THUMB)) ++# define LZO_ARCH_ARM 1 ++# define LZO_ARCH_ARM_THUMB 1 ++# define LZO_INFO_ARCH "arm_thumb" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCARM__) ++# define LZO_ARCH_ARM 1 ++# if defined(__CPU_MODE__) && ((__CPU_MODE__)+0 == 1) ++# define LZO_ARCH_ARM_THUMB 1 ++# define LZO_INFO_ARCH "arm_thumb" ++# elif defined(__CPU_MODE__) && ((__CPU_MODE__)+0 == 2) ++# define LZO_INFO_ARCH "arm" ++# else ++# define LZO_INFO_ARCH "arm" ++# endif ++#elif defined(__arm__) || defined(_M_ARM) ++# define LZO_ARCH_ARM 1 ++# define LZO_INFO_ARCH "arm" ++#elif (UINT_MAX <= LZO_0xffffL) && defined(__AVR__) ++# define LZO_ARCH_AVR 1 ++# define LZO_INFO_ARCH "avr" ++#elif defined(__avr32__) || defined(__AVR32__) ++# define LZO_ARCH_AVR32 1 ++# define LZO_INFO_ARCH "avr32" ++#elif defined(__bfin__) ++# define LZO_ARCH_BLACKFIN 1 ++# define LZO_INFO_ARCH "blackfin" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__C166__) ++# define LZO_ARCH_C166 1 ++# define LZO_INFO_ARCH "c166" ++#elif defined(__cris__) ++# define LZO_ARCH_CRIS 1 ++# define LZO_INFO_ARCH "cris" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCEZ80__) ++# define LZO_ARCH_EZ80 1 ++# define LZO_INFO_ARCH "ez80" ++#elif defined(__H8300__) || defined(__H8300H__) || defined(__H8300S__) || defined(__H8300SX__) ++# define LZO_ARCH_H8300 1 ++# define LZO_INFO_ARCH "h8300" ++#elif defined(__hppa__) || defined(__hppa) ++# define LZO_ARCH_HPPA 1 ++# define LZO_INFO_ARCH "hppa" ++#elif defined(__386__) || defined(__i386__) || defined(__i386) || defined(_M_IX86) || defined(_M_I386) ++# define LZO_ARCH_I386 1 ++# define LZO_ARCH_IA32 1 ++# define LZO_INFO_ARCH "i386" ++#elif (LZO_CC_ZORTECHC && defined(__I86__)) ++# define LZO_ARCH_I386 1 ++# define LZO_ARCH_IA32 1 ++# define LZO_INFO_ARCH "i386" ++#elif (LZO_OS_DOS32 && LZO_CC_HIGHC) && defined(_I386) ++# define LZO_ARCH_I386 1 ++# define LZO_ARCH_IA32 1 ++# define LZO_INFO_ARCH "i386" ++#elif defined(__ia64__) || defined(__ia64) || defined(_M_IA64) ++# define LZO_ARCH_IA64 1 ++# define LZO_INFO_ARCH "ia64" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__m32c__) ++# define LZO_ARCH_M16C 1 ++# define LZO_INFO_ARCH "m16c" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCM16C__) ++# define LZO_ARCH_M16C 1 ++# define LZO_INFO_ARCH "m16c" ++#elif defined(__m32r__) ++# define LZO_ARCH_M32R 1 ++# define LZO_INFO_ARCH "m32r" ++#elif (LZO_OS_TOS) || defined(__m68k__) || defined(__m68000__) || defined(__mc68000__) || defined(__mc68020__) || defined(_M_M68K) ++# define LZO_ARCH_M68K 1 ++# define LZO_INFO_ARCH "m68k" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__C251__) ++# define LZO_ARCH_MCS251 1 ++# define LZO_INFO_ARCH "mcs251" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__C51__) ++# define LZO_ARCH_MCS51 1 ++# define LZO_INFO_ARCH "mcs51" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICC8051__) ++# define LZO_ARCH_MCS51 1 ++# define LZO_INFO_ARCH "mcs51" ++#elif defined(__mips__) || defined(__mips) || defined(_MIPS_ARCH) || defined(_M_MRX000) ++# define LZO_ARCH_MIPS 1 ++# define LZO_INFO_ARCH "mips" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__MSP430__) ++# define LZO_ARCH_MSP430 1 ++# define LZO_INFO_ARCH "msp430" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICC430__) ++# define LZO_ARCH_MSP430 1 ++# define LZO_INFO_ARCH "msp430" ++#elif defined(__powerpc__) || defined(__powerpc) || defined(__ppc__) || defined(__PPC__) || defined(_M_PPC) || defined(_ARCH_PPC) || defined(_ARCH_PWR) ++# define LZO_ARCH_POWERPC 1 ++# define LZO_INFO_ARCH "powerpc" ++#elif defined(__s390__) || defined(__s390) || defined(__s390x__) || defined(__s390x) ++# define LZO_ARCH_S390 1 ++# define LZO_INFO_ARCH "s390" ++#elif defined(__sh__) || defined(_M_SH) ++# define LZO_ARCH_SH 1 ++# define LZO_INFO_ARCH "sh" ++#elif defined(__sparc__) || defined(__sparc) || defined(__sparcv8) ++# define LZO_ARCH_SPARC 1 ++# define LZO_INFO_ARCH "sparc" ++#elif defined(__SPU__) ++# define LZO_ARCH_SPU 1 ++# define LZO_INFO_ARCH "spu" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__z80) ++# define LZO_ARCH_Z80 1 ++# define LZO_INFO_ARCH "z80" ++#elif (LZO_ARCH_CRAY_PVP) ++# if defined(_CRAYSV1) ++# define LZO_ARCH_CRAY_SV1 1 ++# define LZO_INFO_ARCH "cray_sv1" ++# elif (_ADDR64) ++# define LZO_ARCH_CRAY_T90 1 ++# define LZO_INFO_ARCH "cray_t90" ++# elif (_ADDR32) ++# define LZO_ARCH_CRAY_YMP 1 ++# define LZO_INFO_ARCH "cray_ymp" ++# else ++# define LZO_ARCH_CRAY_XMP 1 ++# define LZO_INFO_ARCH "cray_xmp" ++# endif ++#else ++# define LZO_ARCH_UNKNOWN 1 ++# define LZO_INFO_ARCH "unknown" ++#endif ++#endif ++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_DOS32 || LZO_OS_OS2) ++# error "FIXME - missing define for CPU architecture" ++#endif ++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_WIN32) ++# error "FIXME - missing WIN32 define for CPU architecture" ++#endif ++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_WIN64) ++# error "FIXME - missing WIN64 define for CPU architecture" ++#endif ++#if (LZO_OS_OS216 || LZO_OS_WIN16) ++# define LZO_ARCH_I086PM 1 ++# define LZO_ARCH_IA16PM 1 ++#elif 1 && (LZO_OS_DOS16 && defined(BLX286)) ++# define LZO_ARCH_I086PM 1 ++# define LZO_ARCH_IA16PM 1 ++#elif 1 && (LZO_OS_DOS16 && defined(DOSX286)) ++# define LZO_ARCH_I086PM 1 ++# define LZO_ARCH_IA16PM 1 ++#elif 1 && (LZO_OS_DOS16 && LZO_CC_BORLANDC && defined(__DPMI16__)) ++# define LZO_ARCH_I086PM 1 ++# define LZO_ARCH_IA16PM 1 ++#endif ++#if (LZO_ARCH_ARM_THUMB) && !(LZO_ARCH_ARM) ++# error "this should not happen" ++#endif ++#if (LZO_ARCH_I086PM) && !(LZO_ARCH_I086) ++# error "this should not happen" ++#endif ++#if (LZO_ARCH_I086) ++# if (UINT_MAX != LZO_0xffffL) ++# error "this should not happen" ++# endif ++# if (ULONG_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++#endif ++#if (LZO_ARCH_I386) ++# if (UINT_MAX != LZO_0xffffL) && defined(__i386_int16__) ++# error "this should not happen" ++# endif ++# if (UINT_MAX != LZO_0xffffffffL) && !defined(__i386_int16__) ++# error "this should not happen" ++# endif ++# if (ULONG_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++#endif ++#if !defined(__LZO_MM_OVERRIDE) ++#if (LZO_ARCH_I086) ++#if (UINT_MAX != LZO_0xffffL) ++# error "this should not happen" ++#endif ++#if defined(__TINY__) || defined(M_I86TM) || defined(_M_I86TM) ++# define LZO_MM_TINY 1 ++#elif defined(__HUGE__) || defined(_HUGE_) || defined(M_I86HM) || defined(_M_I86HM) ++# define LZO_MM_HUGE 1 ++#elif defined(__SMALL__) || defined(M_I86SM) || defined(_M_I86SM) || defined(SMALL_MODEL) ++# define LZO_MM_SMALL 1 ++#elif defined(__MEDIUM__) || defined(M_I86MM) || defined(_M_I86MM) ++# define LZO_MM_MEDIUM 1 ++#elif defined(__COMPACT__) || defined(M_I86CM) || defined(_M_I86CM) ++# define LZO_MM_COMPACT 1 ++#elif defined(__LARGE__) || defined(M_I86LM) || defined(_M_I86LM) || defined(LARGE_MODEL) ++# define LZO_MM_LARGE 1 ++#elif (LZO_CC_AZTECC) ++# if defined(_LARGE_CODE) && defined(_LARGE_DATA) ++# define LZO_MM_LARGE 1 ++# elif defined(_LARGE_CODE) ++# define LZO_MM_MEDIUM 1 ++# elif defined(_LARGE_DATA) ++# define LZO_MM_COMPACT 1 ++# else ++# define LZO_MM_SMALL 1 ++# endif ++#elif (LZO_CC_ZORTECHC && defined(__VCM__)) ++# define LZO_MM_LARGE 1 ++#else ++# error "unknown memory model" ++#endif ++#if (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16) ++#define LZO_HAVE_MM_HUGE_PTR 1 ++#define LZO_HAVE_MM_HUGE_ARRAY 1 ++#if (LZO_MM_TINY) ++# undef LZO_HAVE_MM_HUGE_ARRAY ++#endif ++#if (LZO_CC_AZTECC || LZO_CC_PACIFICC || LZO_CC_ZORTECHC) ++# undef LZO_HAVE_MM_HUGE_PTR ++# undef LZO_HAVE_MM_HUGE_ARRAY ++#elif (LZO_CC_DMC || LZO_CC_SYMANTECC) ++# undef LZO_HAVE_MM_HUGE_ARRAY ++#elif (LZO_CC_MSC && defined(_QC)) ++# undef LZO_HAVE_MM_HUGE_ARRAY ++# if (_MSC_VER < 600) ++# undef LZO_HAVE_MM_HUGE_PTR ++# endif ++#elif (LZO_CC_TURBOC && (__TURBOC__ < 0x0295)) ++# undef LZO_HAVE_MM_HUGE_ARRAY ++#endif ++#if (LZO_ARCH_I086PM) && !(LZO_HAVE_MM_HUGE_PTR) ++# if (LZO_OS_DOS16) ++# error "this should not happen" ++# elif (LZO_CC_ZORTECHC) ++# else ++# error "this should not happen" ++# endif ++#endif ++#ifdef __cplusplus ++extern "C" { ++#endif ++#if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0200)) ++ extern void __near __cdecl _AHSHIFT(void); ++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) ++#elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) ++ extern void __near __cdecl _AHSHIFT(void); ++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) ++#elif (LZO_CC_MSC || LZO_CC_TOPSPEEDC) ++ extern void __near __cdecl _AHSHIFT(void); ++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) ++#elif (LZO_CC_TURBOC && (__TURBOC__ >= 0x0295)) ++ extern void __near __cdecl _AHSHIFT(void); ++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) ++#elif ((LZO_CC_AZTECC || LZO_CC_PACIFICC || LZO_CC_TURBOC) && LZO_OS_DOS16) ++# define LZO_MM_AHSHIFT 12 ++#elif (LZO_CC_WATCOMC) ++ extern unsigned char _HShift; ++# define LZO_MM_AHSHIFT ((unsigned) _HShift) ++#else ++# error "FIXME - implement LZO_MM_AHSHIFT" ++#endif ++#ifdef __cplusplus ++} ++#endif ++#endif ++#elif (LZO_ARCH_C166) ++#if !defined(__MODEL__) ++# error "FIXME - C166 __MODEL__" ++#elif ((__MODEL__) == 0) ++# define LZO_MM_SMALL 1 ++#elif ((__MODEL__) == 1) ++# define LZO_MM_SMALL 1 ++#elif ((__MODEL__) == 2) ++# define LZO_MM_LARGE 1 ++#elif ((__MODEL__) == 3) ++# define LZO_MM_TINY 1 ++#elif ((__MODEL__) == 4) ++# define LZO_MM_XTINY 1 ++#elif ((__MODEL__) == 5) ++# define LZO_MM_XSMALL 1 ++#else ++# error "FIXME - C166 __MODEL__" ++#endif ++#elif (LZO_ARCH_MCS251) ++#if !defined(__MODEL__) ++# error "FIXME - MCS251 __MODEL__" ++#elif ((__MODEL__) == 0) ++# define LZO_MM_SMALL 1 ++#elif ((__MODEL__) == 2) ++# define LZO_MM_LARGE 1 ++#elif ((__MODEL__) == 3) ++# define LZO_MM_TINY 1 ++#elif ((__MODEL__) == 4) ++# define LZO_MM_XTINY 1 ++#elif ((__MODEL__) == 5) ++# define LZO_MM_XSMALL 1 ++#else ++# error "FIXME - MCS251 __MODEL__" ++#endif ++#elif (LZO_ARCH_MCS51) ++#if !defined(__MODEL__) ++# error "FIXME - MCS51 __MODEL__" ++#elif ((__MODEL__) == 1) ++# define LZO_MM_SMALL 1 ++#elif ((__MODEL__) == 2) ++# define LZO_MM_LARGE 1 ++#elif ((__MODEL__) == 3) ++# define LZO_MM_TINY 1 ++#elif ((__MODEL__) == 4) ++# define LZO_MM_XTINY 1 ++#elif ((__MODEL__) == 5) ++# define LZO_MM_XSMALL 1 ++#else ++# error "FIXME - MCS51 __MODEL__" ++#endif ++#elif (LZO_ARCH_CRAY_PVP) ++# define LZO_MM_PVP 1 ++#else ++# define LZO_MM_FLAT 1 ++#endif ++#if (LZO_MM_COMPACT) ++# define LZO_INFO_MM "compact" ++#elif (LZO_MM_FLAT) ++# define LZO_INFO_MM "flat" ++#elif (LZO_MM_HUGE) ++# define LZO_INFO_MM "huge" ++#elif (LZO_MM_LARGE) ++# define LZO_INFO_MM "large" ++#elif (LZO_MM_MEDIUM) ++# define LZO_INFO_MM "medium" ++#elif (LZO_MM_PVP) ++# define LZO_INFO_MM "pvp" ++#elif (LZO_MM_SMALL) ++# define LZO_INFO_MM "small" ++#elif (LZO_MM_TINY) ++# define LZO_INFO_MM "tiny" ++#else ++# error "unknown memory model" ++#endif ++#endif ++#if defined(SIZEOF_SHORT) ++# define LZO_SIZEOF_SHORT (SIZEOF_SHORT) ++#endif ++#if defined(SIZEOF_INT) ++# define LZO_SIZEOF_INT (SIZEOF_INT) ++#endif ++#if defined(SIZEOF_LONG) ++# define LZO_SIZEOF_LONG (SIZEOF_LONG) ++#endif ++#if defined(SIZEOF_LONG_LONG) ++# define LZO_SIZEOF_LONG_LONG (SIZEOF_LONG_LONG) ++#endif ++#if defined(SIZEOF___INT16) ++# define LZO_SIZEOF___INT16 (SIZEOF___INT16) ++#endif ++#if defined(SIZEOF___INT32) ++# define LZO_SIZEOF___INT32 (SIZEOF___INT32) ++#endif ++#if defined(SIZEOF___INT64) ++# define LZO_SIZEOF___INT64 (SIZEOF___INT64) ++#endif ++#if defined(SIZEOF_VOID_P) ++# define LZO_SIZEOF_VOID_P (SIZEOF_VOID_P) ++#endif ++#if defined(SIZEOF_SIZE_T) ++# define LZO_SIZEOF_SIZE_T (SIZEOF_SIZE_T) ++#endif ++#if defined(SIZEOF_PTRDIFF_T) ++# define LZO_SIZEOF_PTRDIFF_T (SIZEOF_PTRDIFF_T) ++#endif ++#define __LZO_LSR(x,b) (((x)+0ul) >> (b)) ++#if !defined(LZO_SIZEOF_SHORT) ++# if (LZO_ARCH_CRAY_PVP) ++# define LZO_SIZEOF_SHORT 8 ++# elif (USHRT_MAX == LZO_0xffffL) ++# define LZO_SIZEOF_SHORT 2 ++# elif (__LZO_LSR(USHRT_MAX,7) == 1) ++# define LZO_SIZEOF_SHORT 1 ++# elif (__LZO_LSR(USHRT_MAX,15) == 1) ++# define LZO_SIZEOF_SHORT 2 ++# elif (__LZO_LSR(USHRT_MAX,31) == 1) ++# define LZO_SIZEOF_SHORT 4 ++# elif (__LZO_LSR(USHRT_MAX,63) == 1) ++# define LZO_SIZEOF_SHORT 8 ++# elif (__LZO_LSR(USHRT_MAX,127) == 1) ++# define LZO_SIZEOF_SHORT 16 ++# else ++# error "LZO_SIZEOF_SHORT" ++# endif ++#endif ++#if !defined(LZO_SIZEOF_INT) ++# if (LZO_ARCH_CRAY_PVP) ++# define LZO_SIZEOF_INT 8 ++# elif (UINT_MAX == LZO_0xffffL) ++# define LZO_SIZEOF_INT 2 ++# elif (UINT_MAX == LZO_0xffffffffL) ++# define LZO_SIZEOF_INT 4 ++# elif (__LZO_LSR(UINT_MAX,7) == 1) ++# define LZO_SIZEOF_INT 1 ++# elif (__LZO_LSR(UINT_MAX,15) == 1) ++# define LZO_SIZEOF_INT 2 ++# elif (__LZO_LSR(UINT_MAX,31) == 1) ++# define LZO_SIZEOF_INT 4 ++# elif (__LZO_LSR(UINT_MAX,63) == 1) ++# define LZO_SIZEOF_INT 8 ++# elif (__LZO_LSR(UINT_MAX,127) == 1) ++# define LZO_SIZEOF_INT 16 ++# else ++# error "LZO_SIZEOF_INT" ++# endif ++#endif ++#if !defined(LZO_SIZEOF_LONG) ++# if (ULONG_MAX == LZO_0xffffffffL) ++# define LZO_SIZEOF_LONG 4 ++# elif (__LZO_LSR(ULONG_MAX,7) == 1) ++# define LZO_SIZEOF_LONG 1 ++# elif (__LZO_LSR(ULONG_MAX,15) == 1) ++# define LZO_SIZEOF_LONG 2 ++# elif (__LZO_LSR(ULONG_MAX,31) == 1) ++# define LZO_SIZEOF_LONG 4 ++# elif (__LZO_LSR(ULONG_MAX,63) == 1) ++# define LZO_SIZEOF_LONG 8 ++# elif (__LZO_LSR(ULONG_MAX,127) == 1) ++# define LZO_SIZEOF_LONG 16 ++# else ++# error "LZO_SIZEOF_LONG" ++# endif ++#endif ++#if !defined(LZO_SIZEOF_LONG_LONG) && !defined(LZO_SIZEOF___INT64) ++#if (LZO_SIZEOF_LONG > 0 && LZO_SIZEOF_LONG < 8) ++# if defined(__LONG_MAX__) && defined(__LONG_LONG_MAX__) ++# if (LZO_CC_GNUC >= 0x030300ul) ++# if ((__LONG_MAX__)+0 == (__LONG_LONG_MAX__)+0) ++# define LZO_SIZEOF_LONG_LONG LZO_SIZEOF_LONG ++# elif (__LZO_LSR(__LONG_LONG_MAX__,30) == 1) ++# define LZO_SIZEOF_LONG_LONG 4 ++# endif ++# endif ++# endif ++#endif ++#endif ++#if !defined(LZO_SIZEOF_LONG_LONG) && !defined(LZO_SIZEOF___INT64) ++#if (LZO_SIZEOF_LONG > 0 && LZO_SIZEOF_LONG < 8) ++#if (LZO_ARCH_I086 && LZO_CC_DMC) ++#elif (LZO_CC_CILLY) && defined(__GNUC__) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif ((LZO_OS_WIN32 || LZO_OS_WIN64 || defined(_WIN32)) && LZO_CC_MSC && (_MSC_VER >= 1400)) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_OS_WIN64 || defined(_WIN64)) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_DMC)) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_SYMANTECC && (__SC__ >= 0x700))) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_INTELC && defined(__linux__))) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_MWERKS || LZO_CC_PELLESC || LZO_CC_PGI || LZO_CC_SUNPROC)) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_INTELC || LZO_CC_MSC)) ++# define LZO_SIZEOF___INT64 8 ++#elif ((LZO_OS_WIN32 || defined(_WIN32)) && (LZO_CC_MSC)) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0520))) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_WATCOMC && (__WATCOMC__ >= 1100))) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_CC_WATCOMC && defined(_INTEGRAL_MAX_BITS) && (_INTEGRAL_MAX_BITS == 64)) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_OS_OS400 || defined(__OS400__)) && defined(__LLP64_IFC__) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (defined(__vms) || defined(__VMS)) && (__INITIAL_POINTER_SIZE+0 == 64) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_CC_SDCC) && (LZO_SIZEOF_INT == 2) ++#elif 1 && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) ++# define LZO_SIZEOF_LONG_LONG 8 ++#endif ++#endif ++#endif ++#if defined(__cplusplus) && (LZO_CC_GNUC) ++# if (LZO_CC_GNUC < 0x020800ul) ++# undef LZO_SIZEOF_LONG_LONG ++# endif ++#endif ++#if (LZO_CFG_NO_LONG_LONG) || defined(__NO_LONG_LONG) ++# undef LZO_SIZEOF_LONG_LONG ++#endif ++#if !defined(LZO_SIZEOF_VOID_P) ++#if (LZO_ARCH_I086) ++# define __LZO_WORDSIZE 2 ++# if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM) ++# define LZO_SIZEOF_VOID_P 2 ++# elif (LZO_MM_COMPACT || LZO_MM_LARGE || LZO_MM_HUGE) ++# define LZO_SIZEOF_VOID_P 4 ++# else ++# error "LZO_MM" ++# endif ++#elif (LZO_ARCH_AVR || LZO_ARCH_Z80) ++# define __LZO_WORDSIZE 1 ++# define LZO_SIZEOF_VOID_P 2 ++#elif (LZO_ARCH_C166 || LZO_ARCH_MCS51 || LZO_ARCH_MCS251 || LZO_ARCH_MSP430) ++# define LZO_SIZEOF_VOID_P 2 ++#elif (LZO_ARCH_H8300) ++# if defined(__NORMAL_MODE__) ++# define __LZO_WORDSIZE 4 ++# define LZO_SIZEOF_VOID_P 2 ++# elif defined(__H8300H__) || defined(__H8300S__) || defined(__H8300SX__) ++# define __LZO_WORDSIZE 4 ++# define LZO_SIZEOF_VOID_P 4 ++# else ++# define __LZO_WORDSIZE 2 ++# define LZO_SIZEOF_VOID_P 2 ++# endif ++# if (LZO_CC_GNUC && (LZO_CC_GNUC < 0x040000ul)) && (LZO_SIZEOF_INT == 4) ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_INT ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_INT ++# endif ++#elif (LZO_ARCH_M16C) ++# define __LZO_WORDSIZE 2 ++# if defined(__m32c_cpu__) || defined(__m32cm_cpu__) ++# define LZO_SIZEOF_VOID_P 4 ++# else ++# define LZO_SIZEOF_VOID_P 2 ++# endif ++#elif (LZO_SIZEOF_LONG == 8) && ((defined(__mips__) && defined(__R5900__)) || defined(__MIPS_PSX2__)) ++# define __LZO_WORDSIZE 8 ++# define LZO_SIZEOF_VOID_P 4 ++#elif defined(__LLP64__) || defined(__LLP64) || defined(_LLP64) || defined(_WIN64) ++# define __LZO_WORDSIZE 8 ++# define LZO_SIZEOF_VOID_P 8 ++#elif (LZO_OS_OS400 || defined(__OS400__)) && defined(__LLP64_IFC__) ++# define LZO_SIZEOF_VOID_P LZO_SIZEOF_LONG ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG ++#elif (LZO_OS_OS400 || defined(__OS400__)) ++# define __LZO_WORDSIZE LZO_SIZEOF_LONG ++# define LZO_SIZEOF_VOID_P 16 ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG ++#elif (defined(__vms) || defined(__VMS)) && (__INITIAL_POINTER_SIZE+0 == 64) ++# define LZO_SIZEOF_VOID_P 8 ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG ++#elif (LZO_ARCH_SPU) ++# if 0 ++# define __LZO_WORDSIZE 16 ++# endif ++# define LZO_SIZEOF_VOID_P 4 ++#else ++# define LZO_SIZEOF_VOID_P LZO_SIZEOF_LONG ++#endif ++#endif ++#if !defined(LZO_WORDSIZE) ++# if defined(__LZO_WORDSIZE) ++# define LZO_WORDSIZE __LZO_WORDSIZE ++# else ++# define LZO_WORDSIZE LZO_SIZEOF_VOID_P ++# endif ++#endif ++#if !defined(LZO_SIZEOF_SIZE_T) ++#if (LZO_ARCH_I086 || LZO_ARCH_M16C) ++# define LZO_SIZEOF_SIZE_T 2 ++#else ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_VOID_P ++#endif ++#endif ++#if !defined(LZO_SIZEOF_PTRDIFF_T) ++#if (LZO_ARCH_I086) ++# if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM || LZO_MM_HUGE) ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_VOID_P ++# elif (LZO_MM_COMPACT || LZO_MM_LARGE) ++# if (LZO_CC_BORLANDC || LZO_CC_TURBOC) ++# define LZO_SIZEOF_PTRDIFF_T 4 ++# else ++# define LZO_SIZEOF_PTRDIFF_T 2 ++# endif ++# else ++# error "LZO_MM" ++# endif ++#else ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_SIZE_T ++#endif ++#endif ++#if (LZO_ABI_NEUTRAL_ENDIAN) ++# undef LZO_ABI_BIG_ENDIAN ++# undef LZO_ABI_LITTLE_ENDIAN ++#elif !(LZO_ABI_BIG_ENDIAN) && !(LZO_ABI_LITTLE_ENDIAN) ++#if (LZO_ARCH_ALPHA) && (LZO_ARCH_CRAY_MPP) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif (LZO_ARCH_IA64) && (LZO_OS_POSIX_LINUX || LZO_OS_WIN64) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#elif (LZO_ARCH_ALPHA || LZO_ARCH_AMD64 || LZO_ARCH_BLACKFIN || LZO_ARCH_CRIS || LZO_ARCH_I086 || LZO_ARCH_I386 || LZO_ARCH_MSP430) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#elif (LZO_ARCH_AVR32 || LZO_ARCH_M68K || LZO_ARCH_S390) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif 1 && defined(__IAR_SYSTEMS_ICC__) && defined(__LITTLE_ENDIAN__) ++# if (__LITTLE_ENDIAN__ == 1) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++# else ++# define LZO_ABI_BIG_ENDIAN 1 ++# endif ++#elif 1 && defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif 1 && defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#elif 1 && (LZO_ARCH_ARM) && defined(__ARMEB__) && !defined(__ARMEL__) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif 1 && (LZO_ARCH_ARM) && defined(__ARMEL__) && !defined(__ARMEB__) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#elif 1 && (LZO_ARCH_MIPS) && defined(__MIPSEB__) && !defined(__MIPSEL__) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif 1 && (LZO_ARCH_MIPS) && defined(__MIPSEL__) && !defined(__MIPSEB__) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#endif ++#endif ++#if (LZO_ABI_BIG_ENDIAN) && (LZO_ABI_LITTLE_ENDIAN) ++# error "this should not happen" ++#endif ++#if (LZO_ABI_BIG_ENDIAN) ++# define LZO_INFO_ABI_ENDIAN "be" ++#elif (LZO_ABI_LITTLE_ENDIAN) ++# define LZO_INFO_ABI_ENDIAN "le" ++#elif (LZO_ABI_NEUTRAL_ENDIAN) ++# define LZO_INFO_ABI_ENDIAN "neutral" ++#endif ++#if (LZO_SIZEOF_INT == 1 && LZO_SIZEOF_LONG == 2 && LZO_SIZEOF_VOID_P == 2) ++# define LZO_ABI_I8LP16 1 ++# define LZO_INFO_ABI_PM "i8lp16" ++#elif (LZO_SIZEOF_INT == 2 && LZO_SIZEOF_LONG == 2 && LZO_SIZEOF_VOID_P == 2) ++# define LZO_ABI_ILP16 1 ++# define LZO_INFO_ABI_PM "ilp16" ++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 4 && LZO_SIZEOF_VOID_P == 4) ++# define LZO_ABI_ILP32 1 ++# define LZO_INFO_ABI_PM "ilp32" ++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 4 && LZO_SIZEOF_VOID_P == 8 && LZO_SIZEOF_SIZE_T == 8) ++# define LZO_ABI_LLP64 1 ++# define LZO_INFO_ABI_PM "llp64" ++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 8) ++# define LZO_ABI_LP64 1 ++# define LZO_INFO_ABI_PM "lp64" ++#elif (LZO_SIZEOF_INT == 8 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 8) ++# define LZO_ABI_ILP64 1 ++# define LZO_INFO_ABI_PM "ilp64" ++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 4) ++# define LZO_ABI_IP32L64 1 ++# define LZO_INFO_ABI_PM "ip32l64" ++#endif ++#if !defined(__LZO_LIBC_OVERRIDE) ++#if (LZO_LIBC_NAKED) ++# define LZO_INFO_LIBC "naked" ++#elif (LZO_LIBC_FREESTANDING) ++# define LZO_INFO_LIBC "freestanding" ++#elif (LZO_LIBC_MOSTLY_FREESTANDING) ++# define LZO_INFO_LIBC "mfreestanding" ++#elif (LZO_LIBC_ISOC90) ++# define LZO_INFO_LIBC "isoc90" ++#elif (LZO_LIBC_ISOC99) ++# define LZO_INFO_LIBC "isoc99" ++#elif defined(__dietlibc__) ++# define LZO_LIBC_DIETLIBC 1 ++# define LZO_INFO_LIBC "dietlibc" ++#elif defined(_NEWLIB_VERSION) ++# define LZO_LIBC_NEWLIB 1 ++# define LZO_INFO_LIBC "newlib" ++#elif defined(__UCLIBC__) && defined(__UCLIBC_MAJOR__) && defined(__UCLIBC_MINOR__) ++# if defined(__UCLIBC_SUBLEVEL__) ++# define LZO_LIBC_UCLIBC (__UCLIBC_MAJOR__ * 0x10000L + __UCLIBC_MINOR__ * 0x100 + __UCLIBC_SUBLEVEL__) ++# else ++# define LZO_LIBC_UCLIBC 0x00090bL ++# endif ++# define LZO_INFO_LIBC "uclibc" ++#elif defined(__GLIBC__) && defined(__GLIBC_MINOR__) ++# define LZO_LIBC_GLIBC (__GLIBC__ * 0x10000L + __GLIBC_MINOR__ * 0x100) ++# define LZO_INFO_LIBC "glibc" ++#elif (LZO_CC_MWERKS) && defined(__MSL__) ++# define LZO_LIBC_MSL __MSL__ ++# define LZO_INFO_LIBC "msl" ++#elif 1 && defined(__IAR_SYSTEMS_ICC__) ++# define LZO_LIBC_ISOC90 1 ++# define LZO_INFO_LIBC "isoc90" ++#else ++# define LZO_LIBC_DEFAULT 1 ++# define LZO_INFO_LIBC "default" ++#endif ++#endif ++#if !defined(__lzo_gnuc_extension__) ++#if (LZO_CC_GNUC >= 0x020800ul) ++# define __lzo_gnuc_extension__ __extension__ ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_gnuc_extension__ __extension__ ++#else ++# define __lzo_gnuc_extension__ /*empty*/ ++#endif ++#endif ++#if !defined(__lzo_ua_volatile) ++# define __lzo_ua_volatile volatile ++#endif ++#if !defined(__lzo_alignof) ++#if (LZO_CC_CILLY || LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE || LZO_CC_PGI) ++# define __lzo_alignof(e) __alignof__(e) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 700)) ++# define __lzo_alignof(e) __alignof__(e) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1300)) ++# define __lzo_alignof(e) __alignof(e) ++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100)) ++# define __lzo_alignof(e) __alignof__(e) ++#endif ++#endif ++#if defined(__lzo_alignof) ++# define __lzo_HAVE_alignof 1 ++#endif ++#if !defined(__lzo_constructor) ++#if (LZO_CC_GNUC >= 0x030400ul) ++# define __lzo_constructor __attribute__((__constructor__,__used__)) ++#elif (LZO_CC_GNUC >= 0x020700ul) ++# define __lzo_constructor __attribute__((__constructor__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_constructor __attribute__((__constructor__)) ++#endif ++#endif ++#if defined(__lzo_constructor) ++# define __lzo_HAVE_constructor 1 ++#endif ++#if !defined(__lzo_destructor) ++#if (LZO_CC_GNUC >= 0x030400ul) ++# define __lzo_destructor __attribute__((__destructor__,__used__)) ++#elif (LZO_CC_GNUC >= 0x020700ul) ++# define __lzo_destructor __attribute__((__destructor__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_destructor __attribute__((__destructor__)) ++#endif ++#endif ++#if defined(__lzo_destructor) ++# define __lzo_HAVE_destructor 1 ++#endif ++#if (__lzo_HAVE_destructor) && !(__lzo_HAVE_constructor) ++# error "this should not happen" ++#endif ++#if !defined(__lzo_inline) ++#if (LZO_CC_TURBOC && (__TURBOC__ <= 0x0295)) ++#elif defined(__cplusplus) ++# define __lzo_inline inline ++#elif (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0550)) ++# define __lzo_inline __inline ++#elif (LZO_CC_CILLY || LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE || LZO_CC_PGI) ++# define __lzo_inline __inline__ ++#elif (LZO_CC_DMC) ++# define __lzo_inline __inline ++#elif (LZO_CC_INTELC) ++# define __lzo_inline __inline ++#elif (LZO_CC_MWERKS && (__MWERKS__ >= 0x2405)) ++# define __lzo_inline __inline ++#elif (LZO_CC_MSC && (_MSC_VER >= 900)) ++# define __lzo_inline __inline ++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100)) ++# define __lzo_inline __inline__ ++#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) ++# define __lzo_inline inline ++#endif ++#endif ++#if defined(__lzo_inline) ++# define __lzo_HAVE_inline 1 ++#else ++# define __lzo_inline /*empty*/ ++#endif ++#if !defined(__lzo_forceinline) ++#if (LZO_CC_GNUC >= 0x030200ul) ++# define __lzo_forceinline __inline__ __attribute__((__always_inline__)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC) ++# define __lzo_forceinline __forceinline ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_forceinline __inline__ __attribute__((__always_inline__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_forceinline __inline__ __attribute__((__always_inline__)) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1200)) ++# define __lzo_forceinline __forceinline ++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100)) ++# define __lzo_forceinline __inline__ __attribute__((__always_inline__)) ++#endif ++#endif ++#if defined(__lzo_forceinline) ++# define __lzo_HAVE_forceinline 1 ++#else ++# define __lzo_forceinline /*empty*/ ++#endif ++#if !defined(__lzo_noinline) ++#if 1 && (LZO_ARCH_I386) && (LZO_CC_GNUC >= 0x040000ul) && (LZO_CC_GNUC < 0x040003ul) ++# define __lzo_noinline __attribute__((__noinline__,__used__)) ++#elif (LZO_CC_GNUC >= 0x030200ul) ++# define __lzo_noinline __attribute__((__noinline__)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_MSC) ++# define __lzo_noinline __declspec(noinline) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_noinline __attribute__((__noinline__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_noinline __attribute__((__noinline__)) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1300)) ++# define __lzo_noinline __declspec(noinline) ++#elif (LZO_CC_MWERKS && (__MWERKS__ >= 0x3200) && (LZO_OS_WIN32 || LZO_OS_WIN64)) ++# if defined(__cplusplus) ++# else ++# define __lzo_noinline __declspec(noinline) ++# endif ++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100)) ++# define __lzo_noinline __attribute__((__noinline__)) ++#endif ++#endif ++#if defined(__lzo_noinline) ++# define __lzo_HAVE_noinline 1 ++#else ++# define __lzo_noinline /*empty*/ ++#endif ++#if (__lzo_HAVE_forceinline || __lzo_HAVE_noinline) && !(__lzo_HAVE_inline) ++# error "this should not happen" ++#endif ++#if !defined(__lzo_noreturn) ++#if (LZO_CC_GNUC >= 0x020700ul) ++# define __lzo_noreturn __attribute__((__noreturn__)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC) ++# define __lzo_noreturn __declspec(noreturn) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_noreturn __attribute__((__noreturn__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_noreturn __attribute__((__noreturn__)) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1200)) ++# define __lzo_noreturn __declspec(noreturn) ++#endif ++#endif ++#if defined(__lzo_noreturn) ++# define __lzo_HAVE_noreturn 1 ++#else ++# define __lzo_noreturn /*empty*/ ++#endif ++#if !defined(__lzo_nothrow) ++#if (LZO_CC_GNUC >= 0x030300ul) ++# define __lzo_nothrow __attribute__((__nothrow__)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC) && defined(__cplusplus) ++# define __lzo_nothrow __declspec(nothrow) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 900) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_nothrow __attribute__((__nothrow__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_nothrow __attribute__((__nothrow__)) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1200)) && defined(__cplusplus) ++# define __lzo_nothrow __declspec(nothrow) ++#endif ++#endif ++#if defined(__lzo_nothrow) ++# define __lzo_HAVE_nothrow 1 ++#else ++# define __lzo_nothrow /*empty*/ ++#endif ++#if !defined(__lzo_restrict) ++#if (LZO_CC_GNUC >= 0x030400ul) ++# define __lzo_restrict __restrict__ ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_restrict __restrict__ ++#elif (LZO_CC_CLANG || LZO_CC_LLVM) ++# define __lzo_restrict __restrict__ ++#elif (LZO_CC_MSC && (_MSC_VER >= 1400)) ++# define __lzo_restrict __restrict ++#endif ++#endif ++#if defined(__lzo_restrict) ++# define __lzo_HAVE_restrict 1 ++#else ++# define __lzo_restrict /*empty*/ ++#endif ++#if !defined(__lzo_likely) && !defined(__lzo_unlikely) ++#if (LZO_CC_GNUC >= 0x030200ul) ++# define __lzo_likely(e) (__builtin_expect(!!(e),1)) ++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800)) ++# define __lzo_likely(e) (__builtin_expect(!!(e),1)) ++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_likely(e) (__builtin_expect(!!(e),1)) ++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) ++#endif ++#endif ++#if defined(__lzo_likely) ++# define __lzo_HAVE_likely 1 ++#else ++# define __lzo_likely(e) (e) ++#endif ++#if defined(__lzo_unlikely) ++# define __lzo_HAVE_unlikely 1 ++#else ++# define __lzo_unlikely(e) (e) ++#endif ++#if !defined(LZO_UNUSED) ++# if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0600)) ++# define LZO_UNUSED(var) ((void) &var) ++# elif (LZO_CC_BORLANDC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PELLESC || LZO_CC_TURBOC) ++# define LZO_UNUSED(var) if (&var) ; else ++# elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define LZO_UNUSED(var) ((void) var) ++# elif (LZO_CC_MSC && (_MSC_VER < 900)) ++# define LZO_UNUSED(var) if (&var) ; else ++# elif (LZO_CC_KEILC) ++# define LZO_UNUSED(var) {extern int __lzo_unused[1-2*!(sizeof(var)>0)];} ++# elif (LZO_CC_PACIFICC) ++# define LZO_UNUSED(var) ((void) sizeof(var)) ++# elif (LZO_CC_WATCOMC) && defined(__cplusplus) ++# define LZO_UNUSED(var) ((void) var) ++# else ++# define LZO_UNUSED(var) ((void) &var) ++# endif ++#endif ++#if !defined(LZO_UNUSED_FUNC) ++# if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0600)) ++# define LZO_UNUSED_FUNC(func) ((void) func) ++# elif (LZO_CC_BORLANDC || LZO_CC_NDPC || LZO_CC_TURBOC) ++# define LZO_UNUSED_FUNC(func) if (func) ; else ++# elif (LZO_CC_CLANG || LZO_CC_LLVM) ++# define LZO_UNUSED_FUNC(func) ((void) &func) ++# elif (LZO_CC_MSC && (_MSC_VER < 900)) ++# define LZO_UNUSED_FUNC(func) if (func) ; else ++# elif (LZO_CC_MSC) ++# define LZO_UNUSED_FUNC(func) ((void) &func) ++# elif (LZO_CC_KEILC || LZO_CC_PELLESC) ++# define LZO_UNUSED_FUNC(func) {extern int __lzo_unused[1-2*!(sizeof((int)func)>0)];} ++# else ++# define LZO_UNUSED_FUNC(func) ((void) func) ++# endif ++#endif ++#if !defined(LZO_UNUSED_LABEL) ++# if (LZO_CC_WATCOMC) && defined(__cplusplus) ++# define LZO_UNUSED_LABEL(l) switch(0) case 1:goto l ++# elif (LZO_CC_CLANG || LZO_CC_INTELC || LZO_CC_WATCOMC) ++# define LZO_UNUSED_LABEL(l) if (0) goto l ++# else ++# define LZO_UNUSED_LABEL(l) switch(0) case 1:goto l ++# endif ++#endif ++#if !defined(LZO_DEFINE_UNINITIALIZED_VAR) ++# if 0 ++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var ++# elif 0 && (LZO_CC_GNUC) ++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var = var ++# else ++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var = init ++# endif ++#endif ++#if !defined(LZO_UNCONST_CAST) ++# if 0 && defined(__cplusplus) ++# define LZO_UNCONST_CAST(t,e) (const_cast (e)) ++# elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define LZO_UNCONST_CAST(t,e) ((t) ((void *) ((char *) ((lzo_uintptr_t) ((const void *) (e)))))) ++# else ++# define LZO_UNCONST_CAST(t,e) ((t) ((void *) ((char *) ((const void *) (e))))) ++# endif ++#endif ++#if !defined(LZO_COMPILE_TIME_ASSERT_HEADER) ++# if (LZO_CC_AZTECC || LZO_CC_ZORTECHC) ++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-!(e)]; ++# elif (LZO_CC_DMC || LZO_CC_SYMANTECC) ++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1u-2*!(e)]; ++# elif (LZO_CC_TURBOC && (__TURBOC__ == 0x0295)) ++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-!(e)]; ++# else ++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-2*!(e)]; ++# endif ++#endif ++#if !defined(LZO_COMPILE_TIME_ASSERT) ++# if (LZO_CC_AZTECC) ++# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __lzo_cta_t[1-!(e)];} ++# elif (LZO_CC_DMC || LZO_CC_PACIFICC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) ++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break; ++# elif (LZO_CC_MSC && (_MSC_VER < 900)) ++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break; ++# elif (LZO_CC_TURBOC && (__TURBOC__ == 0x0295)) ++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break; ++# else ++# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __lzo_cta_t[1-2*!(e)];} ++# endif ++#endif ++#if (LZO_ARCH_I086 || LZO_ARCH_I386) && (LZO_OS_DOS16 || LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_OS216 || LZO_OS_WIN16 || LZO_OS_WIN32 || LZO_OS_WIN64) ++# if (LZO_CC_GNUC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PACIFICC) ++# elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) ++# define __lzo_cdecl __cdecl ++# define __lzo_cdecl_atexit /*empty*/ ++# define __lzo_cdecl_main __cdecl ++# if (LZO_OS_OS2 && (LZO_CC_DMC || LZO_CC_SYMANTECC)) ++# define __lzo_cdecl_qsort __pascal ++# elif (LZO_OS_OS2 && (LZO_CC_ZORTECHC)) ++# define __lzo_cdecl_qsort _stdcall ++# else ++# define __lzo_cdecl_qsort __cdecl ++# endif ++# elif (LZO_CC_WATCOMC) ++# define __lzo_cdecl __cdecl ++# else ++# define __lzo_cdecl __cdecl ++# define __lzo_cdecl_atexit __cdecl ++# define __lzo_cdecl_main __cdecl ++# define __lzo_cdecl_qsort __cdecl ++# endif ++# if (LZO_CC_GNUC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PACIFICC || LZO_CC_WATCOMC) ++# elif (LZO_OS_OS2 && (LZO_CC_DMC || LZO_CC_SYMANTECC)) ++# define __lzo_cdecl_sighandler __pascal ++# elif (LZO_OS_OS2 && (LZO_CC_ZORTECHC)) ++# define __lzo_cdecl_sighandler _stdcall ++# elif (LZO_CC_MSC && (_MSC_VER >= 1400)) && defined(_M_CEE_PURE) ++# define __lzo_cdecl_sighandler __clrcall ++# elif (LZO_CC_MSC && (_MSC_VER >= 600 && _MSC_VER < 700)) ++# if defined(_DLL) ++# define __lzo_cdecl_sighandler _far _cdecl _loadds ++# elif defined(_MT) ++# define __lzo_cdecl_sighandler _far _cdecl ++# else ++# define __lzo_cdecl_sighandler _cdecl ++# endif ++# else ++# define __lzo_cdecl_sighandler __cdecl ++# endif ++#elif (LZO_ARCH_I386) && (LZO_CC_WATCOMC) ++# define __lzo_cdecl __cdecl ++#elif (LZO_ARCH_M68K && LZO_OS_TOS && (LZO_CC_PUREC || LZO_CC_TURBOC)) ++# define __lzo_cdecl cdecl ++#endif ++#if !defined(__lzo_cdecl) ++# define __lzo_cdecl /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_atexit) ++# define __lzo_cdecl_atexit /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_main) ++# define __lzo_cdecl_main /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_qsort) ++# define __lzo_cdecl_qsort /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_sighandler) ++# define __lzo_cdecl_sighandler /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_va) ++# define __lzo_cdecl_va __lzo_cdecl ++#endif ++#if !(LZO_CFG_NO_WINDOWS_H) ++#if (LZO_OS_CYGWIN || (LZO_OS_EMX && defined(__RSXNT__)) || LZO_OS_WIN32 || LZO_OS_WIN64) ++# if (LZO_CC_WATCOMC && (__WATCOMC__ < 1000)) ++# elif (LZO_OS_WIN32 && LZO_CC_GNUC) && defined(__PW32__) ++# elif ((LZO_OS_CYGWIN || defined(__MINGW32__)) && (LZO_CC_GNUC && (LZO_CC_GNUC < 0x025f00ul))) ++# else ++# define LZO_HAVE_WINDOWS_H 1 ++# endif ++#endif ++#endif ++#if (LZO_ARCH_ALPHA) ++# define LZO_OPT_AVOID_UINT_INDEX 1 ++# define LZO_OPT_AVOID_SHORT 1 ++# define LZO_OPT_AVOID_USHORT 1 ++#elif (LZO_ARCH_AMD64) ++# define LZO_OPT_AVOID_INT_INDEX 1 ++# define LZO_OPT_AVOID_UINT_INDEX 1 ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++# define LZO_OPT_UNALIGNED64 1 ++#elif (LZO_ARCH_ARM && LZO_ARCH_ARM_THUMB) ++#elif (LZO_ARCH_ARM) ++# define LZO_OPT_AVOID_SHORT 1 ++# define LZO_OPT_AVOID_USHORT 1 ++#elif (LZO_ARCH_CRIS) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++#elif (LZO_ARCH_I386) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++#elif (LZO_ARCH_IA64) ++# define LZO_OPT_AVOID_INT_INDEX 1 ++# define LZO_OPT_AVOID_UINT_INDEX 1 ++# define LZO_OPT_PREFER_POSTINC 1 ++#elif (LZO_ARCH_M68K) ++# define LZO_OPT_PREFER_POSTINC 1 ++# define LZO_OPT_PREFER_PREDEC 1 ++# if defined(__mc68020__) && !defined(__mcoldfire__) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++# endif ++#elif (LZO_ARCH_MIPS) ++# define LZO_OPT_AVOID_UINT_INDEX 1 ++#elif (LZO_ARCH_POWERPC) ++# define LZO_OPT_PREFER_PREINC 1 ++# define LZO_OPT_PREFER_PREDEC 1 ++# if (LZO_ABI_BIG_ENDIAN) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++# endif ++#elif (LZO_ARCH_S390) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++# if (LZO_SIZEOF_SIZE_T == 8) ++# define LZO_OPT_UNALIGNED64 1 ++# endif ++#elif (LZO_ARCH_SH) ++# define LZO_OPT_PREFER_POSTINC 1 ++# define LZO_OPT_PREFER_PREDEC 1 ++#endif ++#ifndef LZO_CFG_NO_INLINE_ASM ++#if (LZO_CC_LLVM) ++# define LZO_CFG_NO_INLINE_ASM 1 ++#endif ++#endif ++#ifndef LZO_CFG_NO_UNALIGNED ++#if (LZO_ABI_NEUTRAL_ENDIAN) || (LZO_ARCH_GENERIC) ++# define LZO_CFG_NO_UNALIGNED 1 ++#endif ++#endif ++#if (LZO_CFG_NO_UNALIGNED) ++# undef LZO_OPT_UNALIGNED16 ++# undef LZO_OPT_UNALIGNED32 ++# undef LZO_OPT_UNALIGNED64 ++#endif ++#if (LZO_CFG_NO_INLINE_ASM) ++#elif (LZO_ARCH_I386 && (LZO_OS_DOS32 || LZO_OS_WIN32) && (LZO_CC_DMC || LZO_CC_INTELC || LZO_CC_MSC || LZO_CC_PELLESC)) ++# define LZO_ASM_SYNTAX_MSC 1 ++#elif (LZO_OS_WIN64 && (LZO_CC_DMC || LZO_CC_INTELC || LZO_CC_MSC || LZO_CC_PELLESC)) ++#elif (LZO_ARCH_I386 && LZO_CC_GNUC && (LZO_CC_GNUC == 0x011f00ul)) ++#elif (LZO_ARCH_I386 && (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_INTELC || LZO_CC_PATHSCALE)) ++# define LZO_ASM_SYNTAX_GNUC 1 ++#elif (LZO_ARCH_AMD64 && (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_INTELC || LZO_CC_PATHSCALE)) ++# define LZO_ASM_SYNTAX_GNUC 1 ++#endif ++#if (LZO_ASM_SYNTAX_GNUC) ++#if (LZO_ARCH_I386 && LZO_CC_GNUC && (LZO_CC_GNUC < 0x020000ul)) ++# define __LZO_ASM_CLOBBER "ax" ++#elif (LZO_CC_INTELC) ++# define __LZO_ASM_CLOBBER "memory" ++#else ++# define __LZO_ASM_CLOBBER "cc", "memory" ++#endif ++#endif ++#if defined(__LZO_INFOSTR_MM) ++#elif (LZO_MM_FLAT) && (defined(__LZO_INFOSTR_PM) || defined(LZO_INFO_ABI_PM)) ++# define __LZO_INFOSTR_MM "" ++#elif defined(LZO_INFO_MM) ++# define __LZO_INFOSTR_MM "." LZO_INFO_MM ++#else ++# define __LZO_INFOSTR_MM "" ++#endif ++#if defined(__LZO_INFOSTR_PM) ++#elif defined(LZO_INFO_ABI_PM) ++# define __LZO_INFOSTR_PM "." LZO_INFO_ABI_PM ++#else ++# define __LZO_INFOSTR_PM "" ++#endif ++#if defined(__LZO_INFOSTR_ENDIAN) ++#elif defined(LZO_INFO_ABI_ENDIAN) ++# define __LZO_INFOSTR_ENDIAN "." LZO_INFO_ABI_ENDIAN ++#else ++# define __LZO_INFOSTR_ENDIAN "" ++#endif ++#if defined(__LZO_INFOSTR_OSNAME) ++#elif defined(LZO_INFO_OS_CONSOLE) ++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS "." LZO_INFO_OS_CONSOLE ++#elif defined(LZO_INFO_OS_POSIX) ++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS "." LZO_INFO_OS_POSIX ++#else ++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS ++#endif ++#if defined(__LZO_INFOSTR_LIBC) ++#elif defined(LZO_INFO_LIBC) ++# define __LZO_INFOSTR_LIBC "." LZO_INFO_LIBC ++#else ++# define __LZO_INFOSTR_LIBC "" ++#endif ++#if defined(__LZO_INFOSTR_CCVER) ++#elif defined(LZO_INFO_CCVER) ++# define __LZO_INFOSTR_CCVER " " LZO_INFO_CCVER ++#else ++# define __LZO_INFOSTR_CCVER "" ++#endif ++#define LZO_INFO_STRING \ ++ LZO_INFO_ARCH __LZO_INFOSTR_MM __LZO_INFOSTR_PM __LZO_INFOSTR_ENDIAN \ ++ " " __LZO_INFOSTR_OSNAME __LZO_INFOSTR_LIBC " " LZO_INFO_CC __LZO_INFOSTR_CCVER ++ ++#endif /* already included */ ++ ++/* vim:set ts=4 et: */ +Index: b/grub-core/lib/minilzo/minilzo.c +=================================================================== +--- /dev/null ++++ b/grub-core/lib/minilzo/minilzo.c +@@ -0,0 +1,4562 @@ ++/* minilzo.c -- mini subset of the LZO real-time data compression library ++ ++ This file is part of the LZO real-time data compression library. ++ ++ Copyright (C) 2011 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2010 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2009 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer ++ All Rights Reserved. ++ ++ The LZO library 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; either version 2 of ++ the License, or (at your option) any later version. ++ ++ The LZO library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with the LZO library; see the file COPYING. ++ If not, write to the Free Software Foundation, Inc., ++ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ ++ Markus F.X.J. Oberhumer ++ ++ http://www.oberhumer.com/opensource/lzo/ ++ */ ++ ++/* ++ * NOTE: ++ * the full LZO package can be found at ++ * http://www.oberhumer.com/opensource/lzo/ ++ */ ++ ++#define __LZO_IN_MINILZO 1 ++ ++#if defined(LZO_CFG_FREESTANDING) ++# undef MINILZO_HAVE_CONFIG_H ++# define LZO_LIBC_FREESTANDING 1 ++# define LZO_OS_FREESTANDING 1 ++#endif ++ ++#ifdef MINILZO_HAVE_CONFIG_H ++# include ++#endif ++#include ++#include ++#if defined(MINILZO_CFG_USE_INTERNAL_LZODEFS) ++ ++#ifndef __LZODEFS_H_INCLUDED ++#define __LZODEFS_H_INCLUDED 1 ++ ++#if defined(__CYGWIN32__) && !defined(__CYGWIN__) ++# define __CYGWIN__ __CYGWIN32__ ++#endif ++#if defined(__IBMCPP__) && !defined(__IBMC__) ++# define __IBMC__ __IBMCPP__ ++#endif ++#if defined(__ICL) && defined(_WIN32) && !defined(__INTEL_COMPILER) ++# define __INTEL_COMPILER __ICL ++#endif ++#if 1 && defined(__INTERIX) && defined(__GNUC__) && !defined(_ALL_SOURCE) ++# define _ALL_SOURCE 1 ++#endif ++#if defined(__mips__) && defined(__R5900__) ++# if !defined(__LONG_MAX__) ++# define __LONG_MAX__ 9223372036854775807L ++# endif ++#endif ++#if defined(__INTEL_COMPILER) && defined(__linux__) ++# pragma warning(disable: 193) ++#endif ++#if defined(__KEIL__) && defined(__C166__) ++# pragma warning disable = 322 ++#elif 0 && defined(__C251__) ++# pragma warning disable = 322 ++#endif ++#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && !defined(__MWERKS__) ++# if (_MSC_VER >= 1300) ++# pragma warning(disable: 4668) ++# endif ++#endif ++#if 0 && defined(__WATCOMC__) ++# if (__WATCOMC__ >= 1050) && (__WATCOMC__ < 1060) ++# pragma warning 203 9 ++# endif ++#endif ++#if defined(__BORLANDC__) && defined(__MSDOS__) && !defined(__FLAT__) ++# pragma option -h ++#endif ++#if 0 ++#define LZO_0xffffL 0xfffful ++#define LZO_0xffffffffL 0xfffffffful ++#else ++#define LZO_0xffffL 65535ul ++#define LZO_0xffffffffL 4294967295ul ++#endif ++#if (LZO_0xffffL == LZO_0xffffffffL) ++# error "your preprocessor is broken 1" ++#endif ++#if (16ul * 16384ul != 262144ul) ++# error "your preprocessor is broken 2" ++#endif ++#if 0 ++#if (32767 >= 4294967295ul) ++# error "your preprocessor is broken 3" ++#endif ++#if (65535u >= 4294967295ul) ++# error "your preprocessor is broken 4" ++#endif ++#endif ++#if (UINT_MAX == LZO_0xffffL) ++#if defined(__ZTC__) && defined(__I86__) && !defined(__OS2__) ++# if !defined(MSDOS) ++# define MSDOS 1 ++# endif ++# if !defined(_MSDOS) ++# define _MSDOS 1 ++# endif ++#elif 0 && defined(__VERSION) && defined(MB_LEN_MAX) ++# if (__VERSION == 520) && (MB_LEN_MAX == 1) ++# if !defined(__AZTEC_C__) ++# define __AZTEC_C__ __VERSION ++# endif ++# if !defined(__DOS__) ++# define __DOS__ 1 ++# endif ++# endif ++#endif ++#endif ++#if defined(_MSC_VER) && defined(M_I86HM) && (UINT_MAX == LZO_0xffffL) ++# define ptrdiff_t long ++# define _PTRDIFF_T_DEFINED 1 ++#endif ++#if (UINT_MAX == LZO_0xffffL) ++# undef __LZO_RENAME_A ++# undef __LZO_RENAME_B ++# if defined(__AZTEC_C__) && defined(__DOS__) ++# define __LZO_RENAME_A 1 ++# elif defined(_MSC_VER) && defined(MSDOS) ++# if (_MSC_VER < 600) ++# define __LZO_RENAME_A 1 ++# elif (_MSC_VER < 700) ++# define __LZO_RENAME_B 1 ++# endif ++# elif defined(__TSC__) && defined(__OS2__) ++# define __LZO_RENAME_A 1 ++# elif defined(__MSDOS__) && defined(__TURBOC__) && (__TURBOC__ < 0x0410) ++# define __LZO_RENAME_A 1 ++# elif defined(__PACIFIC__) && defined(DOS) ++# if !defined(__far) ++# define __far far ++# endif ++# if !defined(__near) ++# define __near near ++# endif ++# endif ++# if defined(__LZO_RENAME_A) ++# if !defined(__cdecl) ++# define __cdecl cdecl ++# endif ++# if !defined(__far) ++# define __far far ++# endif ++# if !defined(__huge) ++# define __huge huge ++# endif ++# if !defined(__near) ++# define __near near ++# endif ++# if !defined(__pascal) ++# define __pascal pascal ++# endif ++# if !defined(__huge) ++# define __huge huge ++# endif ++# elif defined(__LZO_RENAME_B) ++# if !defined(__cdecl) ++# define __cdecl _cdecl ++# endif ++# if !defined(__far) ++# define __far _far ++# endif ++# if !defined(__huge) ++# define __huge _huge ++# endif ++# if !defined(__near) ++# define __near _near ++# endif ++# if !defined(__pascal) ++# define __pascal _pascal ++# endif ++# elif (defined(__PUREC__) || defined(__TURBOC__)) && defined(__TOS__) ++# if !defined(__cdecl) ++# define __cdecl cdecl ++# endif ++# if !defined(__pascal) ++# define __pascal pascal ++# endif ++# endif ++# undef __LZO_RENAME_A ++# undef __LZO_RENAME_B ++#endif ++#if (UINT_MAX == LZO_0xffffL) ++#if defined(__AZTEC_C__) && defined(__DOS__) ++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1 ++#elif defined(_MSC_VER) && defined(MSDOS) ++# if (_MSC_VER < 600) ++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1 ++# endif ++# if (_MSC_VER < 700) ++# define LZO_BROKEN_INTEGRAL_PROMOTION 1 ++# define LZO_BROKEN_SIZEOF 1 ++# endif ++#elif defined(__PACIFIC__) && defined(DOS) ++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1 ++#elif defined(__TURBOC__) && defined(__MSDOS__) ++# if (__TURBOC__ < 0x0150) ++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1 ++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1 ++# define LZO_BROKEN_INTEGRAL_PROMOTION 1 ++# endif ++# if (__TURBOC__ < 0x0200) ++# define LZO_BROKEN_SIZEOF 1 ++# endif ++# if (__TURBOC__ < 0x0400) && defined(__cplusplus) ++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1 ++# endif ++#elif (defined(__PUREC__) || defined(__TURBOC__)) && defined(__TOS__) ++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1 ++# define LZO_BROKEN_SIZEOF 1 ++#endif ++#endif ++#if defined(__WATCOMC__) && (__WATCOMC__ < 900) ++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1 ++#endif ++#if defined(_CRAY) && defined(_CRAY1) ++# define LZO_BROKEN_SIGNED_RIGHT_SHIFT 1 ++#endif ++#define LZO_PP_STRINGIZE(x) #x ++#define LZO_PP_MACRO_EXPAND(x) LZO_PP_STRINGIZE(x) ++#define LZO_PP_CONCAT2(a,b) a ## b ++#define LZO_PP_CONCAT3(a,b,c) a ## b ## c ++#define LZO_PP_CONCAT4(a,b,c,d) a ## b ## c ## d ++#define LZO_PP_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e ++#define LZO_PP_ECONCAT2(a,b) LZO_PP_CONCAT2(a,b) ++#define LZO_PP_ECONCAT3(a,b,c) LZO_PP_CONCAT3(a,b,c) ++#define LZO_PP_ECONCAT4(a,b,c,d) LZO_PP_CONCAT4(a,b,c,d) ++#define LZO_PP_ECONCAT5(a,b,c,d,e) LZO_PP_CONCAT5(a,b,c,d,e) ++#if 1 ++#define LZO_CPP_STRINGIZE(x) #x ++#define LZO_CPP_MACRO_EXPAND(x) LZO_CPP_STRINGIZE(x) ++#define LZO_CPP_CONCAT2(a,b) a ## b ++#define LZO_CPP_CONCAT3(a,b,c) a ## b ## c ++#define LZO_CPP_CONCAT4(a,b,c,d) a ## b ## c ## d ++#define LZO_CPP_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e ++#define LZO_CPP_ECONCAT2(a,b) LZO_CPP_CONCAT2(a,b) ++#define LZO_CPP_ECONCAT3(a,b,c) LZO_CPP_CONCAT3(a,b,c) ++#define LZO_CPP_ECONCAT4(a,b,c,d) LZO_CPP_CONCAT4(a,b,c,d) ++#define LZO_CPP_ECONCAT5(a,b,c,d,e) LZO_CPP_CONCAT5(a,b,c,d,e) ++#endif ++#define __LZO_MASK_GEN(o,b) (((((o) << ((b)-1)) - (o)) << 1) + (o)) ++#if 1 && defined(__cplusplus) ++# if !defined(__STDC_CONSTANT_MACROS) ++# define __STDC_CONSTANT_MACROS 1 ++# endif ++# if !defined(__STDC_LIMIT_MACROS) ++# define __STDC_LIMIT_MACROS 1 ++# endif ++#endif ++#if defined(__cplusplus) ++# define LZO_EXTERN_C extern "C" ++#else ++# define LZO_EXTERN_C extern ++#endif ++#if !defined(__LZO_OS_OVERRIDE) ++#if (LZO_OS_FREESTANDING) ++# define LZO_INFO_OS "freestanding" ++#elif (LZO_OS_EMBEDDED) ++# define LZO_INFO_OS "embedded" ++#elif 1 && defined(__IAR_SYSTEMS_ICC__) ++# define LZO_OS_EMBEDDED 1 ++# define LZO_INFO_OS "embedded" ++#elif defined(__CYGWIN__) && defined(__GNUC__) ++# define LZO_OS_CYGWIN 1 ++# define LZO_INFO_OS "cygwin" ++#elif defined(__EMX__) && defined(__GNUC__) ++# define LZO_OS_EMX 1 ++# define LZO_INFO_OS "emx" ++#elif defined(__BEOS__) ++# define LZO_OS_BEOS 1 ++# define LZO_INFO_OS "beos" ++#elif defined(__Lynx__) ++# define LZO_OS_LYNXOS 1 ++# define LZO_INFO_OS "lynxos" ++#elif defined(__OS400__) ++# define LZO_OS_OS400 1 ++# define LZO_INFO_OS "os400" ++#elif defined(__QNX__) ++# define LZO_OS_QNX 1 ++# define LZO_INFO_OS "qnx" ++#elif defined(__BORLANDC__) && defined(__DPMI32__) && (__BORLANDC__ >= 0x0460) ++# define LZO_OS_DOS32 1 ++# define LZO_INFO_OS "dos32" ++#elif defined(__BORLANDC__) && defined(__DPMI16__) ++# define LZO_OS_DOS16 1 ++# define LZO_INFO_OS "dos16" ++#elif defined(__ZTC__) && defined(DOS386) ++# define LZO_OS_DOS32 1 ++# define LZO_INFO_OS "dos32" ++#elif defined(__OS2__) || defined(__OS2V2__) ++# if (UINT_MAX == LZO_0xffffL) ++# define LZO_OS_OS216 1 ++# define LZO_INFO_OS "os216" ++# elif (UINT_MAX == LZO_0xffffffffL) ++# define LZO_OS_OS2 1 ++# define LZO_INFO_OS "os2" ++# else ++# error "check your limits.h header" ++# endif ++#elif defined(__WIN64__) || defined(_WIN64) || defined(WIN64) ++# define LZO_OS_WIN64 1 ++# define LZO_INFO_OS "win64" ++#elif defined(__WIN32__) || defined(_WIN32) || defined(WIN32) || defined(__WINDOWS_386__) ++# define LZO_OS_WIN32 1 ++# define LZO_INFO_OS "win32" ++#elif defined(__MWERKS__) && defined(__INTEL__) ++# define LZO_OS_WIN32 1 ++# define LZO_INFO_OS "win32" ++#elif defined(__WINDOWS__) || defined(_WINDOWS) || defined(_Windows) ++# if (UINT_MAX == LZO_0xffffL) ++# define LZO_OS_WIN16 1 ++# define LZO_INFO_OS "win16" ++# elif (UINT_MAX == LZO_0xffffffffL) ++# define LZO_OS_WIN32 1 ++# define LZO_INFO_OS "win32" ++# else ++# error "check your limits.h header" ++# endif ++#elif defined(__DOS__) || defined(__MSDOS__) || defined(_MSDOS) || defined(MSDOS) || (defined(__PACIFIC__) && defined(DOS)) ++# if (UINT_MAX == LZO_0xffffL) ++# define LZO_OS_DOS16 1 ++# define LZO_INFO_OS "dos16" ++# elif (UINT_MAX == LZO_0xffffffffL) ++# define LZO_OS_DOS32 1 ++# define LZO_INFO_OS "dos32" ++# else ++# error "check your limits.h header" ++# endif ++#elif defined(__WATCOMC__) ++# if defined(__NT__) && (UINT_MAX == LZO_0xffffL) ++# define LZO_OS_DOS16 1 ++# define LZO_INFO_OS "dos16" ++# elif defined(__NT__) && (__WATCOMC__ < 1100) ++# define LZO_OS_WIN32 1 ++# define LZO_INFO_OS "win32" ++# elif defined(__linux__) || defined(__LINUX__) ++# define LZO_OS_POSIX 1 ++# define LZO_INFO_OS "posix" ++# else ++# error "please specify a target using the -bt compiler option" ++# endif ++#elif defined(__palmos__) ++# define LZO_OS_PALMOS 1 ++# define LZO_INFO_OS "palmos" ++#elif defined(__TOS__) || defined(__atarist__) ++# define LZO_OS_TOS 1 ++# define LZO_INFO_OS "tos" ++#elif defined(macintosh) && !defined(__ppc__) ++# define LZO_OS_MACCLASSIC 1 ++# define LZO_INFO_OS "macclassic" ++#elif defined(__VMS) ++# define LZO_OS_VMS 1 ++# define LZO_INFO_OS "vms" ++#elif ((defined(__mips__) && defined(__R5900__)) || defined(__MIPS_PSX2__)) ++# define LZO_OS_CONSOLE 1 ++# define LZO_OS_CONSOLE_PS2 1 ++# define LZO_INFO_OS "console" ++# define LZO_INFO_OS_CONSOLE "ps2" ++#elif (defined(__mips__) && defined(__psp__)) ++# define LZO_OS_CONSOLE 1 ++# define LZO_OS_CONSOLE_PSP 1 ++# define LZO_INFO_OS "console" ++# define LZO_INFO_OS_CONSOLE "psp" ++#else ++# define LZO_OS_POSIX 1 ++# define LZO_INFO_OS "posix" ++#endif ++#if (LZO_OS_POSIX) ++# if defined(_AIX) || defined(__AIX__) || defined(__aix__) ++# define LZO_OS_POSIX_AIX 1 ++# define LZO_INFO_OS_POSIX "aix" ++# elif defined(__FreeBSD__) ++# define LZO_OS_POSIX_FREEBSD 1 ++# define LZO_INFO_OS_POSIX "freebsd" ++# elif defined(__hpux__) || defined(__hpux) ++# define LZO_OS_POSIX_HPUX 1 ++# define LZO_INFO_OS_POSIX "hpux" ++# elif defined(__INTERIX) ++# define LZO_OS_POSIX_INTERIX 1 ++# define LZO_INFO_OS_POSIX "interix" ++# elif defined(__IRIX__) || defined(__irix__) ++# define LZO_OS_POSIX_IRIX 1 ++# define LZO_INFO_OS_POSIX "irix" ++# elif defined(__linux__) || defined(__linux) || defined(__LINUX__) ++# define LZO_OS_POSIX_LINUX 1 ++# define LZO_INFO_OS_POSIX "linux" ++# elif defined(__APPLE__) || defined(__MACOS__) ++# define LZO_OS_POSIX_MACOSX 1 ++# define LZO_INFO_OS_POSIX "macosx" ++# elif defined(__minix__) || defined(__minix) ++# define LZO_OS_POSIX_MINIX 1 ++# define LZO_INFO_OS_POSIX "minix" ++# elif defined(__NetBSD__) ++# define LZO_OS_POSIX_NETBSD 1 ++# define LZO_INFO_OS_POSIX "netbsd" ++# elif defined(__OpenBSD__) ++# define LZO_OS_POSIX_OPENBSD 1 ++# define LZO_INFO_OS_POSIX "openbsd" ++# elif defined(__osf__) ++# define LZO_OS_POSIX_OSF 1 ++# define LZO_INFO_OS_POSIX "osf" ++# elif defined(__solaris__) || defined(__sun) ++# if defined(__SVR4) || defined(__svr4__) ++# define LZO_OS_POSIX_SOLARIS 1 ++# define LZO_INFO_OS_POSIX "solaris" ++# else ++# define LZO_OS_POSIX_SUNOS 1 ++# define LZO_INFO_OS_POSIX "sunos" ++# endif ++# elif defined(__ultrix__) || defined(__ultrix) ++# define LZO_OS_POSIX_ULTRIX 1 ++# define LZO_INFO_OS_POSIX "ultrix" ++# elif defined(_UNICOS) ++# define LZO_OS_POSIX_UNICOS 1 ++# define LZO_INFO_OS_POSIX "unicos" ++# else ++# define LZO_OS_POSIX_UNKNOWN 1 ++# define LZO_INFO_OS_POSIX "unknown" ++# endif ++#endif ++#endif ++#if (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16) ++# if (UINT_MAX != LZO_0xffffL) ++# error "this should not happen" ++# endif ++# if (ULONG_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++#endif ++#if (LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_WIN32 || LZO_OS_WIN64) ++# if (UINT_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++# if (ULONG_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++#endif ++#if defined(CIL) && defined(_GNUCC) && defined(__GNUC__) ++# define LZO_CC_CILLY 1 ++# define LZO_INFO_CC "Cilly" ++# if defined(__CILLY__) ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__CILLY__) ++# else ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif 0 && defined(SDCC) && defined(__VERSION__) && !defined(__GNUC__) ++# define LZO_CC_SDCC 1 ++# define LZO_INFO_CC "sdcc" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(SDCC) ++#elif defined(__PATHSCALE__) && defined(__PATHCC_PATCHLEVEL__) ++# define LZO_CC_PATHSCALE (__PATHCC__ * 0x10000L + __PATHCC_MINOR__ * 0x100 + __PATHCC_PATCHLEVEL__) ++# define LZO_INFO_CC "Pathscale C" ++# define LZO_INFO_CCVER __PATHSCALE__ ++#elif defined(__INTEL_COMPILER) ++# define LZO_CC_INTELC 1 ++# define LZO_INFO_CC "Intel C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__INTEL_COMPILER) ++# if defined(_WIN32) || defined(_WIN64) ++# define LZO_CC_SYNTAX_MSC 1 ++# else ++# define LZO_CC_SYNTAX_GNUC 1 ++# endif ++#elif defined(__POCC__) && defined(_WIN32) ++# define LZO_CC_PELLESC 1 ++# define LZO_INFO_CC "Pelles C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__POCC__) ++#elif defined(__clang__) && defined(__llvm__) && defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__VERSION__) ++# if defined(__GNUC_PATCHLEVEL__) ++# define LZO_CC_CLANG_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__) ++# else ++# define LZO_CC_CLANG_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100) ++# endif ++# if defined(__clang_major__) && defined(__clang_minor__) && defined(__clang_patchlevel__) ++# define LZO_CC_CLANG_CLANG (__clang_major__ * 0x10000L + __clang_minor__ * 0x100 + __clang_patchlevel__) ++# else ++# define LZO_CC_CLANG_CLANG 0x010000L ++# endif ++# define LZO_CC_CLANG LZO_CC_CLANG_GNUC ++# define LZO_INFO_CC "clang" ++# define LZO_INFO_CCVER __VERSION__ ++#elif defined(__llvm__) && defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__VERSION__) ++# if defined(__GNUC_PATCHLEVEL__) ++# define LZO_CC_LLVM_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__) ++# else ++# define LZO_CC_LLVM_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100) ++# endif ++# define LZO_CC_LLVM LZO_CC_LLVM_GNUC ++# define LZO_INFO_CC "llvm-gcc" ++# define LZO_INFO_CCVER __VERSION__ ++#elif defined(__GNUC__) && defined(__VERSION__) ++# if defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) ++# define LZO_CC_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__) ++# elif defined(__GNUC_MINOR__) ++# define LZO_CC_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100) ++# else ++# define LZO_CC_GNUC (__GNUC__ * 0x10000L) ++# endif ++# define LZO_INFO_CC "gcc" ++# define LZO_INFO_CCVER __VERSION__ ++#elif defined(__ACK__) && defined(_ACK) ++# define LZO_CC_ACK 1 ++# define LZO_INFO_CC "Amsterdam Compiler Kit C" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__AZTEC_C__) ++# define LZO_CC_AZTECC 1 ++# define LZO_INFO_CC "Aztec C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__AZTEC_C__) ++#elif defined(__CODEGEARC__) ++# define LZO_CC_CODEGEARC 1 ++# define LZO_INFO_CC "CodeGear C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__CODEGEARC__) ++#elif defined(__BORLANDC__) ++# define LZO_CC_BORLANDC 1 ++# define LZO_INFO_CC "Borland C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__BORLANDC__) ++#elif defined(_CRAYC) && defined(_RELEASE) ++# define LZO_CC_CRAYC 1 ++# define LZO_INFO_CC "Cray C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_RELEASE) ++#elif defined(__DMC__) && defined(__SC__) ++# define LZO_CC_DMC 1 ++# define LZO_INFO_CC "Digital Mars C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__DMC__) ++#elif defined(__DECC) ++# define LZO_CC_DECC 1 ++# define LZO_INFO_CC "DEC C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__DECC) ++#elif defined(__HIGHC__) ++# define LZO_CC_HIGHC 1 ++# define LZO_INFO_CC "MetaWare High C" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__IAR_SYSTEMS_ICC__) ++# define LZO_CC_IARC 1 ++# define LZO_INFO_CC "IAR C" ++# if defined(__VER__) ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__VER__) ++# else ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif defined(__IBMC__) ++# define LZO_CC_IBMC 1 ++# define LZO_INFO_CC "IBM C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__IBMC__) ++#elif defined(__KEIL__) && defined(__C166__) ++# define LZO_CC_KEILC 1 ++# define LZO_INFO_CC "Keil C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__C166__) ++#elif defined(__LCC__) && defined(_WIN32) && defined(__LCCOPTIMLEVEL) ++# define LZO_CC_LCCWIN32 1 ++# define LZO_INFO_CC "lcc-win32" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__LCC__) ++# define LZO_CC_LCC 1 ++# define LZO_INFO_CC "lcc" ++# if defined(__LCC_VERSION__) ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__LCC_VERSION__) ++# else ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif defined(_MSC_VER) ++# define LZO_CC_MSC 1 ++# define LZO_INFO_CC "Microsoft C" ++# if defined(_MSC_FULL_VER) ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_MSC_VER) "." LZO_PP_MACRO_EXPAND(_MSC_FULL_VER) ++# else ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_MSC_VER) ++# endif ++#elif defined(__MWERKS__) ++# define LZO_CC_MWERKS 1 ++# define LZO_INFO_CC "Metrowerks C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__MWERKS__) ++#elif (defined(__NDPC__) || defined(__NDPX__)) && defined(__i386) ++# define LZO_CC_NDPC 1 ++# define LZO_INFO_CC "Microway NDP C" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__PACIFIC__) ++# define LZO_CC_PACIFICC 1 ++# define LZO_INFO_CC "Pacific C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__PACIFIC__) ++#elif defined(__PGI) && (defined(__linux__) || defined(__WIN32__)) ++# define LZO_CC_PGI 1 ++# define LZO_INFO_CC "Portland Group PGI C" ++# define LZO_INFO_CCVER "unknown" ++#elif defined(__PUREC__) && defined(__TOS__) ++# define LZO_CC_PUREC 1 ++# define LZO_INFO_CC "Pure C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__PUREC__) ++#elif defined(__SC__) && defined(__ZTC__) ++# define LZO_CC_SYMANTECC 1 ++# define LZO_INFO_CC "Symantec C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SC__) ++#elif defined(__SUNPRO_C) ++# define LZO_INFO_CC "SunPro C" ++# if ((__SUNPRO_C)+0 > 0) ++# define LZO_CC_SUNPROC __SUNPRO_C ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SUNPRO_C) ++# else ++# define LZO_CC_SUNPROC 1 ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif defined(__SUNPRO_CC) ++# define LZO_INFO_CC "SunPro C" ++# if ((__SUNPRO_CC)+0 > 0) ++# define LZO_CC_SUNPROC __SUNPRO_CC ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SUNPRO_CC) ++# else ++# define LZO_CC_SUNPROC 1 ++# define LZO_INFO_CCVER "unknown" ++# endif ++#elif defined(__TINYC__) ++# define LZO_CC_TINYC 1 ++# define LZO_INFO_CC "Tiny C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TINYC__) ++#elif defined(__TSC__) ++# define LZO_CC_TOPSPEEDC 1 ++# define LZO_INFO_CC "TopSpeed C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TSC__) ++#elif defined(__WATCOMC__) ++# define LZO_CC_WATCOMC 1 ++# define LZO_INFO_CC "Watcom C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__WATCOMC__) ++#elif defined(__TURBOC__) ++# define LZO_CC_TURBOC 1 ++# define LZO_INFO_CC "Turbo C" ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TURBOC__) ++#elif defined(__ZTC__) ++# define LZO_CC_ZORTECHC 1 ++# define LZO_INFO_CC "Zortech C" ++# if (__ZTC__ == 0x310) ++# define LZO_INFO_CCVER "0x310" ++# else ++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__ZTC__) ++# endif ++#else ++# define LZO_CC_UNKNOWN 1 ++# define LZO_INFO_CC "unknown" ++# define LZO_INFO_CCVER "unknown" ++#endif ++#if 0 && (LZO_CC_MSC && (_MSC_VER >= 1200)) && !defined(_MSC_FULL_VER) ++# error "LZO_CC_MSC: _MSC_FULL_VER is not defined" ++#endif ++#if !defined(__LZO_ARCH_OVERRIDE) && !(LZO_ARCH_GENERIC) && defined(_CRAY) ++# if (UINT_MAX > LZO_0xffffffffL) && defined(_CRAY) ++# if defined(_CRAYMPP) || defined(_CRAYT3D) || defined(_CRAYT3E) ++# define LZO_ARCH_CRAY_MPP 1 ++# elif defined(_CRAY1) ++# define LZO_ARCH_CRAY_PVP 1 ++# endif ++# endif ++#endif ++#if !defined(__LZO_ARCH_OVERRIDE) ++#if (LZO_ARCH_GENERIC) ++# define LZO_INFO_ARCH "generic" ++#elif (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16) ++# define LZO_ARCH_I086 1 ++# define LZO_ARCH_IA16 1 ++# define LZO_INFO_ARCH "i086" ++#elif defined(__alpha__) || defined(__alpha) || defined(_M_ALPHA) ++# define LZO_ARCH_ALPHA 1 ++# define LZO_INFO_ARCH "alpha" ++#elif (LZO_ARCH_CRAY_MPP) && (defined(_CRAYT3D) || defined(_CRAYT3E)) ++# define LZO_ARCH_ALPHA 1 ++# define LZO_INFO_ARCH "alpha" ++#elif defined(__amd64__) || defined(__x86_64__) || defined(_M_AMD64) ++# define LZO_ARCH_AMD64 1 ++# define LZO_INFO_ARCH "amd64" ++#elif defined(__thumb__) || (defined(_M_ARM) && defined(_M_THUMB)) ++# define LZO_ARCH_ARM 1 ++# define LZO_ARCH_ARM_THUMB 1 ++# define LZO_INFO_ARCH "arm_thumb" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCARM__) ++# define LZO_ARCH_ARM 1 ++# if defined(__CPU_MODE__) && ((__CPU_MODE__)+0 == 1) ++# define LZO_ARCH_ARM_THUMB 1 ++# define LZO_INFO_ARCH "arm_thumb" ++# elif defined(__CPU_MODE__) && ((__CPU_MODE__)+0 == 2) ++# define LZO_INFO_ARCH "arm" ++# else ++# define LZO_INFO_ARCH "arm" ++# endif ++#elif defined(__arm__) || defined(_M_ARM) ++# define LZO_ARCH_ARM 1 ++# define LZO_INFO_ARCH "arm" ++#elif (UINT_MAX <= LZO_0xffffL) && defined(__AVR__) ++# define LZO_ARCH_AVR 1 ++# define LZO_INFO_ARCH "avr" ++#elif defined(__avr32__) || defined(__AVR32__) ++# define LZO_ARCH_AVR32 1 ++# define LZO_INFO_ARCH "avr32" ++#elif defined(__bfin__) ++# define LZO_ARCH_BLACKFIN 1 ++# define LZO_INFO_ARCH "blackfin" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__C166__) ++# define LZO_ARCH_C166 1 ++# define LZO_INFO_ARCH "c166" ++#elif defined(__cris__) ++# define LZO_ARCH_CRIS 1 ++# define LZO_INFO_ARCH "cris" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCEZ80__) ++# define LZO_ARCH_EZ80 1 ++# define LZO_INFO_ARCH "ez80" ++#elif defined(__H8300__) || defined(__H8300H__) || defined(__H8300S__) || defined(__H8300SX__) ++# define LZO_ARCH_H8300 1 ++# define LZO_INFO_ARCH "h8300" ++#elif defined(__hppa__) || defined(__hppa) ++# define LZO_ARCH_HPPA 1 ++# define LZO_INFO_ARCH "hppa" ++#elif defined(__386__) || defined(__i386__) || defined(__i386) || defined(_M_IX86) || defined(_M_I386) ++# define LZO_ARCH_I386 1 ++# define LZO_ARCH_IA32 1 ++# define LZO_INFO_ARCH "i386" ++#elif (LZO_CC_ZORTECHC && defined(__I86__)) ++# define LZO_ARCH_I386 1 ++# define LZO_ARCH_IA32 1 ++# define LZO_INFO_ARCH "i386" ++#elif (LZO_OS_DOS32 && LZO_CC_HIGHC) && defined(_I386) ++# define LZO_ARCH_I386 1 ++# define LZO_ARCH_IA32 1 ++# define LZO_INFO_ARCH "i386" ++#elif defined(__ia64__) || defined(__ia64) || defined(_M_IA64) ++# define LZO_ARCH_IA64 1 ++# define LZO_INFO_ARCH "ia64" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__m32c__) ++# define LZO_ARCH_M16C 1 ++# define LZO_INFO_ARCH "m16c" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCM16C__) ++# define LZO_ARCH_M16C 1 ++# define LZO_INFO_ARCH "m16c" ++#elif defined(__m32r__) ++# define LZO_ARCH_M32R 1 ++# define LZO_INFO_ARCH "m32r" ++#elif (LZO_OS_TOS) || defined(__m68k__) || defined(__m68000__) || defined(__mc68000__) || defined(__mc68020__) || defined(_M_M68K) ++# define LZO_ARCH_M68K 1 ++# define LZO_INFO_ARCH "m68k" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__C251__) ++# define LZO_ARCH_MCS251 1 ++# define LZO_INFO_ARCH "mcs251" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__C51__) ++# define LZO_ARCH_MCS51 1 ++# define LZO_INFO_ARCH "mcs51" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICC8051__) ++# define LZO_ARCH_MCS51 1 ++# define LZO_INFO_ARCH "mcs51" ++#elif defined(__mips__) || defined(__mips) || defined(_MIPS_ARCH) || defined(_M_MRX000) ++# define LZO_ARCH_MIPS 1 ++# define LZO_INFO_ARCH "mips" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__MSP430__) ++# define LZO_ARCH_MSP430 1 ++# define LZO_INFO_ARCH "msp430" ++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICC430__) ++# define LZO_ARCH_MSP430 1 ++# define LZO_INFO_ARCH "msp430" ++#elif defined(__powerpc__) || defined(__powerpc) || defined(__ppc__) || defined(__PPC__) || defined(_M_PPC) || defined(_ARCH_PPC) || defined(_ARCH_PWR) ++# define LZO_ARCH_POWERPC 1 ++# define LZO_INFO_ARCH "powerpc" ++#elif defined(__s390__) || defined(__s390) || defined(__s390x__) || defined(__s390x) ++# define LZO_ARCH_S390 1 ++# define LZO_INFO_ARCH "s390" ++#elif defined(__sh__) || defined(_M_SH) ++# define LZO_ARCH_SH 1 ++# define LZO_INFO_ARCH "sh" ++#elif defined(__sparc__) || defined(__sparc) || defined(__sparcv8) ++# define LZO_ARCH_SPARC 1 ++# define LZO_INFO_ARCH "sparc" ++#elif defined(__SPU__) ++# define LZO_ARCH_SPU 1 ++# define LZO_INFO_ARCH "spu" ++#elif (UINT_MAX == LZO_0xffffL) && defined(__z80) ++# define LZO_ARCH_Z80 1 ++# define LZO_INFO_ARCH "z80" ++#elif (LZO_ARCH_CRAY_PVP) ++# if defined(_CRAYSV1) ++# define LZO_ARCH_CRAY_SV1 1 ++# define LZO_INFO_ARCH "cray_sv1" ++# elif (_ADDR64) ++# define LZO_ARCH_CRAY_T90 1 ++# define LZO_INFO_ARCH "cray_t90" ++# elif (_ADDR32) ++# define LZO_ARCH_CRAY_YMP 1 ++# define LZO_INFO_ARCH "cray_ymp" ++# else ++# define LZO_ARCH_CRAY_XMP 1 ++# define LZO_INFO_ARCH "cray_xmp" ++# endif ++#else ++# define LZO_ARCH_UNKNOWN 1 ++# define LZO_INFO_ARCH "unknown" ++#endif ++#endif ++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_DOS32 || LZO_OS_OS2) ++# error "FIXME - missing define for CPU architecture" ++#endif ++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_WIN32) ++# error "FIXME - missing WIN32 define for CPU architecture" ++#endif ++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_WIN64) ++# error "FIXME - missing WIN64 define for CPU architecture" ++#endif ++#if (LZO_OS_OS216 || LZO_OS_WIN16) ++# define LZO_ARCH_I086PM 1 ++# define LZO_ARCH_IA16PM 1 ++#elif 1 && (LZO_OS_DOS16 && defined(BLX286)) ++# define LZO_ARCH_I086PM 1 ++# define LZO_ARCH_IA16PM 1 ++#elif 1 && (LZO_OS_DOS16 && defined(DOSX286)) ++# define LZO_ARCH_I086PM 1 ++# define LZO_ARCH_IA16PM 1 ++#elif 1 && (LZO_OS_DOS16 && LZO_CC_BORLANDC && defined(__DPMI16__)) ++# define LZO_ARCH_I086PM 1 ++# define LZO_ARCH_IA16PM 1 ++#endif ++#if (LZO_ARCH_ARM_THUMB) && !(LZO_ARCH_ARM) ++# error "this should not happen" ++#endif ++#if (LZO_ARCH_I086PM) && !(LZO_ARCH_I086) ++# error "this should not happen" ++#endif ++#if (LZO_ARCH_I086) ++# if (UINT_MAX != LZO_0xffffL) ++# error "this should not happen" ++# endif ++# if (ULONG_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++#endif ++#if (LZO_ARCH_I386) ++# if (UINT_MAX != LZO_0xffffL) && defined(__i386_int16__) ++# error "this should not happen" ++# endif ++# if (UINT_MAX != LZO_0xffffffffL) && !defined(__i386_int16__) ++# error "this should not happen" ++# endif ++# if (ULONG_MAX != LZO_0xffffffffL) ++# error "this should not happen" ++# endif ++#endif ++#if !defined(__LZO_MM_OVERRIDE) ++#if (LZO_ARCH_I086) ++#if (UINT_MAX != LZO_0xffffL) ++# error "this should not happen" ++#endif ++#if defined(__TINY__) || defined(M_I86TM) || defined(_M_I86TM) ++# define LZO_MM_TINY 1 ++#elif defined(__HUGE__) || defined(_HUGE_) || defined(M_I86HM) || defined(_M_I86HM) ++# define LZO_MM_HUGE 1 ++#elif defined(__SMALL__) || defined(M_I86SM) || defined(_M_I86SM) || defined(SMALL_MODEL) ++# define LZO_MM_SMALL 1 ++#elif defined(__MEDIUM__) || defined(M_I86MM) || defined(_M_I86MM) ++# define LZO_MM_MEDIUM 1 ++#elif defined(__COMPACT__) || defined(M_I86CM) || defined(_M_I86CM) ++# define LZO_MM_COMPACT 1 ++#elif defined(__LARGE__) || defined(M_I86LM) || defined(_M_I86LM) || defined(LARGE_MODEL) ++# define LZO_MM_LARGE 1 ++#elif (LZO_CC_AZTECC) ++# if defined(_LARGE_CODE) && defined(_LARGE_DATA) ++# define LZO_MM_LARGE 1 ++# elif defined(_LARGE_CODE) ++# define LZO_MM_MEDIUM 1 ++# elif defined(_LARGE_DATA) ++# define LZO_MM_COMPACT 1 ++# else ++# define LZO_MM_SMALL 1 ++# endif ++#elif (LZO_CC_ZORTECHC && defined(__VCM__)) ++# define LZO_MM_LARGE 1 ++#else ++# error "unknown memory model" ++#endif ++#if (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16) ++#define LZO_HAVE_MM_HUGE_PTR 1 ++#define LZO_HAVE_MM_HUGE_ARRAY 1 ++#if (LZO_MM_TINY) ++# undef LZO_HAVE_MM_HUGE_ARRAY ++#endif ++#if (LZO_CC_AZTECC || LZO_CC_PACIFICC || LZO_CC_ZORTECHC) ++# undef LZO_HAVE_MM_HUGE_PTR ++# undef LZO_HAVE_MM_HUGE_ARRAY ++#elif (LZO_CC_DMC || LZO_CC_SYMANTECC) ++# undef LZO_HAVE_MM_HUGE_ARRAY ++#elif (LZO_CC_MSC && defined(_QC)) ++# undef LZO_HAVE_MM_HUGE_ARRAY ++# if (_MSC_VER < 600) ++# undef LZO_HAVE_MM_HUGE_PTR ++# endif ++#elif (LZO_CC_TURBOC && (__TURBOC__ < 0x0295)) ++# undef LZO_HAVE_MM_HUGE_ARRAY ++#endif ++#if (LZO_ARCH_I086PM) && !(LZO_HAVE_MM_HUGE_PTR) ++# if (LZO_OS_DOS16) ++# error "this should not happen" ++# elif (LZO_CC_ZORTECHC) ++# else ++# error "this should not happen" ++# endif ++#endif ++#ifdef __cplusplus ++extern "C" { ++#endif ++#if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0200)) ++ extern void __near __cdecl _AHSHIFT(void); ++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) ++#elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) ++ extern void __near __cdecl _AHSHIFT(void); ++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) ++#elif (LZO_CC_MSC || LZO_CC_TOPSPEEDC) ++ extern void __near __cdecl _AHSHIFT(void); ++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) ++#elif (LZO_CC_TURBOC && (__TURBOC__ >= 0x0295)) ++ extern void __near __cdecl _AHSHIFT(void); ++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) ++#elif ((LZO_CC_AZTECC || LZO_CC_PACIFICC || LZO_CC_TURBOC) && LZO_OS_DOS16) ++# define LZO_MM_AHSHIFT 12 ++#elif (LZO_CC_WATCOMC) ++ extern unsigned char _HShift; ++# define LZO_MM_AHSHIFT ((unsigned) _HShift) ++#else ++# error "FIXME - implement LZO_MM_AHSHIFT" ++#endif ++#ifdef __cplusplus ++} ++#endif ++#endif ++#elif (LZO_ARCH_C166) ++#if !defined(__MODEL__) ++# error "FIXME - C166 __MODEL__" ++#elif ((__MODEL__) == 0) ++# define LZO_MM_SMALL 1 ++#elif ((__MODEL__) == 1) ++# define LZO_MM_SMALL 1 ++#elif ((__MODEL__) == 2) ++# define LZO_MM_LARGE 1 ++#elif ((__MODEL__) == 3) ++# define LZO_MM_TINY 1 ++#elif ((__MODEL__) == 4) ++# define LZO_MM_XTINY 1 ++#elif ((__MODEL__) == 5) ++# define LZO_MM_XSMALL 1 ++#else ++# error "FIXME - C166 __MODEL__" ++#endif ++#elif (LZO_ARCH_MCS251) ++#if !defined(__MODEL__) ++# error "FIXME - MCS251 __MODEL__" ++#elif ((__MODEL__) == 0) ++# define LZO_MM_SMALL 1 ++#elif ((__MODEL__) == 2) ++# define LZO_MM_LARGE 1 ++#elif ((__MODEL__) == 3) ++# define LZO_MM_TINY 1 ++#elif ((__MODEL__) == 4) ++# define LZO_MM_XTINY 1 ++#elif ((__MODEL__) == 5) ++# define LZO_MM_XSMALL 1 ++#else ++# error "FIXME - MCS251 __MODEL__" ++#endif ++#elif (LZO_ARCH_MCS51) ++#if !defined(__MODEL__) ++# error "FIXME - MCS51 __MODEL__" ++#elif ((__MODEL__) == 1) ++# define LZO_MM_SMALL 1 ++#elif ((__MODEL__) == 2) ++# define LZO_MM_LARGE 1 ++#elif ((__MODEL__) == 3) ++# define LZO_MM_TINY 1 ++#elif ((__MODEL__) == 4) ++# define LZO_MM_XTINY 1 ++#elif ((__MODEL__) == 5) ++# define LZO_MM_XSMALL 1 ++#else ++# error "FIXME - MCS51 __MODEL__" ++#endif ++#elif (LZO_ARCH_CRAY_PVP) ++# define LZO_MM_PVP 1 ++#else ++# define LZO_MM_FLAT 1 ++#endif ++#if (LZO_MM_COMPACT) ++# define LZO_INFO_MM "compact" ++#elif (LZO_MM_FLAT) ++# define LZO_INFO_MM "flat" ++#elif (LZO_MM_HUGE) ++# define LZO_INFO_MM "huge" ++#elif (LZO_MM_LARGE) ++# define LZO_INFO_MM "large" ++#elif (LZO_MM_MEDIUM) ++# define LZO_INFO_MM "medium" ++#elif (LZO_MM_PVP) ++# define LZO_INFO_MM "pvp" ++#elif (LZO_MM_SMALL) ++# define LZO_INFO_MM "small" ++#elif (LZO_MM_TINY) ++# define LZO_INFO_MM "tiny" ++#else ++# error "unknown memory model" ++#endif ++#endif ++#if defined(SIZEOF_SHORT) ++# define LZO_SIZEOF_SHORT (SIZEOF_SHORT) ++#endif ++#if defined(SIZEOF_INT) ++# define LZO_SIZEOF_INT (SIZEOF_INT) ++#endif ++#if defined(SIZEOF_LONG) ++# define LZO_SIZEOF_LONG (SIZEOF_LONG) ++#endif ++#if defined(SIZEOF_LONG_LONG) ++# define LZO_SIZEOF_LONG_LONG (SIZEOF_LONG_LONG) ++#endif ++#if defined(SIZEOF___INT16) ++# define LZO_SIZEOF___INT16 (SIZEOF___INT16) ++#endif ++#if defined(SIZEOF___INT32) ++# define LZO_SIZEOF___INT32 (SIZEOF___INT32) ++#endif ++#if defined(SIZEOF___INT64) ++# define LZO_SIZEOF___INT64 (SIZEOF___INT64) ++#endif ++#if defined(SIZEOF_VOID_P) ++# define LZO_SIZEOF_VOID_P (SIZEOF_VOID_P) ++#endif ++#if defined(SIZEOF_SIZE_T) ++# define LZO_SIZEOF_SIZE_T (SIZEOF_SIZE_T) ++#endif ++#if defined(SIZEOF_PTRDIFF_T) ++# define LZO_SIZEOF_PTRDIFF_T (SIZEOF_PTRDIFF_T) ++#endif ++#define __LZO_LSR(x,b) (((x)+0ul) >> (b)) ++#if !defined(LZO_SIZEOF_SHORT) ++# if (LZO_ARCH_CRAY_PVP) ++# define LZO_SIZEOF_SHORT 8 ++# elif (USHRT_MAX == LZO_0xffffL) ++# define LZO_SIZEOF_SHORT 2 ++# elif (__LZO_LSR(USHRT_MAX,7) == 1) ++# define LZO_SIZEOF_SHORT 1 ++# elif (__LZO_LSR(USHRT_MAX,15) == 1) ++# define LZO_SIZEOF_SHORT 2 ++# elif (__LZO_LSR(USHRT_MAX,31) == 1) ++# define LZO_SIZEOF_SHORT 4 ++# elif (__LZO_LSR(USHRT_MAX,63) == 1) ++# define LZO_SIZEOF_SHORT 8 ++# elif (__LZO_LSR(USHRT_MAX,127) == 1) ++# define LZO_SIZEOF_SHORT 16 ++# else ++# error "LZO_SIZEOF_SHORT" ++# endif ++#endif ++#if !defined(LZO_SIZEOF_INT) ++# if (LZO_ARCH_CRAY_PVP) ++# define LZO_SIZEOF_INT 8 ++# elif (UINT_MAX == LZO_0xffffL) ++# define LZO_SIZEOF_INT 2 ++# elif (UINT_MAX == LZO_0xffffffffL) ++# define LZO_SIZEOF_INT 4 ++# elif (__LZO_LSR(UINT_MAX,7) == 1) ++# define LZO_SIZEOF_INT 1 ++# elif (__LZO_LSR(UINT_MAX,15) == 1) ++# define LZO_SIZEOF_INT 2 ++# elif (__LZO_LSR(UINT_MAX,31) == 1) ++# define LZO_SIZEOF_INT 4 ++# elif (__LZO_LSR(UINT_MAX,63) == 1) ++# define LZO_SIZEOF_INT 8 ++# elif (__LZO_LSR(UINT_MAX,127) == 1) ++# define LZO_SIZEOF_INT 16 ++# else ++# error "LZO_SIZEOF_INT" ++# endif ++#endif ++#if !defined(LZO_SIZEOF_LONG) ++# if (ULONG_MAX == LZO_0xffffffffL) ++# define LZO_SIZEOF_LONG 4 ++# elif (__LZO_LSR(ULONG_MAX,7) == 1) ++# define LZO_SIZEOF_LONG 1 ++# elif (__LZO_LSR(ULONG_MAX,15) == 1) ++# define LZO_SIZEOF_LONG 2 ++# elif (__LZO_LSR(ULONG_MAX,31) == 1) ++# define LZO_SIZEOF_LONG 4 ++# elif (__LZO_LSR(ULONG_MAX,63) == 1) ++# define LZO_SIZEOF_LONG 8 ++# elif (__LZO_LSR(ULONG_MAX,127) == 1) ++# define LZO_SIZEOF_LONG 16 ++# else ++# error "LZO_SIZEOF_LONG" ++# endif ++#endif ++#if !defined(LZO_SIZEOF_LONG_LONG) && !defined(LZO_SIZEOF___INT64) ++#if (LZO_SIZEOF_LONG > 0 && LZO_SIZEOF_LONG < 8) ++# if defined(__LONG_MAX__) && defined(__LONG_LONG_MAX__) ++# if (LZO_CC_GNUC >= 0x030300ul) ++# if ((__LONG_MAX__)+0 == (__LONG_LONG_MAX__)+0) ++# define LZO_SIZEOF_LONG_LONG LZO_SIZEOF_LONG ++# elif (__LZO_LSR(__LONG_LONG_MAX__,30) == 1) ++# define LZO_SIZEOF_LONG_LONG 4 ++# endif ++# endif ++# endif ++#endif ++#endif ++#if !defined(LZO_SIZEOF_LONG_LONG) && !defined(LZO_SIZEOF___INT64) ++#if (LZO_SIZEOF_LONG > 0 && LZO_SIZEOF_LONG < 8) ++#if (LZO_ARCH_I086 && LZO_CC_DMC) ++#elif (LZO_CC_CILLY) && defined(__GNUC__) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif ((LZO_OS_WIN32 || LZO_OS_WIN64 || defined(_WIN32)) && LZO_CC_MSC && (_MSC_VER >= 1400)) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_OS_WIN64 || defined(_WIN64)) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_DMC)) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_SYMANTECC && (__SC__ >= 0x700))) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_INTELC && defined(__linux__))) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_MWERKS || LZO_CC_PELLESC || LZO_CC_PGI || LZO_CC_SUNPROC)) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_INTELC || LZO_CC_MSC)) ++# define LZO_SIZEOF___INT64 8 ++#elif ((LZO_OS_WIN32 || defined(_WIN32)) && (LZO_CC_MSC)) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0520))) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_ARCH_I386 && (LZO_CC_WATCOMC && (__WATCOMC__ >= 1100))) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_CC_WATCOMC && defined(_INTEGRAL_MAX_BITS) && (_INTEGRAL_MAX_BITS == 64)) ++# define LZO_SIZEOF___INT64 8 ++#elif (LZO_OS_OS400 || defined(__OS400__)) && defined(__LLP64_IFC__) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (defined(__vms) || defined(__VMS)) && (__INITIAL_POINTER_SIZE+0 == 64) ++# define LZO_SIZEOF_LONG_LONG 8 ++#elif (LZO_CC_SDCC) && (LZO_SIZEOF_INT == 2) ++#elif 1 && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) ++# define LZO_SIZEOF_LONG_LONG 8 ++#endif ++#endif ++#endif ++#if defined(__cplusplus) && (LZO_CC_GNUC) ++# if (LZO_CC_GNUC < 0x020800ul) ++# undef LZO_SIZEOF_LONG_LONG ++# endif ++#endif ++#if (LZO_CFG_NO_LONG_LONG) || defined(__NO_LONG_LONG) ++# undef LZO_SIZEOF_LONG_LONG ++#endif ++#if !defined(LZO_SIZEOF_VOID_P) ++#if (LZO_ARCH_I086) ++# define __LZO_WORDSIZE 2 ++# if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM) ++# define LZO_SIZEOF_VOID_P 2 ++# elif (LZO_MM_COMPACT || LZO_MM_LARGE || LZO_MM_HUGE) ++# define LZO_SIZEOF_VOID_P 4 ++# else ++# error "LZO_MM" ++# endif ++#elif (LZO_ARCH_AVR || LZO_ARCH_Z80) ++# define __LZO_WORDSIZE 1 ++# define LZO_SIZEOF_VOID_P 2 ++#elif (LZO_ARCH_C166 || LZO_ARCH_MCS51 || LZO_ARCH_MCS251 || LZO_ARCH_MSP430) ++# define LZO_SIZEOF_VOID_P 2 ++#elif (LZO_ARCH_H8300) ++# if defined(__NORMAL_MODE__) ++# define __LZO_WORDSIZE 4 ++# define LZO_SIZEOF_VOID_P 2 ++# elif defined(__H8300H__) || defined(__H8300S__) || defined(__H8300SX__) ++# define __LZO_WORDSIZE 4 ++# define LZO_SIZEOF_VOID_P 4 ++# else ++# define __LZO_WORDSIZE 2 ++# define LZO_SIZEOF_VOID_P 2 ++# endif ++# if (LZO_CC_GNUC && (LZO_CC_GNUC < 0x040000ul)) && (LZO_SIZEOF_INT == 4) ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_INT ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_INT ++# endif ++#elif (LZO_ARCH_M16C) ++# define __LZO_WORDSIZE 2 ++# if defined(__m32c_cpu__) || defined(__m32cm_cpu__) ++# define LZO_SIZEOF_VOID_P 4 ++# else ++# define LZO_SIZEOF_VOID_P 2 ++# endif ++#elif (LZO_SIZEOF_LONG == 8) && ((defined(__mips__) && defined(__R5900__)) || defined(__MIPS_PSX2__)) ++# define __LZO_WORDSIZE 8 ++# define LZO_SIZEOF_VOID_P 4 ++#elif defined(__LLP64__) || defined(__LLP64) || defined(_LLP64) || defined(_WIN64) ++# define __LZO_WORDSIZE 8 ++# define LZO_SIZEOF_VOID_P 8 ++#elif (LZO_OS_OS400 || defined(__OS400__)) && defined(__LLP64_IFC__) ++# define LZO_SIZEOF_VOID_P LZO_SIZEOF_LONG ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG ++#elif (LZO_OS_OS400 || defined(__OS400__)) ++# define __LZO_WORDSIZE LZO_SIZEOF_LONG ++# define LZO_SIZEOF_VOID_P 16 ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG ++#elif (defined(__vms) || defined(__VMS)) && (__INITIAL_POINTER_SIZE+0 == 64) ++# define LZO_SIZEOF_VOID_P 8 ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG ++#elif (LZO_ARCH_SPU) ++# if 0 ++# define __LZO_WORDSIZE 16 ++# endif ++# define LZO_SIZEOF_VOID_P 4 ++#else ++# define LZO_SIZEOF_VOID_P LZO_SIZEOF_LONG ++#endif ++#endif ++#if !defined(LZO_WORDSIZE) ++# if defined(__LZO_WORDSIZE) ++# define LZO_WORDSIZE __LZO_WORDSIZE ++# else ++# define LZO_WORDSIZE LZO_SIZEOF_VOID_P ++# endif ++#endif ++#if !defined(LZO_SIZEOF_SIZE_T) ++#if (LZO_ARCH_I086 || LZO_ARCH_M16C) ++# define LZO_SIZEOF_SIZE_T 2 ++#else ++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_VOID_P ++#endif ++#endif ++#if !defined(LZO_SIZEOF_PTRDIFF_T) ++#if (LZO_ARCH_I086) ++# if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM || LZO_MM_HUGE) ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_VOID_P ++# elif (LZO_MM_COMPACT || LZO_MM_LARGE) ++# if (LZO_CC_BORLANDC || LZO_CC_TURBOC) ++# define LZO_SIZEOF_PTRDIFF_T 4 ++# else ++# define LZO_SIZEOF_PTRDIFF_T 2 ++# endif ++# else ++# error "LZO_MM" ++# endif ++#else ++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_SIZE_T ++#endif ++#endif ++#if (LZO_ABI_NEUTRAL_ENDIAN) ++# undef LZO_ABI_BIG_ENDIAN ++# undef LZO_ABI_LITTLE_ENDIAN ++#elif !(LZO_ABI_BIG_ENDIAN) && !(LZO_ABI_LITTLE_ENDIAN) ++#if (LZO_ARCH_ALPHA) && (LZO_ARCH_CRAY_MPP) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif (LZO_ARCH_IA64) && (LZO_OS_POSIX_LINUX || LZO_OS_WIN64) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#elif (LZO_ARCH_ALPHA || LZO_ARCH_AMD64 || LZO_ARCH_BLACKFIN || LZO_ARCH_CRIS || LZO_ARCH_I086 || LZO_ARCH_I386 || LZO_ARCH_MSP430) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#elif (LZO_ARCH_AVR32 || LZO_ARCH_M68K || LZO_ARCH_S390) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif 1 && defined(__IAR_SYSTEMS_ICC__) && defined(__LITTLE_ENDIAN__) ++# if (__LITTLE_ENDIAN__ == 1) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++# else ++# define LZO_ABI_BIG_ENDIAN 1 ++# endif ++#elif 1 && defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif 1 && defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#elif 1 && (LZO_ARCH_ARM) && defined(__ARMEB__) && !defined(__ARMEL__) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif 1 && (LZO_ARCH_ARM) && defined(__ARMEL__) && !defined(__ARMEB__) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#elif 1 && (LZO_ARCH_MIPS) && defined(__MIPSEB__) && !defined(__MIPSEL__) ++# define LZO_ABI_BIG_ENDIAN 1 ++#elif 1 && (LZO_ARCH_MIPS) && defined(__MIPSEL__) && !defined(__MIPSEB__) ++# define LZO_ABI_LITTLE_ENDIAN 1 ++#endif ++#endif ++#if (LZO_ABI_BIG_ENDIAN) && (LZO_ABI_LITTLE_ENDIAN) ++# error "this should not happen" ++#endif ++#if (LZO_ABI_BIG_ENDIAN) ++# define LZO_INFO_ABI_ENDIAN "be" ++#elif (LZO_ABI_LITTLE_ENDIAN) ++# define LZO_INFO_ABI_ENDIAN "le" ++#elif (LZO_ABI_NEUTRAL_ENDIAN) ++# define LZO_INFO_ABI_ENDIAN "neutral" ++#endif ++#if (LZO_SIZEOF_INT == 1 && LZO_SIZEOF_LONG == 2 && LZO_SIZEOF_VOID_P == 2) ++# define LZO_ABI_I8LP16 1 ++# define LZO_INFO_ABI_PM "i8lp16" ++#elif (LZO_SIZEOF_INT == 2 && LZO_SIZEOF_LONG == 2 && LZO_SIZEOF_VOID_P == 2) ++# define LZO_ABI_ILP16 1 ++# define LZO_INFO_ABI_PM "ilp16" ++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 4 && LZO_SIZEOF_VOID_P == 4) ++# define LZO_ABI_ILP32 1 ++# define LZO_INFO_ABI_PM "ilp32" ++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 4 && LZO_SIZEOF_VOID_P == 8 && LZO_SIZEOF_SIZE_T == 8) ++# define LZO_ABI_LLP64 1 ++# define LZO_INFO_ABI_PM "llp64" ++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 8) ++# define LZO_ABI_LP64 1 ++# define LZO_INFO_ABI_PM "lp64" ++#elif (LZO_SIZEOF_INT == 8 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 8) ++# define LZO_ABI_ILP64 1 ++# define LZO_INFO_ABI_PM "ilp64" ++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 4) ++# define LZO_ABI_IP32L64 1 ++# define LZO_INFO_ABI_PM "ip32l64" ++#endif ++#if !defined(__LZO_LIBC_OVERRIDE) ++#if (LZO_LIBC_NAKED) ++# define LZO_INFO_LIBC "naked" ++#elif (LZO_LIBC_FREESTANDING) ++# define LZO_INFO_LIBC "freestanding" ++#elif (LZO_LIBC_MOSTLY_FREESTANDING) ++# define LZO_INFO_LIBC "mfreestanding" ++#elif (LZO_LIBC_ISOC90) ++# define LZO_INFO_LIBC "isoc90" ++#elif (LZO_LIBC_ISOC99) ++# define LZO_INFO_LIBC "isoc99" ++#elif defined(__dietlibc__) ++# define LZO_LIBC_DIETLIBC 1 ++# define LZO_INFO_LIBC "dietlibc" ++#elif defined(_NEWLIB_VERSION) ++# define LZO_LIBC_NEWLIB 1 ++# define LZO_INFO_LIBC "newlib" ++#elif defined(__UCLIBC__) && defined(__UCLIBC_MAJOR__) && defined(__UCLIBC_MINOR__) ++# if defined(__UCLIBC_SUBLEVEL__) ++# define LZO_LIBC_UCLIBC (__UCLIBC_MAJOR__ * 0x10000L + __UCLIBC_MINOR__ * 0x100 + __UCLIBC_SUBLEVEL__) ++# else ++# define LZO_LIBC_UCLIBC 0x00090bL ++# endif ++# define LZO_INFO_LIBC "uclibc" ++#elif defined(__GLIBC__) && defined(__GLIBC_MINOR__) ++# define LZO_LIBC_GLIBC (__GLIBC__ * 0x10000L + __GLIBC_MINOR__ * 0x100) ++# define LZO_INFO_LIBC "glibc" ++#elif (LZO_CC_MWERKS) && defined(__MSL__) ++# define LZO_LIBC_MSL __MSL__ ++# define LZO_INFO_LIBC "msl" ++#elif 1 && defined(__IAR_SYSTEMS_ICC__) ++# define LZO_LIBC_ISOC90 1 ++# define LZO_INFO_LIBC "isoc90" ++#else ++# define LZO_LIBC_DEFAULT 1 ++# define LZO_INFO_LIBC "default" ++#endif ++#endif ++#if !defined(__lzo_gnuc_extension__) ++#if (LZO_CC_GNUC >= 0x020800ul) ++# define __lzo_gnuc_extension__ __extension__ ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_gnuc_extension__ __extension__ ++#else ++# define __lzo_gnuc_extension__ /*empty*/ ++#endif ++#endif ++#if !defined(__lzo_ua_volatile) ++# define __lzo_ua_volatile volatile ++#endif ++#if !defined(__lzo_alignof) ++#if (LZO_CC_CILLY || LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE || LZO_CC_PGI) ++# define __lzo_alignof(e) __alignof__(e) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 700)) ++# define __lzo_alignof(e) __alignof__(e) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1300)) ++# define __lzo_alignof(e) __alignof(e) ++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100)) ++# define __lzo_alignof(e) __alignof__(e) ++#endif ++#endif ++#if defined(__lzo_alignof) ++# define __lzo_HAVE_alignof 1 ++#endif ++#if !defined(__lzo_constructor) ++#if (LZO_CC_GNUC >= 0x030400ul) ++# define __lzo_constructor __attribute__((__constructor__,__used__)) ++#elif (LZO_CC_GNUC >= 0x020700ul) ++# define __lzo_constructor __attribute__((__constructor__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_constructor __attribute__((__constructor__)) ++#endif ++#endif ++#if defined(__lzo_constructor) ++# define __lzo_HAVE_constructor 1 ++#endif ++#if !defined(__lzo_destructor) ++#if (LZO_CC_GNUC >= 0x030400ul) ++# define __lzo_destructor __attribute__((__destructor__,__used__)) ++#elif (LZO_CC_GNUC >= 0x020700ul) ++# define __lzo_destructor __attribute__((__destructor__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_destructor __attribute__((__destructor__)) ++#endif ++#endif ++#if defined(__lzo_destructor) ++# define __lzo_HAVE_destructor 1 ++#endif ++#if (__lzo_HAVE_destructor) && !(__lzo_HAVE_constructor) ++# error "this should not happen" ++#endif ++#if !defined(__lzo_inline) ++#if (LZO_CC_TURBOC && (__TURBOC__ <= 0x0295)) ++#elif defined(__cplusplus) ++# define __lzo_inline inline ++#elif (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0550)) ++# define __lzo_inline __inline ++#elif (LZO_CC_CILLY || LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE || LZO_CC_PGI) ++# define __lzo_inline __inline__ ++#elif (LZO_CC_DMC) ++# define __lzo_inline __inline ++#elif (LZO_CC_INTELC) ++# define __lzo_inline __inline ++#elif (LZO_CC_MWERKS && (__MWERKS__ >= 0x2405)) ++# define __lzo_inline __inline ++#elif (LZO_CC_MSC && (_MSC_VER >= 900)) ++# define __lzo_inline __inline ++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100)) ++# define __lzo_inline __inline__ ++#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) ++# define __lzo_inline inline ++#endif ++#endif ++#if defined(__lzo_inline) ++# define __lzo_HAVE_inline 1 ++#else ++# define __lzo_inline /*empty*/ ++#endif ++#if !defined(__lzo_forceinline) ++#if (LZO_CC_GNUC >= 0x030200ul) ++# define __lzo_forceinline __inline__ __attribute__((__always_inline__)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC) ++# define __lzo_forceinline __forceinline ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_forceinline __inline__ __attribute__((__always_inline__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_forceinline __inline__ __attribute__((__always_inline__)) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1200)) ++# define __lzo_forceinline __forceinline ++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100)) ++# define __lzo_forceinline __inline__ __attribute__((__always_inline__)) ++#endif ++#endif ++#if defined(__lzo_forceinline) ++# define __lzo_HAVE_forceinline 1 ++#else ++# define __lzo_forceinline /*empty*/ ++#endif ++#if !defined(__lzo_noinline) ++#if 1 && (LZO_ARCH_I386) && (LZO_CC_GNUC >= 0x040000ul) && (LZO_CC_GNUC < 0x040003ul) ++# define __lzo_noinline __attribute__((__noinline__,__used__)) ++#elif (LZO_CC_GNUC >= 0x030200ul) ++# define __lzo_noinline __attribute__((__noinline__)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_MSC) ++# define __lzo_noinline __declspec(noinline) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_noinline __attribute__((__noinline__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_noinline __attribute__((__noinline__)) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1300)) ++# define __lzo_noinline __declspec(noinline) ++#elif (LZO_CC_MWERKS && (__MWERKS__ >= 0x3200) && (LZO_OS_WIN32 || LZO_OS_WIN64)) ++# if defined(__cplusplus) ++# else ++# define __lzo_noinline __declspec(noinline) ++# endif ++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100)) ++# define __lzo_noinline __attribute__((__noinline__)) ++#endif ++#endif ++#if defined(__lzo_noinline) ++# define __lzo_HAVE_noinline 1 ++#else ++# define __lzo_noinline /*empty*/ ++#endif ++#if (__lzo_HAVE_forceinline || __lzo_HAVE_noinline) && !(__lzo_HAVE_inline) ++# error "this should not happen" ++#endif ++#if !defined(__lzo_noreturn) ++#if (LZO_CC_GNUC >= 0x020700ul) ++# define __lzo_noreturn __attribute__((__noreturn__)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC) ++# define __lzo_noreturn __declspec(noreturn) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_noreturn __attribute__((__noreturn__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_noreturn __attribute__((__noreturn__)) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1200)) ++# define __lzo_noreturn __declspec(noreturn) ++#endif ++#endif ++#if defined(__lzo_noreturn) ++# define __lzo_HAVE_noreturn 1 ++#else ++# define __lzo_noreturn /*empty*/ ++#endif ++#if !defined(__lzo_nothrow) ++#if (LZO_CC_GNUC >= 0x030300ul) ++# define __lzo_nothrow __attribute__((__nothrow__)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC) && defined(__cplusplus) ++# define __lzo_nothrow __declspec(nothrow) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 900) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_nothrow __attribute__((__nothrow__)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_nothrow __attribute__((__nothrow__)) ++#elif (LZO_CC_MSC && (_MSC_VER >= 1200)) && defined(__cplusplus) ++# define __lzo_nothrow __declspec(nothrow) ++#endif ++#endif ++#if defined(__lzo_nothrow) ++# define __lzo_HAVE_nothrow 1 ++#else ++# define __lzo_nothrow /*empty*/ ++#endif ++#if !defined(__lzo_restrict) ++#if (LZO_CC_GNUC >= 0x030400ul) ++# define __lzo_restrict __restrict__ ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_GNUC) ++# define __lzo_restrict __restrict__ ++#elif (LZO_CC_CLANG || LZO_CC_LLVM) ++# define __lzo_restrict __restrict__ ++#elif (LZO_CC_MSC && (_MSC_VER >= 1400)) ++# define __lzo_restrict __restrict ++#endif ++#endif ++#if defined(__lzo_restrict) ++# define __lzo_HAVE_restrict 1 ++#else ++# define __lzo_restrict /*empty*/ ++#endif ++#if !defined(__lzo_likely) && !defined(__lzo_unlikely) ++#if (LZO_CC_GNUC >= 0x030200ul) ++# define __lzo_likely(e) (__builtin_expect(!!(e),1)) ++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) ++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800)) ++# define __lzo_likely(e) (__builtin_expect(!!(e),1)) ++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) ++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define __lzo_likely(e) (__builtin_expect(!!(e),1)) ++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0)) ++#endif ++#endif ++#if defined(__lzo_likely) ++# define __lzo_HAVE_likely 1 ++#else ++# define __lzo_likely(e) (e) ++#endif ++#if defined(__lzo_unlikely) ++# define __lzo_HAVE_unlikely 1 ++#else ++# define __lzo_unlikely(e) (e) ++#endif ++#if !defined(LZO_UNUSED) ++# if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0600)) ++# define LZO_UNUSED(var) ((void) &var) ++# elif (LZO_CC_BORLANDC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PELLESC || LZO_CC_TURBOC) ++# define LZO_UNUSED(var) if (&var) ; else ++# elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define LZO_UNUSED(var) ((void) var) ++# elif (LZO_CC_MSC && (_MSC_VER < 900)) ++# define LZO_UNUSED(var) if (&var) ; else ++# elif (LZO_CC_KEILC) ++# define LZO_UNUSED(var) {extern int __lzo_unused[1-2*!(sizeof(var)>0)];} ++# elif (LZO_CC_PACIFICC) ++# define LZO_UNUSED(var) ((void) sizeof(var)) ++# elif (LZO_CC_WATCOMC) && defined(__cplusplus) ++# define LZO_UNUSED(var) ((void) var) ++# else ++# define LZO_UNUSED(var) ((void) &var) ++# endif ++#endif ++#if !defined(LZO_UNUSED_FUNC) ++# if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0600)) ++# define LZO_UNUSED_FUNC(func) ((void) func) ++# elif (LZO_CC_BORLANDC || LZO_CC_NDPC || LZO_CC_TURBOC) ++# define LZO_UNUSED_FUNC(func) if (func) ; else ++# elif (LZO_CC_CLANG || LZO_CC_LLVM) ++# define LZO_UNUSED_FUNC(func) ((void) &func) ++# elif (LZO_CC_MSC && (_MSC_VER < 900)) ++# define LZO_UNUSED_FUNC(func) if (func) ; else ++# elif (LZO_CC_MSC) ++# define LZO_UNUSED_FUNC(func) ((void) &func) ++# elif (LZO_CC_KEILC || LZO_CC_PELLESC) ++# define LZO_UNUSED_FUNC(func) {extern int __lzo_unused[1-2*!(sizeof((int)func)>0)];} ++# else ++# define LZO_UNUSED_FUNC(func) ((void) func) ++# endif ++#endif ++#if !defined(LZO_UNUSED_LABEL) ++# if (LZO_CC_WATCOMC) && defined(__cplusplus) ++# define LZO_UNUSED_LABEL(l) switch(0) case 1:goto l ++# elif (LZO_CC_CLANG || LZO_CC_INTELC || LZO_CC_WATCOMC) ++# define LZO_UNUSED_LABEL(l) if (0) goto l ++# else ++# define LZO_UNUSED_LABEL(l) switch(0) case 1:goto l ++# endif ++#endif ++#if !defined(LZO_DEFINE_UNINITIALIZED_VAR) ++# if 0 ++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var ++# elif 0 && (LZO_CC_GNUC) ++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var = var ++# else ++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var = init ++# endif ++#endif ++#if !defined(LZO_UNCONST_CAST) ++# if 0 && defined(__cplusplus) ++# define LZO_UNCONST_CAST(t,e) (const_cast (e)) ++# elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE) ++# define LZO_UNCONST_CAST(t,e) ((t) ((void *) ((char *) ((lzo_uintptr_t) ((const void *) (e)))))) ++# else ++# define LZO_UNCONST_CAST(t,e) ((t) ((void *) ((char *) ((const void *) (e))))) ++# endif ++#endif ++#if !defined(LZO_COMPILE_TIME_ASSERT_HEADER) ++# if (LZO_CC_AZTECC || LZO_CC_ZORTECHC) ++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-!(e)]; ++# elif (LZO_CC_DMC || LZO_CC_SYMANTECC) ++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1u-2*!(e)]; ++# elif (LZO_CC_TURBOC && (__TURBOC__ == 0x0295)) ++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-!(e)]; ++# else ++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-2*!(e)]; ++# endif ++#endif ++#if !defined(LZO_COMPILE_TIME_ASSERT) ++# if (LZO_CC_AZTECC) ++# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __lzo_cta_t[1-!(e)];} ++# elif (LZO_CC_DMC || LZO_CC_PACIFICC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) ++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break; ++# elif (LZO_CC_MSC && (_MSC_VER < 900)) ++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break; ++# elif (LZO_CC_TURBOC && (__TURBOC__ == 0x0295)) ++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break; ++# else ++# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __lzo_cta_t[1-2*!(e)];} ++# endif ++#endif ++#if (LZO_ARCH_I086 || LZO_ARCH_I386) && (LZO_OS_DOS16 || LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_OS216 || LZO_OS_WIN16 || LZO_OS_WIN32 || LZO_OS_WIN64) ++# if (LZO_CC_GNUC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PACIFICC) ++# elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) ++# define __lzo_cdecl __cdecl ++# define __lzo_cdecl_atexit /*empty*/ ++# define __lzo_cdecl_main __cdecl ++# if (LZO_OS_OS2 && (LZO_CC_DMC || LZO_CC_SYMANTECC)) ++# define __lzo_cdecl_qsort __pascal ++# elif (LZO_OS_OS2 && (LZO_CC_ZORTECHC)) ++# define __lzo_cdecl_qsort _stdcall ++# else ++# define __lzo_cdecl_qsort __cdecl ++# endif ++# elif (LZO_CC_WATCOMC) ++# define __lzo_cdecl __cdecl ++# else ++# define __lzo_cdecl __cdecl ++# define __lzo_cdecl_atexit __cdecl ++# define __lzo_cdecl_main __cdecl ++# define __lzo_cdecl_qsort __cdecl ++# endif ++# if (LZO_CC_GNUC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PACIFICC || LZO_CC_WATCOMC) ++# elif (LZO_OS_OS2 && (LZO_CC_DMC || LZO_CC_SYMANTECC)) ++# define __lzo_cdecl_sighandler __pascal ++# elif (LZO_OS_OS2 && (LZO_CC_ZORTECHC)) ++# define __lzo_cdecl_sighandler _stdcall ++# elif (LZO_CC_MSC && (_MSC_VER >= 1400)) && defined(_M_CEE_PURE) ++# define __lzo_cdecl_sighandler __clrcall ++# elif (LZO_CC_MSC && (_MSC_VER >= 600 && _MSC_VER < 700)) ++# if defined(_DLL) ++# define __lzo_cdecl_sighandler _far _cdecl _loadds ++# elif defined(_MT) ++# define __lzo_cdecl_sighandler _far _cdecl ++# else ++# define __lzo_cdecl_sighandler _cdecl ++# endif ++# else ++# define __lzo_cdecl_sighandler __cdecl ++# endif ++#elif (LZO_ARCH_I386) && (LZO_CC_WATCOMC) ++# define __lzo_cdecl __cdecl ++#elif (LZO_ARCH_M68K && LZO_OS_TOS && (LZO_CC_PUREC || LZO_CC_TURBOC)) ++# define __lzo_cdecl cdecl ++#endif ++#if !defined(__lzo_cdecl) ++# define __lzo_cdecl /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_atexit) ++# define __lzo_cdecl_atexit /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_main) ++# define __lzo_cdecl_main /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_qsort) ++# define __lzo_cdecl_qsort /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_sighandler) ++# define __lzo_cdecl_sighandler /*empty*/ ++#endif ++#if !defined(__lzo_cdecl_va) ++# define __lzo_cdecl_va __lzo_cdecl ++#endif ++#if !(LZO_CFG_NO_WINDOWS_H) ++#if (LZO_OS_CYGWIN || (LZO_OS_EMX && defined(__RSXNT__)) || LZO_OS_WIN32 || LZO_OS_WIN64) ++# if (LZO_CC_WATCOMC && (__WATCOMC__ < 1000)) ++# elif (LZO_OS_WIN32 && LZO_CC_GNUC) && defined(__PW32__) ++# elif ((LZO_OS_CYGWIN || defined(__MINGW32__)) && (LZO_CC_GNUC && (LZO_CC_GNUC < 0x025f00ul))) ++# else ++# define LZO_HAVE_WINDOWS_H 1 ++# endif ++#endif ++#endif ++#if (LZO_ARCH_ALPHA) ++# define LZO_OPT_AVOID_UINT_INDEX 1 ++# define LZO_OPT_AVOID_SHORT 1 ++# define LZO_OPT_AVOID_USHORT 1 ++#elif (LZO_ARCH_AMD64) ++# define LZO_OPT_AVOID_INT_INDEX 1 ++# define LZO_OPT_AVOID_UINT_INDEX 1 ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++# define LZO_OPT_UNALIGNED64 1 ++#elif (LZO_ARCH_ARM && LZO_ARCH_ARM_THUMB) ++#elif (LZO_ARCH_ARM) ++# define LZO_OPT_AVOID_SHORT 1 ++# define LZO_OPT_AVOID_USHORT 1 ++#elif (LZO_ARCH_CRIS) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++#elif (LZO_ARCH_I386) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++#elif (LZO_ARCH_IA64) ++# define LZO_OPT_AVOID_INT_INDEX 1 ++# define LZO_OPT_AVOID_UINT_INDEX 1 ++# define LZO_OPT_PREFER_POSTINC 1 ++#elif (LZO_ARCH_M68K) ++# define LZO_OPT_PREFER_POSTINC 1 ++# define LZO_OPT_PREFER_PREDEC 1 ++# if defined(__mc68020__) && !defined(__mcoldfire__) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++# endif ++#elif (LZO_ARCH_MIPS) ++# define LZO_OPT_AVOID_UINT_INDEX 1 ++#elif (LZO_ARCH_POWERPC) ++# define LZO_OPT_PREFER_PREINC 1 ++# define LZO_OPT_PREFER_PREDEC 1 ++# if (LZO_ABI_BIG_ENDIAN) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++# endif ++#elif (LZO_ARCH_S390) ++# define LZO_OPT_UNALIGNED16 1 ++# define LZO_OPT_UNALIGNED32 1 ++# if (LZO_SIZEOF_SIZE_T == 8) ++# define LZO_OPT_UNALIGNED64 1 ++# endif ++#elif (LZO_ARCH_SH) ++# define LZO_OPT_PREFER_POSTINC 1 ++# define LZO_OPT_PREFER_PREDEC 1 ++#endif ++#ifndef LZO_CFG_NO_INLINE_ASM ++#if (LZO_CC_LLVM) ++# define LZO_CFG_NO_INLINE_ASM 1 ++#endif ++#endif ++#ifndef LZO_CFG_NO_UNALIGNED ++#if (LZO_ABI_NEUTRAL_ENDIAN) || (LZO_ARCH_GENERIC) ++# define LZO_CFG_NO_UNALIGNED 1 ++#endif ++#endif ++#if (LZO_CFG_NO_UNALIGNED) ++# undef LZO_OPT_UNALIGNED16 ++# undef LZO_OPT_UNALIGNED32 ++# undef LZO_OPT_UNALIGNED64 ++#endif ++#if (LZO_CFG_NO_INLINE_ASM) ++#elif (LZO_ARCH_I386 && (LZO_OS_DOS32 || LZO_OS_WIN32) && (LZO_CC_DMC || LZO_CC_INTELC || LZO_CC_MSC || LZO_CC_PELLESC)) ++# define LZO_ASM_SYNTAX_MSC 1 ++#elif (LZO_OS_WIN64 && (LZO_CC_DMC || LZO_CC_INTELC || LZO_CC_MSC || LZO_CC_PELLESC)) ++#elif (LZO_ARCH_I386 && LZO_CC_GNUC && (LZO_CC_GNUC == 0x011f00ul)) ++#elif (LZO_ARCH_I386 && (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_INTELC || LZO_CC_PATHSCALE)) ++# define LZO_ASM_SYNTAX_GNUC 1 ++#elif (LZO_ARCH_AMD64 && (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_INTELC || LZO_CC_PATHSCALE)) ++# define LZO_ASM_SYNTAX_GNUC 1 ++#endif ++#if (LZO_ASM_SYNTAX_GNUC) ++#if (LZO_ARCH_I386 && LZO_CC_GNUC && (LZO_CC_GNUC < 0x020000ul)) ++# define __LZO_ASM_CLOBBER "ax" ++#elif (LZO_CC_INTELC) ++# define __LZO_ASM_CLOBBER "memory" ++#else ++# define __LZO_ASM_CLOBBER "cc", "memory" ++#endif ++#endif ++#if defined(__LZO_INFOSTR_MM) ++#elif (LZO_MM_FLAT) && (defined(__LZO_INFOSTR_PM) || defined(LZO_INFO_ABI_PM)) ++# define __LZO_INFOSTR_MM "" ++#elif defined(LZO_INFO_MM) ++# define __LZO_INFOSTR_MM "." LZO_INFO_MM ++#else ++# define __LZO_INFOSTR_MM "" ++#endif ++#if defined(__LZO_INFOSTR_PM) ++#elif defined(LZO_INFO_ABI_PM) ++# define __LZO_INFOSTR_PM "." LZO_INFO_ABI_PM ++#else ++# define __LZO_INFOSTR_PM "" ++#endif ++#if defined(__LZO_INFOSTR_ENDIAN) ++#elif defined(LZO_INFO_ABI_ENDIAN) ++# define __LZO_INFOSTR_ENDIAN "." LZO_INFO_ABI_ENDIAN ++#else ++# define __LZO_INFOSTR_ENDIAN "" ++#endif ++#if defined(__LZO_INFOSTR_OSNAME) ++#elif defined(LZO_INFO_OS_CONSOLE) ++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS "." LZO_INFO_OS_CONSOLE ++#elif defined(LZO_INFO_OS_POSIX) ++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS "." LZO_INFO_OS_POSIX ++#else ++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS ++#endif ++#if defined(__LZO_INFOSTR_LIBC) ++#elif defined(LZO_INFO_LIBC) ++# define __LZO_INFOSTR_LIBC "." LZO_INFO_LIBC ++#else ++# define __LZO_INFOSTR_LIBC "" ++#endif ++#if defined(__LZO_INFOSTR_CCVER) ++#elif defined(LZO_INFO_CCVER) ++# define __LZO_INFOSTR_CCVER " " LZO_INFO_CCVER ++#else ++# define __LZO_INFOSTR_CCVER "" ++#endif ++#define LZO_INFO_STRING \ ++ LZO_INFO_ARCH __LZO_INFOSTR_MM __LZO_INFOSTR_PM __LZO_INFOSTR_ENDIAN \ ++ " " __LZO_INFOSTR_OSNAME __LZO_INFOSTR_LIBC " " LZO_INFO_CC __LZO_INFOSTR_CCVER ++ ++#endif ++ ++#endif ++ ++#undef LZO_HAVE_CONFIG_H ++#include "minilzo.h" ++ ++#if !defined(MINILZO_VERSION) || (MINILZO_VERSION != 0x2050) ++# error "version mismatch in miniLZO source files" ++#endif ++ ++#ifdef MINILZO_HAVE_CONFIG_H ++# define LZO_HAVE_CONFIG_H 1 ++#endif ++ ++#ifndef __LZO_CONF_H ++#define __LZO_CONF_H 1 ++ ++#if !defined(__LZO_IN_MINILZO) ++#if (LZO_CFG_FREESTANDING) ++# define LZO_LIBC_FREESTANDING 1 ++# define LZO_OS_FREESTANDING 1 ++# define ACC_LIBC_FREESTANDING 1 ++# define ACC_OS_FREESTANDING 1 ++#endif ++#if (LZO_CFG_NO_UNALIGNED) ++# define ACC_CFG_NO_UNALIGNED 1 ++#endif ++#if (LZO_ARCH_GENERIC) ++# define ACC_ARCH_GENERIC 1 ++#endif ++#if (LZO_ABI_NEUTRAL_ENDIAN) ++# define ACC_ABI_NEUTRAL_ENDIAN 1 ++#endif ++#if (LZO_HAVE_CONFIG_H) ++# define ACC_CONFIG_NO_HEADER 1 ++#endif ++#if defined(LZO_CFG_EXTRA_CONFIG_HEADER) ++# include LZO_CFG_EXTRA_CONFIG_HEADER ++#endif ++#if defined(__LZOCONF_H) || defined(__LZOCONF_H_INCLUDED) ++# error "include this file first" ++#endif ++#include "lzo/lzoconf.h" ++#endif ++ ++#if (LZO_VERSION < 0x02000) || !defined(__LZOCONF_H_INCLUDED) ++# error "version mismatch" ++#endif ++ ++#if (LZO_CC_BORLANDC && LZO_ARCH_I086) ++# pragma option -h ++#endif ++ ++#if (LZO_CC_MSC && (_MSC_VER >= 1000)) ++# pragma warning(disable: 4127 4701) ++#endif ++#if (LZO_CC_MSC && (_MSC_VER >= 1300)) ++# pragma warning(disable: 4820) ++# pragma warning(disable: 4514 4710 4711) ++#endif ++ ++#if (LZO_CC_SUNPROC) ++#if !defined(__cplusplus) ++# pragma error_messages(off,E_END_OF_LOOP_CODE_NOT_REACHED) ++# pragma error_messages(off,E_LOOP_NOT_ENTERED_AT_TOP) ++# pragma error_messages(off,E_STATEMENT_NOT_REACHED) ++#endif ++#endif ++ ++#if (__LZO_MMODEL_HUGE) && !(LZO_HAVE_MM_HUGE_PTR) ++# error "this should not happen - check defines for __huge" ++#endif ++ ++#if defined(__LZO_IN_MINILZO) || defined(LZO_CFG_FREESTANDING) ++#elif (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16) ++# define ACC_WANT_ACC_INCD_H 1 ++# define ACC_WANT_ACC_INCE_H 1 ++# define ACC_WANT_ACC_INCI_H 1 ++#elif 1 ++# include ++#else ++# define ACC_WANT_ACC_INCD_H 1 ++#endif ++ ++#if (LZO_ARCH_I086) ++# define ACC_MM_AHSHIFT LZO_MM_AHSHIFT ++# define ACC_PTR_FP_OFF(x) (((const unsigned __far*)&(x))[0]) ++# define ACC_PTR_FP_SEG(x) (((const unsigned __far*)&(x))[1]) ++# define ACC_PTR_MK_FP(s,o) ((void __far*)(((unsigned long)(s)<<16)+(unsigned)(o))) ++#endif ++ ++#if !defined(lzo_uintptr_t) ++# if defined(__LZO_MMODEL_HUGE) ++# define lzo_uintptr_t unsigned long ++# elif 1 && defined(LZO_OS_OS400) && (LZO_SIZEOF_VOID_P == 16) ++# define __LZO_UINTPTR_T_IS_POINTER 1 ++ typedef char* lzo_uintptr_t; ++# define lzo_uintptr_t lzo_uintptr_t ++# elif (LZO_SIZEOF_SIZE_T == LZO_SIZEOF_VOID_P) ++# define lzo_uintptr_t size_t ++# elif (LZO_SIZEOF_LONG == LZO_SIZEOF_VOID_P) ++# define lzo_uintptr_t unsigned long ++# elif (LZO_SIZEOF_INT == LZO_SIZEOF_VOID_P) ++# define lzo_uintptr_t unsigned int ++# elif (LZO_SIZEOF_LONG_LONG == LZO_SIZEOF_VOID_P) ++# define lzo_uintptr_t unsigned long long ++# else ++# define lzo_uintptr_t size_t ++# endif ++#endif ++LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uintptr_t) >= sizeof(lzo_voidp)) ++ ++#if 1 && !defined(LZO_CFG_FREESTANDING) ++#if 1 && !defined(HAVE_STRING_H) ++#define HAVE_STRING_H 1 ++#endif ++#if 1 && !defined(HAVE_MEMCMP) ++#define HAVE_MEMCMP 1 ++#endif ++#if 1 && !defined(HAVE_MEMCPY) ++#define HAVE_MEMCPY 1 ++#endif ++#if 1 && !defined(HAVE_MEMMOVE) ++#define HAVE_MEMMOVE 1 ++#endif ++#if 1 && !defined(HAVE_MEMSET) ++#define HAVE_MEMSET 1 ++#endif ++#endif ++ ++#if 1 && defined(HAVE_STRING_H) ++#include ++#endif ++ ++#if (LZO_CFG_FREESTANDING) ++# undef HAVE_MEMCMP ++# undef HAVE_MEMCPY ++# undef HAVE_MEMMOVE ++# undef HAVE_MEMSET ++#endif ++ ++#if !(HAVE_MEMCMP) ++# undef memcmp ++# define memcmp(a,b,c) lzo_memcmp(a,b,c) ++#elif !(__LZO_MMODEL_HUGE) ++# undef lzo_memcmp ++# define lzo_memcmp(a,b,c) memcmp(a,b,c) ++#endif ++#if !(HAVE_MEMCPY) ++# undef memcpy ++# define memcpy(a,b,c) lzo_memcpy(a,b,c) ++#elif !(__LZO_MMODEL_HUGE) ++# undef lzo_memcpy ++# define lzo_memcpy(a,b,c) memcpy(a,b,c) ++#endif ++#if !(HAVE_MEMMOVE) ++# undef memmove ++# define memmove(a,b,c) lzo_memmove(a,b,c) ++#elif !(__LZO_MMODEL_HUGE) ++# undef lzo_memmove ++# define lzo_memmove(a,b,c) memmove(a,b,c) ++#endif ++#if !(HAVE_MEMSET) ++# undef memset ++# define memset(a,b,c) lzo_memset(a,b,c) ++#elif !(__LZO_MMODEL_HUGE) ++# undef lzo_memset ++# define lzo_memset(a,b,c) memset(a,b,c) ++#endif ++ ++#undef NDEBUG ++#if (LZO_CFG_FREESTANDING) ++# undef LZO_DEBUG ++# define NDEBUG 1 ++# undef assert ++# define assert(e) ((void)0) ++#else ++# if !defined(LZO_DEBUG) ++# define NDEBUG 1 ++# endif ++# include ++#endif ++ ++#if 0 && defined(__BOUNDS_CHECKING_ON) ++# include ++#else ++# define BOUNDS_CHECKING_OFF_DURING(stmt) stmt ++# define BOUNDS_CHECKING_OFF_IN_EXPR(expr) (expr) ++#endif ++ ++#if !defined(__lzo_inline) ++# define __lzo_inline /*empty*/ ++#endif ++#if !defined(__lzo_forceinline) ++# define __lzo_forceinline /*empty*/ ++#endif ++#if !defined(__lzo_noinline) ++# define __lzo_noinline /*empty*/ ++#endif ++ ++#if (LZO_CFG_PGO) ++# undef __acc_likely ++# undef __acc_unlikely ++# undef __lzo_likely ++# undef __lzo_unlikely ++# define __acc_likely(e) (e) ++# define __acc_unlikely(e) (e) ++# define __lzo_likely(e) (e) ++# define __lzo_unlikely(e) (e) ++#endif ++ ++#if 1 ++# define LZO_BYTE(x) ((unsigned char) (x)) ++#else ++# define LZO_BYTE(x) ((unsigned char) ((x) & 0xff)) ++#endif ++ ++#define LZO_MAX(a,b) ((a) >= (b) ? (a) : (b)) ++#define LZO_MIN(a,b) ((a) <= (b) ? (a) : (b)) ++#define LZO_MAX3(a,b,c) ((a) >= (b) ? LZO_MAX(a,c) : LZO_MAX(b,c)) ++#define LZO_MIN3(a,b,c) ((a) <= (b) ? LZO_MIN(a,c) : LZO_MIN(b,c)) ++ ++#define lzo_sizeof(type) ((lzo_uint) (sizeof(type))) ++ ++#define LZO_HIGH(array) ((lzo_uint) (sizeof(array)/sizeof(*(array)))) ++ ++#define LZO_SIZE(bits) (1u << (bits)) ++#define LZO_MASK(bits) (LZO_SIZE(bits) - 1) ++ ++#define LZO_LSIZE(bits) (1ul << (bits)) ++#define LZO_LMASK(bits) (LZO_LSIZE(bits) - 1) ++ ++#define LZO_USIZE(bits) ((lzo_uint) 1 << (bits)) ++#define LZO_UMASK(bits) (LZO_USIZE(bits) - 1) ++ ++#if !defined(DMUL) ++#if 0 ++ ++# define DMUL(a,b) ((lzo_xint) ((lzo_uint32)(a) * (lzo_uint32)(b))) ++#else ++# define DMUL(a,b) ((lzo_xint) ((a) * (b))) ++#endif ++#endif ++ ++#if 1 && (LZO_ARCH_AMD64 || LZO_ARCH_I386 || LZO_ARCH_POWERPC) ++# if (LZO_SIZEOF_SHORT == 2) ++# define LZO_UNALIGNED_OK_2 1 ++# endif ++# if (LZO_SIZEOF_INT == 4) ++# define LZO_UNALIGNED_OK_4 1 ++# endif ++#endif ++#if 1 && (LZO_ARCH_AMD64) ++# if defined(LZO_UINT64_MAX) ++# define LZO_UNALIGNED_OK_8 1 ++# endif ++#endif ++#if (LZO_CFG_NO_UNALIGNED) ++# undef LZO_UNALIGNED_OK_2 ++# undef LZO_UNALIGNED_OK_4 ++# undef LZO_UNALIGNED_OK_8 ++#endif ++ ++#undef UA_GET16 ++#undef UA_SET16 ++#undef UA_COPY16 ++#undef UA_GET32 ++#undef UA_SET32 ++#undef UA_COPY32 ++#undef UA_GET64 ++#undef UA_SET64 ++#undef UA_COPY64 ++#if defined(LZO_UNALIGNED_OK_2) ++ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(unsigned short) == 2) ++# if 1 && defined(ACC_UA_COPY16) ++# define UA_GET16 ACC_UA_GET16 ++# define UA_SET16 ACC_UA_SET16 ++# define UA_COPY16 ACC_UA_COPY16 ++# else ++# define UA_GET16(p) (* (__lzo_ua_volatile const lzo_ushortp) (__lzo_ua_volatile const lzo_voidp) (p)) ++# define UA_SET16(p,v) ((* (__lzo_ua_volatile lzo_ushortp) (__lzo_ua_volatile lzo_voidp) (p)) = (unsigned short) (v)) ++# define UA_COPY16(d,s) UA_SET16(d, UA_GET16(s)) ++# endif ++#endif ++#if defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) ++ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint32) == 4) ++# if 1 && defined(ACC_UA_COPY32) ++# define UA_GET32 ACC_UA_GET32 ++# define UA_SET32 ACC_UA_SET32 ++# define UA_COPY32 ACC_UA_COPY32 ++# else ++# define UA_GET32(p) (* (__lzo_ua_volatile const lzo_uint32p) (__lzo_ua_volatile const lzo_voidp) (p)) ++# define UA_SET32(p,v) ((* (__lzo_ua_volatile lzo_uint32p) (__lzo_ua_volatile lzo_voidp) (p)) = (lzo_uint32) (v)) ++# define UA_COPY32(d,s) UA_SET32(d, UA_GET32(s)) ++# endif ++#endif ++#if defined(LZO_UNALIGNED_OK_8) ++ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint64) == 8) ++# if 1 && defined(ACC_UA_COPY64) ++# define UA_GET64 ACC_UA_GET64 ++# define UA_SET64 ACC_UA_SET64 ++# define UA_COPY64 ACC_UA_COPY64 ++# else ++# define UA_GET64(p) (* (__lzo_ua_volatile const lzo_uint64p) (__lzo_ua_volatile const lzo_voidp) (p)) ++# define UA_SET64(p,v) ((* (__lzo_ua_volatile lzo_uint64p) (__lzo_ua_volatile lzo_voidp) (p)) = (lzo_uint64) (v)) ++# define UA_COPY64(d,s) UA_SET64(d, UA_GET64(s)) ++# endif ++#endif ++ ++#define MEMCPY8_DS(dest,src,len) \ ++ lzo_memcpy(dest,src,len); dest += len; src += len ++ ++#define BZERO8_PTR(s,l,n) \ ++ lzo_memset((lzo_voidp)(s),0,(lzo_uint)(l)*(n)) ++ ++#define MEMCPY_DS(dest,src,len) \ ++ do *dest++ = *src++; while (--len > 0) ++ ++LZO_EXTERN(const lzo_bytep) lzo_copyright(void); ++ ++#ifndef __LZO_PTR_H ++#define __LZO_PTR_H 1 ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#if !defined(lzo_uintptr_t) ++# if (__LZO_MMODEL_HUGE) ++# define lzo_uintptr_t unsigned long ++# else ++# define lzo_uintptr_t acc_uintptr_t ++# ifdef __ACC_INTPTR_T_IS_POINTER ++# define __LZO_UINTPTR_T_IS_POINTER 1 ++# endif ++# endif ++#endif ++ ++#if (LZO_ARCH_I086) ++#define PTR(a) ((lzo_bytep) (a)) ++#define PTR_ALIGNED_4(a) ((ACC_PTR_FP_OFF(a) & 3) == 0) ++#define PTR_ALIGNED2_4(a,b) (((ACC_PTR_FP_OFF(a) | ACC_PTR_FP_OFF(b)) & 3) == 0) ++#elif (LZO_MM_PVP) ++#define PTR(a) ((lzo_bytep) (a)) ++#define PTR_ALIGNED_8(a) ((((lzo_uintptr_t)(a)) >> 61) == 0) ++#define PTR_ALIGNED2_8(a,b) ((((lzo_uintptr_t)(a)|(lzo_uintptr_t)(b)) >> 61) == 0) ++#else ++#define PTR(a) ((lzo_uintptr_t) (a)) ++#define PTR_LINEAR(a) PTR(a) ++#define PTR_ALIGNED_4(a) ((PTR_LINEAR(a) & 3) == 0) ++#define PTR_ALIGNED_8(a) ((PTR_LINEAR(a) & 7) == 0) ++#define PTR_ALIGNED2_4(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 3) == 0) ++#define PTR_ALIGNED2_8(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 7) == 0) ++#endif ++ ++#define PTR_LT(a,b) (PTR(a) < PTR(b)) ++#define PTR_GE(a,b) (PTR(a) >= PTR(b)) ++#define PTR_DIFF(a,b) (PTR(a) - PTR(b)) ++#define pd(a,b) ((lzo_uint) ((a)-(b))) ++ ++LZO_EXTERN(lzo_uintptr_t) ++__lzo_ptr_linear(const lzo_voidp ptr); ++ ++typedef union ++{ ++ char a_char; ++ unsigned char a_uchar; ++ short a_short; ++ unsigned short a_ushort; ++ int a_int; ++ unsigned int a_uint; ++ long a_long; ++ unsigned long a_ulong; ++ lzo_int a_lzo_int; ++ lzo_uint a_lzo_uint; ++ lzo_int32 a_lzo_int32; ++ lzo_uint32 a_lzo_uint32; ++#if defined(LZO_UINT64_MAX) ++ lzo_int64 a_lzo_int64; ++ lzo_uint64 a_lzo_uint64; ++#endif ++ ptrdiff_t a_ptrdiff_t; ++ lzo_uintptr_t a_lzo_uintptr_t; ++ lzo_voidp a_lzo_voidp; ++ void * a_void_p; ++ lzo_bytep a_lzo_bytep; ++ lzo_bytepp a_lzo_bytepp; ++ lzo_uintp a_lzo_uintp; ++ lzo_uint * a_lzo_uint_p; ++ lzo_uint32p a_lzo_uint32p; ++ lzo_uint32 * a_lzo_uint32_p; ++ unsigned char * a_uchar_p; ++ char * a_char_p; ++} ++lzo_full_align_t; ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif ++ ++#ifndef LZO_DETERMINISTIC ++#define LZO_DETERMINISTIC 1 ++#endif ++ ++#ifndef LZO_DICT_USE_PTR ++#define LZO_DICT_USE_PTR 1 ++#if 0 && (LZO_ARCH_I086) ++# undef LZO_DICT_USE_PTR ++# define LZO_DICT_USE_PTR 0 ++#endif ++#endif ++ ++#if (LZO_DICT_USE_PTR) ++# define lzo_dict_t const lzo_bytep ++# define lzo_dict_p lzo_dict_t __LZO_MMODEL * ++#else ++# define lzo_dict_t lzo_uint ++# define lzo_dict_p lzo_dict_t __LZO_MMODEL * ++#endif ++ ++#endif ++ ++#if !defined(MINILZO_CFG_SKIP_LZO_PTR) ++ ++LZO_PUBLIC(lzo_uintptr_t) ++__lzo_ptr_linear(const lzo_voidp ptr) ++{ ++ lzo_uintptr_t p; ++ ++#if (LZO_ARCH_I086) ++ p = (((lzo_uintptr_t)(ACC_PTR_FP_SEG(ptr))) << (16 - ACC_MM_AHSHIFT)) + (ACC_PTR_FP_OFF(ptr)); ++#elif (LZO_MM_PVP) ++ p = (lzo_uintptr_t) (ptr); ++ p = (p << 3) | (p >> 61); ++#else ++ p = (lzo_uintptr_t) PTR_LINEAR(ptr); ++#endif ++ ++ return p; ++} ++ ++LZO_PUBLIC(unsigned) ++__lzo_align_gap(const lzo_voidp ptr, lzo_uint size) ++{ ++#if defined(__LZO_UINTPTR_T_IS_POINTER) ++ size_t n = (size_t) ptr; ++ n = (((n + size - 1) / size) * size) - n; ++#else ++ lzo_uintptr_t p, n; ++ p = __lzo_ptr_linear(ptr); ++ n = (((p + size - 1) / size) * size) - p; ++#endif ++ ++ assert(size > 0); ++ assert((long)n >= 0); ++ assert(n <= size); ++ return (unsigned)n; ++} ++ ++#endif ++#if !defined(MINILZO_CFG_SKIP_LZO_UTIL) ++ ++/* If you use the LZO library in a product, I would appreciate that you ++ * keep this copyright string in the executable of your product. ++ */ ++ ++static const char __lzo_copyright[] = ++#if !defined(__LZO_IN_MINLZO) ++ LZO_VERSION_STRING; ++#else ++ "\r\n\n" ++ "LZO data compression library.\n" ++ "$Copyright: LZO Copyright (C) 1996-2011 Markus Franz Xaver Johannes Oberhumer\n" ++ "\n" ++ "http://www.oberhumer.com $\n\n" ++ "$Id: LZO version: v" LZO_VERSION_STRING ", " LZO_VERSION_DATE " $\n" ++ "$Info: " LZO_INFO_STRING " $\n"; ++#endif ++ ++LZO_PUBLIC(const lzo_bytep) ++lzo_copyright(void) ++{ ++#if (LZO_OS_DOS16 && LZO_CC_TURBOC) ++ return (lzo_voidp) __lzo_copyright; ++#else ++ return (const lzo_bytep) __lzo_copyright; ++#endif ++} ++ ++LZO_PUBLIC(unsigned) ++lzo_version(void) ++{ ++ return LZO_VERSION; ++} ++ ++LZO_PUBLIC(const char *) ++lzo_version_string(void) ++{ ++ return LZO_VERSION_STRING; ++} ++ ++LZO_PUBLIC(const char *) ++lzo_version_date(void) ++{ ++ return LZO_VERSION_DATE; ++} ++ ++LZO_PUBLIC(const lzo_charp) ++_lzo_version_string(void) ++{ ++ return LZO_VERSION_STRING; ++} ++ ++LZO_PUBLIC(const lzo_charp) ++_lzo_version_date(void) ++{ ++ return LZO_VERSION_DATE; ++} ++ ++#define LZO_BASE 65521u ++#define LZO_NMAX 5552 ++ ++#define LZO_DO1(buf,i) s1 += buf[i]; s2 += s1 ++#define LZO_DO2(buf,i) LZO_DO1(buf,i); LZO_DO1(buf,i+1); ++#define LZO_DO4(buf,i) LZO_DO2(buf,i); LZO_DO2(buf,i+2); ++#define LZO_DO8(buf,i) LZO_DO4(buf,i); LZO_DO4(buf,i+4); ++#define LZO_DO16(buf,i) LZO_DO8(buf,i); LZO_DO8(buf,i+8); ++ ++LZO_PUBLIC(lzo_uint32) ++lzo_adler32(lzo_uint32 adler, const lzo_bytep buf, lzo_uint len) ++{ ++ lzo_uint32 s1 = adler & 0xffff; ++ lzo_uint32 s2 = (adler >> 16) & 0xffff; ++ unsigned k; ++ ++ if (buf == NULL) ++ return 1; ++ ++ while (len > 0) ++ { ++ k = len < LZO_NMAX ? (unsigned) len : LZO_NMAX; ++ len -= k; ++ if (k >= 16) do ++ { ++ LZO_DO16(buf,0); ++ buf += 16; ++ k -= 16; ++ } while (k >= 16); ++ if (k != 0) do ++ { ++ s1 += *buf++; ++ s2 += s1; ++ } while (--k > 0); ++ s1 %= LZO_BASE; ++ s2 %= LZO_BASE; ++ } ++ return (s2 << 16) | s1; ++} ++ ++#undef LZO_DO1 ++#undef LZO_DO2 ++#undef LZO_DO4 ++#undef LZO_DO8 ++#undef LZO_DO16 ++ ++#endif ++#if !defined(MINILZO_CFG_SKIP_LZO_STRING) ++#undef lzo_memcmp ++#undef lzo_memcpy ++#undef lzo_memmove ++#undef lzo_memset ++#if !defined(__LZO_MMODEL_HUGE) ++# undef LZO_HAVE_MM_HUGE_PTR ++#endif ++#define lzo_hsize_t lzo_uint ++#define lzo_hvoid_p lzo_voidp ++#define lzo_hbyte_p lzo_bytep ++#define LZOLIB_PUBLIC(r,f) LZO_PUBLIC(r) f ++#define lzo_hmemcmp lzo_memcmp ++#define lzo_hmemcpy lzo_memcpy ++#define lzo_hmemmove lzo_memmove ++#define lzo_hmemset lzo_memset ++#define __LZOLIB_HMEMCPY_CH_INCLUDED 1 ++#if !defined(LZOLIB_PUBLIC) ++# define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) ++#endif ++LZOLIB_PUBLIC(int, lzo_hmemcmp) (const lzo_hvoid_p s1, const lzo_hvoid_p s2, lzo_hsize_t len) ++{ ++#if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMCMP) ++ const lzo_hbyte_p p1 = (const lzo_hbyte_p) s1; ++ const lzo_hbyte_p p2 = (const lzo_hbyte_p) s2; ++ if __lzo_likely(len > 0) do ++ { ++ int d = *p1 - *p2; ++ if (d != 0) ++ return d; ++ p1++; p2++; ++ } while __lzo_likely(--len > 0); ++ return 0; ++#else ++ return memcmp(s1, s2, len); ++#endif ++} ++LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemcpy) (lzo_hvoid_p dest, const lzo_hvoid_p src, lzo_hsize_t len) ++{ ++#if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMCPY) ++ lzo_hbyte_p p1 = (lzo_hbyte_p) dest; ++ const lzo_hbyte_p p2 = (const lzo_hbyte_p) src; ++ if (!(len > 0) || p1 == p2) ++ return dest; ++ do ++ *p1++ = *p2++; ++ while __lzo_likely(--len > 0); ++ return dest; ++#else ++ return memcpy(dest, src, len); ++#endif ++} ++LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemmove) (lzo_hvoid_p dest, const lzo_hvoid_p src, lzo_hsize_t len) ++{ ++#if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMMOVE) ++ lzo_hbyte_p p1 = (lzo_hbyte_p) dest; ++ const lzo_hbyte_p p2 = (const lzo_hbyte_p) src; ++ if (!(len > 0) || p1 == p2) ++ return dest; ++ if (p1 < p2) ++ { ++ do ++ *p1++ = *p2++; ++ while __lzo_likely(--len > 0); ++ } ++ else ++ { ++ p1 += len; ++ p2 += len; ++ do ++ *--p1 = *--p2; ++ while __lzo_likely(--len > 0); ++ } ++ return dest; ++#else ++ return memmove(dest, src, len); ++#endif ++} ++LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemset) (lzo_hvoid_p s, int c, lzo_hsize_t len) ++{ ++#if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMSET) ++ lzo_hbyte_p p = (lzo_hbyte_p) s; ++ if __lzo_likely(len > 0) do ++ *p++ = (unsigned char) c; ++ while __lzo_likely(--len > 0); ++ return s; ++#else ++ return memset(s, c, len); ++#endif ++} ++#undef LZOLIB_PUBLIC ++#endif ++#if !defined(MINILZO_CFG_SKIP_LZO_INIT) ++ ++#if !defined(__LZO_IN_MINILZO) ++ ++#define ACC_WANT_ACC_CHK_CH 1 ++#undef ACCCHK_ASSERT ++ ++ ACCCHK_ASSERT_IS_SIGNED_T(lzo_int) ++ ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_uint) ++ ++ ACCCHK_ASSERT_IS_SIGNED_T(lzo_int32) ++ ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_uint32) ++ ACCCHK_ASSERT((LZO_UINT32_C(1) << (int)(8*sizeof(LZO_UINT32_C(1))-1)) > 0) ++ ACCCHK_ASSERT(sizeof(lzo_uint32) >= 4) ++#if defined(LZO_UINT64_MAX) ++ ACCCHK_ASSERT(sizeof(lzo_uint64) == 8) ++ ACCCHK_ASSERT_IS_SIGNED_T(lzo_int64) ++ ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_uint64) ++#endif ++ ++#if !defined(__LZO_UINTPTR_T_IS_POINTER) ++ ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_uintptr_t) ++#endif ++ ACCCHK_ASSERT(sizeof(lzo_uintptr_t) >= sizeof(lzo_voidp)) ++ ++ ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_xint) ++ ACCCHK_ASSERT(sizeof(lzo_xint) >= sizeof(lzo_uint32)) ++ ACCCHK_ASSERT(sizeof(lzo_xint) >= sizeof(lzo_uint)) ++ ACCCHK_ASSERT(sizeof(lzo_xint) == sizeof(lzo_uint32) || sizeof(lzo_xint) == sizeof(lzo_uint)) ++ ++#endif ++#undef ACCCHK_ASSERT ++ ++#if 0 ++#define WANT_lzo_bitops_clz32 1 ++#define WANT_lzo_bitops_clz64 1 ++#endif ++#define WANT_lzo_bitops_ctz32 1 ++#define WANT_lzo_bitops_ctz64 1 ++ ++#if (defined(_WIN32) || defined(_WIN64)) && ((LZO_CC_INTELC && (__INTEL_COMPILER >= 1000)) || (LZO_CC_MSC && (_MSC_VER >= 1400))) ++#include ++#if !defined(lzo_bitops_clz32) && defined(WANT_lzo_bitops_clz32) && 0 ++#pragma intrinsic(_BitScanReverse) ++static __lzo_inline unsigned lzo_bitops_clz32(lzo_uint32 v) ++{ ++ unsigned long r; ++ (void) _BitScanReverse(&r, v); ++ return (unsigned) r; ++} ++#define lzo_bitops_clz32 lzo_bitops_clz32 ++#endif ++#if !defined(lzo_bitops_clz64) && defined(WANT_lzo_bitops_clz64) && defined(LZO_UINT64_MAX) && 0 ++#pragma intrinsic(_BitScanReverse64) ++static __lzo_inline unsigned lzo_bitops_clz64(lzo_uint64 v) ++{ ++ unsigned long r; ++ (void) _BitScanReverse64(&r, v); ++ return (unsigned) r; ++} ++#define lzo_bitops_clz64 lzo_bitops_clz64 ++#endif ++#if !defined(lzo_bitops_ctz32) && defined(WANT_lzo_bitops_ctz32) ++#pragma intrinsic(_BitScanForward) ++static __lzo_inline unsigned lzo_bitops_ctz32(lzo_uint32 v) ++{ ++ unsigned long r; ++ (void) _BitScanForward(&r, v); ++ return (unsigned) r; ++} ++#define lzo_bitops_ctz32 lzo_bitops_ctz32 ++#endif ++#if !defined(lzo_bitops_ctz64) && defined(WANT_lzo_bitops_ctz64) && defined(LZO_UINT64_MAX) ++#pragma intrinsic(_BitScanForward64) ++static __lzo_inline unsigned lzo_bitops_ctz64(lzo_uint64 v) ++{ ++ unsigned long r; ++ (void) _BitScanForward64(&r, v); ++ return (unsigned) r; ++} ++#define lzo_bitops_ctz64 lzo_bitops_ctz64 ++#endif ++ ++#elif (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x030400ul) || (LZO_CC_INTELC && (__INTEL_COMPILER >= 1000)) || LZO_CC_LLVM) ++#if !defined(lzo_bitops_clz32) && defined(WANT_lzo_bitops_clz32) ++#define lzo_bitops_clz32(v) ((unsigned) __builtin_clz(v)) ++#endif ++#if !defined(lzo_bitops_clz64) && defined(WANT_lzo_bitops_clz64) && defined(LZO_UINT64_MAX) ++#define lzo_bitops_clz64(v) ((unsigned) __builtin_clzll(v)) ++#endif ++#if !defined(lzo_bitops_ctz32) && defined(WANT_lzo_bitops_ctz32) ++#define lzo_bitops_ctz32(v) ((unsigned) __builtin_ctz(v)) ++#endif ++#if !defined(lzo_bitops_ctz64) && defined(WANT_lzo_bitops_ctz64) && defined(LZO_UINT64_MAX) ++#define lzo_bitops_ctz64(v) ((unsigned) __builtin_ctzll(v)) ++#endif ++#if !defined(lzo_bitops_popcount32) && defined(WANT_lzo_bitops_popcount32) ++#define lzo_bitops_popcount32(v) ((unsigned) __builtin_popcount(v)) ++#endif ++#if !defined(lzo_bitops_popcount32) && defined(WANT_lzo_bitops_popcount64) && defined(LZO_UINT64_MAX) ++#define lzo_bitops_popcount64(v) ((unsigned) __builtin_popcountll(v)) ++#endif ++#endif ++ ++#if 0 ++#define u2p(ptr,off) ((lzo_voidp) (((lzo_bytep)(lzo_voidp)(ptr)) + (off))) ++#else ++static __lzo_noinline lzo_voidp u2p(lzo_voidp ptr, lzo_uint off) ++{ ++ return (lzo_voidp) ((lzo_bytep) ptr + off); ++} ++#endif ++ ++LZO_PUBLIC(int) ++_lzo_config_check(void) ++{ ++ lzo_bool r = 1; ++ union { ++ lzo_xint a[2]; unsigned char b[2*LZO_MAX(8,sizeof(lzo_xint))]; ++#if defined(LZO_UNALIGNED_OK_8) ++ lzo_uint64 c[2]; ++#endif ++ unsigned short x[2]; lzo_uint32 y[2]; lzo_uint z[2]; ++ } u; ++ lzo_voidp p; ++ ++ u.a[0] = u.a[1] = 0; ++ p = u2p(&u, 0); ++ r &= ((* (lzo_bytep) p) == 0); ++#if !defined(LZO_CFG_NO_CONFIG_CHECK) ++#if defined(LZO_ABI_BIG_ENDIAN) ++ u.a[0] = u.a[1] = 0; u.b[sizeof(lzo_uint) - 1] = 128; ++ p = u2p(&u, 0); ++ r &= ((* (lzo_uintp) p) == 128); ++#endif ++#if defined(LZO_ABI_LITTLE_ENDIAN) ++ u.a[0] = u.a[1] = 0; u.b[0] = 128; ++ p = u2p(&u, 0); ++ r &= ((* (lzo_uintp) p) == 128); ++#endif ++#if defined(LZO_UNALIGNED_OK_2) ++ u.a[0] = u.a[1] = 0; ++ u.b[0] = 1; u.b[sizeof(unsigned short) + 1] = 2; ++ p = u2p(&u, 1); ++ r &= ((* (lzo_ushortp) p) == 0); ++#endif ++#if defined(LZO_UNALIGNED_OK_4) ++ u.a[0] = u.a[1] = 0; ++ u.b[0] = 3; u.b[sizeof(lzo_uint32) + 1] = 4; ++ p = u2p(&u, 1); ++ r &= ((* (lzo_uint32p) p) == 0); ++#endif ++#if defined(LZO_UNALIGNED_OK_8) ++ u.c[0] = u.c[1] = 0; ++ u.b[0] = 5; u.b[sizeof(lzo_uint64) + 1] = 6; ++ p = u2p(&u, 1); ++ r &= ((* (lzo_uint64p) p) == 0); ++#endif ++#if defined(lzo_bitops_clz32) ++ { unsigned i; lzo_uint32 v = 1; ++ for (i = 0; i < 31; i++, v <<= 1) ++ r &= lzo_bitops_clz32(v) == 31 - i; ++ } ++#endif ++#if defined(lzo_bitops_clz64) ++ { unsigned i; lzo_uint64 v = 1; ++ for (i = 0; i < 63; i++, v <<= 1) ++ r &= lzo_bitops_clz64(v) == 63 - i; ++ } ++#endif ++#if defined(lzo_bitops_ctz32) ++ { unsigned i; lzo_uint32 v = 1; ++ for (i = 0; i < 31; i++, v <<= 1) ++ r &= lzo_bitops_ctz32(v) == i; ++ } ++#endif ++#if defined(lzo_bitops_ctz64) ++ { unsigned i; lzo_uint64 v = 1; ++ for (i = 0; i < 63; i++, v <<= 1) ++ r &= lzo_bitops_ctz64(v) == i; ++ } ++#endif ++#endif ++ ++ return r == 1 ? LZO_E_OK : LZO_E_ERROR; ++} ++ ++LZO_PUBLIC(int) ++__lzo_init_v2(unsigned v, int s1, int s2, int s3, int s4, int s5, ++ int s6, int s7, int s8, int s9) ++{ ++ int r; ++ ++#if defined(__LZO_IN_MINILZO) ++#elif (LZO_CC_MSC && ((_MSC_VER) < 700)) ++#else ++#define ACC_WANT_ACC_CHK_CH 1 ++#undef ACCCHK_ASSERT ++#define ACCCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr) ++#endif ++#undef ACCCHK_ASSERT ++ ++ if (v == 0) ++ return LZO_E_ERROR; ++ ++ r = (s1 == -1 || s1 == (int) sizeof(short)) && ++ (s2 == -1 || s2 == (int) sizeof(int)) && ++ (s3 == -1 || s3 == (int) sizeof(long)) && ++ (s4 == -1 || s4 == (int) sizeof(lzo_uint32)) && ++ (s5 == -1 || s5 == (int) sizeof(lzo_uint)) && ++ (s6 == -1 || s6 == (int) lzo_sizeof_dict_t) && ++ (s7 == -1 || s7 == (int) sizeof(char *)) && ++ (s8 == -1 || s8 == (int) sizeof(lzo_voidp)) && ++ (s9 == -1 || s9 == (int) sizeof(lzo_callback_t)); ++ if (!r) ++ return LZO_E_ERROR; ++ ++ r = _lzo_config_check(); ++ if (r != LZO_E_OK) ++ return r; ++ ++ return r; ++} ++ ++#if !defined(__LZO_IN_MINILZO) ++ ++#if (LZO_OS_WIN16 && LZO_CC_WATCOMC) && defined(__SW_BD) ++ ++#if 0 ++BOOL FAR PASCAL LibMain ( HANDLE hInstance, WORD wDataSegment, ++ WORD wHeapSize, LPSTR lpszCmdLine ) ++#else ++int __far __pascal LibMain ( int a, short b, short c, long d ) ++#endif ++{ ++ LZO_UNUSED(a); LZO_UNUSED(b); LZO_UNUSED(c); LZO_UNUSED(d); ++ return 1; ++} ++ ++#endif ++ ++#endif ++ ++#endif ++ ++#define LZO1X 1 ++#define LZO_EOF_CODE 1 ++#define M2_MAX_OFFSET 0x0800 ++ ++#if !defined(MINILZO_CFG_SKIP_LZO1X_1_COMPRESS) ++ ++#if 1 && defined(UA_GET32) ++#undef LZO_DICT_USE_PTR ++#define LZO_DICT_USE_PTR 0 ++#undef lzo_dict_t ++#define lzo_dict_t unsigned short ++#endif ++ ++#define LZO_NEED_DICT_H 1 ++#ifndef D_BITS ++#define D_BITS 14 ++#endif ++#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX3(p,5,5,6)) >> 5) ++#define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f) ++#if 1 ++#define DINDEX(dv,p) DM(((DMUL(0x1824429d,dv)) >> (32-D_BITS))) ++#else ++#define DINDEX(dv,p) DM((dv) + ((dv) >> (32-D_BITS))) ++#endif ++ ++#ifndef __LZO_CONFIG1X_H ++#define __LZO_CONFIG1X_H 1 ++ ++#if !defined(LZO1X) && !defined(LZO1Y) && !defined(LZO1Z) ++# define LZO1X 1 ++#endif ++ ++#if !defined(__LZO_IN_MINILZO) ++#include "lzo/lzo1x.h" ++#endif ++ ++#ifndef LZO_EOF_CODE ++#define LZO_EOF_CODE 1 ++#endif ++#undef LZO_DETERMINISTIC ++ ++#define M1_MAX_OFFSET 0x0400 ++#ifndef M2_MAX_OFFSET ++#define M2_MAX_OFFSET 0x0800 ++#endif ++#define M3_MAX_OFFSET 0x4000 ++#define M4_MAX_OFFSET 0xbfff ++ ++#define MX_MAX_OFFSET (M1_MAX_OFFSET + M2_MAX_OFFSET) ++ ++#define M1_MIN_LEN 2 ++#define M1_MAX_LEN 2 ++#define M2_MIN_LEN 3 ++#ifndef M2_MAX_LEN ++#define M2_MAX_LEN 8 ++#endif ++#define M3_MIN_LEN 3 ++#define M3_MAX_LEN 33 ++#define M4_MIN_LEN 3 ++#define M4_MAX_LEN 9 ++ ++#define M1_MARKER 0 ++#define M2_MARKER 64 ++#define M3_MARKER 32 ++#define M4_MARKER 16 ++ ++#ifndef MIN_LOOKAHEAD ++#define MIN_LOOKAHEAD (M2_MAX_LEN + 1) ++#endif ++ ++#if defined(LZO_NEED_DICT_H) ++ ++#ifndef LZO_HASH ++#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_B ++#endif ++#define DL_MIN_LEN M2_MIN_LEN ++ ++#ifndef __LZO_DICT_H ++#define __LZO_DICT_H 1 ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#if !defined(D_BITS) && defined(DBITS) ++# define D_BITS DBITS ++#endif ++#if !defined(D_BITS) ++# error "D_BITS is not defined" ++#endif ++#if (D_BITS < 16) ++# define D_SIZE LZO_SIZE(D_BITS) ++# define D_MASK LZO_MASK(D_BITS) ++#else ++# define D_SIZE LZO_USIZE(D_BITS) ++# define D_MASK LZO_UMASK(D_BITS) ++#endif ++#define D_HIGH ((D_MASK >> 1) + 1) ++ ++#if !defined(DD_BITS) ++# define DD_BITS 0 ++#endif ++#define DD_SIZE LZO_SIZE(DD_BITS) ++#define DD_MASK LZO_MASK(DD_BITS) ++ ++#if !defined(DL_BITS) ++# define DL_BITS (D_BITS - DD_BITS) ++#endif ++#if (DL_BITS < 16) ++# define DL_SIZE LZO_SIZE(DL_BITS) ++# define DL_MASK LZO_MASK(DL_BITS) ++#else ++# define DL_SIZE LZO_USIZE(DL_BITS) ++# define DL_MASK LZO_UMASK(DL_BITS) ++#endif ++ ++#if (D_BITS != DL_BITS + DD_BITS) ++# error "D_BITS does not match" ++#endif ++#if (D_BITS < 6 || D_BITS > 18) ++# error "invalid D_BITS" ++#endif ++#if (DL_BITS < 6 || DL_BITS > 20) ++# error "invalid DL_BITS" ++#endif ++#if (DD_BITS < 0 || DD_BITS > 6) ++# error "invalid DD_BITS" ++#endif ++ ++#if !defined(DL_MIN_LEN) ++# define DL_MIN_LEN 3 ++#endif ++#if !defined(DL_SHIFT) ++# define DL_SHIFT ((DL_BITS + (DL_MIN_LEN - 1)) / DL_MIN_LEN) ++#endif ++ ++#define LZO_HASH_GZIP 1 ++#define LZO_HASH_GZIP_INCREMENTAL 2 ++#define LZO_HASH_LZO_INCREMENTAL_A 3 ++#define LZO_HASH_LZO_INCREMENTAL_B 4 ++ ++#if !defined(LZO_HASH) ++# error "choose a hashing strategy" ++#endif ++ ++#undef DM ++#undef DX ++ ++#if (DL_MIN_LEN == 3) ++# define _DV2_A(p,shift1,shift2) \ ++ (((( (lzo_xint)((p)[0]) << shift1) ^ (p)[1]) << shift2) ^ (p)[2]) ++# define _DV2_B(p,shift1,shift2) \ ++ (((( (lzo_xint)((p)[2]) << shift1) ^ (p)[1]) << shift2) ^ (p)[0]) ++# define _DV3_B(p,shift1,shift2,shift3) \ ++ ((_DV2_B((p)+1,shift1,shift2) << (shift3)) ^ (p)[0]) ++#elif (DL_MIN_LEN == 2) ++# define _DV2_A(p,shift1,shift2) \ ++ (( (lzo_xint)(p[0]) << shift1) ^ p[1]) ++# define _DV2_B(p,shift1,shift2) \ ++ (( (lzo_xint)(p[1]) << shift1) ^ p[2]) ++#else ++# error "invalid DL_MIN_LEN" ++#endif ++#define _DV_A(p,shift) _DV2_A(p,shift,shift) ++#define _DV_B(p,shift) _DV2_B(p,shift,shift) ++#define DA2(p,s1,s2) \ ++ (((((lzo_xint)((p)[2]) << (s2)) + (p)[1]) << (s1)) + (p)[0]) ++#define DS2(p,s1,s2) \ ++ (((((lzo_xint)((p)[2]) << (s2)) - (p)[1]) << (s1)) - (p)[0]) ++#define DX2(p,s1,s2) \ ++ (((((lzo_xint)((p)[2]) << (s2)) ^ (p)[1]) << (s1)) ^ (p)[0]) ++#define DA3(p,s1,s2,s3) ((DA2((p)+1,s2,s3) << (s1)) + (p)[0]) ++#define DS3(p,s1,s2,s3) ((DS2((p)+1,s2,s3) << (s1)) - (p)[0]) ++#define DX3(p,s1,s2,s3) ((DX2((p)+1,s2,s3) << (s1)) ^ (p)[0]) ++#define DMS(v,s) ((lzo_uint) (((v) & (D_MASK >> (s))) << (s))) ++#define DM(v) DMS(v,0) ++ ++#if (LZO_HASH == LZO_HASH_GZIP) ++# define _DINDEX(dv,p) (_DV_A((p),DL_SHIFT)) ++ ++#elif (LZO_HASH == LZO_HASH_GZIP_INCREMENTAL) ++# define __LZO_HASH_INCREMENTAL 1 ++# define DVAL_FIRST(dv,p) dv = _DV_A((p),DL_SHIFT) ++# define DVAL_NEXT(dv,p) dv = (((dv) << DL_SHIFT) ^ p[2]) ++# define _DINDEX(dv,p) (dv) ++# define DVAL_LOOKAHEAD DL_MIN_LEN ++ ++#elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_A) ++# define __LZO_HASH_INCREMENTAL 1 ++# define DVAL_FIRST(dv,p) dv = _DV_A((p),5) ++# define DVAL_NEXT(dv,p) \ ++ dv ^= (lzo_xint)(p[-1]) << (2*5); dv = (((dv) << 5) ^ p[2]) ++# define _DINDEX(dv,p) ((DMUL(0x9f5f,dv)) >> 5) ++# define DVAL_LOOKAHEAD DL_MIN_LEN ++ ++#elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_B) ++# define __LZO_HASH_INCREMENTAL 1 ++# define DVAL_FIRST(dv,p) dv = _DV_B((p),5) ++# define DVAL_NEXT(dv,p) \ ++ dv ^= p[-1]; dv = (((dv) >> 5) ^ ((lzo_xint)(p[2]) << (2*5))) ++# define _DINDEX(dv,p) ((DMUL(0x9f5f,dv)) >> 5) ++# define DVAL_LOOKAHEAD DL_MIN_LEN ++ ++#else ++# error "choose a hashing strategy" ++#endif ++ ++#ifndef DINDEX ++#define DINDEX(dv,p) ((lzo_uint)((_DINDEX(dv,p)) & DL_MASK) << DD_BITS) ++#endif ++#if !defined(DINDEX1) && defined(D_INDEX1) ++#define DINDEX1 D_INDEX1 ++#endif ++#if !defined(DINDEX2) && defined(D_INDEX2) ++#define DINDEX2 D_INDEX2 ++#endif ++ ++#if !defined(__LZO_HASH_INCREMENTAL) ++# define DVAL_FIRST(dv,p) ((void) 0) ++# define DVAL_NEXT(dv,p) ((void) 0) ++# define DVAL_LOOKAHEAD 0 ++#endif ++ ++#if !defined(DVAL_ASSERT) ++#if defined(__LZO_HASH_INCREMENTAL) && !defined(NDEBUG) ++#if (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x020700ul) || LZO_CC_LLVM) ++static void __attribute__((__unused__)) ++#else ++static void ++#endif ++DVAL_ASSERT(lzo_xint dv, const lzo_bytep p) ++{ ++ lzo_xint df; ++ DVAL_FIRST(df,(p)); ++ assert(DINDEX(dv,p) == DINDEX(df,p)); ++} ++#else ++# define DVAL_ASSERT(dv,p) ((void) 0) ++#endif ++#endif ++ ++#if (LZO_DICT_USE_PTR) ++# define DENTRY(p,in) (p) ++# define GINDEX(m_pos,m_off,dict,dindex,in) m_pos = dict[dindex] ++#else ++# define DENTRY(p,in) ((lzo_dict_t) pd(p, in)) ++# define GINDEX(m_pos,m_off,dict,dindex,in) m_off = dict[dindex] ++#endif ++ ++#if (DD_BITS == 0) ++ ++# define UPDATE_D(dict,drun,dv,p,in) dict[ DINDEX(dv,p) ] = DENTRY(p,in) ++# define UPDATE_I(dict,drun,index,p,in) dict[index] = DENTRY(p,in) ++# define UPDATE_P(ptr,drun,p,in) (ptr)[0] = DENTRY(p,in) ++ ++#else ++ ++# define UPDATE_D(dict,drun,dv,p,in) \ ++ dict[ DINDEX(dv,p) + drun++ ] = DENTRY(p,in); drun &= DD_MASK ++# define UPDATE_I(dict,drun,index,p,in) \ ++ dict[ (index) + drun++ ] = DENTRY(p,in); drun &= DD_MASK ++# define UPDATE_P(ptr,drun,p,in) \ ++ (ptr) [ drun++ ] = DENTRY(p,in); drun &= DD_MASK ++ ++#endif ++ ++#if (LZO_DICT_USE_PTR) ++ ++#define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \ ++ (m_pos == NULL || (m_off = pd(ip, m_pos)) > max_offset) ++ ++#define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \ ++ (BOUNDS_CHECKING_OFF_IN_EXPR(( \ ++ m_pos = ip - (lzo_uint) PTR_DIFF(ip,m_pos), \ ++ PTR_LT(m_pos,in) || \ ++ (m_off = (lzo_uint) PTR_DIFF(ip,m_pos)) == 0 || \ ++ m_off > max_offset ))) ++ ++#else ++ ++#define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \ ++ (m_off == 0 || \ ++ ((m_off = pd(ip, in) - m_off) > max_offset) || \ ++ (m_pos = (ip) - (m_off), 0) ) ++ ++#define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \ ++ (pd(ip, in) <= m_off || \ ++ ((m_off = pd(ip, in) - m_off) > max_offset) || \ ++ (m_pos = (ip) - (m_off), 0) ) ++ ++#endif ++ ++#if (LZO_DETERMINISTIC) ++# define LZO_CHECK_MPOS LZO_CHECK_MPOS_DET ++#else ++# define LZO_CHECK_MPOS LZO_CHECK_MPOS_NON_DET ++#endif ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif ++ ++#endif ++ ++#endif ++ ++#define LZO_DETERMINISTIC !(LZO_DICT_USE_PTR) ++ ++#ifndef DO_COMPRESS ++#define DO_COMPRESS lzo1x_1_compress ++#endif ++ ++#if 1 && defined(DO_COMPRESS) && !defined(do_compress) ++# define do_compress LZO_CPP_ECONCAT2(DO_COMPRESS,_core) ++#endif ++ ++#if defined(UA_GET64) ++# define WANT_lzo_bitops_ctz64 1 ++#elif defined(UA_GET32) ++# define WANT_lzo_bitops_ctz32 1 ++#endif ++ ++#if (defined(_WIN32) || defined(_WIN64)) && ((LZO_CC_INTELC && (__INTEL_COMPILER >= 1000)) || (LZO_CC_MSC && (_MSC_VER >= 1400))) ++#include ++#if !defined(lzo_bitops_clz32) && defined(WANT_lzo_bitops_clz32) && 0 ++#pragma intrinsic(_BitScanReverse) ++static __lzo_inline unsigned lzo_bitops_clz32(lzo_uint32 v) ++{ ++ unsigned long r; ++ (void) _BitScanReverse(&r, v); ++ return (unsigned) r; ++} ++#define lzo_bitops_clz32 lzo_bitops_clz32 ++#endif ++#if !defined(lzo_bitops_clz64) && defined(WANT_lzo_bitops_clz64) && defined(LZO_UINT64_MAX) && 0 ++#pragma intrinsic(_BitScanReverse64) ++static __lzo_inline unsigned lzo_bitops_clz64(lzo_uint64 v) ++{ ++ unsigned long r; ++ (void) _BitScanReverse64(&r, v); ++ return (unsigned) r; ++} ++#define lzo_bitops_clz64 lzo_bitops_clz64 ++#endif ++#if !defined(lzo_bitops_ctz32) && defined(WANT_lzo_bitops_ctz32) ++#pragma intrinsic(_BitScanForward) ++static __lzo_inline unsigned lzo_bitops_ctz32(lzo_uint32 v) ++{ ++ unsigned long r; ++ (void) _BitScanForward(&r, v); ++ return (unsigned) r; ++} ++#define lzo_bitops_ctz32 lzo_bitops_ctz32 ++#endif ++#if !defined(lzo_bitops_ctz64) && defined(WANT_lzo_bitops_ctz64) && defined(LZO_UINT64_MAX) ++#pragma intrinsic(_BitScanForward64) ++static __lzo_inline unsigned lzo_bitops_ctz64(lzo_uint64 v) ++{ ++ unsigned long r; ++ (void) _BitScanForward64(&r, v); ++ return (unsigned) r; ++} ++#define lzo_bitops_ctz64 lzo_bitops_ctz64 ++#endif ++ ++#elif (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x030400ul) || (LZO_CC_INTELC && (__INTEL_COMPILER >= 1000)) || LZO_CC_LLVM) ++#if !defined(lzo_bitops_clz32) && defined(WANT_lzo_bitops_clz32) ++#define lzo_bitops_clz32(v) ((unsigned) __builtin_clz(v)) ++#endif ++#if !defined(lzo_bitops_clz64) && defined(WANT_lzo_bitops_clz64) && defined(LZO_UINT64_MAX) ++#define lzo_bitops_clz64(v) ((unsigned) __builtin_clzll(v)) ++#endif ++#if !defined(lzo_bitops_ctz32) && defined(WANT_lzo_bitops_ctz32) ++#define lzo_bitops_ctz32(v) ((unsigned) __builtin_ctz(v)) ++#endif ++#if !defined(lzo_bitops_ctz64) && defined(WANT_lzo_bitops_ctz64) && defined(LZO_UINT64_MAX) ++#define lzo_bitops_ctz64(v) ((unsigned) __builtin_ctzll(v)) ++#endif ++#if !defined(lzo_bitops_popcount32) && defined(WANT_lzo_bitops_popcount32) ++#define lzo_bitops_popcount32(v) ((unsigned) __builtin_popcount(v)) ++#endif ++#if !defined(lzo_bitops_popcount32) && defined(WANT_lzo_bitops_popcount64) && defined(LZO_UINT64_MAX) ++#define lzo_bitops_popcount64(v) ((unsigned) __builtin_popcountll(v)) ++#endif ++#endif ++ ++static __lzo_noinline lzo_uint ++do_compress ( const lzo_bytep in , lzo_uint in_len, ++ lzo_bytep out, lzo_uintp out_len, ++ lzo_uint ti, lzo_voidp wrkmem) ++{ ++ register const lzo_bytep ip; ++ lzo_bytep op; ++ const lzo_bytep const in_end = in + in_len; ++ const lzo_bytep const ip_end = in + in_len - 20; ++ const lzo_bytep ii; ++ lzo_dict_p const dict = (lzo_dict_p) wrkmem; ++ ++ op = out; ++ ip = in; ++ ii = ip - ti; ++ ++ ip += ti < 4 ? 4 - ti : 0; ++ for (;;) ++ { ++ const lzo_bytep m_pos; ++#if !(LZO_DETERMINISTIC) ++ LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0); ++ lzo_uint m_len; ++ lzo_uint dindex; ++next: ++ if __lzo_unlikely(ip >= ip_end) ++ break; ++ DINDEX1(dindex,ip); ++ GINDEX(m_pos,m_off,dict,dindex,in); ++ if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET)) ++ goto literal; ++#if 1 ++ if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) ++ goto try_match; ++ DINDEX2(dindex,ip); ++#endif ++ GINDEX(m_pos,m_off,dict,dindex,in); ++ if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET)) ++ goto literal; ++ if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) ++ goto try_match; ++ goto literal; ++ ++try_match: ++#if defined(UA_GET32) ++ if (UA_GET32(m_pos) != UA_GET32(ip)) ++#else ++ if (m_pos[0] != ip[0] || m_pos[1] != ip[1] || m_pos[2] != ip[2] || m_pos[3] != ip[3]) ++#endif ++ { ++literal: ++ UPDATE_I(dict,0,dindex,ip,in); ++ ip += 1 + ((ip - ii) >> 5); ++ continue; ++ } ++ UPDATE_I(dict,0,dindex,ip,in); ++#else ++ lzo_uint m_off; ++ lzo_uint m_len; ++ { ++ lzo_uint32 dv; ++ lzo_uint dindex; ++literal: ++ ip += 1 + ((ip - ii) >> 5); ++next: ++ if __lzo_unlikely(ip >= ip_end) ++ break; ++ dv = UA_GET32(ip); ++ dindex = DINDEX(dv,ip); ++ GINDEX(m_off,m_pos,in+dict,dindex,in); ++ UPDATE_I(dict,0,dindex,ip,in); ++ if __lzo_unlikely(dv != UA_GET32(m_pos)) ++ goto literal; ++ } ++#endif ++ ++ { ++ register lzo_uint t = pd(ip,ii); ++ if (t != 0) ++ { ++ if (t <= 3) ++ { ++ op[-2] |= LZO_BYTE(t); ++#if defined(UA_COPY32) ++ UA_COPY32(op, ii); ++ op += t; ++#else ++ { do *op++ = *ii++; while (--t > 0); } ++#endif ++ } ++#if defined(UA_COPY32) || defined(UA_COPY64) ++ else if (t <= 16) ++ { ++ *op++ = LZO_BYTE(t - 3); ++#if defined(UA_COPY64) ++ UA_COPY64(op, ii); ++ UA_COPY64(op+8, ii+8); ++#else ++ UA_COPY32(op, ii); ++ UA_COPY32(op+4, ii+4); ++ UA_COPY32(op+8, ii+8); ++ UA_COPY32(op+12, ii+12); ++#endif ++ op += t; ++ } ++#endif ++ else ++ { ++ if (t <= 18) ++ *op++ = LZO_BYTE(t - 3); ++ else ++ { ++ register lzo_uint tt = t - 18; ++ *op++ = 0; ++ while __lzo_unlikely(tt > 255) ++ { ++ tt -= 255; ++#if 1 && (LZO_CC_MSC && (_MSC_VER >= 1400)) ++ * (volatile unsigned char *) op++ = 0; ++#else ++ *op++ = 0; ++#endif ++ } ++ assert(tt > 0); ++ *op++ = LZO_BYTE(tt); ++ } ++#if defined(UA_COPY32) || defined(UA_COPY64) ++ do { ++#if defined(UA_COPY64) ++ UA_COPY64(op, ii); ++ UA_COPY64(op+8, ii+8); ++#else ++ UA_COPY32(op, ii); ++ UA_COPY32(op+4, ii+4); ++ UA_COPY32(op+8, ii+8); ++ UA_COPY32(op+12, ii+12); ++#endif ++ op += 16; ii += 16; t -= 16; ++ } while (t >= 16); if (t > 0) ++#endif ++ { do *op++ = *ii++; while (--t > 0); } ++ } ++ } ++ } ++ m_len = 4; ++ { ++#if defined(UA_GET64) ++ lzo_uint64 v; ++ v = UA_GET64(ip + m_len) ^ UA_GET64(m_pos + m_len); ++ if __lzo_unlikely(v == 0) { ++ do { ++ m_len += 8; ++ v = UA_GET64(ip + m_len) ^ UA_GET64(m_pos + m_len); ++ if __lzo_unlikely(ip + m_len >= ip_end) ++ goto m_len_done; ++ } while (v == 0); ++ } ++#if (LZO_ABI_LITTLE_ENDIAN) && defined(lzo_bitops_ctz64) ++ m_len += lzo_bitops_ctz64(v) / CHAR_BIT; ++#elif (LZO_ABI_LITTLE_ENDIAN) ++ if ((v & UCHAR_MAX) == 0) do { ++ v >>= CHAR_BIT; ++ m_len += 1; ++ } while ((v & UCHAR_MAX) == 0); ++#else ++ if (ip[m_len] == m_pos[m_len]) do { ++ m_len += 1; ++ } while (ip[m_len] == m_pos[m_len]); ++#endif ++#elif defined(UA_GET32) ++ lzo_uint32 v; ++ v = UA_GET32(ip + m_len) ^ UA_GET32(m_pos + m_len); ++ if __lzo_unlikely(v == 0) { ++ do { ++ m_len += 4; ++ v = UA_GET32(ip + m_len) ^ UA_GET32(m_pos + m_len); ++ if __lzo_unlikely(ip + m_len >= ip_end) ++ goto m_len_done; ++ } while (v == 0); ++ } ++#if (LZO_ABI_LITTLE_ENDIAN) && defined(lzo_bitops_ctz32) ++ m_len += lzo_bitops_ctz32(v) / CHAR_BIT; ++#elif (LZO_ABI_LITTLE_ENDIAN) ++ if ((v & UCHAR_MAX) == 0) do { ++ v >>= CHAR_BIT; ++ m_len += 1; ++ } while ((v & UCHAR_MAX) == 0); ++#else ++ if (ip[m_len] == m_pos[m_len]) do { ++ m_len += 1; ++ } while (ip[m_len] == m_pos[m_len]); ++#endif ++#else ++ if __lzo_unlikely(ip[m_len] == m_pos[m_len]) { ++ do { ++ m_len += 1; ++ if __lzo_unlikely(ip + m_len >= ip_end) ++ goto m_len_done; ++ } while (ip[m_len] == m_pos[m_len]); ++ } ++#endif ++ } ++m_len_done: ++ m_off = pd(ip,m_pos); ++ ip += m_len; ++ ii = ip; ++ if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) ++ { ++ m_off -= 1; ++#if defined(LZO1X) ++ *op++ = LZO_BYTE(((m_len - 1) << 5) | ((m_off & 7) << 2)); ++ *op++ = LZO_BYTE(m_off >> 3); ++#elif defined(LZO1Y) ++ *op++ = LZO_BYTE(((m_len + 1) << 4) | ((m_off & 3) << 2)); ++ *op++ = LZO_BYTE(m_off >> 2); ++#endif ++ } ++ else if (m_off <= M3_MAX_OFFSET) ++ { ++ m_off -= 1; ++ if (m_len <= M3_MAX_LEN) ++ *op++ = LZO_BYTE(M3_MARKER | (m_len - 2)); ++ else ++ { ++ m_len -= M3_MAX_LEN; ++ *op++ = M3_MARKER | 0; ++ while __lzo_unlikely(m_len > 255) ++ { ++ m_len -= 255; ++#if 1 && (LZO_CC_MSC && (_MSC_VER >= 1400)) ++ * (volatile unsigned char *) op++ = 0; ++#else ++ *op++ = 0; ++#endif ++ } ++ *op++ = LZO_BYTE(m_len); ++ } ++ *op++ = LZO_BYTE(m_off << 2); ++ *op++ = LZO_BYTE(m_off >> 6); ++ } ++ else ++ { ++ m_off -= 0x4000; ++ if (m_len <= M4_MAX_LEN) ++ *op++ = LZO_BYTE(M4_MARKER | ((m_off >> 11) & 8) | (m_len - 2)); ++ else ++ { ++ m_len -= M4_MAX_LEN; ++ *op++ = LZO_BYTE(M4_MARKER | ((m_off >> 11) & 8)); ++ while __lzo_unlikely(m_len > 255) ++ { ++ m_len -= 255; ++#if 1 && (LZO_CC_MSC && (_MSC_VER >= 1400)) ++ * (volatile unsigned char *) op++ = 0; ++#else ++ *op++ = 0; ++#endif ++ } ++ *op++ = LZO_BYTE(m_len); ++ } ++ *op++ = LZO_BYTE(m_off << 2); ++ *op++ = LZO_BYTE(m_off >> 6); ++ } ++ goto next; ++ } ++ ++ *out_len = pd(op, out); ++ return pd(in_end,ii); ++} ++ ++LZO_PUBLIC(int) ++DO_COMPRESS ( const lzo_bytep in , lzo_uint in_len, ++ lzo_bytep out, lzo_uintp out_len, ++ lzo_voidp wrkmem ) ++{ ++ const lzo_bytep ip = in; ++ lzo_bytep op = out; ++ lzo_uint l = in_len; ++ lzo_uint t = 0; ++ ++ while (l > 20) ++ { ++ lzo_uint ll = l; ++ lzo_uintptr_t ll_end; ++#if 0 || (LZO_DETERMINISTIC) ++ ll = LZO_MIN(ll, 49152); ++#endif ++ ll_end = (lzo_uintptr_t)ip + ll; ++ if ((ll_end + ((t + ll) >> 5)) <= ll_end || (const lzo_bytep)(ll_end + ((t + ll) >> 5)) <= ip + ll) ++ break; ++#if (LZO_DETERMINISTIC) ++ lzo_memset(wrkmem, 0, ((lzo_uint)1 << D_BITS) * sizeof(lzo_dict_t)); ++#endif ++ t = do_compress(ip,ll,op,out_len,t,wrkmem); ++ ip += ll; ++ op += *out_len; ++ l -= ll; ++ } ++ t += l; ++ ++ if (t > 0) ++ { ++ const lzo_bytep ii = in + in_len - t; ++ ++ if (op == out && t <= 238) ++ *op++ = LZO_BYTE(17 + t); ++ else if (t <= 3) ++ op[-2] |= LZO_BYTE(t); ++ else if (t <= 18) ++ *op++ = LZO_BYTE(t - 3); ++ else ++ { ++ lzo_uint tt = t - 18; ++ ++ *op++ = 0; ++ while (tt > 255) ++ { ++ tt -= 255; ++#if 1 && (LZO_CC_MSC && (_MSC_VER >= 1400)) ++ ++ * (volatile unsigned char *) op++ = 0; ++#else ++ *op++ = 0; ++#endif ++ } ++ assert(tt > 0); ++ *op++ = LZO_BYTE(tt); ++ } ++ do *op++ = *ii++; while (--t > 0); ++ } ++ ++ *op++ = M4_MARKER | 1; ++ *op++ = 0; ++ *op++ = 0; ++ ++ *out_len = pd(op, out); ++ return LZO_E_OK; ++} ++ ++#endif ++ ++#undef do_compress ++#undef DO_COMPRESS ++#undef LZO_HASH ++ ++#undef LZO_TEST_OVERRUN ++#undef DO_DECOMPRESS ++#define DO_DECOMPRESS lzo1x_decompress ++ ++#if !defined(MINILZO_CFG_SKIP_LZO1X_DECOMPRESS) ++ ++#if defined(LZO_TEST_OVERRUN) ++# if !defined(LZO_TEST_OVERRUN_INPUT) ++# define LZO_TEST_OVERRUN_INPUT 2 ++# endif ++# if !defined(LZO_TEST_OVERRUN_OUTPUT) ++# define LZO_TEST_OVERRUN_OUTPUT 2 ++# endif ++# if !defined(LZO_TEST_OVERRUN_LOOKBEHIND) ++# define LZO_TEST_OVERRUN_LOOKBEHIND 1 ++# endif ++#endif ++ ++#undef TEST_IP ++#undef TEST_OP ++#undef TEST_LB ++#undef TEST_LBO ++#undef NEED_IP ++#undef NEED_OP ++#undef HAVE_TEST_IP ++#undef HAVE_TEST_OP ++#undef HAVE_NEED_IP ++#undef HAVE_NEED_OP ++#undef HAVE_ANY_IP ++#undef HAVE_ANY_OP ++ ++#if defined(LZO_TEST_OVERRUN_INPUT) ++# if (LZO_TEST_OVERRUN_INPUT >= 1) ++# define TEST_IP (ip < ip_end) ++# endif ++# if (LZO_TEST_OVERRUN_INPUT >= 2) ++# define NEED_IP(x) \ ++ if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun ++# endif ++#endif ++ ++#if defined(LZO_TEST_OVERRUN_OUTPUT) ++# if (LZO_TEST_OVERRUN_OUTPUT >= 1) ++# define TEST_OP (op <= op_end) ++# endif ++# if (LZO_TEST_OVERRUN_OUTPUT >= 2) ++# undef TEST_OP ++# define NEED_OP(x) \ ++ if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun ++# endif ++#endif ++ ++#if defined(LZO_TEST_OVERRUN_LOOKBEHIND) ++# define TEST_LB(m_pos) if (m_pos < out || m_pos >= op) goto lookbehind_overrun ++# define TEST_LBO(m_pos,o) if (m_pos < out || m_pos >= op - (o)) goto lookbehind_overrun ++#else ++# define TEST_LB(m_pos) ((void) 0) ++# define TEST_LBO(m_pos,o) ((void) 0) ++#endif ++ ++#if !defined(LZO_EOF_CODE) && !defined(TEST_IP) ++# define TEST_IP (ip < ip_end) ++#endif ++ ++#if defined(TEST_IP) ++# define HAVE_TEST_IP 1 ++#else ++# define TEST_IP 1 ++#endif ++#if defined(TEST_OP) ++# define HAVE_TEST_OP 1 ++#else ++# define TEST_OP 1 ++#endif ++ ++#if defined(NEED_IP) ++# define HAVE_NEED_IP 1 ++#else ++# define NEED_IP(x) ((void) 0) ++#endif ++#if defined(NEED_OP) ++# define HAVE_NEED_OP 1 ++#else ++# define NEED_OP(x) ((void) 0) ++#endif ++ ++#if defined(HAVE_TEST_IP) || defined(HAVE_NEED_IP) ++# define HAVE_ANY_IP 1 ++#endif ++#if defined(HAVE_TEST_OP) || defined(HAVE_NEED_OP) ++# define HAVE_ANY_OP 1 ++#endif ++ ++#if defined(DO_DECOMPRESS) ++LZO_PUBLIC(int) ++DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, ++ lzo_bytep out, lzo_uintp out_len, ++ lzo_voidp wrkmem ) ++#endif ++{ ++ register lzo_bytep op; ++ register const lzo_bytep ip; ++ register lzo_uint t; ++#if defined(COPY_DICT) ++ lzo_uint m_off; ++ const lzo_bytep dict_end; ++#else ++ register const lzo_bytep m_pos; ++#endif ++ ++ const lzo_bytep const ip_end = in + in_len; ++#if defined(HAVE_ANY_OP) ++ lzo_bytep const op_end = out + *out_len; ++#endif ++#if defined(LZO1Z) ++ lzo_uint last_m_off = 0; ++#endif ++ ++ LZO_UNUSED(wrkmem); ++ ++#if defined(COPY_DICT) ++ if (dict) ++ { ++ if (dict_len > M4_MAX_OFFSET) ++ { ++ dict += dict_len - M4_MAX_OFFSET; ++ dict_len = M4_MAX_OFFSET; ++ } ++ dict_end = dict + dict_len; ++ } ++ else ++ { ++ dict_len = 0; ++ dict_end = NULL; ++ } ++#endif ++ ++ *out_len = 0; ++ ++ op = out; ++ ip = in; ++ ++ if (*ip > 17) ++ { ++ t = *ip++ - 17; ++ if (t < 4) ++ goto match_next; ++ assert(t > 0); NEED_OP(t); NEED_IP(t+1); ++ do *op++ = *ip++; while (--t > 0); ++ goto first_literal_run; ++ } ++ ++ while (TEST_IP && TEST_OP) ++ { ++ t = *ip++; ++ if (t >= 16) ++ goto match; ++ if (t == 0) ++ { ++ NEED_IP(1); ++ while (*ip == 0) ++ { ++ t += 255; ++ ip++; ++ NEED_IP(1); ++ } ++ t += 15 + *ip++; ++ } ++ assert(t > 0); NEED_OP(t+3); NEED_IP(t+4); ++#if defined(LZO_UNALIGNED_OK_8) && defined(LZO_UNALIGNED_OK_4) ++ t += 3; ++ if (t >= 8) do ++ { ++ UA_COPY64(op,ip); ++ op += 8; ip += 8; t -= 8; ++ } while (t >= 8); ++ if (t >= 4) ++ { ++ UA_COPY32(op,ip); ++ op += 4; ip += 4; t -= 4; ++ } ++ if (t > 0) ++ { ++ *op++ = *ip++; ++ if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } } ++ } ++#elif defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) ++#if !defined(LZO_UNALIGNED_OK_4) ++ if (PTR_ALIGNED2_4(op,ip)) ++ { ++#endif ++ UA_COPY32(op,ip); ++ op += 4; ip += 4; ++ if (--t > 0) ++ { ++ if (t >= 4) ++ { ++ do { ++ UA_COPY32(op,ip); ++ op += 4; ip += 4; t -= 4; ++ } while (t >= 4); ++ if (t > 0) do *op++ = *ip++; while (--t > 0); ++ } ++ else ++ do *op++ = *ip++; while (--t > 0); ++ } ++#if !defined(LZO_UNALIGNED_OK_4) ++ } ++ else ++#endif ++#endif ++#if !defined(LZO_UNALIGNED_OK_4) && !defined(LZO_UNALIGNED_OK_8) ++ { ++ *op++ = *ip++; *op++ = *ip++; *op++ = *ip++; ++ do *op++ = *ip++; while (--t > 0); ++ } ++#endif ++ ++first_literal_run: ++ ++ t = *ip++; ++ if (t >= 16) ++ goto match; ++#if defined(COPY_DICT) ++#if defined(LZO1Z) ++ m_off = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); ++ last_m_off = m_off; ++#else ++ m_off = (1 + M2_MAX_OFFSET) + (t >> 2) + (*ip++ << 2); ++#endif ++ NEED_OP(3); ++ t = 3; COPY_DICT(t,m_off) ++#else ++#if defined(LZO1Z) ++ t = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); ++ m_pos = op - t; ++ last_m_off = t; ++#else ++ m_pos = op - (1 + M2_MAX_OFFSET); ++ m_pos -= t >> 2; ++ m_pos -= *ip++ << 2; ++#endif ++ TEST_LB(m_pos); NEED_OP(3); ++ *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos; ++#endif ++ goto match_done; ++ ++ do { ++match: ++ if (t >= 64) ++ { ++#if defined(COPY_DICT) ++#if defined(LZO1X) ++ m_off = 1 + ((t >> 2) & 7) + (*ip++ << 3); ++ t = (t >> 5) - 1; ++#elif defined(LZO1Y) ++ m_off = 1 + ((t >> 2) & 3) + (*ip++ << 2); ++ t = (t >> 4) - 3; ++#elif defined(LZO1Z) ++ m_off = t & 0x1f; ++ if (m_off >= 0x1c) ++ m_off = last_m_off; ++ else ++ { ++ m_off = 1 + (m_off << 6) + (*ip++ >> 2); ++ last_m_off = m_off; ++ } ++ t = (t >> 5) - 1; ++#endif ++#else ++#if defined(LZO1X) ++ m_pos = op - 1; ++ m_pos -= (t >> 2) & 7; ++ m_pos -= *ip++ << 3; ++ t = (t >> 5) - 1; ++#elif defined(LZO1Y) ++ m_pos = op - 1; ++ m_pos -= (t >> 2) & 3; ++ m_pos -= *ip++ << 2; ++ t = (t >> 4) - 3; ++#elif defined(LZO1Z) ++ { ++ lzo_uint off = t & 0x1f; ++ m_pos = op; ++ if (off >= 0x1c) ++ { ++ assert(last_m_off > 0); ++ m_pos -= last_m_off; ++ } ++ else ++ { ++ off = 1 + (off << 6) + (*ip++ >> 2); ++ m_pos -= off; ++ last_m_off = off; ++ } ++ } ++ t = (t >> 5) - 1; ++#endif ++ TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1); ++ goto copy_match; ++#endif ++ } ++ else if (t >= 32) ++ { ++ t &= 31; ++ if (t == 0) ++ { ++ NEED_IP(1); ++ while (*ip == 0) ++ { ++ t += 255; ++ ip++; ++ NEED_IP(1); ++ } ++ t += 31 + *ip++; ++ } ++#if defined(COPY_DICT) ++#if defined(LZO1Z) ++ m_off = 1 + (ip[0] << 6) + (ip[1] >> 2); ++ last_m_off = m_off; ++#else ++ m_off = 1 + (ip[0] >> 2) + (ip[1] << 6); ++#endif ++#else ++#if defined(LZO1Z) ++ { ++ lzo_uint off = 1 + (ip[0] << 6) + (ip[1] >> 2); ++ m_pos = op - off; ++ last_m_off = off; ++ } ++#elif defined(LZO_UNALIGNED_OK_2) && defined(LZO_ABI_LITTLE_ENDIAN) ++ m_pos = op - 1; ++ m_pos -= UA_GET16(ip) >> 2; ++#else ++ m_pos = op - 1; ++ m_pos -= (ip[0] >> 2) + (ip[1] << 6); ++#endif ++#endif ++ ip += 2; ++ } ++ else if (t >= 16) ++ { ++#if defined(COPY_DICT) ++ m_off = (t & 8) << 11; ++#else ++ m_pos = op; ++ m_pos -= (t & 8) << 11; ++#endif ++ t &= 7; ++ if (t == 0) ++ { ++ NEED_IP(1); ++ while (*ip == 0) ++ { ++ t += 255; ++ ip++; ++ NEED_IP(1); ++ } ++ t += 7 + *ip++; ++ } ++#if defined(COPY_DICT) ++#if defined(LZO1Z) ++ m_off += (ip[0] << 6) + (ip[1] >> 2); ++#else ++ m_off += (ip[0] >> 2) + (ip[1] << 6); ++#endif ++ ip += 2; ++ if (m_off == 0) ++ goto eof_found; ++ m_off += 0x4000; ++#if defined(LZO1Z) ++ last_m_off = m_off; ++#endif ++#else ++#if defined(LZO1Z) ++ m_pos -= (ip[0] << 6) + (ip[1] >> 2); ++#elif defined(LZO_UNALIGNED_OK_2) && defined(LZO_ABI_LITTLE_ENDIAN) ++ m_pos -= UA_GET16(ip) >> 2; ++#else ++ m_pos -= (ip[0] >> 2) + (ip[1] << 6); ++#endif ++ ip += 2; ++ if (m_pos == op) ++ goto eof_found; ++ m_pos -= 0x4000; ++#if defined(LZO1Z) ++ last_m_off = pd((const lzo_bytep)op, m_pos); ++#endif ++#endif ++ } ++ else ++ { ++#if defined(COPY_DICT) ++#if defined(LZO1Z) ++ m_off = 1 + (t << 6) + (*ip++ >> 2); ++ last_m_off = m_off; ++#else ++ m_off = 1 + (t >> 2) + (*ip++ << 2); ++#endif ++ NEED_OP(2); ++ t = 2; COPY_DICT(t,m_off) ++#else ++#if defined(LZO1Z) ++ t = 1 + (t << 6) + (*ip++ >> 2); ++ m_pos = op - t; ++ last_m_off = t; ++#else ++ m_pos = op - 1; ++ m_pos -= t >> 2; ++ m_pos -= *ip++ << 2; ++#endif ++ TEST_LB(m_pos); NEED_OP(2); ++ *op++ = *m_pos++; *op++ = *m_pos; ++#endif ++ goto match_done; ++ } ++ ++#if defined(COPY_DICT) ++ ++ NEED_OP(t+3-1); ++ t += 3-1; COPY_DICT(t,m_off) ++ ++#else ++ ++ TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1); ++#if defined(LZO_UNALIGNED_OK_8) && defined(LZO_UNALIGNED_OK_4) ++ if (op - m_pos >= 8) ++ { ++ t += (3 - 1); ++ if (t >= 8) do ++ { ++ UA_COPY64(op,m_pos); ++ op += 8; m_pos += 8; t -= 8; ++ } while (t >= 8); ++ if (t >= 4) ++ { ++ UA_COPY32(op,m_pos); ++ op += 4; m_pos += 4; t -= 4; ++ } ++ if (t > 0) ++ { ++ *op++ = m_pos[0]; ++ if (t > 1) { *op++ = m_pos[1]; if (t > 2) { *op++ = m_pos[2]; } } ++ } ++ } ++ else ++#elif defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) ++#if !defined(LZO_UNALIGNED_OK_4) ++ if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op,m_pos)) ++ { ++ assert((op - m_pos) >= 4); ++#else ++ if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4) ++ { ++#endif ++ UA_COPY32(op,m_pos); ++ op += 4; m_pos += 4; t -= 4 - (3 - 1); ++ do { ++ UA_COPY32(op,m_pos); ++ op += 4; m_pos += 4; t -= 4; ++ } while (t >= 4); ++ if (t > 0) do *op++ = *m_pos++; while (--t > 0); ++ } ++ else ++#endif ++ { ++copy_match: ++ *op++ = *m_pos++; *op++ = *m_pos++; ++ do *op++ = *m_pos++; while (--t > 0); ++ } ++ ++#endif ++ ++match_done: ++#if defined(LZO1Z) ++ t = ip[-1] & 3; ++#else ++ t = ip[-2] & 3; ++#endif ++ if (t == 0) ++ break; ++ ++match_next: ++ assert(t > 0); assert(t < 4); NEED_OP(t); NEED_IP(t+1); ++#if 0 ++ do *op++ = *ip++; while (--t > 0); ++#else ++ *op++ = *ip++; ++ if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } } ++#endif ++ t = *ip++; ++ } while (TEST_IP && TEST_OP); ++ } ++ ++#if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP) ++ *out_len = pd(op, out); ++ return LZO_E_EOF_NOT_FOUND; ++#endif ++ ++eof_found: ++ assert(t == 1); ++ *out_len = pd(op, out); ++ return (ip == ip_end ? LZO_E_OK : ++ (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); ++ ++#if defined(HAVE_NEED_IP) ++input_overrun: ++ *out_len = pd(op, out); ++ return LZO_E_INPUT_OVERRUN; ++#endif ++ ++#if defined(HAVE_NEED_OP) ++output_overrun: ++ *out_len = pd(op, out); ++ return LZO_E_OUTPUT_OVERRUN; ++#endif ++ ++#if defined(LZO_TEST_OVERRUN_LOOKBEHIND) ++lookbehind_overrun: ++ *out_len = pd(op, out); ++ return LZO_E_LOOKBEHIND_OVERRUN; ++#endif ++} ++ ++#endif ++ ++#define LZO_TEST_OVERRUN 1 ++#undef DO_DECOMPRESS ++#define DO_DECOMPRESS lzo1x_decompress_safe ++ ++#if !defined(MINILZO_CFG_SKIP_LZO1X_DECOMPRESS_SAFE) ++ ++#if defined(LZO_TEST_OVERRUN) ++# if !defined(LZO_TEST_OVERRUN_INPUT) ++# define LZO_TEST_OVERRUN_INPUT 2 ++# endif ++# if !defined(LZO_TEST_OVERRUN_OUTPUT) ++# define LZO_TEST_OVERRUN_OUTPUT 2 ++# endif ++# if !defined(LZO_TEST_OVERRUN_LOOKBEHIND) ++# define LZO_TEST_OVERRUN_LOOKBEHIND 1 ++# endif ++#endif ++ ++#undef TEST_IP ++#undef TEST_OP ++#undef TEST_LB ++#undef TEST_LBO ++#undef NEED_IP ++#undef NEED_OP ++#undef HAVE_TEST_IP ++#undef HAVE_TEST_OP ++#undef HAVE_NEED_IP ++#undef HAVE_NEED_OP ++#undef HAVE_ANY_IP ++#undef HAVE_ANY_OP ++ ++#if defined(LZO_TEST_OVERRUN_INPUT) ++# if (LZO_TEST_OVERRUN_INPUT >= 1) ++# define TEST_IP (ip < ip_end) ++# endif ++# if (LZO_TEST_OVERRUN_INPUT >= 2) ++# define NEED_IP(x) \ ++ if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun ++# endif ++#endif ++ ++#if defined(LZO_TEST_OVERRUN_OUTPUT) ++# if (LZO_TEST_OVERRUN_OUTPUT >= 1) ++# define TEST_OP (op <= op_end) ++# endif ++# if (LZO_TEST_OVERRUN_OUTPUT >= 2) ++# undef TEST_OP ++# define NEED_OP(x) \ ++ if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun ++# endif ++#endif ++ ++#if defined(LZO_TEST_OVERRUN_LOOKBEHIND) ++# define TEST_LB(m_pos) if (m_pos < out || m_pos >= op) goto lookbehind_overrun ++# define TEST_LBO(m_pos,o) if (m_pos < out || m_pos >= op - (o)) goto lookbehind_overrun ++#else ++# define TEST_LB(m_pos) ((void) 0) ++# define TEST_LBO(m_pos,o) ((void) 0) ++#endif ++ ++#if !defined(LZO_EOF_CODE) && !defined(TEST_IP) ++# define TEST_IP (ip < ip_end) ++#endif ++ ++#if defined(TEST_IP) ++# define HAVE_TEST_IP 1 ++#else ++# define TEST_IP 1 ++#endif ++#if defined(TEST_OP) ++# define HAVE_TEST_OP 1 ++#else ++# define TEST_OP 1 ++#endif ++ ++#if defined(NEED_IP) ++# define HAVE_NEED_IP 1 ++#else ++# define NEED_IP(x) ((void) 0) ++#endif ++#if defined(NEED_OP) ++# define HAVE_NEED_OP 1 ++#else ++# define NEED_OP(x) ((void) 0) ++#endif ++ ++#if defined(HAVE_TEST_IP) || defined(HAVE_NEED_IP) ++# define HAVE_ANY_IP 1 ++#endif ++#if defined(HAVE_TEST_OP) || defined(HAVE_NEED_OP) ++# define HAVE_ANY_OP 1 ++#endif ++ ++#if defined(DO_DECOMPRESS) ++LZO_PUBLIC(int) ++DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, ++ lzo_bytep out, lzo_uintp out_len, ++ lzo_voidp wrkmem ) ++#endif ++{ ++ register lzo_bytep op; ++ register const lzo_bytep ip; ++ register lzo_uint t; ++#if defined(COPY_DICT) ++ lzo_uint m_off; ++ const lzo_bytep dict_end; ++#else ++ register const lzo_bytep m_pos; ++#endif ++ ++ const lzo_bytep const ip_end = in + in_len; ++#if defined(HAVE_ANY_OP) ++ lzo_bytep const op_end = out + *out_len; ++#endif ++#if defined(LZO1Z) ++ lzo_uint last_m_off = 0; ++#endif ++ ++ LZO_UNUSED(wrkmem); ++ ++#if defined(COPY_DICT) ++ if (dict) ++ { ++ if (dict_len > M4_MAX_OFFSET) ++ { ++ dict += dict_len - M4_MAX_OFFSET; ++ dict_len = M4_MAX_OFFSET; ++ } ++ dict_end = dict + dict_len; ++ } ++ else ++ { ++ dict_len = 0; ++ dict_end = NULL; ++ } ++#endif ++ ++ *out_len = 0; ++ ++ op = out; ++ ip = in; ++ ++ if (*ip > 17) ++ { ++ t = *ip++ - 17; ++ if (t < 4) ++ goto match_next; ++ assert(t > 0); NEED_OP(t); NEED_IP(t+1); ++ do *op++ = *ip++; while (--t > 0); ++ goto first_literal_run; ++ } ++ ++ while (TEST_IP && TEST_OP) ++ { ++ t = *ip++; ++ if (t >= 16) ++ goto match; ++ if (t == 0) ++ { ++ NEED_IP(1); ++ while (*ip == 0) ++ { ++ t += 255; ++ ip++; ++ NEED_IP(1); ++ } ++ t += 15 + *ip++; ++ } ++ assert(t > 0); NEED_OP(t+3); NEED_IP(t+4); ++#if defined(LZO_UNALIGNED_OK_8) && defined(LZO_UNALIGNED_OK_4) ++ t += 3; ++ if (t >= 8) do ++ { ++ UA_COPY64(op,ip); ++ op += 8; ip += 8; t -= 8; ++ } while (t >= 8); ++ if (t >= 4) ++ { ++ UA_COPY32(op,ip); ++ op += 4; ip += 4; t -= 4; ++ } ++ if (t > 0) ++ { ++ *op++ = *ip++; ++ if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } } ++ } ++#elif defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) ++#if !defined(LZO_UNALIGNED_OK_4) ++ if (PTR_ALIGNED2_4(op,ip)) ++ { ++#endif ++ UA_COPY32(op,ip); ++ op += 4; ip += 4; ++ if (--t > 0) ++ { ++ if (t >= 4) ++ { ++ do { ++ UA_COPY32(op,ip); ++ op += 4; ip += 4; t -= 4; ++ } while (t >= 4); ++ if (t > 0) do *op++ = *ip++; while (--t > 0); ++ } ++ else ++ do *op++ = *ip++; while (--t > 0); ++ } ++#if !defined(LZO_UNALIGNED_OK_4) ++ } ++ else ++#endif ++#endif ++#if !defined(LZO_UNALIGNED_OK_4) && !defined(LZO_UNALIGNED_OK_8) ++ { ++ *op++ = *ip++; *op++ = *ip++; *op++ = *ip++; ++ do *op++ = *ip++; while (--t > 0); ++ } ++#endif ++ ++first_literal_run: ++ ++ t = *ip++; ++ if (t >= 16) ++ goto match; ++#if defined(COPY_DICT) ++#if defined(LZO1Z) ++ m_off = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); ++ last_m_off = m_off; ++#else ++ m_off = (1 + M2_MAX_OFFSET) + (t >> 2) + (*ip++ << 2); ++#endif ++ NEED_OP(3); ++ t = 3; COPY_DICT(t,m_off) ++#else ++#if defined(LZO1Z) ++ t = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); ++ m_pos = op - t; ++ last_m_off = t; ++#else ++ m_pos = op - (1 + M2_MAX_OFFSET); ++ m_pos -= t >> 2; ++ m_pos -= *ip++ << 2; ++#endif ++ TEST_LB(m_pos); NEED_OP(3); ++ *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos; ++#endif ++ goto match_done; ++ ++ do { ++match: ++ if (t >= 64) ++ { ++#if defined(COPY_DICT) ++#if defined(LZO1X) ++ m_off = 1 + ((t >> 2) & 7) + (*ip++ << 3); ++ t = (t >> 5) - 1; ++#elif defined(LZO1Y) ++ m_off = 1 + ((t >> 2) & 3) + (*ip++ << 2); ++ t = (t >> 4) - 3; ++#elif defined(LZO1Z) ++ m_off = t & 0x1f; ++ if (m_off >= 0x1c) ++ m_off = last_m_off; ++ else ++ { ++ m_off = 1 + (m_off << 6) + (*ip++ >> 2); ++ last_m_off = m_off; ++ } ++ t = (t >> 5) - 1; ++#endif ++#else ++#if defined(LZO1X) ++ m_pos = op - 1; ++ m_pos -= (t >> 2) & 7; ++ m_pos -= *ip++ << 3; ++ t = (t >> 5) - 1; ++#elif defined(LZO1Y) ++ m_pos = op - 1; ++ m_pos -= (t >> 2) & 3; ++ m_pos -= *ip++ << 2; ++ t = (t >> 4) - 3; ++#elif defined(LZO1Z) ++ { ++ lzo_uint off = t & 0x1f; ++ m_pos = op; ++ if (off >= 0x1c) ++ { ++ assert(last_m_off > 0); ++ m_pos -= last_m_off; ++ } ++ else ++ { ++ off = 1 + (off << 6) + (*ip++ >> 2); ++ m_pos -= off; ++ last_m_off = off; ++ } ++ } ++ t = (t >> 5) - 1; ++#endif ++ TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1); ++ goto copy_match; ++#endif ++ } ++ else if (t >= 32) ++ { ++ t &= 31; ++ if (t == 0) ++ { ++ NEED_IP(1); ++ while (*ip == 0) ++ { ++ t += 255; ++ ip++; ++ NEED_IP(1); ++ } ++ t += 31 + *ip++; ++ } ++#if defined(COPY_DICT) ++#if defined(LZO1Z) ++ m_off = 1 + (ip[0] << 6) + (ip[1] >> 2); ++ last_m_off = m_off; ++#else ++ m_off = 1 + (ip[0] >> 2) + (ip[1] << 6); ++#endif ++#else ++#if defined(LZO1Z) ++ { ++ lzo_uint off = 1 + (ip[0] << 6) + (ip[1] >> 2); ++ m_pos = op - off; ++ last_m_off = off; ++ } ++#elif defined(LZO_UNALIGNED_OK_2) && defined(LZO_ABI_LITTLE_ENDIAN) ++ m_pos = op - 1; ++ m_pos -= UA_GET16(ip) >> 2; ++#else ++ m_pos = op - 1; ++ m_pos -= (ip[0] >> 2) + (ip[1] << 6); ++#endif ++#endif ++ ip += 2; ++ } ++ else if (t >= 16) ++ { ++#if defined(COPY_DICT) ++ m_off = (t & 8) << 11; ++#else ++ m_pos = op; ++ m_pos -= (t & 8) << 11; ++#endif ++ t &= 7; ++ if (t == 0) ++ { ++ NEED_IP(1); ++ while (*ip == 0) ++ { ++ t += 255; ++ ip++; ++ NEED_IP(1); ++ } ++ t += 7 + *ip++; ++ } ++#if defined(COPY_DICT) ++#if defined(LZO1Z) ++ m_off += (ip[0] << 6) + (ip[1] >> 2); ++#else ++ m_off += (ip[0] >> 2) + (ip[1] << 6); ++#endif ++ ip += 2; ++ if (m_off == 0) ++ goto eof_found; ++ m_off += 0x4000; ++#if defined(LZO1Z) ++ last_m_off = m_off; ++#endif ++#else ++#if defined(LZO1Z) ++ m_pos -= (ip[0] << 6) + (ip[1] >> 2); ++#elif defined(LZO_UNALIGNED_OK_2) && defined(LZO_ABI_LITTLE_ENDIAN) ++ m_pos -= UA_GET16(ip) >> 2; ++#else ++ m_pos -= (ip[0] >> 2) + (ip[1] << 6); ++#endif ++ ip += 2; ++ if (m_pos == op) ++ goto eof_found; ++ m_pos -= 0x4000; ++#if defined(LZO1Z) ++ last_m_off = pd((const lzo_bytep)op, m_pos); ++#endif ++#endif ++ } ++ else ++ { ++#if defined(COPY_DICT) ++#if defined(LZO1Z) ++ m_off = 1 + (t << 6) + (*ip++ >> 2); ++ last_m_off = m_off; ++#else ++ m_off = 1 + (t >> 2) + (*ip++ << 2); ++#endif ++ NEED_OP(2); ++ t = 2; COPY_DICT(t,m_off) ++#else ++#if defined(LZO1Z) ++ t = 1 + (t << 6) + (*ip++ >> 2); ++ m_pos = op - t; ++ last_m_off = t; ++#else ++ m_pos = op - 1; ++ m_pos -= t >> 2; ++ m_pos -= *ip++ << 2; ++#endif ++ TEST_LB(m_pos); NEED_OP(2); ++ *op++ = *m_pos++; *op++ = *m_pos; ++#endif ++ goto match_done; ++ } ++ ++#if defined(COPY_DICT) ++ ++ NEED_OP(t+3-1); ++ t += 3-1; COPY_DICT(t,m_off) ++ ++#else ++ ++ TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1); ++#if defined(LZO_UNALIGNED_OK_8) && defined(LZO_UNALIGNED_OK_4) ++ if (op - m_pos >= 8) ++ { ++ t += (3 - 1); ++ if (t >= 8) do ++ { ++ UA_COPY64(op,m_pos); ++ op += 8; m_pos += 8; t -= 8; ++ } while (t >= 8); ++ if (t >= 4) ++ { ++ UA_COPY32(op,m_pos); ++ op += 4; m_pos += 4; t -= 4; ++ } ++ if (t > 0) ++ { ++ *op++ = m_pos[0]; ++ if (t > 1) { *op++ = m_pos[1]; if (t > 2) { *op++ = m_pos[2]; } } ++ } ++ } ++ else ++#elif defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4) ++#if !defined(LZO_UNALIGNED_OK_4) ++ if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op,m_pos)) ++ { ++ assert((op - m_pos) >= 4); ++#else ++ if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4) ++ { ++#endif ++ UA_COPY32(op,m_pos); ++ op += 4; m_pos += 4; t -= 4 - (3 - 1); ++ do { ++ UA_COPY32(op,m_pos); ++ op += 4; m_pos += 4; t -= 4; ++ } while (t >= 4); ++ if (t > 0) do *op++ = *m_pos++; while (--t > 0); ++ } ++ else ++#endif ++ { ++copy_match: ++ *op++ = *m_pos++; *op++ = *m_pos++; ++ do *op++ = *m_pos++; while (--t > 0); ++ } ++ ++#endif ++ ++match_done: ++#if defined(LZO1Z) ++ t = ip[-1] & 3; ++#else ++ t = ip[-2] & 3; ++#endif ++ if (t == 0) ++ break; ++ ++match_next: ++ assert(t > 0); assert(t < 4); NEED_OP(t); NEED_IP(t+1); ++#if 0 ++ do *op++ = *ip++; while (--t > 0); ++#else ++ *op++ = *ip++; ++ if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } } ++#endif ++ t = *ip++; ++ } while (TEST_IP && TEST_OP); ++ } ++ ++#if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP) ++ *out_len = pd(op, out); ++ return LZO_E_EOF_NOT_FOUND; ++#endif ++ ++eof_found: ++ assert(t == 1); ++ *out_len = pd(op, out); ++ return (ip == ip_end ? LZO_E_OK : ++ (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); ++ ++#if defined(HAVE_NEED_IP) ++input_overrun: ++ *out_len = pd(op, out); ++ return LZO_E_INPUT_OVERRUN; ++#endif ++ ++#if defined(HAVE_NEED_OP) ++output_overrun: ++ *out_len = pd(op, out); ++ return LZO_E_OUTPUT_OVERRUN; ++#endif ++ ++#if defined(LZO_TEST_OVERRUN_LOOKBEHIND) ++lookbehind_overrun: ++ *out_len = pd(op, out); ++ return LZO_E_LOOKBEHIND_OVERRUN; ++#endif ++} ++ ++#endif ++ ++/***** End of minilzo.c *****/ ++ +Index: b/grub-core/lib/minilzo/minilzo.h +=================================================================== +--- /dev/null ++++ b/grub-core/lib/minilzo/minilzo.h +@@ -0,0 +1,109 @@ ++/* minilzo.h -- mini subset of the LZO real-time data compression library ++ ++ This file is part of the LZO real-time data compression library. ++ ++ Copyright (C) 2011 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2010 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2009 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer ++ Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer ++ All Rights Reserved. ++ ++ The LZO library 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; either version 2 of ++ the License, or (at your option) any later version. ++ ++ The LZO library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with the LZO library; see the file COPYING. ++ If not, write to the Free Software Foundation, Inc., ++ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ++ ++ Markus F.X.J. Oberhumer ++ ++ http://www.oberhumer.com/opensource/lzo/ ++ */ ++ ++/* ++ * NOTE: ++ * the full LZO package can be found at ++ * http://www.oberhumer.com/opensource/lzo/ ++ */ ++ ++ ++#ifndef __MINILZO_H ++#define __MINILZO_H 1 ++ ++#define MINILZO_VERSION 0x2050 ++ ++#ifdef __LZOCONF_H ++# error "you cannot use both LZO and miniLZO" ++#endif ++ ++#undef LZO_HAVE_CONFIG_H ++#include "lzoconf.h" ++ ++#if !defined(LZO_VERSION) || (LZO_VERSION != MINILZO_VERSION) ++# error "version mismatch in header files" ++#endif ++ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++ ++/*********************************************************************** ++// ++************************************************************************/ ++ ++/* Memory required for the wrkmem parameter. ++ * When the required size is 0, you can also pass a NULL pointer. ++ */ ++ ++#define LZO1X_MEM_COMPRESS LZO1X_1_MEM_COMPRESS ++#define LZO1X_1_MEM_COMPRESS ((lzo_uint32) (16384L * lzo_sizeof_dict_t)) ++#define LZO1X_MEM_DECOMPRESS (0) ++ ++ ++/* compression */ ++LZO_EXTERN(int) ++lzo1x_1_compress ( const lzo_bytep src, lzo_uint src_len, ++ lzo_bytep dst, lzo_uintp dst_len, ++ lzo_voidp wrkmem ); ++ ++/* decompression */ ++LZO_EXTERN(int) ++lzo1x_decompress ( const lzo_bytep src, lzo_uint src_len, ++ lzo_bytep dst, lzo_uintp dst_len, ++ lzo_voidp wrkmem /* NOT USED */ ); ++ ++/* safe decompression with overrun testing */ ++LZO_EXTERN(int) ++lzo1x_decompress_safe ( const lzo_bytep src, lzo_uint src_len, ++ lzo_bytep dst, lzo_uintp dst_len, ++ lzo_voidp wrkmem /* NOT USED */ ); ++ ++ ++#ifdef __cplusplus ++} /* extern "C" */ ++#endif ++ ++#endif /* already included */ ++ +Index: b/grub-core/lib/posix_wrap/limits.h +=================================================================== +--- /dev/null ++++ b/grub-core/lib/posix_wrap/limits.h +@@ -0,0 +1,31 @@ ++/* ++ * GRUB -- GRand Unified Bootloader ++ * Copyright (C) 2010 Free Software Foundation, Inc. ++ * ++ * GRUB 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, either version 3 of the License, or ++ * (at your option) any later version. ++ * ++ * GRUB is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with GRUB. If not, see . ++ */ ++ ++#ifndef GRUB_POSIX_LIMITS_H ++#define GRUB_POSIX_LIMITS_H ++ ++#include ++ ++#define UCHAR_MAX GRUB_UCHAR_MAX ++#define USHRT_MAX GRUB_USHRT_MAX ++#define UINT_MAX GRUB_UINT_MAX ++#define ULONG_MAX GRUB_ULONG_MAX ++ ++#define CHAR_BIT 8 ++ ++#endif +Index: b/grub-core/lib/posix_wrap/sys/types.h +=================================================================== +--- a/grub-core/lib/posix_wrap/sys/types.h ++++ b/grub-core/lib/posix_wrap/sys/types.h +@@ -24,9 +24,6 @@ + typedef grub_size_t size_t; + typedef enum { false = 0, true = 1 } bool; + +-#define ULONG_MAX GRUB_ULONG_MAX +-#define UCHAR_MAX 0xff +- + typedef grub_uint8_t uint8_t; + typedef grub_uint16_t uint16_t; + typedef grub_uint32_t uint32_t; +Index: b/include/grub/file.h +=================================================================== +--- a/include/grub/file.h ++++ b/include/grub/file.h +@@ -56,9 +56,10 @@ + { + GRUB_FILE_FILTER_GZIO, + GRUB_FILE_FILTER_XZIO, ++ GRUB_FILE_FILTER_LZOPIO, + GRUB_FILE_FILTER_MAX, + GRUB_FILE_FILTER_COMPRESSION_FIRST = GRUB_FILE_FILTER_GZIO, +- GRUB_FILE_FILTER_COMPRESSION_LAST = GRUB_FILE_FILTER_XZIO, ++ GRUB_FILE_FILTER_COMPRESSION_LAST = GRUB_FILE_FILTER_LZOPIO, + } grub_file_filter_id_t; + + typedef grub_file_t (*grub_file_filter_t) (grub_file_t in); +Index: b/include/grub/libgcc.h +=================================================================== +--- a/include/grub/libgcc.h ++++ b/include/grub/libgcc.h +@@ -39,6 +39,12 @@ + # ifdef HAVE___BSWAPDI2 + void EXPORT_FUNC (__bswapdi2) (void); + # endif ++# ifdef HAVE___CTZDI2 ++void EXPORT_FUNC (__ctzdi2) (void); ++# endif ++# ifdef HAVE___CTZSI2 ++void EXPORT_FUNC (__ctzsi2) (void); ++# endif + #endif + + #ifdef HAVE___TRAMPOLINE_SETUP +Index: b/include/grub/types.h +=================================================================== +--- a/include/grub/types.h ++++ b/include/grub/types.h +@@ -113,6 +113,10 @@ + # define PRIuGRUB_SIZE "u" + #endif + ++#define GRUB_UCHAR_MAX 0xFF ++#define GRUB_USHRT_MAX 65535 ++#define GRUB_UINT_MAX 4294967295U ++ + #if GRUB_CPU_SIZEOF_LONG == 8 + # define GRUB_ULONG_MAX 18446744073709551615UL + # define GRUB_LONG_MAX 9223372036854775807L +@@ -215,4 +219,31 @@ + # define grub_cpu_to_le32_compile_time(x) ((grub_uint32_t) (x)) + #endif /* ! WORDS_BIGENDIAN */ + ++static inline grub_uint16_t grub_get_unaligned16(void *ptr) ++{ ++ struct ++ { ++ grub_uint16_t d; ++ } __attribute__((packed)) *dd = ptr; ++ return dd->d; ++} ++ ++static inline grub_uint32_t grub_get_unaligned32(void *ptr) ++{ ++ struct ++ { ++ grub_uint32_t d; ++ } __attribute__((packed)) *dd = ptr; ++ return dd->d; ++} ++ ++static inline grub_uint64_t grub_get_unaligned64(void *ptr) ++{ ++ struct ++ { ++ grub_uint64_t d; ++ } __attribute__((packed)) *dd = ptr; ++ return dd->d; ++} ++ + #endif /* ! GRUB_TYPES_HEADER */ +Index: b/util/import_gcry.py +=================================================================== +--- a/util/import_gcry.py ++++ b/util/import_gcry.py +@@ -73,6 +73,8 @@ + cryptolist.write ("AES-192: gcry_rijndael\n"); + cryptolist.write ("AES-256: gcry_rijndael\n"); + ++cryptolist.write ("ADLER32: adler32\n"); ++ + for cipher_file in cipher_files: + infile = os.path.join (cipher_dir_in, cipher_file) + outfile = os.path.join (cipher_dir_out, cipher_file) diff --git a/master/debian/mkconfig_gnumach.patch b/master/debian/mkconfig_gnumach.patch new file mode 100644 index 0000000..2c28ef5 --- /dev/null +++ b/master/debian/mkconfig_gnumach.patch @@ -0,0 +1,53 @@ +Description: Add support for GRUB_CMDLINE_GNUMACH +Author: Samuel Thibault +Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3942 +Last-Update: 2012-03-05 + +Index: b/docs/grub.texi +=================================================================== +--- a/docs/grub.texi ++++ b/docs/grub.texi +@@ -1167,6 +1167,9 @@ + As @samp{GRUB_CMDLINE_LINUX} and @samp{GRUB_CMDLINE_LINUX_DEFAULT}, but for + NetBSD. + ++@item GRUB_CMDLINE_GNUMACH ++As @samp{GRUB_CMDLINE_LINUX}, but for GNU Mach. ++ + @item GRUB_CMDLINE_XEN + @itemx GRUB_CMDLINE_XEN_DEFAULT + The values of these options are appended to the values of +Index: b/util/grub-mkconfig.in +=================================================================== +--- a/util/grub-mkconfig.in ++++ b/util/grub-mkconfig.in +@@ -244,6 +244,7 @@ + GRUB_CMDLINE_LINUX_XEN_REPLACE_DEFAULT \ + GRUB_CMDLINE_NETBSD \ + GRUB_CMDLINE_NETBSD_DEFAULT \ ++ GRUB_CMDLINE_GNUMACH \ + GRUB_TERMINAL_INPUT \ + GRUB_TERMINAL_OUTPUT \ + GRUB_SERIAL_COMMAND \ +Index: b/util/grub.d/10_hurd.in +=================================================================== +--- a/util/grub.d/10_hurd.in ++++ b/util/grub.d/10_hurd.in +@@ -84,7 +84,7 @@ + message="$(gettext_printf "Loading GNU Mach ...")" + cat << EOF + echo '$message' +- multiboot ${kernel} root=device:${GRUB_DEVICE#/dev/} ++ multiboot ${kernel} root=device:${GRUB_DEVICE#/dev/} ${GRUB_CMDLINE_GNUMACH} + EOF + save_default_entry | sed -e "s/^/\t/" + prepare_grub_to_access_device ${GRUB_DEVICE} | sed -e "s/^/\t/" +@@ -108,7 +108,7 @@ + message="$(gettext_printf "Loading GNU Mach ...")" + cat << EOF + echo '$message' +- multiboot ${kernel} root=device:${GRUB_DEVICE#/dev/} -s ++ multiboot ${kernel} root=device:${GRUB_DEVICE#/dev/} -s ${GRUB_CMDLINE_GNUMACH} + EOF + prepare_grub_to_access_device ${GRUB_DEVICE} | sed -e "s/^/\t/" + message="$(gettext_printf "Loading the Hurd ...")" diff --git a/master/debian/mkconfig_loopback.patch b/master/debian/mkconfig_loopback.patch new file mode 100644 index 0000000..1c04063 --- /dev/null +++ b/master/debian/mkconfig_loopback.patch @@ -0,0 +1,84 @@ +Description: Handle filesystems loop-mounted on file images + Improve prepare_grub_to_access_device to emit appropriate commands for such + filesystems, and ignore them in Linux grub.d scripts. + . + This is needed for Ubuntu's Wubi installation method. + . + This patch isn't inherently Debian/Ubuntu-specific. losetup and + /proc/mounts are Linux-specific, though, so we might need to refine this + before sending it upstream. The changes to the Linux grub.d scripts might + be better handled by integrating 10_lupin properly instead. + +Index: b/util/grub-mkconfig_lib.in +=================================================================== +--- a/util/grub-mkconfig_lib.in ++++ b/util/grub-mkconfig_lib.in +@@ -105,6 +105,21 @@ + { + device="$1" + ++ loop_file= ++ case ${device} in ++ /dev/loop/*|/dev/loop[0-9]) ++ grub_loop_device="${device#/dev/}" ++ loop_file=`losetup "${device}" | sed -e "s/^[^(]*(\([^)]\+\)).*/\1/"` ++ case $loop_file in ++ /dev/*) ;; ++ *) ++ loop_device="${device}" ++ device=`"${grub_probe}" --target=device "${loop_file}"` ++ ;; ++ esac ++ ;; ++ esac ++ + if dmsetup status $device 2>/dev/null | grep -q 'crypt[[:space:]]$'; then + grub_warn \ + "$device is a crypto device, which GRUB cannot read directly. Some" \ +@@ -141,6 +156,14 @@ + if fs_uuid="`"${grub_probe}" --device "${device}" --target=fs_uuid 2> /dev/null`" ; then + echo "search --no-floppy --fs-uuid --set=root ${fs_uuid}" + fi ++ ++ if [ "x${loop_file}" != x ]; then ++ loop_mountpoint="$(awk '"'${loop_file}'" ~ "^"$2 && $2 != "/" { print $2 }' /proc/mounts | tail -n1)" ++ if [ "x${loop_mountpoint}" != x ]; then ++ echo "loopback ${grub_loop_device} ${loop_file#$loop_mountpoint}" ++ echo "set root=(${grub_loop_device})" ++ fi ++ fi + } + + grub_file_is_not_garbage () +Index: b/util/grub.d/10_linux.in +=================================================================== +--- a/util/grub.d/10_linux.in ++++ b/util/grub.d/10_linux.in +@@ -40,6 +40,11 @@ + case ${GRUB_DEVICE} in + /dev/loop/*|/dev/loop[0-9]) + GRUB_DEVICE=`losetup ${GRUB_DEVICE} | sed -e "s/^[^(]*(\([^)]\+\)).*/\1/"` ++ # We can't cope with devices loop-mounted from files here. ++ case ${GRUB_DEVICE} in ++ /dev/*) ;; ++ *) exit 0 ;; ++ esac + ;; + esac + +Index: b/util/grub.d/20_linux_xen.in +=================================================================== +--- a/util/grub.d/20_linux_xen.in ++++ b/util/grub.d/20_linux_xen.in +@@ -40,6 +40,11 @@ + case ${GRUB_DEVICE} in + /dev/loop/*|/dev/loop[0-9]) + GRUB_DEVICE=`losetup ${GRUB_DEVICE} | sed -e "s/^[^(]*(\([^)]\+\)).*/\1/"` ++ # We can't cope with devices loop-mounted from files here. ++ case ${GRUB_DEVICE} in ++ /dev/*) ;; ++ *) exit 0 ;; ++ esac + ;; + esac + diff --git a/master/debian/mkconfig_skip_dmcrypt.patch b/master/debian/mkconfig_skip_dmcrypt.patch new file mode 100644 index 0000000..4e74652 --- /dev/null +++ b/master/debian/mkconfig_skip_dmcrypt.patch @@ -0,0 +1,30 @@ +Description: Warn and return without error if /boot is a dm-crypt device + With any luck the administrator knows what they're doing; in any event, we + probably can't improve matters by having update-grub exit non-zero. +Author: Marc Haber +Author: Colin Watson +Origin: other, http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=542165#25 +Bug-Debian: http://bugs.debian.org/542165 +Forwarded: no +Last-Update: 2010-06-05 + +Index: b/util/grub-mkconfig_lib.in +=================================================================== +--- a/util/grub-mkconfig_lib.in ++++ b/util/grub-mkconfig_lib.in +@@ -105,6 +105,15 @@ + { + device="$1" + ++ if dmsetup status $device 2>/dev/null | grep -q 'crypt[[:space:]]$'; then ++ grub_warn \ ++ "$device is a crypto device, which GRUB cannot read directly. Some" \ ++ "necessary modules may be missing from /boot/grub/grub.cfg. You may" \ ++ "need to list them in GRUB_PRELOAD_MODULES in /etc/default/grub. See" \ ++ "http://bugs.debian.org/542165 for details." ++ return 0 ++ fi ++ + # Abstraction modules aren't auto-loaded. + abstraction="`"${grub_probe}" --device "${device}" --target=abstraction`" + for module in ${abstraction} ; do diff --git a/master/debian/mkconfig_skip_readme.patch b/master/debian/mkconfig_skip_readme.patch new file mode 100644 index 0000000..e354c2c --- /dev/null +++ b/master/debian/mkconfig_skip_readme.patch @@ -0,0 +1,20 @@ +Description: Skip */README* as well as README* +Author: Colin Watson +Bug-Ubuntu: https://bugs.launchpad.net/bugs/537123 +Forwarded: yes +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3422 +Last-Update: 2011-09-05 + +Index: b/util/grub-mkconfig_lib.in +=================================================================== +--- a/util/grub-mkconfig_lib.in ++++ b/util/grub-mkconfig_lib.in +@@ -171,7 +171,7 @@ + if test -f "$1" ; then + case "$1" in + *.dpkg-*) return 1 ;; # debian dpkg +- README*) return 1 ;; # documentation ++ README*|*/README*) return 1 ;; # documentation + esac + else + return 1 diff --git a/master/debian/mkrescue_diet.patch b/master/debian/mkrescue_diet.patch new file mode 100644 index 0000000..57246b2 --- /dev/null +++ b/master/debian/mkrescue_diet.patch @@ -0,0 +1,54 @@ +Description: Allow reducing size of xorriso-created rescue images + This lets us create smaller images that will fit on floppy disks. It has + been approved by the upstream maintainer but has not yet been applied. +Author: Thomas Schmitt +Origin: other, http://lists.gnu.org/archive/html/grub-devel/2010-05/msg00100.html +Forwarded: yes +Last-Update: 2010-06-02 + +Index: b/util/grub-mkrescue.in +=================================================================== +--- a/util/grub-mkrescue.in ++++ b/util/grub-mkrescue.in +@@ -44,6 +44,7 @@ + grub_mkimage=${bindir}/`echo grub-mkimage | sed ${transform}` + + xorriso=xorriso ++diet=no + + # Usage: usage + # Print the usage. +@@ -59,6 +60,7 @@ + --rom-directory=DIR save rom images in DIR [optional] + --xorriso=FILE use FILE as xorriso [optional] + --grub-mkimage=FILE use FILE as grub-mkimage ++ --diet apply size reducing measures [optional] + + $self generates a bootable rescue image with specified source files, source + directories, or mkisofs options listed by: xorriso -as mkisofs -help +@@ -133,6 +135,9 @@ + --xorriso=*) + xorriso=`echo "${option}/" | sed 's/--xorriso=//'` ;; + ++ --diet) ++ diet=yes ;; ++ + *) + source="${source} ${option} $@"; break ;; + esac +@@ -307,7 +312,14 @@ + fi + + # build iso image +-"${xorriso}" -as mkisofs -graft-points ${grub_mkisofs_arguments} --protective-msdos-label -o ${output_image} -r ${iso9660_dir} --sort-weight 0 / --sort-weight 1 /boot ${source} ++if [ "${diet}" = yes ]; then ++ if [ -e "${output_image}" ]; then ++ rm "${output_image}" || exit 1 ++ fi ++ "${xorriso}" -report_about HINT -as mkisofs -graft-points -no-pad ${grub_mkisofs_arguments} --protective-msdos-label -r ${iso9660_dir} --sort-weight 0 / --sort-weight 1 /boot ${source} | cat >"${output_image}" ++else ++ "${xorriso}" -report_about HINT -as mkisofs -graft-points ${grub_mkisofs_arguments} --protective-msdos-label -o ${output_image} -r ${iso9660_dir} --sort-weight 0 / --sort-weight 1 /boot ${source} ++fi + rm -rf ${iso9660_dir} + + rm -f ${embed_img} diff --git a/master/debian/mkrescue_efi_modules.patch b/master/debian/mkrescue_efi_modules.patch new file mode 100644 index 0000000..47029f4 --- /dev/null +++ b/master/debian/mkrescue_efi_modules.patch @@ -0,0 +1,22 @@ +Description: Build part_msdos and vfat into EFI boot images +Author: Mario Limonciello +Bug-Ubuntu: https://bugs.launchpad.net/bugs/677758 +Forwarded: http://lists.gnu.org/archive/html/grub-devel/2011-01/msg00028.html +Last-Update: 2011-04-11 + +Index: b/util/grub-mkrescue.in +=================================================================== +--- a/util/grub-mkrescue.in ++++ b/util/grub-mkrescue.in +@@ -288,9 +288,9 @@ + mkdir -p "${efi_dir}/efi/boot" + + # build bootx64.efi +- make_image "${efi64_dir}" x86_64-efi "${efi_dir}"/efi/boot/bootx64.efi "" ++ make_image "${efi64_dir}" x86_64-efi "${efi_dir}"/efi/boot/bootx64.efi "part_msdos fat" + # build bootia32.efi +- make_image "${efi32_dir}" i386-efi "${efi_dir}"/efi/boot/bootia32.efi "" ++ make_image "${efi32_dir}" i386-efi "${efi_dir}"/efi/boot/bootia32.efi "part_msdos fat" + if [ -e "${efi_dir}"/efi/boot/bootia32.efi ]; then + # For old macs. Suggested by Peter Jones. + cp "${efi_dir}"/efi/boot/bootia32.efi "${efi_dir}"/efi/boot/boot.efi diff --git a/master/debian/no_libzfs.patch b/master/debian/no_libzfs.patch new file mode 100644 index 0000000..5b9b7eb --- /dev/null +++ b/master/debian/no_libzfs.patch @@ -0,0 +1,227 @@ +--- a/grub-core/kern/emu/getroot.c ++++ b/grub-core/kern/emu/getroot.c +@@ -32,6 +32,9 @@ + #include + #include + #include ++#ifdef HAVE_LIMITS_H ++#include ++#endif + #include + #include + +@@ -238,7 +241,67 @@ + + #endif /* __linux__ */ + +-#if defined(HAVE_LIBZFS) && defined(HAVE_LIBNVPAIR) ++static char * ++find_device_from_pool (const char *poolname) ++{ ++ char *device; ++ char *cmd; ++ FILE *fp; ++ int ret; ++ char *line; ++ size_t len; ++ int st; ++ ++ char name[PATH_MAX], state[256], readlen[256], writelen[256], cksum[256], notes[256]; ++ unsigned int dummy; ++ ++ cmd = xasprintf ("zpool status %s", poolname); ++ fp = popen (cmd, "r"); ++ free (cmd); ++ ++ st = 0; ++ while (st < 3) ++ { ++ line = NULL; ++ ret = getline (&line, &len, fp); ++ if (ret == -1) ++ { ++ pclose (fp); ++ return NULL; ++ } ++ ++ if (sscanf (line, " %s %s %s %s %s %s", name, state, readlen, writelen, cksum, notes) >= 5) ++ switch (st) ++ { ++ case 0: ++ if (!strcmp (name, "NAME") ++ && !strcmp (state, "STATE") ++ && !strcmp (readlen, "READ") ++ && !strcmp (writelen, "WRITE") ++ && !strcmp (cksum, "CKSUM")) ++ st++; ++ break; ++ case 1: ++ if (!strcmp (name, poolname)) ++ st++; ++ break; ++ case 2: ++ if (strcmp (name, "mirror") && !sscanf (name, "mirror-%u", &dummy) ++ && !sscanf (name, "raidz%u", &dummy) ++ && !strcmp (state, "ONLINE")) ++ st++; ++ break; ++ } ++ ++ free (line); ++ } ++ pclose (fp); ++ ++ device = xasprintf ("/dev/%s", name); ++ ++ return device; ++} ++ + static char * + find_root_device_from_libzfs (const char *dir) + { +@@ -250,49 +313,7 @@ + if (! poolname) + return NULL; + +- { +- zpool_handle_t *zpool; +- libzfs_handle_t *libzfs; +- nvlist_t *config, *vdev_tree; +- nvlist_t **children, **path; +- unsigned int nvlist_count; +- unsigned int i; +- +- libzfs = grub_get_libzfs_handle (); +- if (! libzfs) +- return NULL; +- +- zpool = zpool_open (libzfs, poolname); +- config = zpool_get_config (zpool, NULL); +- +- if (nvlist_lookup_nvlist (config, "vdev_tree", &vdev_tree) != 0) +- error (1, errno, "nvlist_lookup_nvlist (\"vdev_tree\")"); +- +- if (nvlist_lookup_nvlist_array (vdev_tree, "children", &children, &nvlist_count) != 0) +- error (1, errno, "nvlist_lookup_nvlist_array (\"children\")"); +- assert (nvlist_count > 0); +- +- while (nvlist_lookup_nvlist_array (children[0], "children", +- &children, &nvlist_count) == 0) +- assert (nvlist_count > 0); +- +- for (i = 0; i < nvlist_count; i++) +- { +- if (nvlist_lookup_string (children[i], "path", &device) != 0) +- error (1, errno, "nvlist_lookup_string (\"path\")"); +- +- struct stat st; +- if (stat (device, &st) == 0) +- { +- device = xstrdup (device); +- break; +- } +- +- device = NULL; +- } +- +- zpool_close (zpool); +- } ++ device = find_device_from_pool (poolname); + + free (poolname); + if (poolfs) +@@ -300,7 +321,6 @@ + + return device; + } +-#endif + + #ifdef __MINGW32__ + +@@ -603,10 +623,8 @@ + os_dev = grub_find_root_device_from_mountinfo (dir, NULL); + #endif /* __linux__ */ + +-#if defined(HAVE_LIBZFS) && defined(HAVE_LIBNVPAIR) + if (!os_dev) + os_dev = find_root_device_from_libzfs (dir); +-#endif + + if (os_dev) + { +@@ -708,7 +726,7 @@ + } + + int +-grub_util_get_dev_abstraction (const char *os_dev __attribute__((unused))) ++grub_util_get_dev_abstraction (const char *os_dev) + { + #if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) + /* User explicitly claims that this drive is visible by BIOS. */ +--- a/grub-core/kern/emu/misc.c ++++ b/grub-core/kern/emu/misc.c +@@ -287,7 +287,6 @@ + } + #endif /* HAVE_LIBZFS */ + +-#if defined(HAVE_LIBZFS) && defined(HAVE_LIBNVPAIR) + /* ZFS has similar problems to those of btrfs (see above). */ + void + grub_find_zpool_from_dir (const char *dir, char **poolname, char **poolfs) +@@ -348,7 +347,6 @@ + else + *poolfs = xstrdup (""); + } +-#endif + + /* This function never prints trailing slashes (so that its output + can be appended a slash unconditionally). */ +@@ -361,22 +359,18 @@ + dev_t num; + size_t len; + +-#if defined(HAVE_LIBZFS) && defined(HAVE_LIBNVPAIR) + char *poolfs = NULL; +-#endif + + /* canonicalize. */ + p = canonicalize_file_name (path); + if (p == NULL) + grub_util_error ("failed to get canonical path of %s", path); + +-#if defined(HAVE_LIBZFS) && defined(HAVE_LIBNVPAIR) + /* For ZFS sub-pool filesystems, could be extended to others (btrfs?). */ + { + char *dummy; + grub_find_zpool_from_dir (p, &dummy, &poolfs); + } +-#endif + + len = strlen (p) + 1; + buf = xstrdup (p); +@@ -428,10 +422,8 @@ + } + #endif + free (buf2); +-#if defined(HAVE_LIBZFS) && defined(HAVE_LIBNVPAIR) + if (poolfs) + return xasprintf ("/%s/@", poolfs); +-#endif + return xstrdup (""); + } + else +@@ -488,14 +480,12 @@ + len--; + } + +-#if defined(HAVE_LIBZFS) && defined(HAVE_LIBNVPAIR) + if (poolfs) + { + ret = xasprintf ("/%s/@%s", poolfs, buf3); + free (buf3); + } + else +-#endif + ret = buf3; + + return ret; diff --git a/master/debian/olpc_prefix_hack.patch b/master/debian/olpc_prefix_hack.patch new file mode 100644 index 0000000..79c2a5b --- /dev/null +++ b/master/debian/olpc_prefix_hack.patch @@ -0,0 +1,50 @@ + +This sucks, but it's better than what OFW was giving us. + +Index: b/grub-core/kern/ieee1275/init.c +=================================================================== +--- a/grub-core/kern/ieee1275/init.c ++++ b/grub-core/kern/ieee1275/init.c +@@ -53,6 +53,7 @@ + grub_ieee1275_exit (); + } + ++#ifndef __i386__ + /* Translate an OF filesystem path (separated by backslashes), into a GRUB + path (separated by forward slashes). */ + static void +@@ -67,13 +68,16 @@ + backslash = grub_strchr (filepath, '\\'); + } + } ++#endif + + void + grub_machine_set_prefix (void) + { ++#ifndef __i386__ + char bootpath[64]; /* XXX check length */ + char *filename; + char *prefix; ++#endif + + if (grub_prefix[0]) + { +@@ -82,6 +86,9 @@ + return; + } + ++#ifdef __i386__ ++ grub_env_set ("prefix", "(sd,1)/"); ++#else + if (grub_ieee1275_get_property (grub_ieee1275_chosen, "bootpath", &bootpath, + sizeof (bootpath), 0)) + { +@@ -120,6 +127,7 @@ + + grub_free (filename); + grub_free (prefix); ++#endif + } + + /* Claim some available memory in the first /memory node. */ diff --git a/master/debian/partition_performance.patch b/master/debian/partition_performance.patch new file mode 100644 index 0000000..79fb453 --- /dev/null +++ b/master/debian/partition_performance.patch @@ -0,0 +1,36 @@ +Description: Give up scanning partitions after ten consecutive open failures + Scanning all the way up to 10000 is excessive and can cause serious + performance problems in some configurations. +Author: Colin Watson +Bug-Ubuntu: https://bugs.launchpad.net/bugs/787461 +Forwarded: yes +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3320 +Last-Update: 2011-05-27 + +Index: b/grub-core/kern/emu/hostdisk.c +=================================================================== +--- a/grub-core/kern/emu/hostdisk.c ++++ b/grub-core/kern/emu/hostdisk.c +@@ -564,6 +564,7 @@ + int i; + char real_dev[PATH_MAX]; + struct linux_partition_cache *cache; ++ int missing = 0; + + strcpy(real_dev, dev); + +@@ -602,7 +603,13 @@ + + fd = open (real_dev, O_RDONLY); + if (fd == -1) +- continue; ++ { ++ if (missing++ < 10) ++ continue; ++ else ++ return 0; ++ } ++ missing = 0; + close (fd); + + start = find_partition_start (real_dev); diff --git a/master/debian/probe_canonicalise.patch b/master/debian/probe_canonicalise.patch new file mode 100644 index 0000000..ba40995 --- /dev/null +++ b/master/debian/probe_canonicalise.patch @@ -0,0 +1,26 @@ +Description: Canonicalise path argument to grub-probe + This fixes use of "/path/.." as in grub-install for EFI, as well as + handling symlinks correctly. +Author: Mario Limonciello +Author: Colin Watson +Bug-Debian: http://bugs.debian.org/637768 +Forwarded: yes +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3401 +Last-Update: 2011-08-15 + +Index: b/util/grub-probe.c +=================================================================== +--- a/util/grub-probe.c ++++ b/util/grub-probe.c +@@ -108,7 +108,10 @@ + #endif + } + else +- device_name = grub_guess_root_device (path); ++ { ++ grub_path = canonicalize_file_name (path); ++ device_name = grub_guess_root_device (grub_path); ++ } + + if (! device_name) + grub_util_error ("cannot find a device for %s (is /dev mounted?)", path); diff --git a/master/debian/qemu_img_exists.patch b/master/debian/qemu_img_exists.patch new file mode 100644 index 0000000..b560067 --- /dev/null +++ b/master/debian/qemu_img_exists.patch @@ -0,0 +1,18 @@ +Description: Skip partmap test if qemu-img doesn't exist (e.g. on the Hurd) +Author: Colin Watson +Forwarded: no +Last-Update: 2010-11-22 + +Index: b/tests/partmap_test.in +=================================================================== +--- a/tests/partmap_test.in ++++ b/tests/partmap_test.in +@@ -51,6 +51,8 @@ + echo + } + ++which qemu-img >/dev/null 2>&1 || exit 77 ++ + imgfile=`mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` || exit 1 + outfile=`mktemp "${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` || exit 1 + diff --git a/master/debian/series b/master/debian/series new file mode 100644 index 0000000..95505f9 --- /dev/null +++ b/master/debian/series @@ -0,0 +1,45 @@ +olpc_prefix_hack.patch +core_in_fs.patch +dpkg_version_comparison.patch +grub_legacy_0_based_partitions.patch +disable_floppies.patch +grub.cfg_400.patch +gfxpayload_keep_default.patch +mkrescue_diet.patch +mkconfig_skip_dmcrypt.patch +install_stage2_confusion.patch +qemu_img_exists.patch +branch_devmapper.patch +branch_squash.patch +branch_longlinuxcmd.patch +branch_parse-color.patch +branch_embed-sectors.patch +branch_fuse.patch +mkrescue_efi_modules.patch +mkconfig_loopback.patch +lazy_stat.patch +btrfs_stat.patch +partition_performance.patch +kfreebsd-9_ada_devices.patch +gfxterm_background.patch +zfs_packed_la_array.patch +xen_replace.patch +kfreebsd_mfi_devices.patch +probe_canonicalise.patch +mkconfig_skip_readme.patch +kfreebsd_lvm.patch +zfs_update.patch +no_libzfs.patch +xfs_invalid_bmap.patch +handle_new_autotools.patch +bash-completion_identifiers.patch +mkconfig_gnumach.patch +gcc_4_6_space.patch +lzo.patch +fat_uuid.patch +efiemu_fix.patch +4k_sectors.patch +efi_disk_cache.patch +dirlen.patch +hurd.patch +userland-part.patch diff --git a/master/debian/userland-part.patch b/master/debian/userland-part.patch new file mode 100644 index 0000000..16d2156 --- /dev/null +++ b/master/debian/userland-part.patch @@ -0,0 +1,149 @@ +Description: Handle hurd userspace partitions. +Author: Samuel Thibault +Origin: upstream, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/4290 +Forwarded: not-needed +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/4290 +Last-Update: 2012-06-08 + +--- a/grub-core/kern/emu/getroot.c 2012-05-03 20:59:16 +0000 ++++ b/grub-core/kern/emu/getroot.c 2012-05-03 21:41:46 +0000 +@@ -337,6 +337,75 @@ + + #elif defined (__GNU__) + ++static char * ++find_hurd_root_device (const char *path) ++{ ++ file_t file; ++ error_t err; ++ char *argz = NULL, *name = NULL, *ret; ++ size_t argz_len = 0; ++ int i; ++ ++ file = file_name_lookup (path, 0, 0); ++ if (file == MACH_PORT_NULL) ++ grub_util_error ("cannot open `%s': %s", path, strerror (errno)); ++ ++ /* This returns catenated 0-terminated strings. */ ++ err = file_get_fs_options (file, &argz, &argz_len); ++ if (err) ++ grub_util_error ("cannot get filesystem options " ++ "for path `%s': %s", path, strerror(err)); ++ if (argz_len == 0) ++ /* TRANSLATORS: a "translator" is similar to a filesystem, but handled by a ++ * userland daemon. */ ++ grub_util_error ("translator is empty for path `%s'", path); ++ ++ /* Make sure the string is terminated. */ ++ argz[argz_len-1] = 0; ++ ++ /* Skip first word (translator path) and options. */ ++ for (i = strlen (argz) + 1; i < argz_len; i += strlen (argz + i) + 1) ++ { ++ if (argz[i] != '-') ++ { ++ /* Non-option. Only accept one, assumed to be the FS path. */ ++ /* XXX: this should be replaced by an RPC to the translator. */ ++ if (name) ++ /* TRANSLATORS: we expect to get something like ++ /hurd/foobar --option1 --option2=baz /dev/something ++ */ ++ grub_util_error ("translator `%s' for path `%s' has several " ++ "non-option words, at least `%s' and `%s'", ++ argz, path, name, argz + i); ++ name = argz + i; ++ } ++ } ++ ++ if (!name) ++ /* TRANSLATORS: we expect to get something like ++ /hurd/foobar --option1 --option2=baz /dev/something ++ */ ++ grub_util_error ("translator `%s' for path `%s' is given only options, " ++ "cannot find device part", argz, path); ++ ++ if (strncmp (name, "device:", sizeof ("device:") - 1) == 0) ++ { ++ char *dev_name = name + sizeof ("device:") - 1; ++ size_t size = sizeof ("/dev/") - 1 + strlen (dev_name) + 1; ++ char *next; ++ ret = malloc (size); ++ next = stpncpy (ret, "/dev/", size); ++ stpncpy (next, dev_name, size - (next - ret)); ++ } ++ else if (!strncmp (name, "file:", sizeof ("file:") - 1)) ++ ret = strdup (name + sizeof ("file:") - 1); ++ else ++ ret = strdup (name); ++ ++ munmap (argz, argz_len); ++ return ret; ++} ++ + #elif ! defined(__CYGWIN__) + + char * +@@ -565,61 +634,8 @@ + { + char *os_dev = NULL; + #ifdef __GNU__ +- file_t file; +- mach_port_t *ports; +- int *ints; +- loff_t *offsets; +- char *data; +- error_t err; +- mach_msg_type_number_t num_ports = 0, num_ints = 0, num_offsets = 0, data_len = 0; +- size_t name_len; +- +- file = file_name_lookup (dir, 0, 0); +- if (file == MACH_PORT_NULL) +- return 0; +- +- err = file_get_storage_info (file, +- &ports, &num_ports, +- &ints, &num_ints, +- &offsets, &num_offsets, +- &data, &data_len); +- +- if (num_ints < 1) +- grub_util_error ("Storage info for `%s' does not include type", dir); +- if (ints[0] != STORAGE_DEVICE) +- grub_util_error ("Filesystem of `%s' is not stored on local disk", dir); +- +- if (num_ints < 5) +- grub_util_error ("Storage info for `%s' does not include name", dir); +- name_len = ints[4]; +- if (name_len < data_len) +- grub_util_error ("Bogus name length for storage info for `%s'", dir); +- if (data[name_len - 1] != '\0') +- grub_util_error ("Storage name for `%s' not NUL-terminated", dir); +- +- os_dev = xmalloc (strlen ("/dev/") + data_len); +- memcpy (os_dev, "/dev/", strlen ("/dev/")); +- memcpy (os_dev + strlen ("/dev/"), data, data_len); +- +- if (ports && num_ports > 0) +- { +- mach_msg_type_number_t i; +- for (i = 0; i < num_ports; i++) +- { +- mach_port_t port = ports[i]; +- if (port != MACH_PORT_NULL) +- mach_port_deallocate (mach_task_self(), port); +- } +- munmap ((caddr_t) ports, num_ports * sizeof (*ports)); +- } +- +- if (ints && num_ints > 0) +- munmap ((caddr_t) ints, num_ints * sizeof (*ints)); +- if (offsets && num_offsets > 0) +- munmap ((caddr_t) offsets, num_offsets * sizeof (*offsets)); +- if (data && data_len > 0) +- munmap (data, data_len); +- mach_port_deallocate (mach_task_self (), file); ++ /* GNU/Hurd specific function. */ ++ os_dev = find_hurd_root_device (dir); + #else /* !__GNU__ */ + struct stat st; + dev_t dev; diff --git a/master/debian/xen_replace.patch b/master/debian/xen_replace.patch new file mode 100644 index 0000000..84df6b3 --- /dev/null +++ b/master/debian/xen_replace.patch @@ -0,0 +1,64 @@ +Description: New GRUB_CMDLINE_LINUX_XEN_REPLACE* options + Honour GRUB_CMDLINE_LINUX_XEN_REPLACE and + GRUB_CMDLINE_LINUX_XEN_REPLACE_DEFAULT, which replace GRUB_CMDLINE_LINUX + and GRUB_CMDLINE_LINUX_DEFAULT (complementing the existing options which + append). +Author: Colin Watson +Bug-Debian: http://bugs.debian.org/617538 +Forwarded: yes +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3294 +Last-Update: 2011-08-08 + +Index: b/docs/grub.texi +=================================================================== +--- a/docs/grub.texi ++++ b/docs/grub.texi +@@ -1169,8 +1169,14 @@ + + @item GRUB_CMDLINE_XEN + @itemx GRUB_CMDLINE_XEN_DEFAULT +-As @samp{GRUB_CMDLINE_LINUX} and @samp{GRUB_CMDLINE_LINUX_DEFAULT}, but for +-Linux and Xen. ++The values of these options are appended to the values of ++@samp{GRUB_CMDLINE_LINUX} and @samp{GRUB_CMDLINE_LINUX_DEFAULT} for Linux ++and Xen menu entries. ++ ++@item GRUB_CMDLINE_LINUX_XEN_REPLACE ++@item GRUB_CMDLINE_LINUX_XEN_REPLACE_DEFAULT ++The values of these options replace the values of @samp{GRUB_CMDLINE_LINUX} ++and @samp{GRUB_CMDLINE_LINUX_DEFAULT} for Linux and Xen menu entries. + + @item GRUB_DISABLE_LINUX_UUID + Normally, @command{grub-mkconfig} will generate menu entries that use +Index: b/util/grub.d/20_linux_xen.in +=================================================================== +--- a/util/grub.d/20_linux_xen.in ++++ b/util/grub.d/20_linux_xen.in +@@ -56,6 +56,14 @@ + LINUX_ROOT_DEVICE=UUID=${GRUB_DEVICE_UUID} + fi + ++# Allow overriding GRUB_CMDLINE_LINUX and GRUB_CMDLINE_LINUX_DEFAULT. ++if [ "${GRUB_CMDLINE_LINUX_XEN_REPLACE}" ]; then ++ GRUB_CMDLINE_LINUX="${GRUB_CMDLINE_LINUX_XEN_REPLACE}" ++fi ++if [ "${GRUB_CMDLINE_LINUX_XEN_REPLACE_DEFAULT}" ]; then ++ GRUB_CMDLINE_LINUX_DEFAULT="${GRUB_CMDLINE_LINUX_XEN_REPLACE_DEFAULT}" ++fi ++ + if [ "x`${grub_probe} --device ${GRUB_DEVICE} --target=fs 2>/dev/null || true`" = xbtrfs ] \ + || [ "x`stat -f --printf=%T /`" = xbtrfs ]; then + rootsubvol="`make_system_path_relative_to_its_root /`" +Index: b/util/grub-mkconfig.in +=================================================================== +--- a/util/grub-mkconfig.in ++++ b/util/grub-mkconfig.in +@@ -239,6 +239,8 @@ + GRUB_CMDLINE_LINUX_DEFAULT \ + GRUB_CMDLINE_XEN \ + GRUB_CMDLINE_XEN_DEFAULT \ ++ GRUB_CMDLINE_LINUX_XEN_REPLACE \ ++ GRUB_CMDLINE_LINUX_XEN_REPLACE_DEFAULT \ + GRUB_CMDLINE_NETBSD \ + GRUB_CMDLINE_NETBSD_DEFAULT \ + GRUB_TERMINAL_INPUT \ diff --git a/master/debian/xfs_invalid_bmap.patch b/master/debian/xfs_invalid_bmap.patch new file mode 100644 index 0000000..71d04de --- /dev/null +++ b/master/debian/xfs_invalid_bmap.patch @@ -0,0 +1,188 @@ +Description: Rewrite XFS btree parsing; fixes invalid BMAP +Author: Vladimir Serbinenko +Bug: http://savannah.gnu.org/bugs/?34213 +Bug-Debian: http://bugs.debian.org/657776 +Applied-Upstream: http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3443 +Last-Update: 2012-01-29 + +Index: b/grub-core/fs/xfs.c +=================================================================== +--- a/grub-core/fs/xfs.c ++++ b/grub-core/fs/xfs.c +@@ -111,7 +111,9 @@ + grub_uint64_t nblocks; + grub_uint32_t extsize; + grub_uint32_t nextents; +- grub_uint8_t unused3[20]; ++ grub_uint16_t unused3; ++ grub_uint8_t fork_offset; ++ grub_uint8_t unused4[17]; + union + { + char raw[156]; +@@ -145,7 +147,7 @@ + grub_disk_t disk; + int pos; + int bsize; +- int agsize; ++ grub_uint32_t agsize; + struct grub_fshelp_node diropen; + }; + +@@ -159,33 +161,67 @@ + #define FILETYPE_INO_DIRECTORY 0040000 + #define FILETYPE_INO_SYMLINK 0120000 + +-#define GRUB_XFS_INO_AGBITS(data) \ +- ((data)->sblock.log2_agblk + (data)->sblock.log2_inop) +-#define GRUB_XFS_INO_INOINAG(data, ino) \ +- (grub_be_to_cpu64 (ino) & ((1LL << GRUB_XFS_INO_AGBITS (data)) - 1)) +-#define GRUB_XFS_INO_AG(data,ino) \ +- (grub_be_to_cpu64 (ino) >> GRUB_XFS_INO_AGBITS (data)) +- +-#define GRUB_XFS_FSB_TO_BLOCK(data, fsb) \ +- (((fsb) >> (data)->sblock.log2_agblk) * (data)->agsize \ +- + ((fsb) & ((1LL << (data)->sblock.log2_agblk) - 1))) +- +-#define GRUB_XFS_EXTENT_OFFSET(exts,ex) \ +- ((grub_be_to_cpu32 (exts[ex][0]) & ~(1 << 31)) << 23 \ +- | grub_be_to_cpu32 (exts[ex][1]) >> 9) +- +-#define GRUB_XFS_EXTENT_BLOCK(exts,ex) \ +- ((grub_uint64_t) (grub_be_to_cpu32 (exts[ex][1]) \ +- & (0x1ff)) << 43 \ +- | (grub_uint64_t) grub_be_to_cpu32 (exts[ex][2]) << 11 \ +- | grub_be_to_cpu32 (exts[ex][3]) >> 21) +- +-#define GRUB_XFS_EXTENT_SIZE(exts,ex) \ +- (grub_be_to_cpu32 (exts[ex][3]) & ((1 << 20) - 1)) +- +-#define GRUB_XFS_ROUND_TO_DIRENT(pos) ((((pos) + 8 - 1) / 8) * 8) +-#define GRUB_XFS_NEXT_DIRENT(pos,len) \ +- (pos) + GRUB_XFS_ROUND_TO_DIRENT (8 + 1 + len + 2) ++static inline int ++GRUB_XFS_INO_AGBITS(struct grub_xfs_data *data) ++{ ++ return ((data)->sblock.log2_agblk + (data)->sblock.log2_inop); ++} ++ ++static inline grub_uint64_t ++GRUB_XFS_INO_INOINAG (struct grub_xfs_data *data, ++ grub_uint64_t ino) ++{ ++ return (grub_be_to_cpu64 (ino) & ((1LL << GRUB_XFS_INO_AGBITS (data)) - 1)); ++} ++ ++static inline grub_uint64_t ++GRUB_XFS_INO_AG (struct grub_xfs_data *data, ++ grub_uint64_t ino) ++{ ++ return (grub_be_to_cpu64 (ino) >> GRUB_XFS_INO_AGBITS (data)); ++} ++ ++static inline grub_disk_addr_t ++GRUB_XFS_FSB_TO_BLOCK (struct grub_xfs_data *data, grub_disk_addr_t fsb) ++{ ++ return ((fsb >> data->sblock.log2_agblk) * data->agsize ++ + (fsb & ((1LL << data->sblock.log2_agblk) - 1))); ++} ++ ++static inline grub_uint64_t ++GRUB_XFS_EXTENT_OFFSET (grub_xfs_extent *exts, int ex) ++{ ++ return ((grub_be_to_cpu32 (exts[ex][0]) & ~(1 << 31)) << 23 ++ | grub_be_to_cpu32 (exts[ex][1]) >> 9); ++} ++ ++static inline grub_uint64_t ++GRUB_XFS_EXTENT_BLOCK (grub_xfs_extent *exts, int ex) ++{ ++ return ((grub_uint64_t) (grub_be_to_cpu32 (exts[ex][1]) ++ & (0x1ff)) << 43 ++ | (grub_uint64_t) grub_be_to_cpu32 (exts[ex][2]) << 11 ++ | grub_be_to_cpu32 (exts[ex][3]) >> 21); ++} ++ ++static inline grub_uint64_t ++GRUB_XFS_EXTENT_SIZE (grub_xfs_extent *exts, int ex) ++{ ++ return (grub_be_to_cpu32 (exts[ex][3]) & ((1 << 20) - 1)); ++} ++ ++static inline int ++GRUB_XFS_ROUND_TO_DIRENT (int pos) ++{ ++ return ((((pos) + 8 - 1) / 8) * 8); ++} ++ ++static inline int ++GRUB_XFS_NEXT_DIRENT (int pos, int len) ++{ ++ return (pos) + GRUB_XFS_ROUND_TO_DIRENT (8 + 1 + len + 2); ++} ++ + + static inline grub_uint64_t + grub_xfs_inode_block (struct grub_xfs_data *data, +@@ -241,13 +277,23 @@ + if (node->inode.format == XFS_INODE_FORMAT_BTREE) + { + grub_uint64_t *keys; ++ int recoffset; + +- leaf = grub_malloc (node->data->sblock.bsize); ++ leaf = grub_malloc (node->data->bsize); + if (leaf == 0) + return 0; + + nrec = grub_be_to_cpu16 (node->inode.data.btree.numrecs); + keys = &node->inode.data.btree.keys[0]; ++ if (node->inode.fork_offset) ++ recoffset = (node->inode.fork_offset ++ - ((char *) &node->inode.data.btree.keys - (char *) &node->inode)) ++ / (2 * sizeof (grub_uint64_t)); ++ else ++ recoffset = ((1 << node->data->sblock.log2_inode) ++ - ((char *) &node->inode.data.btree.keys ++ - (char *) &node->inode)) ++ / (2 * sizeof (grub_uint64_t)); + do + { + int i; +@@ -264,12 +310,9 @@ + grub_free (leaf); + return 0; + } +- + if (grub_disk_read (node->data->disk, +- grub_be_to_cpu64 (keys[i - 1 + nrec]) +- << (node->data->sblock.log2_bsize +- - GRUB_DISK_SECTOR_BITS), +- 0, node->data->sblock.bsize, leaf)) ++ GRUB_XFS_FSB_TO_BLOCK (node->data, grub_be_to_cpu64 (keys[i - 1 + recoffset])) << (node->data->sblock.log2_bsize - GRUB_DISK_SECTOR_BITS), ++ 0, node->data->bsize, leaf)) + return 0; + + if (grub_strncmp ((char *) leaf->magic, "BMAP", 4)) +@@ -281,7 +324,11 @@ + + nrec = grub_be_to_cpu16 (leaf->numrecs); + keys = &leaf->keys[0]; +- } while (leaf->level); ++ recoffset = ((node->data->bsize - ((char *) &leaf->keys ++ - (char *) leaf)) ++ / (2 * sizeof (grub_uint64_t))); ++ } ++ while (leaf->level); + exts = (grub_xfs_extent *) keys; + } + else if (node->inode.format == XFS_INODE_FORMAT_EXT) +@@ -328,7 +375,7 @@ + grub_xfs_read_file (grub_fshelp_node_t node, + void NESTED_FUNC_ATTR (*read_hook) (grub_disk_addr_t sector, + unsigned offset, unsigned length), +- int pos, grub_size_t len, char *buf) ++ grub_off_t pos, grub_size_t len, char *buf) + { + return grub_fshelp_read_file (node->data->disk, node, read_hook, + pos, len, buf, grub_xfs_read_block, diff --git a/master/debian/zfs_packed_la_array.patch b/master/debian/zfs_packed_la_array.patch new file mode 100644 index 0000000..e31778b --- /dev/null +++ b/master/debian/zfs_packed_la_array.patch @@ -0,0 +1,17 @@ +2011-08-03 Robert Millan + + * include/grub/zfs/zap_leaf.h (typedef union zap_leaf_chunk): Mark + la_array as packed. + Reported by: Zachary Bedell + +--- a/include/grub/zfs/zap_leaf.h ++++ b/include/grub/zfs/zap_leaf.h +@@ -90,7 +90,7 @@ + { + grub_uint8_t la_array[ZAP_LEAF_ARRAY_BYTES]; + grub_uint64_t la_array64; +- }; ++ } __attribute__ ((packed)); + grub_uint16_t la_next; /* next blk or CHAIN_END */ + } l_array; + struct zap_leaf_free { diff --git a/master/debian/zfs_update.patch b/master/debian/zfs_update.patch new file mode 100644 index 0000000..12e4599 --- /dev/null +++ b/master/debian/zfs_update.patch @@ -0,0 +1,2415 @@ + +Revisions: + +3340: ZFS zlib support +3474: Fix 2G limit on ZFS +3486: ZFS fixes +3488: ZFS multi-device and version 33 support +3494: Fix memory leak +3518: Rewrite RAIDZ part based on reverse engineering +3519: Fix RAIDZ(2) for >= 5 devices +3520: Add ability to sustain a single drive failure on both raidz and raidz2 +3521: Support raidz3 +3533: Support second redundancy strip on raidz(2,3) +3534: Support case-insensitive ZFS subvolumes +3535: Support third redundancy strip on raidz3 + +--- a/grub-core/fs/zfs/zfs.c ++++ b/grub-core/fs/zfs/zfs.c +@@ -51,6 +51,7 @@ + #include + #include + #include ++#include + + GRUB_MOD_LICENSE ("GPLv3+"); + +@@ -139,6 +140,27 @@ + grub_zfs_endian_t endian; + } dnode_end_t; + ++struct grub_zfs_device_desc ++{ ++ enum { DEVICE_LEAF, DEVICE_MIRROR, DEVICE_RAIDZ } type; ++ grub_uint64_t id; ++ grub_uint64_t guid; ++ ++ /* Valid only for non-leafs. */ ++ unsigned n_children; ++ struct grub_zfs_device_desc *children; ++ ++ /* Valid only for RAIDZ. */ ++ unsigned nparity; ++ unsigned ashift; ++ ++ /* Valid only for leaf devices. */ ++ grub_device_t dev; ++ grub_disk_addr_t vdev_phys_sector; ++ uberblock_t current_uberblock; ++ int original; ++}; ++ + struct grub_zfs_data + { + /* cache for a file block of the currently zfs_open()-ed file */ +@@ -153,23 +175,45 @@ + grub_uint64_t dnode_end; + grub_zfs_endian_t dnode_endian; + +- uberblock_t current_uberblock; +- grub_disk_t disk; +- + dnode_end_t mos; + dnode_end_t mdn; + dnode_end_t dnode; + +- grub_disk_addr_t vdev_phys_sector; ++ struct grub_zfs_device_desc *devices_attached; ++ unsigned n_devices_attached; ++ unsigned n_devices_allocated; ++ struct grub_zfs_device_desc *device_original; ++ ++ uberblock_t current_uberblock; ++ ++ int mounted; ++ grub_uint64_t guid; + }; + ++static grub_err_t ++zlib_decompress (void *s, void *d, ++ grub_size_t slen, grub_size_t dlen) ++{ ++ if (grub_zlib_decompress (s, slen, 0, d, dlen) < 0) ++ return grub_errno; ++ return GRUB_ERR_NONE; ++} ++ + static decomp_entry_t decomp_table[ZIO_COMPRESS_FUNCTIONS] = { + {"inherit", NULL}, /* ZIO_COMPRESS_INHERIT */ + {"on", lzjb_decompress}, /* ZIO_COMPRESS_ON */ + {"off", NULL}, /* ZIO_COMPRESS_OFF */ + {"lzjb", lzjb_decompress}, /* ZIO_COMPRESS_LZJB */ + {"empty", NULL}, /* ZIO_COMPRESS_EMPTY */ +- {"gzip", NULL}, /* ZIO_COMPRESS_GZIP */ ++ {"gzip-1", zlib_decompress}, /* ZIO_COMPRESS_GZIP1 */ ++ {"gzip-2", zlib_decompress}, /* ZIO_COMPRESS_GZIP2 */ ++ {"gzip-3", zlib_decompress}, /* ZIO_COMPRESS_GZIP3 */ ++ {"gzip-4", zlib_decompress}, /* ZIO_COMPRESS_GZIP4 */ ++ {"gzip-5", zlib_decompress}, /* ZIO_COMPRESS_GZIP5 */ ++ {"gzip-6", zlib_decompress}, /* ZIO_COMPRESS_GZIP6 */ ++ {"gzip-7", zlib_decompress}, /* ZIO_COMPRESS_GZIP7 */ ++ {"gzip-8", zlib_decompress}, /* ZIO_COMPRESS_GZIP8 */ ++ {"gzip-9", zlib_decompress}, /* ZIO_COMPRESS_GZIP9 */ + }; + + static grub_err_t zio_read_data (blkptr_t * bp, grub_zfs_endian_t endian, +@@ -224,7 +268,7 @@ + */ + static grub_err_t + zio_checksum_verify (zio_cksum_t zc, grub_uint32_t checksum, +- grub_zfs_endian_t endian, char *buf, int size) ++ grub_zfs_endian_t endian, char *buf, grub_size_t size) + { + zio_eck_t *zec = (zio_eck_t *) (buf + size) - 1; + zio_checksum_info_t *ci = &zio_checksum_table[checksum]; +@@ -253,13 +297,13 @@ + || (actual_cksum.zc_word[2] != zc.zc_word[2]) + || (actual_cksum.zc_word[3] != zc.zc_word[3])) + { +- grub_dprintf ("zfs", "checksum %d verification failed\n", checksum); +- grub_dprintf ("zfs", "actual checksum %16llx %16llx %16llx %16llx\n", ++ grub_dprintf ("zfs", "checksum %s verification failed\n", ci->ci_name); ++ grub_dprintf ("zfs", "actual checksum %016llx %016llx %016llx %016llx\n", + (unsigned long long) actual_cksum.zc_word[0], + (unsigned long long) actual_cksum.zc_word[1], + (unsigned long long) actual_cksum.zc_word[2], + (unsigned long long) actual_cksum.zc_word[3]); +- grub_dprintf ("zfs", "expected checksum %16llx %16llx %16llx %16llx\n", ++ grub_dprintf ("zfs", "expected checksum %016llx %016llx %016llx %016llx\n", + (unsigned long long) zc.zc_word[0], + (unsigned long long) zc.zc_word[1], + (unsigned long long) zc.zc_word[2], +@@ -319,7 +363,7 @@ + * + */ + static grub_err_t +-uberblock_verify (uberblock_phys_t * ub, int offset) ++uberblock_verify (uberblock_phys_t * ub, grub_uint64_t offset) + { + uberblock_t *uber = &ub->ubp_uberblock; + grub_err_t err; +@@ -392,7 +436,7 @@ + } + + static grub_uint64_t +-dva_get_offset (dva_t * dva, grub_zfs_endian_t endian) ++dva_get_offset (const dva_t *dva, grub_zfs_endian_t endian) + { + grub_dprintf ("zfs", "dva=%llx, %llx\n", + (unsigned long long) dva->dva_word[0], +@@ -401,6 +445,842 @@ + endian) << SPA_MINBLOCKSHIFT; + } + ++static grub_err_t ++zfs_fetch_nvlist (struct grub_zfs_device_desc *diskdesc, char **nvlist) ++{ ++ grub_err_t err; ++ ++ *nvlist = grub_malloc (VDEV_PHYS_SIZE); ++ if (!diskdesc->dev) ++ return grub_error (GRUB_ERR_BAD_FS, "member drive unknown"); ++ ++ /* Read in the vdev name-value pair list (112K). */ ++ err = grub_disk_read (diskdesc->dev->disk, diskdesc->vdev_phys_sector, 0, ++ VDEV_PHYS_SIZE, *nvlist); ++ if (err) ++ { ++ grub_free (*nvlist); ++ *nvlist = 0; ++ return err; ++ } ++ return GRUB_ERR_NONE; ++} ++ ++static grub_err_t ++fill_vdev_info_real (struct grub_zfs_data *data, ++ const char *nvlist, ++ struct grub_zfs_device_desc *fill, ++ struct grub_zfs_device_desc *insert) ++{ ++ char *type; ++ ++ type = grub_zfs_nvlist_lookup_string (nvlist, ZPOOL_CONFIG_TYPE); ++ ++ if (!type) ++ return grub_errno; ++ ++ if (!grub_zfs_nvlist_lookup_uint64 (nvlist, "id", &(fill->id))) ++ return grub_error (GRUB_ERR_BAD_FS, "couldn't find vdev id"); ++ ++ if (!grub_zfs_nvlist_lookup_uint64 (nvlist, "guid", &(fill->guid))) ++ return grub_error (GRUB_ERR_BAD_FS, "couldn't find vdev id"); ++ ++ if (grub_strcmp (type, VDEV_TYPE_DISK) == 0 ++ || grub_strcmp (type, VDEV_TYPE_FILE) == 0) ++ { ++ fill->type = DEVICE_LEAF; ++ ++ if (!fill->dev && fill->guid == insert->guid) ++ { ++ fill->dev = insert->dev; ++ fill->vdev_phys_sector = insert->vdev_phys_sector; ++ fill->current_uberblock = insert->current_uberblock; ++ fill->original = insert->original; ++ if (!data->device_original) ++ data->device_original = fill; ++ } ++ ++ return GRUB_ERR_NONE; ++ } ++ ++ if (grub_strcmp (type, VDEV_TYPE_MIRROR) == 0 ++ || grub_strcmp (type, VDEV_TYPE_RAIDZ) == 0) ++ { ++ int nelm, i; ++ ++ if (grub_strcmp (type, VDEV_TYPE_MIRROR) == 0) ++ fill->type = DEVICE_MIRROR; ++ else ++ { ++ grub_uint64_t par; ++ fill->type = DEVICE_RAIDZ; ++ if (!grub_zfs_nvlist_lookup_uint64 (nvlist, "nparity", &par)) ++ return grub_error (GRUB_ERR_BAD_FS, "couldn't find raidz parity"); ++ fill->nparity = par; ++ if (!grub_zfs_nvlist_lookup_uint64 (nvlist, "ashift", &par)) ++ return grub_error (GRUB_ERR_BAD_FS, "couldn't find raidz ashift"); ++ fill->ashift = par; ++ } ++ ++ nelm = grub_zfs_nvlist_lookup_nvlist_array_get_nelm (nvlist, ZPOOL_CONFIG_CHILDREN); ++ ++ if (nelm <= 0) ++ return grub_error (GRUB_ERR_BAD_FS, "incorrect mirror VDEV"); ++ ++ if (!fill->children) ++ { ++ fill->n_children = nelm; ++ ++ fill->children = grub_zalloc (fill->n_children ++ * sizeof (fill->children[0])); ++ } ++ ++ for (i = 0; i < nelm; i++) ++ { ++ char *child; ++ grub_err_t err; ++ ++ child = grub_zfs_nvlist_lookup_nvlist_array ++ (nvlist, ZPOOL_CONFIG_CHILDREN, i); ++ ++ err = fill_vdev_info_real (data, child, &fill->children[i], insert); ++ ++ grub_free (child); ++ ++ if (err) ++ return err; ++ } ++ return GRUB_ERR_NONE; ++ } ++ ++ return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, "vdev %s isn't supported", ++ type); ++} ++ ++static grub_err_t ++fill_vdev_info (struct grub_zfs_data *data, ++ char *nvlist, struct grub_zfs_device_desc *diskdesc) ++{ ++ grub_uint64_t id; ++ unsigned i; ++ ++ if (!grub_zfs_nvlist_lookup_uint64 (nvlist, "id", &id)) ++ return grub_error (GRUB_ERR_BAD_FS, "couldn't find vdev id"); ++ ++ for (i = 0; i < data->n_devices_attached; i++) ++ if (data->devices_attached[i].id == id) ++ return fill_vdev_info_real (data, nvlist, &data->devices_attached[i], ++ diskdesc); ++ ++ data->n_devices_attached++; ++ if (data->n_devices_attached > data->n_devices_allocated) ++ { ++ void *tmp; ++ data->n_devices_allocated = 2 * data->n_devices_attached + 1; ++ data->devices_attached ++ = grub_realloc (tmp = data->devices_attached, ++ data->n_devices_allocated ++ * sizeof (data->devices_attached[0])); ++ if (!data->devices_attached) ++ { ++ data->devices_attached = tmp; ++ return grub_errno; ++ } ++ } ++ ++ grub_memset (&data->devices_attached[data->n_devices_attached - 1], ++ 0, sizeof (data->devices_attached[data->n_devices_attached - 1])); ++ ++ return fill_vdev_info_real (data, nvlist, ++ &data->devices_attached[data->n_devices_attached - 1], ++ diskdesc); ++} ++ ++/* ++ * Check the disk label information and retrieve needed vdev name-value pairs. ++ * ++ */ ++static grub_err_t ++check_pool_label (struct grub_zfs_data *data, ++ struct grub_zfs_device_desc *diskdesc) ++{ ++ grub_uint64_t pool_state, txg = 0; ++ char *nvlist; ++#if 0 ++ char *nv; ++#endif ++ grub_uint64_t poolguid; ++ grub_uint64_t version; ++ int found; ++ grub_err_t err; ++ ++ err = zfs_fetch_nvlist (diskdesc, &nvlist); ++ if (err) ++ return err; ++ ++ grub_dprintf ("zfs", "check 2 passed\n"); ++ ++ found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_STATE, ++ &pool_state); ++ if (! found) ++ { ++ grub_free (nvlist); ++ if (! grub_errno) ++ grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_POOL_STATE " not found"); ++ return grub_errno; ++ } ++ grub_dprintf ("zfs", "check 3 passed\n"); ++ ++ if (pool_state == POOL_STATE_DESTROYED) ++ { ++ grub_free (nvlist); ++ return grub_error (GRUB_ERR_BAD_FS, "zpool is marked as destroyed"); ++ } ++ grub_dprintf ("zfs", "check 4 passed\n"); ++ ++ found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_TXG, &txg); ++ if (!found) ++ { ++ grub_free (nvlist); ++ if (! grub_errno) ++ grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_POOL_TXG " not found"); ++ return grub_errno; ++ } ++ grub_dprintf ("zfs", "check 6 passed\n"); ++ ++ /* not an active device */ ++ if (txg == 0) ++ { ++ grub_free (nvlist); ++ return grub_error (GRUB_ERR_BAD_FS, "zpool isn't active"); ++ } ++ grub_dprintf ("zfs", "check 7 passed\n"); ++ ++ found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_VERSION, ++ &version); ++ if (! found) ++ { ++ grub_free (nvlist); ++ if (! grub_errno) ++ grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_VERSION " not found"); ++ return grub_errno; ++ } ++ grub_dprintf ("zfs", "check 8 passed\n"); ++ ++ if (version > SPA_VERSION) ++ { ++ grub_free (nvlist); ++ return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, ++ "too new version %llu > %llu", ++ (unsigned long long) version, ++ (unsigned long long) SPA_VERSION); ++ } ++ grub_dprintf ("zfs", "check 9 passed\n"); ++ ++ found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_GUID, ++ &(diskdesc->guid)); ++ if (! found) ++ { ++ grub_free (nvlist); ++ if (! grub_errno) ++ grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_GUID " not found"); ++ return grub_errno; ++ } ++ ++ found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_GUID, ++ &poolguid); ++ if (! found) ++ { ++ grub_free (nvlist); ++ if (! grub_errno) ++ grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_POOL_GUID " not found"); ++ return grub_errno; ++ } ++ ++ grub_dprintf ("zfs", "check 11 passed\n"); ++ ++ if (data->mounted && data->guid != poolguid) ++ return grub_error (GRUB_ERR_BAD_FS, "another zpool"); ++ else ++ data->guid = poolguid; ++ ++ { ++ char *nv; ++ nv = grub_zfs_nvlist_lookup_nvlist (nvlist, ZPOOL_CONFIG_VDEV_TREE); ++ ++ if (!nv) ++ { ++ grub_free (nvlist); ++ return grub_error (GRUB_ERR_BAD_FS, "couldn't find vdev tree"); ++ } ++ err = fill_vdev_info (data, nv, diskdesc); ++ if (err) ++ { ++ grub_free (nvlist); ++ return err; ++ } ++ } ++ grub_dprintf ("zfs", "check 10 passed\n"); ++ ++ grub_free (nvlist); ++ ++ return GRUB_ERR_NONE; ++} ++ ++static grub_err_t ++scan_disk (grub_device_t dev, struct grub_zfs_data *data, ++ int original) ++{ ++ int label = 0; ++ uberblock_phys_t *ub_array, *ubbest = NULL; ++ vdev_boot_header_t *bh; ++ grub_err_t err; ++ int vdevnum; ++ struct grub_zfs_device_desc desc; ++ ++ ub_array = grub_malloc (VDEV_UBERBLOCK_RING); ++ if (!ub_array) ++ return grub_errno; ++ ++ bh = grub_malloc (VDEV_BOOT_HEADER_SIZE); ++ if (!bh) ++ { ++ grub_free (ub_array); ++ return grub_errno; ++ } ++ ++ vdevnum = VDEV_LABELS; ++ ++ desc.dev = dev; ++ desc.original = original; ++ ++ /* Don't check back labels on CDROM. */ ++ if (grub_disk_get_size (dev->disk) == GRUB_DISK_SIZE_UNKNOWN) ++ vdevnum = VDEV_LABELS / 2; ++ ++ for (label = 0; ubbest == NULL && label < vdevnum; label++) ++ { ++ desc.vdev_phys_sector ++ = label * (sizeof (vdev_label_t) >> SPA_MINBLOCKSHIFT) ++ + ((VDEV_SKIP_SIZE + VDEV_BOOT_HEADER_SIZE) >> SPA_MINBLOCKSHIFT) ++ + (label < VDEV_LABELS / 2 ? 0 : grub_disk_get_size (dev->disk) ++ - VDEV_LABELS * (sizeof (vdev_label_t) >> SPA_MINBLOCKSHIFT)); ++ ++ /* Read in the uberblock ring (128K). */ ++ err = grub_disk_read (dev->disk, desc.vdev_phys_sector ++ + (VDEV_PHYS_SIZE >> SPA_MINBLOCKSHIFT), ++ 0, VDEV_UBERBLOCK_RING, (char *) ub_array); ++ if (err) ++ { ++ grub_errno = GRUB_ERR_NONE; ++ continue; ++ } ++ grub_dprintf ("zfs", "label ok %d\n", label); ++ ++ ubbest = find_bestub (ub_array, desc.vdev_phys_sector); ++ if (!ubbest) ++ { ++ grub_dprintf ("zfs", "No uberblock found\n"); ++ grub_errno = GRUB_ERR_NONE; ++ continue; ++ } ++ ++ grub_memmove (&(desc.current_uberblock), ++ &ubbest->ubp_uberblock, sizeof (uberblock_t)); ++ if (original) ++ grub_memmove (&(data->current_uberblock), ++ &ubbest->ubp_uberblock, sizeof (uberblock_t)); ++ ++ err = check_pool_label (data, &desc); ++ if (err) ++ { ++ grub_errno = GRUB_ERR_NONE; ++ continue; ++ } ++#if 0 ++ if (find_best_root && ++ vdev_uberblock_compare (&ubbest->ubp_uberblock, ++ &(current_uberblock)) <= 0) ++ continue; ++#endif ++ grub_free (ub_array); ++ grub_free (bh); ++ return GRUB_ERR_NONE; ++ } ++ ++ grub_free (ub_array); ++ grub_free (bh); ++ ++ return grub_error (GRUB_ERR_BAD_FS, "couldn't find a valid label"); ++} ++ ++static grub_err_t ++scan_devices (struct grub_zfs_data *data) ++{ ++ auto int hook (const char *name); ++ int hook (const char *name) ++ { ++ grub_device_t dev; ++ grub_err_t err; ++ dev = grub_device_open (name); ++ if (!dev) ++ return 0; ++ if (!dev->disk) ++ { ++ grub_device_close (dev); ++ return 0; ++ } ++ err = scan_disk (dev, data, 0); ++ if (err == GRUB_ERR_BAD_FS) ++ { ++ grub_device_close (dev); ++ grub_errno = GRUB_ERR_NONE; ++ return 0; ++ } ++ if (err) ++ { ++ grub_device_close (dev); ++ grub_print_error (); ++ return 0; ++ } ++ ++ return 0; ++ } ++ grub_device_iterate (hook); ++ return GRUB_ERR_NONE; ++} ++ ++static inline void ++xor (grub_uint64_t *a, const grub_uint64_t *b, grub_size_t s) ++{ ++ s /= sizeof (grub_uint64_t); ++ while (s--) ++ *a++ ^= *b++; ++} ++ ++/* x**y. */ ++static grub_uint8_t powx[255 * 2]; ++/* Such an s that x**s = y */ ++static int powx_inv[256]; ++static const grub_uint8_t poly = 0x1d; ++ ++/* perform the operation a ^= b * (x ** (known_idx * recovery_pow) ) */ ++static inline void ++xor_out (void *a_in, const void *b_in, grub_size_t s, ++ int known_idx, int recovery_pow) ++{ ++ int add; ++ grub_uint8_t *a = a_in; ++ const grub_uint8_t *b = b_in; ++ ++ /* Simple xor. */ ++ if (known_idx == 0 || recovery_pow == 0) ++ { ++ xor (a_in, b_in, s); ++ return; ++ } ++ add = (known_idx * recovery_pow) % 255; ++ for (;s--; b++, a++) ++ if (*b) ++ *a ^= powx[powx_inv[*b] + add]; ++} ++ ++static inline grub_uint8_t ++gf_mul (grub_uint8_t a, grub_uint8_t b) ++{ ++ if (a == 0 || b == 0) ++ return 0; ++ return powx[powx_inv[a] + powx_inv[b]]; ++} ++ ++static inline grub_err_t ++recovery (grub_uint8_t *bufs[4], grub_size_t s, const int nbufs, ++ const unsigned *powers, ++ const int *idx) ++{ ++ grub_dprintf ("zfs", "recovering %u bufers\n", nbufs); ++ /* Now we have */ ++ /* b_i = sum (r_j* (x ** (powers[i] * idx[j])))*/ ++ /* Let's invert the matrix in question. */ ++ switch (nbufs) ++ { ++ /* Easy: r_0 = bufs[0] / (x << (powers[i] * idx[j])). */ ++ case 1: ++ { ++ int add; ++ grub_uint8_t *a; ++ if (powers[0] == 0 || idx[0] == 0) ++ return GRUB_ERR_NONE; ++ add = 255 - ((powers[0] * idx[0]) % 255); ++ for (a = bufs[0]; s--; a++) ++ if (*a) ++ *a = powx[powx_inv[*a] + add]; ++ return GRUB_ERR_NONE; ++ } ++ /* Case 2x2: Let's use the determinant formula. */ ++ case 2: ++ { ++ grub_uint8_t det, det_inv; ++ grub_uint8_t matrixinv[2][2]; ++ unsigned i; ++ /* The determinant is: */ ++ det = (powx[(powers[0] * idx[0] + powers[1] * idx[1]) % 255] ++ ^ powx[(powers[0] * idx[1] + powers[1] * idx[0]) % 255]); ++ if (det == 0) ++ return grub_error (GRUB_ERR_BAD_FS, "singular recovery matrix"); ++ det_inv = powx[255 - powx_inv[det]]; ++ matrixinv[0][0] = gf_mul (powx[(powers[1] * idx[1]) % 255], det_inv); ++ matrixinv[1][1] = gf_mul (powx[(powers[0] * idx[0]) % 255], det_inv); ++ matrixinv[0][1] = gf_mul (powx[(powers[0] * idx[1]) % 255], det_inv); ++ matrixinv[1][0] = gf_mul (powx[(powers[1] * idx[0]) % 255], det_inv); ++ for (i = 0; i < s; i++) ++ { ++ grub_uint8_t b0, b1; ++ b0 = bufs[0][i]; ++ b1 = bufs[1][i]; ++ ++ bufs[0][i] = (gf_mul (b0, matrixinv[0][0]) ++ ^ gf_mul (b1, matrixinv[0][1])); ++ bufs[1][i] = (gf_mul (b0, matrixinv[1][0]) ++ ^ gf_mul (b1, matrixinv[1][1])); ++ } ++ return GRUB_ERR_NONE; ++ } ++ /* Otherwise use Gauss. */ ++ default: ++ { ++ grub_uint8_t matrix1[nbufs][nbufs], matrix2[nbufs][nbufs]; ++ int i, j, k; ++ ++ for (i = 0; i < nbufs; i++) ++ for (j = 0; j < nbufs; j++) ++ matrix1[i][j] = powx[(powers[i] * idx[j]) % 255]; ++ for (i = 0; i < nbufs; i++) ++ for (j = 0; j < nbufs; j++) ++ matrix2[i][j] = 0; ++ for (i = 0; i < nbufs; i++) ++ matrix2[i][i] = 1; ++ ++ for (i = 0; i < nbufs; i++) ++ { ++ grub_uint8_t mul; ++ for (j = i; j < nbufs; j++) ++ if (matrix1[i][j]) ++ break; ++ if (j == nbufs) ++ return grub_error (GRUB_ERR_BAD_FS, "singular recovery matrix"); ++ if (j != i) ++ { ++ int xchng; ++ xchng = j; ++ for (j = 0; j < nbufs; j++) ++ { ++ grub_uint8_t t; ++ t = matrix1[xchng][j]; ++ matrix1[xchng][j] = matrix1[i][j]; ++ matrix1[i][j] = t; ++ } ++ for (j = 0; j < nbufs; j++) ++ { ++ grub_uint8_t t; ++ t = matrix2[xchng][j]; ++ matrix2[xchng][j] = matrix2[i][j]; ++ matrix2[i][j] = t; ++ } ++ } ++ mul = powx[255 - powx_inv[matrix1[i][i]]]; ++ for (j = 0; j < nbufs; j++) ++ matrix1[i][j] = gf_mul (matrix1[i][j], mul); ++ for (j = 0; j < nbufs; j++) ++ matrix2[i][j] = gf_mul (matrix2[i][j], mul); ++ for (j = i + 1; j < nbufs; j++) ++ { ++ mul = matrix1[j][i]; ++ for (k = 0; k < nbufs; k++) ++ matrix1[j][k] ^= gf_mul (matrix1[i][k], mul); ++ for (k = 0; k < nbufs; k++) ++ matrix2[j][k] ^= gf_mul (matrix2[i][k], mul); ++ } ++ } ++ for (i = nbufs - 1; i >= 0; i--) ++ { ++ for (j = 0; j < i; j++) ++ { ++ grub_uint8_t mul; ++ mul = matrix1[j][i]; ++ for (k = 0; k < nbufs; k++) ++ matrix1[j][k] ^= gf_mul (matrix1[i][k], mul); ++ for (k = 0; k < nbufs; k++) ++ matrix2[j][k] ^= gf_mul (matrix2[i][k], mul); ++ } ++ } ++ ++ for (i = 0; i < (int) s; i++) ++ { ++ grub_uint8_t b[nbufs]; ++ for (j = 0; j < nbufs; j++) ++ b[j] = bufs[j][i]; ++ for (j = 0; j < nbufs; j++) ++ { ++ bufs[j][i] = 0; ++ for (k = 0; k < nbufs; k++) ++ bufs[j][i] ^= gf_mul (matrix2[j][k], b[k]); ++ } ++ } ++ return GRUB_ERR_NONE; ++ } ++ } ++} ++ ++static grub_err_t ++read_device (grub_uint64_t offset, struct grub_zfs_device_desc *desc, ++ grub_size_t len, void *buf) ++{ ++ switch (desc->type) ++ { ++ case DEVICE_LEAF: ++ { ++ grub_uint64_t sector; ++ sector = DVA_OFFSET_TO_PHYS_SECTOR (offset); ++ if (!desc->dev) ++ { ++ return grub_error (GRUB_ERR_BAD_FS, "member drive unknown"); ++ } ++ /* read in a data block */ ++ return grub_disk_read (desc->dev->disk, sector, 0, len, buf); ++ } ++ case DEVICE_MIRROR: ++ { ++ grub_err_t err = GRUB_ERR_NONE; ++ unsigned i; ++ if (desc->n_children <= 0) ++ return grub_error (GRUB_ERR_BAD_FS, ++ "non-positive number of mirror children"); ++ for (i = 0; i < desc->n_children; i++) ++ { ++ err = read_device (offset, &desc->children[i], ++ len, buf); ++ if (!err) ++ break; ++ grub_errno = GRUB_ERR_NONE; ++ } ++ return (grub_errno = err); ++ } ++ case DEVICE_RAIDZ: ++ { ++ unsigned c = 0; ++ grub_uint64_t high; ++ grub_uint64_t devn; ++ grub_uint64_t m; ++ grub_uint32_t s, orig_s; ++ void *orig_buf = buf; ++ grub_size_t orig_len = len; ++ grub_uint8_t *recovery_buf[4]; ++ grub_size_t recovery_len[4]; ++ int recovery_idx[4]; ++ unsigned failed_devices = 0; ++ int idx, orig_idx; ++ ++ if (desc->nparity < 1 || desc->nparity > 3) ++ return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, ++ "raidz%d is not supported", desc->nparity); ++ ++ orig_s = (((len + (1 << desc->ashift) - 1) >> desc->ashift) ++ + (desc->n_children - desc->nparity) - 1); ++ s = orig_s; ++ ++ high = grub_divmod64_full ((offset >> desc->ashift), ++ desc->n_children, &m); ++ if (desc->nparity == 2) ++ c = 2; ++ if (desc->nparity == 3) ++ c = 3; ++ if (((len + (1 << desc->ashift) - 1) >> desc->ashift) ++ >= (desc->n_children - desc->nparity)) ++ idx = (desc->n_children - desc->nparity - 1); ++ else ++ idx = ((len + (1 << desc->ashift) - 1) >> desc->ashift) - 1; ++ orig_idx = idx; ++ while (len > 0) ++ { ++ grub_size_t csize; ++ grub_uint32_t bsize; ++ grub_err_t err; ++ bsize = s / (desc->n_children - desc->nparity); ++ ++ if (desc->nparity == 1 ++ && ((offset >> (desc->ashift + 11)) & 1) == c) ++ c++; ++ ++ high = grub_divmod64_full ((offset >> desc->ashift) + c, ++ desc->n_children, &devn); ++ csize = bsize << desc->ashift; ++ if (csize > len) ++ csize = len; ++ ++ grub_dprintf ("zfs", "RAIDZ mapping 0x%" PRIxGRUB_UINT64_T ++ "+%u (%" PRIxGRUB_SIZE ", %" PRIxGRUB_UINT32_T ++ ") -> (0x%" PRIxGRUB_UINT64_T ", 0x%" ++ PRIxGRUB_UINT64_T ")\n", ++ offset >> desc->ashift, c, len, bsize, high, ++ devn); ++ err = read_device ((high << desc->ashift) ++ | (offset & ((1 << desc->ashift) - 1)), ++ &desc->children[devn], ++ csize, buf); ++ if (err && failed_devices < desc->nparity) ++ { ++ recovery_buf[failed_devices] = buf; ++ recovery_len[failed_devices] = csize; ++ recovery_idx[failed_devices] = idx; ++ failed_devices++; ++ grub_errno = err = 0; ++ } ++ if (err) ++ return err; ++ ++ c++; ++ idx--; ++ s--; ++ buf = (char *) buf + csize; ++ len -= csize; ++ } ++ if (failed_devices) ++ { ++ unsigned redundancy_pow[4]; ++ unsigned cur_redundancy_pow = 0; ++ unsigned n_redundancy = 0; ++ unsigned i, j; ++ grub_err_t err; ++ ++ /* Compute mul. x**s has a period of 255. */ ++ if (powx[0] == 0) ++ { ++ grub_uint8_t cur = 1; ++ for (i = 0; i < 255; i++) ++ { ++ powx[i] = cur; ++ powx[i + 255] = cur; ++ powx_inv[cur] = i; ++ if (cur & 0x80) ++ cur = (cur << 1) ^ poly; ++ else ++ cur <<= 1; ++ } ++ } ++ ++ /* Read redundancy data. */ ++ for (n_redundancy = 0, cur_redundancy_pow = 0; ++ n_redundancy < failed_devices; ++ cur_redundancy_pow++) ++ { ++ high = grub_divmod64_full ((offset >> desc->ashift) ++ + cur_redundancy_pow ++ + ((desc->nparity == 1) ++ && ((offset >> (desc->ashift + 11)) ++ & 1)), ++ desc->n_children, &devn); ++ err = read_device ((high << desc->ashift) ++ | (offset & ((1 << desc->ashift) - 1)), ++ &desc->children[devn], ++ recovery_len[n_redundancy], ++ recovery_buf[n_redundancy]); ++ /* Ignore error if we may still have enough devices. */ ++ if (err && n_redundancy + desc->nparity - cur_redundancy_pow - 1 ++ >= failed_devices) ++ { ++ grub_errno = GRUB_ERR_NONE; ++ continue; ++ } ++ if (err) ++ return err; ++ redundancy_pow[n_redundancy] = cur_redundancy_pow; ++ n_redundancy++; ++ } ++ /* Now xor-our the parts we already know. */ ++ buf = orig_buf; ++ len = orig_len; ++ s = orig_s; ++ idx = orig_idx; ++ ++ while (len > 0) ++ { ++ grub_size_t csize; ++ csize = ((s / (desc->n_children - desc->nparity)) ++ << desc->ashift); ++ if (csize > len) ++ csize = len; ++ ++ for (j = 0; j < failed_devices; j++) ++ if (buf == recovery_buf[j]) ++ break; ++ ++ if (j == failed_devices) ++ for (j = 0; j < failed_devices; j++) ++ xor_out (recovery_buf[j], buf, ++ csize < recovery_len[j] ? csize : recovery_len[j], ++ idx, redundancy_pow[j]); ++ ++ s--; ++ buf = (char *) buf + csize; ++ len -= csize; ++ idx--; ++ } ++ for (i = 0; i < failed_devices ++ && recovery_len[i] == recovery_len[0]; ++ i++); ++ /* Since the chunks have variable length handle the last block ++ separately. */ ++ if (i != failed_devices) ++ { ++ grub_uint8_t *tmp_recovery_buf[4]; ++ for (j = 0; j < i; j++) ++ tmp_recovery_buf[j] = recovery_buf[j] + recovery_len[j] - 1; ++ err = recovery (tmp_recovery_buf, 1, i, redundancy_pow, ++ recovery_idx); ++ if (err) ++ return err; ++ } ++ err = recovery (recovery_buf, recovery_len[failed_devices - 1], ++ failed_devices, redundancy_pow, recovery_idx); ++ if (err) ++ return err; ++ } ++ return GRUB_ERR_NONE; ++ } ++ } ++ return grub_error (GRUB_ERR_BAD_FS, "unsupported device type"); ++} ++ ++static grub_err_t ++read_dva (const dva_t *dva, ++ grub_zfs_endian_t endian, struct grub_zfs_data *data, ++ void *buf, grub_size_t len) ++{ ++ grub_uint64_t offset; ++ unsigned i; ++ grub_err_t err; ++ int try = 0; ++ offset = dva_get_offset (dva, endian); ++ ++ for (try = 0; try < 2; try++) ++ { ++ for (i = 0; i < data->n_devices_attached; i++) ++ if (data->devices_attached[i].id == DVA_GET_VDEV (dva)) ++ { ++ err = read_device (offset, &data->devices_attached[i], len, buf); ++ if (!err) ++ return GRUB_ERR_NONE; ++ break; ++ } ++ if (try == 1) ++ break; ++ err = scan_devices (data); ++ if (err) ++ return err; ++ } ++ return err; ++} + + /* + * Read a block of data based on the gang block address dva, +@@ -412,7 +1292,6 @@ + struct grub_zfs_data *data) + { + zio_gbh_phys_t *zio_gb; +- grub_uint64_t offset, sector; + unsigned i; + grub_err_t err; + zio_cksum_t zc; +@@ -424,13 +1303,8 @@ + return grub_errno; + grub_dprintf ("zfs", endian == LITTLE_ENDIAN ? "little-endian gang\n" + :"big-endian gang\n"); +- offset = dva_get_offset (dva, endian); +- sector = DVA_OFFSET_TO_PHYS_SECTOR (offset); +- grub_dprintf ("zfs", "offset=%llx\n", (unsigned long long) offset); + +- /* read in the gang block header */ +- err = grub_disk_read (data->disk, sector, 0, SPA_GANGBLOCKSIZE, +- (char *) zio_gb); ++ err = read_dva (dva, endian, data, zio_gb, SPA_GANGBLOCKSIZE); + if (err) + { + grub_free (zio_gb); +@@ -483,20 +1357,13 @@ + /* pick a good dva from the block pointer */ + for (i = 0; i < SPA_DVAS_PER_BP; i++) + { +- grub_uint64_t offset, sector; +- + if (bp->blk_dva[i].dva_word[0] == 0 && bp->blk_dva[i].dva_word[1] == 0) + continue; + + if ((grub_zfs_to_cpu64 (bp->blk_dva[i].dva_word[1], endian)>>63) & 1) + err = zio_read_gang (bp, endian, &bp->blk_dva[i], buf, data); + else +- { +- /* read in a data block */ +- offset = dva_get_offset (&bp->blk_dva[i], endian); +- sector = DVA_OFFSET_TO_PHYS_SECTOR (offset); +- err = grub_disk_read (data->disk, sector, 0, psize, buf); +- } ++ err = read_dva (&bp->blk_dva[i], endian, data, buf, psize); + if (!err) + return GRUB_ERR_NONE; + grub_errno = GRUB_ERR_NONE; +@@ -527,7 +1394,7 @@ + *buf = NULL; + + checksum = (grub_zfs_to_cpu64((bp)->blk_prop, endian) >> 40) & 0xff; +- comp = (grub_zfs_to_cpu64((bp)->blk_prop, endian)>>32) & 0x7; ++ comp = (grub_zfs_to_cpu64((bp)->blk_prop, endian)>>32) & 0xff; + lsize = (BP_IS_HOLE(bp) ? 0 : + (((grub_zfs_to_cpu64 ((bp)->blk_prop, endian) & 0xffff) + 1) + << SPA_MINBLOCKSHIFT)); +@@ -602,7 +1469,8 @@ + dmu_read (dnode_end_t * dn, grub_uint64_t blkid, void **buf, + grub_zfs_endian_t *endian_out, struct grub_zfs_data *data) + { +- int idx, level; ++ int level; ++ grub_off_t idx; + blkptr_t *bp_array = dn->dn.dn_blkptr; + int epbs = dn->dn.dn_indblkshift - SPA_BLKPTRSHIFT; + blkptr_t *bp; +@@ -670,7 +1538,8 @@ + */ + static grub_err_t + mzap_lookup (mzap_phys_t * zapobj, grub_zfs_endian_t endian, +- int objsize, char *name, grub_uint64_t * value) ++ int objsize, char *name, grub_uint64_t * value, ++ int case_insensitive) + { + int i, chunks; + mzap_ent_phys_t *mzap_ent = zapobj->mz_chunk; +@@ -678,7 +1547,8 @@ + chunks = objsize / MZAP_ENT_LEN - 1; + for (i = 0; i < chunks; i++) + { +- if (grub_strcmp (mzap_ent[i].mze_name, name) == 0) ++ if (case_insensitive ? (grub_strcasecmp (mzap_ent[i].mze_name, name) == 0) ++ : (grub_strcmp (mzap_ent[i].mze_name, name) == 0)) + { + *value = grub_zfs_to_cpu64 (mzap_ent[i].mze_value, endian); + return GRUB_ERR_NONE; +@@ -711,7 +1581,8 @@ + } + + static grub_uint64_t +-zap_hash (grub_uint64_t salt, const char *name) ++zap_hash (grub_uint64_t salt, const char *name, ++ int case_insensitive) + { + static grub_uint64_t table[256]; + const grub_uint8_t *cp; +@@ -729,8 +1600,12 @@ + } + } + +- for (cp = (const grub_uint8_t *) name; (c = *cp) != '\0'; cp++) +- crc = (crc >> 8) ^ table[(crc ^ c) & 0xFF]; ++ if (case_insensitive) ++ for (cp = (const grub_uint8_t *) name; (c = *cp) != '\0'; cp++) ++ crc = (crc >> 8) ^ table[(crc ^ grub_toupper (c)) & 0xFF]; ++ else ++ for (cp = (const grub_uint8_t *) name; (c = *cp) != '\0'; cp++) ++ crc = (crc >> 8) ^ table[(crc ^ c) & 0xFF]; + + /* + * Only use 28 bits, since we need 4 bits in the cookie for the +@@ -748,10 +1623,34 @@ + * array_len is actual len in bytes (not encoded le_value_length). + * buf is null-terminated. + */ ++ ++static inline int ++name_cmp (const char *s1, const char *s2, grub_size_t n, ++ int case_insensitive) ++{ ++ const char *t1 = (const char *) s1; ++ const char *t2 = (const char *) s2; ++ ++ if (!case_insensitive) ++ return grub_memcmp (t1, t2, n); ++ ++ while (n--) ++ { ++ if (grub_toupper (*t1) != grub_toupper (*t2)) ++ return (int) grub_toupper (*t1) - (int) grub_toupper (*t2); ++ ++ t1++; ++ t2++; ++ } ++ ++ return 0; ++} ++ + /* XXX */ + static int + zap_leaf_array_equal (zap_leaf_phys_t * l, grub_zfs_endian_t endian, +- int blksft, int chunk, int array_len, const char *buf) ++ int blksft, int chunk, int array_len, const char *buf, ++ int case_insensitive) + { + int bseen = 0; + +@@ -763,7 +1662,8 @@ + if (chunk >= ZAP_LEAF_NUMCHUNKS (blksft)) + return (0); + +- if (grub_memcmp (la->la_array, buf + bseen, toread) != 0) ++ if (name_cmp ((char *) la->la_array, buf + bseen, toread, ++ case_insensitive) != 0) + break; + chunk = grub_zfs_to_cpu16 (la->la_next, endian); + bseen += toread; +@@ -804,7 +1704,8 @@ + static grub_err_t + zap_leaf_lookup (zap_leaf_phys_t * l, grub_zfs_endian_t endian, + int blksft, grub_uint64_t h, +- const char *name, grub_uint64_t * value) ++ const char *name, grub_uint64_t * value, ++ int case_insensitive) + { + grub_uint16_t chunk; + struct zap_leaf_entry *le; +@@ -816,7 +1717,7 @@ + return grub_error (GRUB_ERR_BAD_FS, "invalid leaf magic"); + + for (chunk = grub_zfs_to_cpu16 (l->l_hash[LEAF_HASH (blksft, h)], endian); +- chunk != CHAIN_END; chunk = le->le_next) ++ chunk != CHAIN_END; chunk = grub_zfs_to_cpu16 (le->le_next, endian)) + { + + if (chunk >= ZAP_LEAF_NUMCHUNKS (blksft)) +@@ -836,11 +1737,12 @@ + if (zap_leaf_array_equal (l, endian, blksft, + grub_zfs_to_cpu16 (le->le_name_chunk,endian), + grub_zfs_to_cpu16 (le->le_name_length, endian), +- name)) ++ name, case_insensitive)) + { + struct zap_leaf_array *la; + +- if (le->le_int_size != 8 || le->le_value_length != 1) ++ if (le->le_int_size != 8 || grub_zfs_to_cpu16 (le->le_value_length, ++ endian) != 1) + return grub_error (GRUB_ERR_BAD_FS, "invalid leaf chunk entry"); + + /* get the uint64_t property value */ +@@ -858,9 +1760,9 @@ + + /* Verify if this is a fat zap header block */ + static grub_err_t +-zap_verify (zap_phys_t *zap) ++zap_verify (zap_phys_t *zap, grub_zfs_endian_t endian) + { +- if (zap->zap_magic != (grub_uint64_t) ZAP_MAGIC) ++ if (grub_zfs_to_cpu64 (zap->zap_magic, endian) != (grub_uint64_t) ZAP_MAGIC) + return grub_error (GRUB_ERR_BAD_FS, "bad ZAP magic"); + + if (zap->zap_flags != 0) +@@ -879,7 +1781,8 @@ + /* XXX */ + static grub_err_t + fzap_lookup (dnode_end_t * zap_dnode, zap_phys_t * zap, +- char *name, grub_uint64_t * value, struct grub_zfs_data *data) ++ char *name, grub_uint64_t * value, struct grub_zfs_data *data, ++ int case_insensitive) + { + void *l; + grub_uint64_t hash, idx, blkid; +@@ -888,18 +1791,18 @@ + grub_err_t err; + grub_zfs_endian_t leafendian; + +- err = zap_verify (zap); ++ err = zap_verify (zap, zap_dnode->endian); + if (err) + return err; + +- hash = zap_hash (zap->zap_salt, name); ++ hash = zap_hash (zap->zap_salt, name, case_insensitive); + + /* get block id from index */ + if (zap->zap_ptrtbl.zt_numblks != 0) + return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, + "external pointer tables not supported"); + idx = ZAP_HASH_IDX (hash, zap->zap_ptrtbl.zt_shift); +- blkid = ((grub_uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))]; ++ blkid = grub_zfs_to_cpu64 (((grub_uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))], zap_dnode->endian); + + /* Get the leaf block */ + if ((1U << blksft) < sizeof (zap_leaf_phys_t)) +@@ -908,7 +1811,8 @@ + if (err) + return err; + +- err = zap_leaf_lookup (l, leafendian, blksft, hash, name, value); ++ err = zap_leaf_lookup (l, leafendian, blksft, hash, name, value, ++ case_insensitive); + grub_free (l); + return err; + } +@@ -922,14 +1826,14 @@ + { + zap_leaf_phys_t *l; + void *l_in; +- grub_uint64_t idx, blkid; ++ grub_uint64_t idx, idx2, blkid; + grub_uint16_t chunk; + int blksft = zfs_log2 (grub_zfs_to_cpu16 (zap_dnode->dn.dn_datablkszsec, + zap_dnode->endian) << DNODE_SHIFT); + grub_err_t err; + grub_zfs_endian_t endian; + +- if (zap_verify (zap)) ++ if (zap_verify (zap, zap_dnode->endian)) + return 0; + + /* get block id from index */ +@@ -945,9 +1849,17 @@ + grub_error (GRUB_ERR_BAD_FS, "ZAP leaf is too small"); + return 0; + } +- for (idx = 0; idx < zap->zap_ptrtbl.zt_numblks; idx++) ++ for (idx = 0; idx < (1ULL << zap->zap_ptrtbl.zt_shift); idx++) + { +- blkid = ((grub_uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))]; ++ blkid = grub_zfs_to_cpu64 (((grub_uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))], ++ zap_dnode->endian); ++ ++ for (idx2 = 0; idx2 < idx; idx2++) ++ if (blkid == grub_zfs_to_cpu64 (((grub_uint64_t *) zap)[idx2 + (1 << (blksft - 3 - 1))], ++ zap_dnode->endian)) ++ break; ++ if (idx2 != idx) ++ continue; + + err = dmu_read (zap_dnode, blkid, &l_in, &endian, data); + l = l_in; +@@ -983,8 +1895,11 @@ + + buf = grub_malloc (grub_zfs_to_cpu16 (le->le_name_length, endian) + + 1); +- if (zap_leaf_array_get (l, endian, blksft, le->le_name_chunk, +- le->le_name_length, buf)) ++ if (zap_leaf_array_get (l, endian, blksft, ++ grub_zfs_to_cpu16 (le->le_name_chunk, ++ endian), ++ grub_zfs_to_cpu16 (le->le_name_length, ++ endian), buf)) + { + grub_free (buf); + continue; +@@ -996,7 +1911,9 @@ + continue; + + /* get the uint64_t property value */ +- la = &ZAP_LEAF_CHUNK (l, blksft, le->le_value_chunk).l_array; ++ la = &ZAP_LEAF_CHUNK (l, blksft, ++ grub_zfs_to_cpu16 (le->le_value_chunk, ++ endian)).l_array; + val = grub_be_to_cpu64 (la->la_array64); + if (hook (buf, val)) + return 1; +@@ -1014,7 +1931,7 @@ + */ + static grub_err_t + zap_lookup (dnode_end_t * zap_dnode, char *name, grub_uint64_t * val, +- struct grub_zfs_data *data) ++ struct grub_zfs_data *data, int case_insensitive) + { + grub_uint64_t block_type; + int size; +@@ -1037,7 +1954,8 @@ + if (block_type == ZBT_MICRO) + { + grub_dprintf ("zfs", "micro zap\n"); +- err = (mzap_lookup (zapbuf, endian, size, name, val)); ++ err = mzap_lookup (zapbuf, endian, size, name, val, ++ case_insensitive); + grub_dprintf ("zfs", "returned %d\n", err); + grub_free (zapbuf); + return err; +@@ -1046,7 +1964,8 @@ + { + grub_dprintf ("zfs", "fat zap\n"); + /* this is a fat zap */ +- err = (fzap_lookup (zap_dnode, zapbuf, name, val, data)); ++ err = fzap_lookup (zap_dnode, zapbuf, name, val, data, ++ case_insensitive); + grub_dprintf ("zfs", "returned %d\n", err); + grub_free (zapbuf); + return err; +@@ -1074,7 +1993,7 @@ + return 0; + block_type = grub_zfs_to_cpu64 (*((grub_uint64_t *) zapbuf), endian); + +- grub_dprintf ("zfs", "zap read\n"); ++ grub_dprintf ("zfs", "zap iterate\n"); + + if (block_type == ZBT_MICRO) + { +@@ -1172,9 +2091,9 @@ + */ + static grub_err_t + dnode_get_path (dnode_end_t * mdn, const char *path_in, dnode_end_t * dn, +- struct grub_zfs_data *data) ++ struct grub_zfs_data *data, int *case_insensitive) + { +- grub_uint64_t objnum, version; ++ grub_uint64_t objnum, version, insensitivity; + char *cname, ch; + grub_err_t err = GRUB_ERR_NONE; + char *path, *path_buf; +@@ -1199,19 +2118,31 @@ + return err; + } + +- err = zap_lookup (&(dnode_path->dn), ZPL_VERSION_STR, &version, data); ++ err = zap_lookup (&(dnode_path->dn), ZPL_VERSION_STR, &version, ++ data, 0); + if (err) + { + grub_free (dn_new); + return err; + } ++ + if (version > ZPL_VERSION) + { + grub_free (dn_new); + return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, "too new ZPL version"); + } +- +- err = zap_lookup (&(dnode_path->dn), ZFS_ROOT_OBJ, &objnum, data); ++ ++ err = zap_lookup (&(dnode_path->dn), "casesensitivity", &insensitivity, ++ data, 0); ++ if (err == GRUB_ERR_FILE_NOT_FOUND) ++ { ++ grub_errno = GRUB_ERR_NONE; ++ insensitivity = 0; ++ } ++ if (case_insensitive) ++ *case_insensitive = insensitivity; ++ ++ err = zap_lookup (&(dnode_path->dn), ZFS_ROOT_OBJ, &objnum, data, 0); + if (err) + { + grub_free (dn_new); +@@ -1272,7 +2203,7 @@ + grub_free (path_buf); + return grub_error (GRUB_ERR_BAD_FILE_TYPE, "not a directory"); + } +- err = zap_lookup (&(dnode_path->dn), cname, &objnum, data); ++ err = zap_lookup (&(dnode_path->dn), cname, &objnum, data, insensitivity); + if (err) + break; + +@@ -1291,22 +2222,54 @@ + break; + + *path = ch; +-#if 0 +- if (((grub_zfs_to_cpu64(((znode_phys_t *) DN_BONUS (&dnode_path->dn.dn))->zp_mode, dnode_path->dn.endian) >> 12) & 0xf) == 0xa && ch) ++ if (dnode_path->dn.dn.dn_bonustype == DMU_OT_ZNODE ++ && ((grub_zfs_to_cpu64(((znode_phys_t *) DN_BONUS (&dnode_path->dn.dn))->zp_mode, dnode_path->dn.endian) >> 12) & 0xf) == 0xa) + { ++ char *sym_value; ++ grub_size_t sym_sz; ++ int free_symval = 0; + char *oldpath = path, *oldpathbuf = path_buf; +- path = path_buf +- = grub_malloc (sizeof (dnode_path->dn.dn.dn_bonus) +- - sizeof (znode_phys_t) + grub_strlen (oldpath) + 1); ++ sym_value = ((char *) DN_BONUS (&dnode_path->dn.dn) + sizeof (struct znode_phys)); ++ ++ sym_sz = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dnode_path->dn.dn))->zp_size, dnode_path->dn.endian); ++ ++ if (dnode_path->dn.dn.dn_flags & 1) ++ { ++ grub_size_t block; ++ grub_size_t blksz; ++ blksz = (grub_zfs_to_cpu16 (dnode_path->dn.dn.dn_datablkszsec, ++ dnode_path->dn.endian) ++ << SPA_MINBLOCKSHIFT); ++ ++ sym_value = grub_malloc (sym_sz); ++ if (!sym_value) ++ return grub_errno; ++ for (block = 0; block < (sym_sz + blksz - 1) / blksz; block++) ++ { ++ void *t; ++ grub_size_t movesize; ++ ++ err = dmu_read (&(dnode_path->dn), block, &t, 0, data); ++ if (err) ++ return err; ++ ++ movesize = MIN (sym_sz - block * blksz, blksz); ++ ++ grub_memcpy (sym_value + block * blksz, t, movesize); ++ grub_free (t); ++ } ++ free_symval = 1; ++ } ++ path = path_buf = grub_malloc (sym_sz + grub_strlen (oldpath) + 1); + if (!path_buf) + { + grub_free (oldpathbuf); + return grub_errno; + } +- grub_memcpy (path, +- (char *) DN_BONUS(&dnode_path->dn.dn) + sizeof (znode_phys_t), +- sizeof (dnode_path->dn.dn.dn_bonus) - sizeof (znode_phys_t)); +- path [sizeof (dnode_path->dn.dn.dn_bonus) - sizeof (znode_phys_t)] = 0; ++ grub_memcpy (path, sym_value, sym_sz); ++ if (free_symval) ++ grub_free (sym_value); ++ path [sym_sz] = 0; + grub_memcpy (path + grub_strlen (path), oldpath, + grub_strlen (oldpath) + 1); + +@@ -1324,7 +2287,62 @@ + grub_free (dn_new); + } + } +-#endif ++ if (dnode_path->dn.dn.dn_bonustype == DMU_OT_SA) ++ { ++ void *sahdrp; ++ int hdrsize; ++ ++ if (dnode_path->dn.dn.dn_bonuslen != 0) ++ { ++ sahdrp = DN_BONUS (&dnode_path->dn.dn); ++ } ++ else if (dnode_path->dn.dn.dn_flags & DNODE_FLAG_SPILL_BLKPTR) ++ { ++ blkptr_t *bp = &dnode_path->dn.dn.dn_spill; ++ ++ err = zio_read (bp, dnode_path->dn.endian, &sahdrp, NULL, data); ++ if (err) ++ return err; ++ } ++ else ++ { ++ return grub_error (GRUB_ERR_BAD_FS, "filesystem is corrupt"); ++ } ++ ++ hdrsize = SA_HDR_SIZE (((sa_hdr_phys_t *) sahdrp)); ++ ++ if (((grub_zfs_to_cpu64 (*(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_TYPE_OFFSET), dnode_path->dn.endian) >> 12) & 0xf) == 0xa) ++ { ++ char *sym_value = (char *) sahdrp + hdrsize + SA_SYMLINK_OFFSET; ++ grub_size_t sym_sz = ++ grub_zfs_to_cpu64 (*(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_SIZE_OFFSET), dnode_path->dn.endian); ++ char *oldpath = path, *oldpathbuf = path_buf; ++ path = path_buf = grub_malloc (sym_sz + grub_strlen (oldpath) + 1); ++ if (!path_buf) ++ { ++ grub_free (oldpathbuf); ++ return grub_errno; ++ } ++ grub_memcpy (path, sym_value, sym_sz); ++ path [sym_sz] = 0; ++ grub_memcpy (path + grub_strlen (path), oldpath, ++ grub_strlen (oldpath) + 1); ++ ++ grub_free (oldpathbuf); ++ if (path[0] != '/') ++ { ++ dn_new = dnode_path; ++ dnode_path = dn_new->next; ++ grub_free (dn_new); ++ } ++ else while (dnode_path != root) ++ { ++ dn_new = dnode_path; ++ dnode_path = dn_new->next; ++ grub_free (dn_new); ++ } ++ } ++ } + } + + if (!err) +@@ -1417,7 +2435,7 @@ + + grub_dprintf ("zfs", "alive\n"); + +- err = zap_lookup (mdn, DMU_POOL_ROOT_DATASET, &objnum, data); ++ err = zap_lookup (mdn, DMU_POOL_ROOT_DATASET, &objnum, data, 0); + if (err) + return err; + +@@ -1452,7 +2470,7 @@ + if (err) + return err; + +- err = zap_lookup (mdn, cname, &objnum, data); ++ err = zap_lookup (mdn, cname, &objnum, data, 0); + if (err) + return err; + +@@ -1495,7 +2513,7 @@ + static grub_err_t + dnode_get_fullpath (const char *fullpath, dnode_end_t * mdn, + grub_uint64_t *mdnobj, dnode_end_t * dn, int *isfs, +- struct grub_zfs_data *data) ++ struct grub_zfs_data *data, int *case_insensitive) + { + char *fsname, *snapname; + const char *ptr_at, *filename; +@@ -1573,7 +2591,7 @@ + err = dnode_get (&(data->mos), snapobj, + DMU_OT_DSL_DS_SNAP_MAP, mdn, data); + if (!err) +- err = zap_lookup (mdn, snapname, &headobj, data); ++ err = zap_lookup (mdn, snapname, &headobj, data, 0); + if (!err) + err = dnode_get (&(data->mos), headobj, DMU_OT_DSL_DATASET, mdn, data); + if (err) +@@ -1597,7 +2615,7 @@ + grub_free (snapname); + return GRUB_ERR_NONE; + } +- err = dnode_get_path (mdn, filename, dn, data); ++ err = dnode_get_path (mdn, filename, dn, data, case_insensitive); + grub_free (fsname); + grub_free (snapname); + return err; +@@ -1625,11 +2643,12 @@ + */ + + static int +-nvlist_find_value (char *nvlist, char *name, int valtype, char **val, ++nvlist_find_value (const char *nvlist, const char *name, ++ int valtype, char **val, + grub_size_t *size_out, grub_size_t *nelm_out) + { + int name_len, type, encode_size; +- char *nvpair, *nvp_name; ++ const char *nvpair, *nvp_name; + + /* Verify if the 1st and 2nd byte in the nvlist are valid. */ + /* NOTE: independently of what endianness header announces all +@@ -1671,7 +2690,7 @@ + + if ((grub_strncmp (nvp_name, name, name_len) == 0) && type == valtype) + { +- *val = nvpair; ++ *val = (char *) nvpair; + *size_out = encode_size; + if (nelm_out) + *nelm_out = nelm; +@@ -1684,7 +2703,8 @@ + } + + int +-grub_zfs_nvlist_lookup_uint64 (char *nvlist, char *name, grub_uint64_t * out) ++grub_zfs_nvlist_lookup_uint64 (const char *nvlist, const char *name, ++ grub_uint64_t * out) + { + char *nvpair; + grub_size_t size; +@@ -1704,7 +2724,7 @@ + } + + char * +-grub_zfs_nvlist_lookup_string (char *nvlist, char *name) ++grub_zfs_nvlist_lookup_string (const char *nvlist, const char *name) + { + char *nvpair; + char *ret; +@@ -1732,7 +2752,7 @@ + } + + char * +-grub_zfs_nvlist_lookup_nvlist (char *nvlist, char *name) ++grub_zfs_nvlist_lookup_nvlist (const char *nvlist, const char *name) + { + char *nvpair; + char *ret; +@@ -1753,199 +2773,114 @@ + } + + int +-grub_zfs_nvlist_lookup_nvlist_array_get_nelm (char *nvlist, char *name) +-{ +- char *nvpair; +- grub_size_t nelm, size; +- int found; +- +- found = nvlist_find_value (nvlist, name, DATA_TYPE_NVLIST, &nvpair, +- &size, &nelm); +- if (! found) +- return -1; +- return nelm; +-} +- +-char * +-grub_zfs_nvlist_lookup_nvlist_array (char *nvlist, char *name, +- grub_size_t index) +-{ +- char *nvpair, *nvpairptr; +- int found; +- char *ret; +- grub_size_t size; +- unsigned i; +- grub_size_t nelm; +- +- found = nvlist_find_value (nvlist, name, DATA_TYPE_NVLIST, &nvpair, +- &size, &nelm); +- if (!found) +- return 0; +- if (index >= nelm) +- { +- grub_error (GRUB_ERR_OUT_OF_RANGE, "trying to lookup past nvlist array"); +- return 0; +- } +- +- nvpairptr = nvpair; +- +- for (i = 0; i < index; i++) +- { +- grub_uint32_t encode_size; +- +- /* skip the header, nvl_version, and nvl_nvflag */ +- nvpairptr = nvpairptr + 4 * 2; +- +- while (nvpairptr < nvpair + size +- && (encode_size = grub_be_to_cpu32 (*(grub_uint32_t *) nvpairptr))) +- nvlist += encode_size; /* goto the next nvpair */ +- +- nvlist = nvlist + 4 * 2; /* skip the ending 2 zeros - 8 bytes */ +- } +- +- if (nvpairptr >= nvpair + size +- || nvpairptr + grub_be_to_cpu32 (*(grub_uint32_t *) (nvpairptr + 4 * 2)) +- >= nvpair + size) +- { +- grub_error (GRUB_ERR_BAD_FS, "incorrect nvlist array"); +- return 0; +- } +- +- ret = grub_zalloc (grub_be_to_cpu32 (*(grub_uint32_t *) (nvpairptr + 4 * 2)) +- + 3 * sizeof (grub_uint32_t)); +- if (!ret) +- return 0; +- grub_memcpy (ret, nvlist, sizeof (grub_uint32_t)); +- +- grub_memcpy (ret + sizeof (grub_uint32_t), nvpairptr, size); +- return ret; +-} +- +-static grub_err_t +-zfs_fetch_nvlist (struct grub_zfs_data * data, char **nvlist) +-{ +- grub_err_t err; +- +- *nvlist = grub_malloc (VDEV_PHYS_SIZE); +- /* Read in the vdev name-value pair list (112K). */ +- err = grub_disk_read (data->disk, data->vdev_phys_sector, 0, +- VDEV_PHYS_SIZE, *nvlist); +- if (err) +- { +- grub_free (*nvlist); +- *nvlist = 0; +- return err; +- } +- return GRUB_ERR_NONE; +-} +- +-/* +- * Check the disk label information and retrieve needed vdev name-value pairs. +- * +- */ +-static grub_err_t +-check_pool_label (struct grub_zfs_data *data) ++grub_zfs_nvlist_lookup_nvlist_array_get_nelm (const char *nvlist, ++ const char *name) + { +- grub_uint64_t pool_state, txg = 0; +- char *nvlist; +-#if 0 +- char *nv; +-#endif +- grub_uint64_t diskguid; +- grub_uint64_t version; ++ char *nvpair; ++ grub_size_t nelm, size; + int found; +- grub_err_t err; + +- err = zfs_fetch_nvlist (data, &nvlist); +- if (err) +- return err; ++ found = nvlist_find_value (nvlist, name, DATA_TYPE_NVLIST_ARRAY, &nvpair, ++ &size, &nelm); ++ if (! found) ++ return -1; ++ return nelm; ++} + +- grub_dprintf ("zfs", "check 2 passed\n"); ++static int ++get_nvlist_size (const char *beg, const char *limit) ++{ ++ const char *ptr; ++ grub_uint32_t encode_size; ++ ++ ptr = beg + 8; + +- found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_STATE, +- &pool_state); +- if (! found) +- { +- grub_free (nvlist); +- if (! grub_errno) +- grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_POOL_STATE " not found"); +- return grub_errno; +- } +- grub_dprintf ("zfs", "check 3 passed\n"); ++ while (ptr < limit ++ && (encode_size = grub_be_to_cpu32 (*(grub_uint32_t *) ptr))) ++ ptr += encode_size; /* goto the next nvpair */ ++ ptr += 8; ++ return (ptr > limit) ? -1 : (ptr - beg); ++} + +- if (pool_state == POOL_STATE_DESTROYED) +- { +- grub_free (nvlist); +- return grub_error (GRUB_ERR_BAD_FS, "zpool is marked as destroyed"); +- } +- grub_dprintf ("zfs", "check 4 passed\n"); ++char * ++grub_zfs_nvlist_lookup_nvlist_array (const char *nvlist, const char *name, ++ grub_size_t index) ++{ ++ char *nvpair, *nvpairptr; ++ int found; ++ char *ret; ++ grub_size_t size; ++ unsigned i; ++ grub_size_t nelm; ++ int elemsize = 0; + +- found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_TXG, &txg); ++ found = nvlist_find_value (nvlist, name, DATA_TYPE_NVLIST_ARRAY, &nvpair, ++ &size, &nelm); + if (!found) ++ return 0; ++ if (index >= nelm) + { +- grub_free (nvlist); +- if (! grub_errno) +- grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_POOL_TXG " not found"); +- return grub_errno; ++ grub_error (GRUB_ERR_OUT_OF_RANGE, "trying to lookup past nvlist array"); ++ return 0; + } +- grub_dprintf ("zfs", "check 6 passed\n"); + +- /* not an active device */ +- if (txg == 0) +- { +- grub_free (nvlist); +- return grub_error (GRUB_ERR_BAD_FS, "zpool isn't active"); +- } +- grub_dprintf ("zfs", "check 7 passed\n"); ++ nvpairptr = nvpair; + +- found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_VERSION, +- &version); +- if (! found) ++ for (i = 0; i < index; i++) + { +- grub_free (nvlist); +- if (! grub_errno) +- grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_VERSION " not found"); +- return grub_errno; +- } +- grub_dprintf ("zfs", "check 8 passed\n"); ++ int r; ++ r = get_nvlist_size (nvpairptr, nvpair + size); + +- if (version > SPA_VERSION) +- { +- grub_free (nvlist); +- return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, +- "too new version %llu > %llu", +- (unsigned long long) version, +- (unsigned long long) SPA_VERSION); +- } +- grub_dprintf ("zfs", "check 9 passed\n"); +-#if 0 +- if (nvlist_lookup_value (nvlist, ZPOOL_CONFIG_VDEV_TREE, &nv, +- DATA_TYPE_NVLIST, NULL)) +- { +- grub_free (vdev); +- return (GRUB_ERR_BAD_FS); ++ if (r < 0) ++ { ++ grub_error (GRUB_ERR_BAD_FS, "incorrect nvlist array"); ++ return NULL; ++ } ++ nvpairptr += r; + } +- grub_dprintf ("zfs", "check 10 passed\n"); +-#endif + +- found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_GUID, &diskguid); +- if (! found) ++ elemsize = get_nvlist_size (nvpairptr, nvpair + size); ++ ++ if (elemsize < 0) + { +- grub_free (nvlist); +- if (! grub_errno) +- grub_error (GRUB_ERR_BAD_FS, ZPOOL_CONFIG_GUID " not found"); +- return grub_errno; ++ grub_error (GRUB_ERR_BAD_FS, "incorrect nvlist array"); ++ return 0; + } +- grub_dprintf ("zfs", "check 11 passed\n"); + +- grub_free (nvlist); ++ ret = grub_zalloc (elemsize + sizeof (grub_uint32_t)); ++ if (!ret) ++ return 0; ++ grub_memcpy (ret, nvlist, sizeof (grub_uint32_t)); + +- return GRUB_ERR_NONE; ++ grub_memcpy (ret + sizeof (grub_uint32_t), nvpairptr, elemsize); ++ return ret; ++} ++ ++static void ++unmount_device (struct grub_zfs_device_desc *desc) ++{ ++ unsigned i; ++ switch (desc->type) ++ { ++ case DEVICE_LEAF: ++ if (!desc->original && desc->dev) ++ grub_device_close (desc->dev); ++ return; ++ case DEVICE_RAIDZ: ++ case DEVICE_MIRROR: ++ for (i = 0; i < desc->n_children; i++) ++ unmount_device (&desc->children[i]); ++ return; ++ } + } + + static void + zfs_unmount (struct grub_zfs_data *data) + { ++ unsigned i; ++ for (i = 0; i < data->n_devices_attached; i++) ++ unmount_device (&data->devices_attached[i]); ++ grub_free (data->devices_attached); + grub_free (data->dnode_buf); + grub_free (data->dnode_mdn); + grub_free (data->file_buf); +@@ -1961,13 +2896,11 @@ + zfs_mount (grub_device_t dev) + { + struct grub_zfs_data *data = 0; +- int label = 0; +- uberblock_phys_t *ub_array, *ubbest = NULL; +- vdev_boot_header_t *bh; +- void *osp = 0; +- grub_size_t ospsize; + grub_err_t err; +- int vdevnum; ++ objset_phys_t *osp = 0; ++ grub_size_t ospsize; ++ grub_zfs_endian_t ub_endian = UNKNOWN_ENDIAN; ++ uberblock_t *ub; + + if (! dev->disk) + { +@@ -1975,119 +2908,56 @@ + return 0; + } + +- data = grub_malloc (sizeof (*data)); ++ data = grub_zalloc (sizeof (*data)); + if (!data) + return 0; +- grub_memset (data, 0, sizeof (*data)); + #if 0 + /* if it's our first time here, zero the best uberblock out */ + if (data->best_drive == 0 && data->best_part == 0 && find_best_root) + grub_memset (¤t_uberblock, 0, sizeof (uberblock_t)); + #endif + +- data->disk = dev->disk; +- +- ub_array = grub_malloc (VDEV_UBERBLOCK_RING); +- if (!ub_array) ++ data->n_devices_allocated = 16; ++ data->devices_attached = grub_malloc (sizeof (data->devices_attached[0]) ++ * data->n_devices_allocated); ++ data->n_devices_attached = 0; ++ err = scan_disk (dev, data, 1); ++ if (err) + { + zfs_unmount (data); +- return 0; ++ return NULL; + } + +- bh = grub_malloc (VDEV_BOOT_HEADER_SIZE); +- if (!bh) ++ ub = &(data->current_uberblock); ++ ub_endian = (grub_zfs_to_cpu64 (ub->ub_magic, ++ LITTLE_ENDIAN) == UBERBLOCK_MAGIC ++ ? LITTLE_ENDIAN : BIG_ENDIAN); ++ ++ err = zio_read (&ub->ub_rootbp, ub_endian, ++ (void **) &osp, &ospsize, data); ++ if (err) + { + zfs_unmount (data); +- grub_free (ub_array); +- return 0; ++ return NULL; + } + +- vdevnum = VDEV_LABELS; +- +- /* Don't check back labels on CDROM. */ +- if (grub_disk_get_size (dev->disk) == GRUB_DISK_SIZE_UNKNOWN) +- vdevnum = VDEV_LABELS / 2; +- +- for (label = 0; ubbest == NULL && label < vdevnum; label++) ++ if (ospsize < OBJSET_PHYS_SIZE_V14) + { +- grub_zfs_endian_t ub_endian = UNKNOWN_ENDIAN; +- grub_dprintf ("zfs", "label %d\n", label); +- +- data->vdev_phys_sector +- = label * (sizeof (vdev_label_t) >> SPA_MINBLOCKSHIFT) +- + ((VDEV_SKIP_SIZE + VDEV_BOOT_HEADER_SIZE) >> SPA_MINBLOCKSHIFT) +- + (label < VDEV_LABELS / 2 ? 0 : grub_disk_get_size (dev->disk) +- - VDEV_LABELS * (sizeof (vdev_label_t) >> SPA_MINBLOCKSHIFT)); +- +- /* Read in the uberblock ring (128K). */ +- err = grub_disk_read (data->disk, data->vdev_phys_sector +- + (VDEV_PHYS_SIZE >> SPA_MINBLOCKSHIFT), +- 0, VDEV_UBERBLOCK_RING, (char *) ub_array); +- if (err) +- { +- grub_errno = GRUB_ERR_NONE; +- continue; +- } +- grub_dprintf ("zfs", "label ok %d\n", label); +- +- ubbest = find_bestub (ub_array, data->vdev_phys_sector); +- if (!ubbest) +- { +- grub_dprintf ("zfs", "No uberblock found\n"); +- grub_errno = GRUB_ERR_NONE; +- continue; +- } +- ub_endian = (grub_zfs_to_cpu64 (ubbest->ubp_uberblock.ub_magic, +- LITTLE_ENDIAN) == UBERBLOCK_MAGIC +- ? LITTLE_ENDIAN : BIG_ENDIAN); +- err = zio_read (&ubbest->ubp_uberblock.ub_rootbp, +- ub_endian, +- &osp, &ospsize, data); +- if (err) +- { +- grub_dprintf ("zfs", "couldn't zio_read\n"); +- grub_errno = GRUB_ERR_NONE; +- continue; +- } +- +- if (ospsize < OBJSET_PHYS_SIZE_V14) +- { +- grub_dprintf ("zfs", "osp too small\n"); +- grub_free (osp); +- continue; +- } +- grub_dprintf ("zfs", "ubbest %p\n", ubbest); +- +- err = check_pool_label (data); +- if (err) +- { +- grub_errno = GRUB_ERR_NONE; +- continue; +- } +-#if 0 +- if (find_best_root && +- vdev_uberblock_compare (&ubbest->ubp_uberblock, +- &(current_uberblock)) <= 0) +- continue; +-#endif +- /* Got the MOS. Save it at the memory addr MOS. */ +- grub_memmove (&(data->mos.dn), &((objset_phys_t *) osp)->os_meta_dnode, +- DNODE_SIZE); +- data->mos.endian = (grub_zfs_to_cpu64 (ubbest->ubp_uberblock.ub_rootbp.blk_prop, ub_endian) >> 63) & 1; +- grub_memmove (&(data->current_uberblock), +- &ubbest->ubp_uberblock, sizeof (uberblock_t)); +- grub_free (ub_array); +- grub_free (bh); ++ grub_error (GRUB_ERR_BAD_FS, "OSP too small"); + grub_free (osp); +- return data; ++ zfs_unmount (data); ++ return NULL; + } +- grub_error (GRUB_ERR_BAD_FS, "couldn't find a valid label"); +- zfs_unmount (data); +- grub_free (ub_array); +- grub_free (bh); ++ ++ /* Got the MOS. Save it at the memory addr MOS. */ ++ grub_memmove (&(data->mos.dn), &osp->os_meta_dnode, DNODE_SIZE); ++ data->mos.endian = (grub_zfs_to_cpu64 (ub->ub_rootbp.blk_prop, ++ ub_endian) >> 63) & 1; + grub_free (osp); + +- return 0; ++ data->mounted = 1; ++ ++ return data; + } + + grub_err_t +@@ -2099,7 +2969,7 @@ + zfs = zfs_mount (dev); + if (!zfs) + return grub_errno; +- err = zfs_fetch_nvlist (zfs, nvlist); ++ err = zfs_fetch_nvlist (zfs->device_original, nvlist); + zfs_unmount (zfs); + return err; + } +@@ -2115,7 +2985,7 @@ + if (! data) + return grub_errno; + +- err = zfs_fetch_nvlist (data, &nvlist); ++ err = zfs_fetch_nvlist (data->device_original, &nvlist); + if (err) + { + zfs_unmount (data); +@@ -2131,11 +3001,7 @@ + static grub_err_t + zfs_uuid (grub_device_t device, char **uuid) + { +- char *nvlist; +- int found; + struct grub_zfs_data *data; +- grub_uint64_t guid; +- grub_err_t err; + + *uuid = 0; + +@@ -2143,24 +3009,36 @@ + if (! data) + return grub_errno; + +- err = zfs_fetch_nvlist (data, &nvlist); +- if (err) +- { +- zfs_unmount (data); +- return err; +- } +- +- found = grub_zfs_nvlist_lookup_uint64 (nvlist, ZPOOL_CONFIG_POOL_GUID, &guid); +- if (! found) +- return grub_errno; +- grub_free (nvlist); +- *uuid = grub_xasprintf ("%016llx", (long long unsigned) guid); ++ *uuid = grub_xasprintf ("%016llx", (long long unsigned) data->guid); + zfs_unmount (data); + if (! *uuid) + return grub_errno; + return GRUB_ERR_NONE; + } + ++static grub_err_t ++zfs_mtime (grub_device_t device, grub_int32_t *mt) ++{ ++ struct grub_zfs_data *data; ++ grub_zfs_endian_t ub_endian = UNKNOWN_ENDIAN; ++ uberblock_t *ub; ++ ++ *mt = 0; ++ ++ data = zfs_mount (device); ++ if (! data) ++ return grub_errno; ++ ++ ub = &(data->current_uberblock); ++ ub_endian = (grub_zfs_to_cpu64 (ub->ub_magic, ++ LITTLE_ENDIAN) == UBERBLOCK_MAGIC ++ ? LITTLE_ENDIAN : BIG_ENDIAN); ++ ++ *mt = grub_zfs_to_cpu64 (ub->ub_timestamp, ub_endian); ++ zfs_unmount (data); ++ return GRUB_ERR_NONE; ++} ++ + /* + * zfs_open() locates a file in the rootpool by following the + * MOS and places the dnode of the file in the memory address DNODE. +@@ -2177,7 +3055,7 @@ + return grub_errno; + + err = dnode_get_fullpath (fsfilename, &(data->mdn), 0, +- &(data->dnode), &isfs, data); ++ &(data->dnode), &isfs, data, NULL); + if (err) + { + zfs_unmount (data); +@@ -2227,12 +3105,14 @@ + } + + hdrsize = SA_HDR_SIZE (((sa_hdr_phys_t *) sahdrp)); +- file->size = *(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_SIZE_OFFSET); ++ file->size = grub_zfs_to_cpu64 (*(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_SIZE_OFFSET), data->dnode.endian); + } +- else ++ else if (data->dnode.dn.dn_bonustype == DMU_OT_ZNODE) + { + file->size = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&data->dnode.dn))->zp_size, data->dnode.endian); + } ++ else ++ return grub_error (GRUB_ERR_BAD_FS, "bad bonus type"); + + file->data = data; + file->offset = 0; +@@ -2248,7 +3128,7 @@ + grub_zfs_read (grub_file_t file, char *buf, grub_size_t len) + { + struct grub_zfs_data *data = (struct grub_zfs_data *) file->data; +- int blksz, movesize; ++ grub_size_t blksz, movesize; + grub_size_t length; + grub_size_t read; + grub_err_t err; +@@ -2302,7 +3182,7 @@ + data->file_start = blkid * blksz; + data->file_end = data->file_start + blksz; + +- movesize = MIN (length, data->file_end - (int) file->offset - read); ++ movesize = MIN (length, data->file_end - file->offset - read); + + grub_memmove (buf, data->file_buf + file->offset + read + - data->file_start, movesize); +@@ -2339,7 +3219,7 @@ + return grub_errno; + + err = dnode_get_fullpath (fsfilename, &(data->mdn), mdnobj, +- &(data->dnode), &isfs, data); ++ &(data->dnode), &isfs, data, NULL); + zfs_unmount (data); + return err; + } +@@ -2377,7 +3257,7 @@ + return; + } + +- err = zap_lookup (&dn, ZFS_ROOT_OBJ, &objnum, data); ++ err = zap_lookup (&dn, ZFS_ROOT_OBJ, &objnum, data, 0); + if (err) + { + grub_dprintf ("zfs", "failed here\n"); +@@ -2391,8 +3271,39 @@ + return; + } + +- info->mtimeset = 1; +- info->mtime = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dn.dn))->zp_mtime[0], dn.endian); ++ if (dn.dn.dn_bonustype == DMU_OT_SA) ++ { ++ void *sahdrp; ++ int hdrsize; ++ ++ if (dn.dn.dn_bonuslen != 0) ++ { ++ sahdrp = (sa_hdr_phys_t *) DN_BONUS (&dn.dn); ++ } ++ else if (dn.dn.dn_flags & DNODE_FLAG_SPILL_BLKPTR) ++ { ++ blkptr_t *bp = &dn.dn.dn_spill; ++ ++ err = zio_read (bp, dn.endian, &sahdrp, NULL, data); ++ if (err) ++ return; ++ } ++ else ++ { ++ grub_error (GRUB_ERR_BAD_FS, "filesystem is corrupt"); ++ return; ++ } ++ ++ hdrsize = SA_HDR_SIZE (((sa_hdr_phys_t *) sahdrp)); ++ info->mtimeset = 1; ++ info->mtime = grub_zfs_to_cpu64 (*(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_MTIME_OFFSET), dn.endian); ++ } ++ ++ if (dn.dn.dn_bonustype == DMU_OT_ZNODE) ++ { ++ info->mtimeset = 1; ++ info->mtime = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dn.dn))->zp_mtime[0], dn.endian); ++ } + return; + } + +@@ -2403,6 +3314,7 @@ + struct grub_zfs_data *data; + grub_err_t err; + int isfs; ++ int case_insensitive = 0; + auto int NESTED_FUNC_ATTR iterate_zap (const char *name, grub_uint64_t val); + auto int NESTED_FUNC_ATTR iterate_zap_fs (const char *name, + grub_uint64_t val); +@@ -2416,10 +3328,48 @@ + grub_memset (&info, 0, sizeof (info)); + + dnode_get (&(data->mdn), val, 0, &dn, data); +- info.mtimeset = 1; +- info.mtime = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dn.dn))->zp_mtime[0], dn.endian); +- info.dir = (dn.dn.dn_type == DMU_OT_DIRECTORY_CONTENTS); +- grub_dprintf ("zfs", "type=%d, name=%s\n", ++ ++ if (dn.dn.dn_bonustype == DMU_OT_SA) ++ { ++ void *sahdrp; ++ int hdrsize; ++ ++ if (dn.dn.dn_bonuslen != 0) ++ { ++ sahdrp = (sa_hdr_phys_t *) DN_BONUS (&data->dnode.dn); ++ } ++ else if (dn.dn.dn_flags & DNODE_FLAG_SPILL_BLKPTR) ++ { ++ blkptr_t *bp = &dn.dn.dn_spill; ++ ++ err = zio_read (bp, dn.endian, &sahdrp, NULL, data); ++ if (err) ++ { ++ grub_print_error (); ++ return 0; ++ } ++ } ++ else ++ { ++ grub_error (GRUB_ERR_BAD_FS, "filesystem is corrupt"); ++ grub_print_error (); ++ return 0; ++ } ++ ++ hdrsize = SA_HDR_SIZE (((sa_hdr_phys_t *) sahdrp)); ++ info.mtimeset = 1; ++ info.mtime = grub_zfs_to_cpu64 (*(grub_uint64_t *) ((char *) sahdrp + hdrsize + SA_MTIME_OFFSET), dn.endian); ++ info.case_insensitive = case_insensitive; ++ } ++ ++ if (dn.dn.dn_bonustype == DMU_OT_ZNODE) ++ { ++ info.mtimeset = 1; ++ info.mtime = grub_zfs_to_cpu64 (((znode_phys_t *) DN_BONUS (&dn.dn))->zp_mtime[0], ++ dn.endian); ++ } ++ info.dir = (dn.dn.dn_type == DMU_OT_DIRECTORY_CONTENTS); ++ grub_dprintf ("zfs", "type=%d, name=%s\n", + (int)dn.dn.dn_type, (char *)name); + return hook (name, &info); + } +@@ -2464,7 +3414,8 @@ + data = zfs_mount (device); + if (! data) + return grub_errno; +- err = dnode_get_fullpath (path, &(data->mdn), 0, &(data->dnode), &isfs, data); ++ err = dnode_get_fullpath (path, &(data->mdn), 0, &(data->dnode), &isfs, data, ++ &case_insensitive); + if (err) + { + zfs_unmount (data); +@@ -2532,12 +3483,13 @@ + .close = grub_zfs_close, + .label = zfs_label, + .uuid = zfs_uuid, +- .mtime = 0, ++ .mtime = zfs_mtime, + .next = 0 + }; + + GRUB_MOD_INIT (zfs) + { ++ COMPILE_TIME_ASSERT (sizeof (zap_leaf_chunk_t) == ZAP_LEAF_CHUNKSIZE); + grub_fs_register (&grub_zfs_fs); + #ifndef GRUB_UTIL + my_mod = mod; +--- a/include/grub/zfs/zio.h ++++ b/include/grub/zfs/zio.h +@@ -77,7 +77,15 @@ + ZIO_COMPRESS_OFF, + ZIO_COMPRESS_LZJB, + ZIO_COMPRESS_EMPTY, +- ZIO_COMPRESS_GZIP, ++ ZIO_COMPRESS_GZIP1, ++ ZIO_COMPRESS_GZIP2, ++ ZIO_COMPRESS_GZIP3, ++ ZIO_COMPRESS_GZIP4, ++ ZIO_COMPRESS_GZIP5, ++ ZIO_COMPRESS_GZIP6, ++ ZIO_COMPRESS_GZIP7, ++ ZIO_COMPRESS_GZIP8, ++ ZIO_COMPRESS_GZIP9, + ZIO_COMPRESS_FUNCTIONS + }; + +--- a/grub-core/fs/zfs/zfsinfo.c ++++ b/grub-core/fs/zfs/zfsinfo.c +@@ -141,7 +141,6 @@ + } + grub_printf ("Mirror VDEV with %d children\n", nelm); + print_state (nvlist, tab); +- + for (i = 0; i < nelm; i++) + { + char *child; +@@ -161,6 +160,7 @@ + + grub_free (child); + } ++ return GRUB_ERR_NONE; + } + + print_tabs (tab); +--- a/include/grub/zfs/sa_impl.h ++++ b/include/grub/zfs/sa_impl.h +@@ -29,6 +29,9 @@ + } sa_hdr_phys_t; + + #define SA_HDR_SIZE(hdr) BF32_GET_SB(hdr->sa_layout_info, 10, 16, 3, 0) ++#define SA_TYPE_OFFSET 0x0 + #define SA_SIZE_OFFSET 0x8 ++#define SA_MTIME_OFFSET 0x38 ++#define SA_SYMLINK_OFFSET 0xa0 + + #endif /* _SYS_SA_IMPL_H */ +--- a/include/grub/zfs/zfs.h ++++ b/include/grub/zfs/zfs.h +@@ -28,7 +28,7 @@ + /* + * On-disk version number. + */ +-#define SPA_VERSION 28ULL ++#define SPA_VERSION 33ULL + + /* + * The following are configuration names used in the nvlist describing a pool's +@@ -112,12 +112,14 @@ + grub_err_t grub_zfs_getmdnobj (grub_device_t dev, const char *fsfilename, + grub_uint64_t *mdnobj); + +-char *grub_zfs_nvlist_lookup_string (char *nvlist, char *name); +-char *grub_zfs_nvlist_lookup_nvlist (char *nvlist, char *name); +-int grub_zfs_nvlist_lookup_uint64 (char *nvlist, char *name, ++char *grub_zfs_nvlist_lookup_string (const char *nvlist, const char *name); ++char *grub_zfs_nvlist_lookup_nvlist (const char *nvlist, const char *name); ++int grub_zfs_nvlist_lookup_uint64 (const char *nvlist, const char *name, + grub_uint64_t *out); +-char *grub_zfs_nvlist_lookup_nvlist_array (char *nvlist, char *name, ++char *grub_zfs_nvlist_lookup_nvlist_array (const char *nvlist, ++ const char *name, + grub_size_t index); +-int grub_zfs_nvlist_lookup_nvlist_array_get_nelm (char *nvlist, char *name); ++int grub_zfs_nvlist_lookup_nvlist_array_get_nelm (const char *nvlist, ++ const char *name); + + #endif /* ! GRUB_ZFS_HEADER */ -- cgit v1.2.3