/* grub-setup.c - make GRUB usable */ /* * GRUB -- GRand Unified Bootloader * Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,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 #include #include #include #include #include #include #include #ifdef GRUB_SETUP_SPARC64 #include #include #include #else #include #include #endif #include #include #include #include #include #include #include #include #include #include "progname.h" #include #include #include #ifdef __linux__ #include #include #include #endif #define _GNU_SOURCE 1 #include /* On SPARC this program fills in various fields inside of the 'boot' and 'core' * image files. * * The 'boot' image needs to know the OBP path name of the root * device. It also needs to know the initial block number of * 'core' (which is 'diskboot' concatenated with 'kernel' and * all the modules, this is created by grub-mkimage). This resulting * 'boot' image is 512 bytes in size and is placed in the second block * of a partition. * * The initial 'diskboot' block acts as a loader for the actual GRUB * kernel. It contains the loading code and then a block list. * * The block list of 'core' starts at the end of the 'diskboot' image * and works it's way backwards towards the end of the code of 'diskboot'. * * We patch up the images with the necessary values and write out the * result. */ #define DEFAULT_BOOT_FILE "boot.img" #define DEFAULT_CORE_FILE "core.img" #ifdef GRUB_SETUP_SPARC64 #define grub_target_to_host16(x) grub_be_to_cpu16(x) #define grub_target_to_host32(x) grub_be_to_cpu32(x) #define grub_target_to_host64(x) grub_be_to_cpu64(x) #define grub_host_to_target16(x) grub_cpu_to_be16(x) #define grub_host_to_target32(x) grub_cpu_to_be32(x) #define grub_host_to_target64(x) grub_cpu_to_be64(x) #elif defined (GRUB_SETUP_BIOS) #define grub_target_to_host16(x) grub_le_to_cpu16(x) #define grub_target_to_host32(x) grub_le_to_cpu32(x) #define grub_target_to_host64(x) grub_le_to_cpu64(x) #define grub_host_to_target16(x) grub_cpu_to_le16(x) #define grub_host_to_target32(x) grub_cpu_to_le32(x) #define grub_host_to_target64(x) grub_cpu_to_le64(x) #else #error Complete this #endif static void write_rootdev (char *core_img, grub_device_t root_dev, char *boot_img, grub_uint64_t first_sector) { #ifdef GRUB_SETUP_BIOS { grub_uint8_t *boot_drive; grub_disk_addr_t *kernel_sector; boot_drive = (grub_uint8_t *) (boot_img + GRUB_BOOT_MACHINE_BOOT_DRIVE); kernel_sector = (grub_disk_addr_t *) (boot_img + GRUB_BOOT_MACHINE_KERNEL_SECTOR); /* FIXME: can this be skipped? */ *boot_drive = 0xFF; *kernel_sector = grub_cpu_to_le64 (first_sector); } #endif #ifdef GRUB_SETUP_SPARC64 { grub_disk_addr_t *kernel_byte; kernel_byte = (grub_disk_addr_t *) (boot_img + GRUB_BOOT_AOUT_HEADER_SIZE + GRUB_BOOT_MACHINE_KERNEL_BYTE); *kernel_byte = grub_cpu_to_be64 (first_sector << GRUB_DISK_SECTOR_BITS); } #endif } #ifdef GRUB_SETUP_SPARC64 #define BOOT_SECTOR 1 #else #define BOOT_SECTOR 0 #endif static void setup (const char *dir, const char *boot_file, const char *core_file, const char *dest, int force, int fs_probe, int allow_floppy) { char *boot_path, *core_path, *core_path_dev, *core_path_dev_full; char *boot_img, *core_img; char *root = 0; size_t boot_size, core_size; grub_uint16_t core_sectors; grub_device_t root_dev = 0, dest_dev; struct grub_boot_blocklist *first_block, *block; char *tmp_img; grub_disk_addr_t first_sector; #ifdef GRUB_SETUP_BIOS grub_uint16_t current_segment = GRUB_BOOT_I386_PC_KERNEL_SEG + (GRUB_DISK_SECTOR_SIZE >> 4); #endif grub_uint16_t last_length = GRUB_DISK_SECTOR_SIZE; FILE *fp; auto void NESTED_FUNC_ATTR save_first_sector (grub_disk_addr_t sector, unsigned offset, unsigned length); auto void NESTED_FUNC_ATTR save_blocklists (grub_disk_addr_t sector, unsigned offset, unsigned length); void NESTED_FUNC_ATTR save_first_sector (grub_disk_addr_t sector, unsigned offset, unsigned length) { grub_util_info ("the first sector is <%" PRIuGRUB_UINT64_T ",%u,%u>", sector, offset, length); if (offset != 0 || length != GRUB_DISK_SECTOR_SIZE) grub_util_error ("%s", _("the first sector of the core file is not sector-aligned")); first_sector = sector; } void NESTED_FUNC_ATTR save_blocklists (grub_disk_addr_t sector, unsigned offset, unsigned length) { struct grub_boot_blocklist *prev = block + 1; grub_util_info ("saving <%" PRIuGRUB_UINT64_T ",%u,%u>", sector, offset, length); if (offset != 0 || last_length != GRUB_DISK_SECTOR_SIZE) grub_util_error ("%s", _("non-sector-aligned data is found in the core file")); if (block != first_block && (grub_target_to_host64 (prev->start) + grub_target_to_host16 (prev->len)) == sector) { grub_uint16_t t = grub_target_to_host16 (prev->len) + 1; prev->len = grub_host_to_target16 (t); } else { block->start = grub_host_to_target64 (sector); block->len = grub_host_to_target16 (1); #ifdef GRUB_SETUP_BIOS block->segment = grub_host_to_target16 (current_segment); #endif block--; if (block->len) grub_util_error ("%s", _("the sectors of the core file are too fragmented")); } last_length = length; #ifdef GRUB_SETUP_BIOS current_segment += GRUB_DISK_SECTOR_SIZE >> 4; #endif } /* Read the boot image by the OS service. */ boot_path = grub_util_get_path (dir, boot_file); boot_size = grub_util_get_image_size (boot_path); if (boot_size != GRUB_DISK_SECTOR_SIZE) grub_util_error (_("the size of `%s' is not %u"), boot_path, GRUB_DISK_SECTOR_SIZE); boot_img = grub_util_read_image (boot_path); free (boot_path); core_path = grub_util_get_path (dir, core_file); core_size = grub_util_get_image_size (core_path); core_sectors = ((core_size + GRUB_DISK_SECTOR_SIZE - 1) >> GRUB_DISK_SECTOR_BITS); if (core_size < GRUB_DISK_SECTOR_SIZE) grub_util_error (_("the size of `%s' is too small"), core_path); #ifdef GRUB_SETUP_BIOS if (core_size > 0xFFFF * GRUB_DISK_SECTOR_SIZE) grub_util_error (_("the size of `%s' is too large"), core_path); #endif core_img = grub_util_read_image (core_path); /* Have FIRST_BLOCK to point to the first blocklist. */ first_block = (struct grub_boot_blocklist *) (core_img + GRUB_DISK_SECTOR_SIZE - sizeof (*block)); grub_util_info ("root is `%s', dest is `%s'", root, dest); grub_util_info ("Opening dest"); dest_dev = grub_device_open (dest); if (! dest_dev) grub_util_error ("%s", grub_errmsg); { char **root_devices = grub_guess_root_devices (dir); char **cur; int found = 0; for (cur = root_devices; *cur; cur++) { char *drive; grub_device_t try_dev; drive = grub_util_get_grub_dev (*cur); if (!drive) continue; try_dev = grub_device_open (drive); if (! try_dev) continue; if (!found && try_dev->disk->id == dest_dev->disk->id && try_dev->disk->dev->id == dest_dev->disk->dev->id) { if (root_dev) grub_device_close (root_dev); free (root); root_dev = try_dev; root = drive; found = 1; continue; } if (!root_dev) { root_dev = try_dev; root = drive; continue; } grub_device_close (try_dev); free (drive); } if (!root_dev) { grub_util_error ("guessing the root device failed, because of `%s'", grub_errmsg); } grub_util_info ("guessed root_dev `%s' from " "dir `%s'", root_dev->disk->name, dir); } grub_util_info ("setting the root device to `%s'", root); if (grub_env_set ("root", root) != GRUB_ERR_NONE) grub_util_error ("%s", grub_errmsg); #ifdef GRUB_SETUP_BIOS /* Read the original sector from the disk. */ tmp_img = xmalloc (GRUB_DISK_SECTOR_SIZE); if (grub_disk_read (dest_dev->disk, 0, 0, GRUB_DISK_SECTOR_SIZE, tmp_img)) grub_util_error ("%s", grub_errmsg); #endif #ifdef GRUB_SETUP_BIOS { grub_uint16_t *boot_drive_check; boot_drive_check = (grub_uint16_t *) (boot_img + GRUB_BOOT_MACHINE_DRIVE_CHECK); /* Copy the possible DOS BPB. */ memcpy (boot_img + GRUB_BOOT_MACHINE_BPB_START, tmp_img + GRUB_BOOT_MACHINE_BPB_START, GRUB_BOOT_MACHINE_BPB_END - GRUB_BOOT_MACHINE_BPB_START); /* If DEST_DRIVE is a hard disk, enable the workaround, which is for buggy BIOSes which don't pass boot drive correctly. Instead, they pass 0x00 or 0x01 even when booted from 0x80. */ if (!allow_floppy && !grub_util_biosdisk_is_floppy (dest_dev->disk)) /* Replace the jmp (2 bytes) with double nop's. */ *boot_drive_check = 0x9090; } #endif #ifdef GRUB_SETUP_BIOS { grub_partition_map_t dest_partmap = NULL; grub_partition_t container = dest_dev->disk->partition; int multiple_partmaps = 0; int is_ldm; grub_err_t err; grub_disk_addr_t *sectors; int i; grub_fs_t fs; unsigned int nsec, maxsec; /* Unlike root_dev, with dest_dev we're interested in the partition map even if dest_dev itself is a whole disk. */ auto int NESTED_FUNC_ATTR identify_partmap (grub_disk_t disk, const grub_partition_t p); int NESTED_FUNC_ATTR identify_partmap (grub_disk_t disk __attribute__ ((unused)), const grub_partition_t p) { if (p->parent != container) return 0; /* NetBSD and OpenBSD subpartitions have metadata inside a partition, so they are safe to ignore. */ if (grub_strcmp (p->partmap->name, "netbsd") == 0 || grub_strcmp (p->partmap->name, "openbsd") == 0) return 0; if (dest_partmap == NULL) { dest_partmap = p->partmap; return 0; } if (dest_partmap == p->partmap) return 0; multiple_partmaps = 1; return 1; } grub_partition_iterate (dest_dev->disk, identify_partmap); if (container && grub_strcmp (container->partmap->name, "msdos") == 0 && dest_partmap && (container->msdostype == GRUB_PC_PARTITION_TYPE_NETBSD || container->msdostype == GRUB_PC_PARTITION_TYPE_OPENBSD)) { grub_util_warn ("%s", _("Attempting to install GRUB to a disk with multiple partition labels or both partition label and filesystem. This is not supported yet.")); goto unable_to_embed; } fs = grub_fs_probe (dest_dev); if (!fs) grub_errno = GRUB_ERR_NONE; is_ldm = grub_util_is_ldm (dest_dev->disk); #ifdef GRUB_SETUP_BIOS if (fs_probe) { if (!fs && !dest_partmap) grub_util_error (_("unable to identify a filesystem in %s; safety check can't be performed"), dest_dev->disk->name); if (fs && !fs->reserved_first_sector) /* TRANSLATORS: Filesystem may reserve the space just GRUB isn't sure about it. */ grub_util_error (_("%s appears to contain a %s filesystem which isn't known to " "reserve space for DOS-style boot. Installing GRUB there could " "result in FILESYSTEM DESTRUCTION if valuable data is overwritten " "by grub-setup (--skip-fs-probe disables this " "check, use at your own risk)"), dest_dev->disk->name, fs->name); if (dest_partmap && strcmp (dest_partmap->name, "msdos") != 0 && strcmp (dest_partmap->name, "gpt") != 0 && strcmp (dest_partmap->name, "bsd") != 0 && strcmp (dest_partmap->name, "netbsd") != 0 && strcmp (dest_partmap->name, "openbsd") != 0 && strcmp (dest_partmap->name, "sunpc") != 0) /* TRANSLATORS: Partition map may reserve the space just GRUB isn't sure about it. */ grub_util_error (_("%s appears to contain a %s partition map which isn't known to " "reserve space for DOS-style boot. Installing GRUB there could " "result in FILESYSTEM DESTRUCTION if valuable data is overwritten " "by grub-setup (--skip-fs-probe disables this " "check, use at your own risk)"), dest_dev->disk->name, dest_partmap->name); if (is_ldm && dest_partmap && strcmp (dest_partmap->name, "msdos") != 0 && strcmp (dest_partmap->name, "gpt") != 0) grub_util_error (_("%s appears to contain a %s partition map and " "LDM which isn't known to be a safe combination." " Installing GRUB there could " "result in FILESYSTEM DESTRUCTION if valuable data" " is overwritten " "by grub-setup (--skip-fs-probe disables this " "check, use at your own risk)"), dest_dev->disk->name, dest_partmap->name); } #endif /* Copy the partition table. */ if (dest_partmap || (!allow_floppy && !grub_util_biosdisk_is_floppy (dest_dev->disk))) memcpy (boot_img + GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC, tmp_img + GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC, GRUB_BOOT_MACHINE_PART_END - GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC); free (tmp_img); if (! dest_partmap && ! fs && !is_ldm) { grub_util_warn ("%s", _("Attempting to install GRUB to a partitionless disk or to a partition. This is a BAD idea.")); goto unable_to_embed; } if (multiple_partmaps || (dest_partmap && fs) || (is_ldm && fs)) { grub_util_warn ("%s", _("Attempting to install GRUB to a disk with multiple partition labels. This is not supported yet.")); goto unable_to_embed; } if (dest_partmap && !dest_partmap->embed) { grub_util_warn (_("Partition style `%s' doesn't support embedding"), dest_partmap->name); goto unable_to_embed; } if (fs && !fs->embed) { grub_util_warn (_("File system `%s' doesn't support embedding"), fs->name); goto unable_to_embed; } nsec = core_sectors; maxsec = 2 * core_sectors; if (maxsec > ((0x78000 - GRUB_KERNEL_I386_PC_LINK_ADDR) >> GRUB_DISK_SECTOR_BITS)) maxsec = ((0x78000 - GRUB_KERNEL_I386_PC_LINK_ADDR) >> GRUB_DISK_SECTOR_BITS); if (is_ldm) err = grub_util_ldm_embed (dest_dev->disk, &nsec, maxsec, GRUB_EMBED_PCBIOS, §ors); else if (dest_partmap) err = dest_partmap->embed (dest_dev->disk, &nsec, maxsec, GRUB_EMBED_PCBIOS, §ors); else err = fs->embed (dest_dev, &nsec, maxsec, GRUB_EMBED_PCBIOS, §ors); if (!err && nsec < core_sectors) { err = grub_error (GRUB_ERR_OUT_OF_RANGE, N_("Your embedding area is unusually small. " "core.img won't fit in it.")); } err = dest_partmap->embed (dest_dev->disk, &nsec, maxsec, GRUB_EMBED_PCBIOS, §ors); if (err) { grub_util_warn ("%s", grub_errmsg); grub_errno = GRUB_ERR_NONE; goto unable_to_embed; } assert (nsec <= maxsec); /* Clean out the blocklists. */ block = first_block; while (block->len) { grub_memset (block, 0, sizeof (block)); block--; if ((char *) block <= core_img) grub_util_error ("%s", _("no terminator in the core image")); } save_first_sector (sectors[0] + grub_partition_get_start (container), 0, GRUB_DISK_SECTOR_SIZE); block = first_block; for (i = 1; i < nsec; i++) 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); first_block = (struct grub_boot_blocklist *) (core_img + GRUB_DISK_SECTOR_SIZE - sizeof (*block)); grub_size_t no_rs_length; *(grub_uint32_t *) (core_img + GRUB_DISK_SECTOR_SIZE + GRUB_KERNEL_I386_PC_REED_SOLOMON_REDUNDANCY) = grub_host_to_target32 (nsec * GRUB_DISK_SECTOR_SIZE - core_size); no_rs_length = grub_target_to_host16 (*(grub_uint16_t *) (core_img + GRUB_DISK_SECTOR_SIZE + GRUB_KERNEL_I386_PC_NO_REED_SOLOMON_LENGTH)); if (no_rs_length == 0xffff) grub_util_error ("%s", _("core.img version mismatch")); void *tmp = xmalloc (core_size); grub_memcpy (tmp, core_img, core_size); grub_reed_solomon_add_redundancy (core_img + no_rs_length + GRUB_DISK_SECTOR_SIZE, core_size - no_rs_length - GRUB_DISK_SECTOR_SIZE, nsec * GRUB_DISK_SECTOR_SIZE - core_size); assert (grub_memcmp (tmp, core_img, core_size) == 0); free (tmp); /* Write the core image onto the disk. */ for (i = 0; i < nsec; i++) grub_disk_write (dest_dev->disk, sectors[i], 0, GRUB_DISK_SECTOR_SIZE, core_img + i * GRUB_DISK_SECTOR_SIZE); grub_free (sectors); goto finish; } unable_to_embed: #endif if (dest_dev->disk->dev->id != root_dev->disk->dev->id) grub_util_error ("%s", _("embedding is not possible, but this is required for " "RAID and LVM install")); { grub_fs_t fs; fs = grub_fs_probe (root_dev); if (!fs) grub_util_error (_("can't determine filesystem on %s"), root); if (!fs->blocklist_install) grub_util_error (_("filesystem `%s' doesn't support blocklists"), fs->name); } #ifdef GRUB_SETUP_BIOS if (dest_dev->disk->id != root_dev->disk->id || dest_dev->disk->dev->id != root_dev->disk->dev->id) /* TRANSLATORS: cross-disk refers to /boot being on one disk but MBR on another. */ grub_util_error ("%s", _("embedding is not possible, but this is required for " "cross-disk install")); #endif grub_util_warn ("%s", _("Embedding is not possible. GRUB can only be installed in this " "setup by using blocklists. However, blocklists are UNRELIABLE and " "their use is discouraged.")); if (! force) grub_util_error ("%s", _("will not proceed with blocklists")); /* The core image must be put on a filesystem unfortunately. */ grub_util_info ("will leave the core image on the filesystem"); /* 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); core_path_dev = grub_make_system_path_relative_to_its_root (core_path_dev_full); free (core_path_dev_full); grub_util_biosdisk_flush (root_dev->disk); #ifndef __linux__ #define MAX_TRIES 5 { int i; for (i = 0; i < MAX_TRIES; i++) { grub_file_t file; grub_util_info ((i == 0) ? _("attempting to read the core image `%s' from GRUB") : _("attempting to read the core image `%s' from GRUB again"), core_path_dev); grub_disk_cache_invalidate_all (); grub_file_filter_disable_compression (); file = grub_file_open (core_path_dev); if (file) { if (grub_file_size (file) != core_size) grub_util_info ("succeeded in opening the core image but the size is different (%d != %d)", (int) grub_file_size (file), (int) core_size); else if (grub_file_read (file, tmp_img, core_size) != (grub_ssize_t) core_size) grub_util_info ("succeeded in opening the core image but cannot read %d bytes", (int) core_size); else if (memcmp (core_img, tmp_img, core_size) != 0) { #if 0 FILE *dump; FILE *dump2; dump = fopen ("dump.img", "wb"); if (dump) { fwrite (tmp_img, 1, core_size, dump); fclose (dump); } dump2 = fopen ("dump2.img", "wb"); if (dump2) { fwrite (core_img, 1, core_size, dump2); fclose (dump2); } #endif grub_util_info ("succeeded in opening the core image but the data is different"); } else { grub_file_close (file); break; } grub_file_close (file); } else grub_util_info ("couldn't open the core image"); if (grub_errno) grub_util_info ("error message = %s", grub_errmsg); grub_errno = GRUB_ERR_NONE; grub_util_biosdisk_flush (root_dev->disk); sleep (1); } if (i == MAX_TRIES) grub_util_error (_("cannot read `%s' correctly"), core_path_dev); } #endif /* Clean out the blocklists. */ block = first_block; while (block->len) { block->start = 0; block->len = 0; #ifdef GRUB_SETUP_BIOS block->segment = 0; #endif block--; if ((char *) block <= core_img) grub_util_error ("%s", _("no terminator in the core image")); } block = first_block; #ifdef __linux__ { grub_partition_t container = root_dev->disk->partition; struct fiemap fie1; int fd; /* Write the first two sectors of the core image onto the disk. */ grub_util_info ("opening the core image `%s'", core_path); fp = fopen (core_path, "rb"); if (! fp) grub_util_error (_("cannot open `%s': %s"), core_path, strerror (errno)); fd = fileno (fp); grub_memset (&fie1, 0, sizeof (fie1)); fie1.fm_length = core_size; fie1.fm_flags = FIEMAP_FLAG_SYNC; if (ioctl (fd, FS_IOC_FIEMAP, &fie1) < 0) { int nblocks, i, j; int bsize; int mul; grub_util_info ("FIEMAP failed. Reverting to FIBMAP"); if (ioctl (fd, FIGETBSZ, &bsize) < 0) grub_util_error (_("can't retrieve blocklists: %s"), strerror (errno)); if (bsize & (GRUB_DISK_SECTOR_SIZE - 1)) grub_util_error ("%s", _("blocksize is not divisible by 512")); mul = bsize >> GRUB_DISK_SECTOR_BITS; nblocks = (core_size + bsize - 1) / bsize; for (i = 0; i < nblocks; i++) { unsigned blk = i; if (ioctl (fd, FIBMAP, &blk) < 0) grub_util_error (_("can't retrieve blocklists: %s"), strerror (errno)); for (j = 0; j < mul; j++) { int rest = core_size - ((i * mul + j) << GRUB_DISK_SECTOR_BITS); if (rest <= 0) break; if (rest > GRUB_DISK_SECTOR_SIZE) rest = GRUB_DISK_SECTOR_SIZE; if (i == 0 && j == 0) save_first_sector (((grub_uint64_t) blk) * mul + grub_partition_get_start (container), 0, rest); else save_blocklists (((grub_uint64_t) blk) * mul + j + grub_partition_get_start (container), 0, rest); } } } else { struct fiemap *fie2; int i, j; fie2 = xmalloc (sizeof (*fie2) + fie1.fm_mapped_extents * sizeof (fie1.fm_extents[1])); memset (fie2, 0, sizeof (*fie2) + fie1.fm_mapped_extents * sizeof (fie2->fm_extents[1])); fie2->fm_length = core_size; fie2->fm_flags = FIEMAP_FLAG_SYNC; fie2->fm_extent_count = fie1.fm_mapped_extents; if (ioctl (fd, FS_IOC_FIEMAP, fie2) < 0) grub_util_error (_("can't retrieve blocklists: %s"), strerror (errno)); for (i = 0; i < fie2->fm_mapped_extents; i++) { for (j = 0; j < ((fie2->fm_extents[i].fe_length + GRUB_DISK_SECTOR_SIZE - 1) >> GRUB_DISK_SECTOR_BITS); j++) { size_t len = (fie2->fm_extents[i].fe_length - j * GRUB_DISK_SECTOR_SIZE); if (len > GRUB_DISK_SECTOR_SIZE) len = GRUB_DISK_SECTOR_SIZE; if (i == 0 && j == 0) save_first_sector ((fie2->fm_extents[i].fe_physical >> GRUB_DISK_SECTOR_BITS) + j, fie2->fm_extents[i].fe_physical & (GRUB_DISK_SECTOR_SIZE - 1), len); else save_blocklists ((fie2->fm_extents[i].fe_physical >> GRUB_DISK_SECTOR_BITS) + j, fie2->fm_extents[i].fe_physical & (GRUB_DISK_SECTOR_SIZE - 1), len); } } } fclose (fp); } #else { grub_file_t file; /* Now read the core image to determine where the sectors are. */ grub_file_filter_disable_compression (); file = grub_file_open (core_path_dev); if (! file) grub_util_error ("%s", grub_errmsg); file->read_hook = save_first_sector; if (grub_file_read (file, tmp_img, GRUB_DISK_SECTOR_SIZE) != GRUB_DISK_SECTOR_SIZE) grub_util_error ("%s", _("failed to read the first sector of the core image")); block = first_block; file->read_hook = save_blocklists; if (grub_file_read (file, tmp_img, core_size - GRUB_DISK_SECTOR_SIZE) != (grub_ssize_t) core_size - GRUB_DISK_SECTOR_SIZE) grub_util_error ("%s", _("failed to read the rest sectors of the core image")); grub_file_close (file); } #endif #ifdef GRUB_SETUP_SPARC64 { char *boot_devpath; boot_devpath = (char *) (boot_img + GRUB_BOOT_AOUT_HEADER_SIZE + GRUB_BOOT_MACHINE_BOOT_DEVPATH); if (dest_dev->disk->id != root_dev->disk->id || dest_dev->disk->dev->id != root_dev->disk->dev->id) { const char *dest_ofpath; dest_ofpath = grub_util_devname_to_ofpath (grub_util_biosdisk_get_osdev (root_dev->disk)); grub_util_info ("dest_ofpath is `%s'", dest_ofpath); strncpy (boot_devpath, dest_ofpath, GRUB_BOOT_MACHINE_BOOT_DEVPATH_END - GRUB_BOOT_MACHINE_BOOT_DEVPATH - 1); boot_devpath[GRUB_BOOT_MACHINE_BOOT_DEVPATH_END - GRUB_BOOT_MACHINE_BOOT_DEVPATH - 1] = 0; } else { grub_util_info ("non cross-disk install"); memset (boot_devpath, 0, GRUB_BOOT_MACHINE_BOOT_DEVPATH_END - GRUB_BOOT_MACHINE_BOOT_DEVPATH); } grub_util_info ("boot device path %s", boot_devpath); } #endif free (core_path_dev); free (tmp_img); write_rootdev (core_img, root_dev, boot_img, first_sector); /* Write the first two sectors of the core image onto the disk. */ grub_util_info ("opening the core image `%s'", core_path); fp = fopen (core_path, "r+b"); if (! fp) grub_util_error (_("cannot open `%s': %s"), core_path, strerror (errno)); grub_util_write_image (core_img, GRUB_DISK_SECTOR_SIZE * 2, fp, core_path); fflush (fp); fsync (fileno (fp)); fclose (fp); grub_util_biosdisk_flush (root_dev->disk); grub_disk_cache_invalidate_all (); { char *buf, *ptr = core_img; size_t len = core_size; grub_uint64_t blk; grub_partition_t container = root_dev->disk->partition; grub_err_t err; root_dev->disk->partition = 0; buf = xmalloc (core_size); blk = first_sector; err = grub_disk_read (dest_dev->disk, blk, 0, GRUB_DISK_SECTOR_SIZE, buf); if (err) grub_util_error (_("cannot read `%s': %s"), dest_dev->disk->name, grub_errmsg); if (grub_memcmp (buf, ptr, GRUB_DISK_SECTOR_SIZE) != 0) grub_util_error ("%s", _("blocklists are invalid")); ptr += GRUB_DISK_SECTOR_SIZE; len -= GRUB_DISK_SECTOR_SIZE; block = first_block; while (block->len) { size_t cur = grub_target_to_host16 (block->len) << GRUB_DISK_SECTOR_BITS; blk = grub_target_to_host64 (block->start); if (cur > len) cur = len; err = grub_disk_read (dest_dev->disk, blk, 0, cur, buf); if (err) grub_util_error (_("cannot read `%s': %s"), dest_dev->disk->name, grub_errmsg); if (grub_memcmp (buf, ptr, cur) != 0) grub_util_error ("%s", _("blocklists are invalid")); ptr += cur; len -= cur; block--; if ((char *) block <= core_img) grub_util_error ("%s", _("no terminator in the core image")); } root_dev->disk->partition = container; free (buf); } #ifdef GRUB_SETUP_BIOS finish: #endif /* Write the boot image onto the disk. */ if (grub_disk_write (dest_dev->disk, BOOT_SECTOR, 0, GRUB_DISK_SECTOR_SIZE, boot_img)) grub_util_error ("%s", grub_errmsg); grub_util_biosdisk_flush (root_dev->disk); grub_util_biosdisk_flush (dest_dev->disk); free (core_path); free (core_img); free (boot_img); grub_device_close (dest_dev); grub_device_close (root_dev); } static struct argp_option options[] = { {"boot-image", 'b', N_("FILE"), 0, N_("use FILE as the boot image [default=%s]"), 0}, {"core-image", 'c', N_("FILE"), 0, N_("use FILE as the core image [default=%s]"), 0}, {"directory", 'd', N_("DIR"), 0, N_("use GRUB files in the directory DIR [default=%s]"), 0}, {"device-map", 'm', N_("FILE"), 0, N_("use FILE as the device map [default=%s]"), 0}, {"force", 'f', 0, 0, N_("install even if problems are detected"), 0}, {"skip-fs-probe",'s',0, 0, N_("do not probe for filesystems in DEVICE"), 0}, {"verbose", 'v', 0, 0, N_("print verbose messages."), 0}, {"allow-floppy", 'a', 0, 0, N_("make the drive also bootable as floppy (default for fdX devices). May break on some BIOSes."), 0}, { 0, 0, 0, 0, 0, 0 } }; static char * help_filter (int key, const char *text, void *input __attribute__ ((unused))) { switch (key) { case 'b': return xasprintf (text, DEFAULT_BOOT_FILE); case 'c': return xasprintf (text, DEFAULT_CORE_FILE); case 'd': return xasprintf (text, DEFAULT_DIRECTORY); case 'm': return xasprintf (text, DEFAULT_DEVICE_MAP); default: return (char *) text; } } struct arguments { char *boot_file; char *core_file; char *dir; char *dev_map; int force; int fs_probe; int allow_floppy; char *device; }; static error_t argp_parser (int key, char *arg, struct argp_state *state) { /* Get the input argument from argp_parse, which we know is a pointer to our arguments structure. */ struct arguments *arguments = state->input; switch (key) { case 'a': arguments->allow_floppy = 1; break; case 'b': if (arguments->boot_file) free (arguments->boot_file); arguments->boot_file = xstrdup (arg); break; case 'c': if (arguments->core_file) free (arguments->core_file); arguments->core_file = xstrdup (arg); break; case 'd': if (arguments->dir) free (arguments->dir); arguments->dir = xstrdup (arg); break; case 'm': if (arguments->dev_map) free (arguments->dev_map); arguments->dev_map = xstrdup (arg); break; case 'f': arguments->force = 1; break; case 's': arguments->fs_probe = 0; break; case 'v': verbosity++; break; case ARGP_KEY_ARG: if (state->arg_num == 0) arguments->device = xstrdup(arg); else { /* Too many arguments. */ fprintf (stderr, _("Unknown extra argument `%s'."), arg); fprintf (stderr, "\n"); argp_usage (state); } break; case ARGP_KEY_NO_ARGS: fprintf (stderr, "%s", _("No device is specified.\n")); argp_usage (state); exit (1); break; default: return ARGP_ERR_UNKNOWN; } return 0; } static struct argp argp = { options, argp_parser, N_("DEVICE"), "\n"N_("\ Set up images to boot from DEVICE.\n\ \n\ You should not normally run this program directly. Use grub-install instead.") "\v"N_("\ DEVICE must be an OS device (e.g. /dev/sda)."), NULL, help_filter, NULL }; static char * get_device_name (char *dev) { size_t len = strlen (dev); if (dev[0] != '(' || dev[len - 1] != ')') return 0; dev[len - 1] = '\0'; return dev + 1; } int main (int argc, char *argv[]) { char *root_dev = NULL; char *dest_dev = NULL; struct arguments arguments; set_program_name (argv[0]); grub_util_init_nls (); /* Default option values. */ memset (&arguments, 0, sizeof (struct arguments)); arguments.fs_probe = 1; /* Parse our arguments */ if (argp_parse (&argp, argc, argv, 0, 0, &arguments) != 0) { fprintf (stderr, "%s", _("Error in parsing command line arguments\n")); exit(1); } #ifdef GRUB_SETUP_SPARC64 arguments.force = 1; #endif if (verbosity > 1) grub_env_set ("debug", "all"); /* Initialize the emulated biosdisk driver. */ grub_util_biosdisk_init (arguments.dev_map ? : DEFAULT_DEVICE_MAP); /* Initialize all modules. */ grub_init_all (); grub_gcry_init_all (); grub_lvm_fini (); grub_mdraid09_fini (); grub_mdraid1x_fini (); grub_diskfilter_fini (); grub_diskfilter_init (); grub_mdraid09_init (); grub_mdraid1x_init (); grub_lvm_init (); dest_dev = get_device_name (arguments.device); if (! dest_dev) { /* Possibly, the user specified an OS device file. */ dest_dev = grub_util_get_grub_dev (arguments.device); if (! dest_dev) { char *program = xstrdup(program_name); fprintf (stderr, _("Invalid device `%s'.\n"), arguments.device); argp_help (&argp, stderr, ARGP_HELP_STD_USAGE, program); free(program); exit(1); } grub_util_info ("transformed OS device `%s' into GRUB device `%s'", arguments.device, dest_dev); } else { /* For simplicity. */ dest_dev = xstrdup (dest_dev); grub_util_info ("Using `%s' as GRUB device", dest_dev); } /* Do the real work. */ setup (arguments.dir ? : DEFAULT_DIRECTORY, arguments.boot_file ? : DEFAULT_BOOT_FILE, arguments.core_file ? : DEFAULT_CORE_FILE, dest_dev, arguments.force, arguments.fs_probe, arguments.allow_floppy); /* Free resources. */ grub_fini_all (); grub_util_biosdisk_fini (); free (arguments.boot_file); free (arguments.core_file); free (arguments.dir); free (arguments.dev_map); free (arguments.device); free (root_dev); free (dest_dev); return 0; }