grub-install源码分析---4

grub-install源码分析—4

上一章重点分析了grub是如何探测一个文件系统的，本章分析grub-install的最后一部分代码，该代码包含了最主要的业务逻辑，下面来看。

grub2-install第六部分
util/grub-install.c

    ...

    char mkimage_target[200];
    const char *core_name = NULL;

    switch (platform){
        ...
    case GRUB_INSTALL_PLATFORM_I386_PC:
    snprintf (mkimage_target, sizeof (mkimage_target), "%s-%s",
        grub_install_get_platform_cpu (platform),
        grub_install_get_platform_platform (platform));
    core_name = "core.img";
    break;

        ...
    }

    char *imgfile = grub_util_path_concat (2, platdir, core_name);
    char *prefix = xasprintf ("%s%s", prefix_drive ? : "",
                relative_grubdir);
    grub_install_make_image_wrap (grub_install_source_directory,
                prefix, imgfile, NULL, NULL, mkimage_target, 0);

    ...

前面的章节分析过，grub_install_get_platform_cpu函数最终返回i386，grub_install_get_platform_platform函数最终返回pc，通过snprintf函数拼接在一起，最终的mkimage_target字符串为i386-pc。设置imgfile为”/boot/grub/i386-pc/core.img”，prefix为”/boot/grub”，变量grub_install_source_directory为”/usr/local/lib/grub/i386-pc”，最后通过grub_install_make_image_wrap函数生成core.img。

grub2-install->grub_install_make_image_wrap
util/grub-install-common.c

void grub_install_make_image_wrap (const char *dir, const char *prefix,
                  const char *outname, char *memdisk_path,
                  char *config_path,
                  const char *mkimage_target, int note) {
    FILE *fp;

    fp = grub_util_fopen (outname, "wb");
    grub_install_make_image_wrap_file (dir, prefix, fp, outname,
                     memdisk_path, config_path,
                     mkimage_target, note);
    grub_util_file_sync (fp);
    fclose (fp);
}

首先打开将要写入的文件”/boot/grub/i386-pc/core.img”，然后主体调用grub_install_make_image_wrap_file函数，最后的grub_util_file_sync函数将文件从缓存中同步到硬盘中。下面重点来看grub_install_make_image_wrap_file函数。

grub2-install->grub_install_make_image_wrap->grub_install_make_image_wrap_file
util/grub-install-common.c

void grub_install_make_image_wrap_file (const char *dir, const char *prefix,
                   FILE *fp, const char *outname,
                   char *memdisk_path,
                   char *config_path,
                   const char *mkimage_target, int note){

    const struct grub_install_image_target_desc *tgt;
    const char *const compnames[] = {
        [GRUB_COMPRESSION_AUTO] = "auto",
        [GRUB_COMPRESSION_NONE] = "none",
        [GRUB_COMPRESSION_XZ] = "xz",
        [GRUB_COMPRESSION_LZMA] = "lzma",
    };
    grub_size_t slen = 1;
    char *s, *p;
    char **pk, **md;
    int dc = decompressors ();

    for (md = modules.entries; *md; md++){
        slen += 10 + grub_strlen (*md);
    }

    p = xmalloc (slen);

    for (md = modules.entries; *md; md++) {
        *p++ = '\'';
        p = grub_stpcpy (p, *md);
        *p++ = '\'';
        *p++ = ' ';
    }

    *p = '\0';

    tgt = grub_install_get_image_target (mkimage_target);

    grub_install_generate_image (dir, prefix, fp, outname,
                   modules.entries, memdisk_path,
                   pubkeys, npubkeys, config_path, tgt,
                   note, compression);
    while (dc--)
        grub_install_pop_module ();
}

decompressors函数根据压缩函数指针compress_func加入相应的压缩模块。接下来将全局变量modules中的字符串添加到新分配的内存空间p中。grub_install_get_image_target根据cpu体系mkimage_target获得对应的grub_install_image_target_desc结构，然后调用grub_install_generate_image函数生成core.img，该函数的《grub-mkimage源码分析》文章中分析了。最后通过grub_install_pop_module函数将decompressors函数中添加的模块删除。

grub2-install->grub_install_make_image_wrap->grub_install_make_image_wrap_file->decompressors
util/grub-install-common.c

static int decompressors (void) {
    if (compress_func == grub_install_compress_gzip){
        grub_install_push_module ("gzio");
        return 1;
    }
    if (compress_func == grub_install_compress_xz){
        grub_install_push_module ("xzio");
        grub_install_push_module ("gcry_crc");
        return 2;
    }
    if (compress_func == grub_install_compress_lzop){
        grub_install_push_module ("lzopio");
        grub_install_push_module ("adler32");
        grub_install_push_module ("gcry_crc");
        return 3;
    }
    return 0;
}

decompressors函数就是根据compress_func函数指针，选择需要向core.img映像中添加的模块，例如压缩函数为grub_install_compress_gzip时，就需要添加gzio模块。

grub2-install->grub_install_make_image_wrap->grub_install_make_image_wrap_file->grub_install_get_image_target
util/mkimage.c

const struct grub_install_image_target_desc * grub_install_get_image_target (const char *arg){
    unsigned i, j;
    for (i = 0; i < ARRAY_SIZE (image_targets); i++)
        for (j = 0; j < ARRAY_SIZE (image_targets[i].names) &&
            image_targets[i].names[j]; j++)
            if (strcmp (arg, image_targets[i].names[j]) == 0)
                return &image_targets[i];
    return NULL;
}

grub_install_get_image_target函数比较cpu体系字符串arg，如果和全局的image_targets数组中的每个项的name字段对应，就返回该项。假设参数arg为i386-pc，最终返回的结构如下

    {
        .dirname = "i386-pc",
        .names = { "i386-pc", NULL },
        .voidp_sizeof = 4,
        .bigendian = 0,
        .id = IMAGE_I386_PC, 
        .flags = PLATFORM_FLAGS_DECOMPRESSORS,
        .total_module_size = TARGET_NO_FIELD,
        .decompressor_compressed_size = GRUB_DECOMPRESSOR_I386_PC_COMPRESSED_SIZE,
        .decompressor_uncompressed_size = GRUB_DECOMPRESSOR_I386_PC_UNCOMPRESSED_SIZE,
        .decompressor_uncompressed_addr = TARGET_NO_FIELD,
        .section_align = 1,
        .vaddr_offset = 0,
        .link_addr = GRUB_KERNEL_I386_PC_LINK_ADDR,
        .default_compression = GRUB_COMPRESSION_LZMA
    }

grub2-install第七部分
util/grub-install.c

    ...

    switch (platform){
    case GRUB_INSTALL_PLATFORM_I386_PC:
    char *boot_img_src = grub_util_path_concat (2, 
                grub_install_source_directory, "boot.img");
    char *boot_img = grub_util_path_concat (2, platdir, "boot.img");
    grub_install_copy_file (boot_img_src, boot_img, 1);

    if (install_bootsector)
        grub_util_bios_setup (platdir, "boot.img", "core.img",
                install_drive, force,
                fs_probe, allow_floppy, add_rs_codes);
    break;

    ...

    }

    grub_gcry_fini_all ();
    grub_fini_all ();

    return 0;
}

继续往下看，接下来获取boot.img所在路径boot_img_src，默认为”/usr/local/lib/grub/i386-pc/boot.img”，boot_img为该文件需要拷贝到的路径，默认为”/boot/grub/i386-pc/boot.img”。然后就通过grub_install_copy_file函数将boot_img_src处的boot.img拷贝到boot_img路径中。

变量install_bootsector默认为1，因此接下来通过grub_util_bios_setup函数执行grub文件的安装操作。最后调用grub_gcry_fini_all和grub_fini_all函数做一些收尾工作，本章不关心。

下面重点分析grub_util_bios_setup函数，该函数较长，分为多个部分分析。

grub_util_bios_setup

grub_util_bios_setup第一部分
util/setup.c

void SETUP (const char *dir, const char *boot_file, const char *core_file,
    const char *dest, int force, int fs_probe, int allow_floppy,
    int add_rs_codes __attribute__ ((unused))) {

    char *core_path;
    char *boot_img, *core_img, *boot_path;
    char *root = 0;
    size_t boot_size, core_size;
    grub_uint16_t core_sectors;
    grub_device_t root_dev = 0, dest_dev, core_dev;
    grub_util_fd_t fp;
    struct blocklists bl;

    bl.first_sector = (grub_disk_addr_t) -1;
    bl.current_segment = GRUB_BOOT_I386_PC_KERNEL_SEG + (GRUB_DISK_SECTOR_SIZE >> 4);
    bl.last_length = 0;

    boot_path = grub_util_get_path (dir, boot_file);
    boot_size = grub_util_get_image_size (boot_path);

    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);
    core_img = grub_util_read_image (core_path);

    bl.first_block = (struct grub_boot_blocklist *) (core_img
                           + GRUB_DISK_SECTOR_SIZE
                           - sizeof (*bl.block));

    ...

current_segment定义为0x820，其实是后面解压缩程序的装载地址。boot_path为grub目录下boot.img所在路径，默认为”/boot/grub/i386-pc/boot.img”。然后通过grub_util_get_image_size函数获取该文件大小boot_size，必须为512字节。，再通过grub_util_read_image函数读取该文件到内存boot_img中。

同理，core_path为/boot/grub/i386-pc/core.img，该文件由前面的grub_install_generate_image函数生成，内部包含了diskboot.img，lzma_decompress.img和grub的核心代码kernel.img。core_size为core.img文件的大小，对应的扇区数core_sectors。最后读取该文件到内存core_img中。

core.img的前512字节为diskboot.img，由diskboot.S编译而来，first_block指向diskboot.S文件中的标号blocklist_default_start处，该标号处于grub_boot_blocklist数组最后一项的起始地址，grub_boot_blocklist内部保存了如何从硬盘读取后续文件的信息。

grub_util_bios_setup第二部分
util/setup.c

    ...

    dest_dev = grub_device_open (dest);
    core_dev = dest_dev;

    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);
        try_dev = grub_device_open (drive);

        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);
    }

    for (cur = root_devices; *cur; cur++)
        free (*cur);
    free (root_devices);


    grub_env_set ("root", root)；

    ...

传入的参数dest是要将grub安装到的硬盘，例如hd0。参数dir是grub文件所在目录，例如”/boot/grub/i386-pc/”。首先通过grub_guess_root_devices函数获得grub文件夹所在的根设备，返回对应的设备文件，例如”/dev/sdb”。

接下来遍历可能的根设备文件root_devices，调用grub_util_get_grub_dev函数获得对应的设备，例如hd0。调用grub_device_open打开该设备，获取设备参数，保存在try_dev中。

接下来设置根设备root_dev为新打开的设备try_dev，设置环境变量root指向根设备，例如hd0，如果grub目录所在的根设备try_dev和将要安装的根设备dest_dev相同，就设置found为1。最后设置环境变量root并返回。

grub_util_bios_setup第三部分
util/setup.c

    ...

    char *tmp_img;
    grub_uint8_t *boot_drive_check;

    tmp_img = xmalloc (GRUB_DISK_SECTOR_SIZE);
    grub_disk_read (dest_dev->disk, 0, 0, GRUB_DISK_SECTOR_SIZE, tmp_img);

    boot_drive_check = (grub_uint8_t *) (boot_img
                + GRUB_BOOT_MACHINE_DRIVE_CHECK);

    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 (!allow_floppy && !grub_util_biosdisk_is_floppy (dest_dev->disk)){
        boot_drive_check[0] = 0x90;
        boot_drive_check[1] = 0x90;
    }

    struct identify_partmap_ctx ctx = {
        .dest_partmap = NULL,
        .container = dest_dev->disk->partition,
        .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;

    grub_partition_iterate (dest_dev->disk, identify_partmap, &ctx);

    ...

    fs = grub_fs_probe (dest_dev);
    is_ldm = grub_util_is_ldm (dest_dev->disk);

    ...

首先读取目的设备dest_dev的引导扇区至新分配的内存tmp_img中。根据GRUB_BOOT_MACHINE_DRIVE_CHECK偏移将boot_drive_check指向boot.S文件的标号boot_drive_check处。首先拷贝BIOS参数到tmp_img中，allow_floppy表示是否允许从软盘启动，如果不允许，并且grub_util_biosdisk_is_floppy函数检测出目的设备dest_dev不是软盘，则改变boot.img中boot_drive_check偏移处的起始jmp语句为nop（0x90），jmp语句之下会检测设备是否为硬盘，即是否大于0x80，如果小于0x80，则此时将设备号设置为0x80。

接着通过grub_partition_iterate函数遍历分区，假设最后返回的ctx中的dest_partmap保存了分区类型，例如grub_msdos_partition_map。往下省略的部分是对分区进行检查，grub_fs_probe探测文件系统，假设为ext2。
grub_util_is_ldm和硬盘的LVM相关，这里假设最后返回false。

grub_util_bios_setup第四部分
util/setup.c

    if (fs_probe){
        ...

        if (ctx.dest_partmap && !ctx.dest_partmap->embed){
            goto unable_to_embed;
        }

        ..
    }

unable_to_embed:

    grub_fs_t fs;
    fs = grub_fs_probe (root_dev);

    ...

    bl.block = bl.first_block;
    while (bl.block->len){
        bl.block->start = 0;
        bl.block->len = 0;
        bl.block->segment = 0;
        bl.block--;
    }

    bl.block = bl.first_block;

    grub_install_get_blocklist (root_dev, core_path, core_img, core_size,
                  save_blocklists, &bl);
    write_rootdev (root_dev, boot_img, bl.first_sector);
    fp = grub_util_fd_open (core_path, GRUB_UTIL_FD_O_WRONLY);
    grub_util_fd_write (fp, core_img, GRUB_DISK_SECTOR_SIZE * 2)；
    grub_util_fd_sync (fp);
    grub_util_fd_close (fp);
    grub_util_biosdisk_flush (root_dev->disk);
    grub_disk_cache_invalidate_all ();

    ...

    grub_disk_write (dest_dev->disk, BOOT_SECTOR,
            0, GRUB_DISK_SECTOR_SIZE, boot_img);

    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);
}

假设上面一个函数grub_partition_iterate函数返回的分区类型为grub_msdos_partition_map，此时直接跳到unable_to_embed标号处执行。然后获得grub目录对应根设备的文件系统fs。

bl的block字段指向diskboot.S源文件中blocklist数组的最后一个block处。最后一个block（也即first_block）的len变量记录了需要的block大小，该值在grub_install_generate_image函数的最后设置（《grub-mkimage源码分析—3》）。根据len值，通过while循环初始化blocklist数组。然后调用grub_install_get_blocklist函数根据core_img的大小设置该blocklist数组，内部调用函数指针save_blocklists将其写入内存core_img。

接下来调用write_rootdev更新boot.img文件在内存中的映像boot_img，first_sector表示core.img在硬盘上第一个扇区的扇区号，也即diskboot.S代码所在的扇区起始号。再往下以只写方式打开”/boot/grub/i386-pc/core.img”文件，再通过grub_util_fd_write函数向其中写入core_img的前两个扇区。其中第一个扇区是diskboot.img。根据前面的分析，这里写入一个扇区也行，因为前面的操作只修改了第一个扇区，也即diskboot.img中的值，写入两个扇区应该是考虑了其他不同的情况，这里不往下深究了。

省略的部分是对刚刚写入硬盘的core.img作检查，其做法是首先读取第一个扇区，也即diskboot.img，然后根据diskboot.img最后部分的blocklist，依次读取接下来的扇区，然后比较一共读取的数据长度和总长度core_size，如果不相等，则说明blocklist发生了错误。

接下来通过grub_disk_write函数将boot_img写入根设备的主引导扇区中，传入的宏定义BOOT_SECTOR为0标识了该引导扇区为主引导扇区。最后同步文件，关闭设备。

grub_util_bios_setup->grub_install_get_blocklist
util/setup.c

void grub_install_get_blocklist (grub_device_t root_dev, const char *core_path,
            const char *core_img __attribute__ ((unused)),
            size_t core_size,
            void (*callback) (grub_disk_addr_t sector,
                    unsigned offset,
                    unsigned length,
                    void *data),
            void *hook_data){

    grub_partition_t container = root_dev->disk->partition;
    grub_uint64_t container_start = grub_partition_get_start (container);
    struct fiemap fie1;
    int fd;

    fd = open (core_path, O_RDONLY);

    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;
        int bsize;
        int mul;

        ioctl (fd, FIGETBSZ, &bsize);

        mul = bsize >> GRUB_DISK_SECTOR_BITS;
        nblocks = (core_size + bsize - 1) / bsize;

        for (i = 0; i < nblocks; i++){
            unsigned blk = i;
            int rest;
            ioctl (fd, FIBMAP, &blk);

            rest = core_size - ((i * mul) << GRUB_DISK_SECTOR_BITS);
            if (rest <= 0)
                break;
            if (rest > GRUB_DISK_SECTOR_SIZE * mul)
                rest = GRUB_DISK_SECTOR_SIZE * mul;

            callback (((grub_uint64_t) blk) * mul
                + container_start, 0, rest, hook_data);
        }
    }else{
        ...
    }
    close (fd);
}

首先获得grub目录所在分区container，通过grub_partition_get_start函数获得该分区的起始地址container_start。然后通过参数为FS_IOC_FIEMAP的ioctl判断文件系统的block管理方式，else部分表示使用extent来管理，即不使用block或者说block bitmap来管理block，这里不关心。下面只看if部分的代码。

首先通过参数为FIGETBSZ的ioctl函数获得文件系统一个block的大小bsize，mul表示一个block大小占用多少扇区数，nblocks表示core.img的大小占用多少block。再通过参数为FIBMAP的ioctl函数根据逻辑块号i获取物理块号，保存在blk中。变量rest表示grub一次读取的block数，默认为一次读取一个block。

参数callback函数指针指向save_blocklists，调用该函数设置内存映像core_img中的blocklist。

grub_util_bios_setup->grub_install_get_blocklist->save_blocklists
util/setup.c

static void save_blocklists (grub_disk_addr_t sector, unsigned offset, 
            unsigned length, void *data){

    struct blocklists *bl = data;
    struct grub_boot_blocklist *prev = bl->block + 1;
    grub_uint64_t seclen;

    if (bl->first_sector == (grub_disk_addr_t) -1){
        bl->first_sector = sector;
        sector++;
        length -= GRUB_DISK_SECTOR_SIZE;
        if (!length)
            return;
    }

    seclen = (length + GRUB_DISK_SECTOR_SIZE - 1) >> GRUB_DISK_SECTOR_BITS;

    if (bl->block != bl->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);
        t += seclen;
        prev->len = grub_host_to_target16 (t);
    }else{
        bl->block->start = grub_host_to_target64 (sector);
        bl->block->len = grub_host_to_target16 (seclen);
        bl->block->segment = grub_host_to_target16(bl->current_segment);
        bl->block--;
    }

    bl->last_length = length & (GRUB_DISK_SECTOR_SIZE - 1);
    bl->current_segment += seclen << (GRUB_DISK_SECTOR_BITS - 4);
}

sector表示本次读取的扇区起始地址，length是一次读取的字节长度，seclen是length对应的扇区长度，prev表示上一个block结构的地址。if语句里表示的是文件的内容在物理block上是连续的，此时只要增加上一个block结构的len变量即可。
进入else部分就表示文件的内容在物理block上不连续，或者是第一次进入进入该函数，即此时block和firstblock相等，此时设置start表示绝对扇区标号，len是读取的以扇区为单位的长度，segment是将这段文件内容装在到内存时的段地址。last_length是最后一个扇区的字节长度。

grub_util_bios_setup->write_rootdev
util/setup.c

static void write_rootdev (grub_device_t root_dev, char *boot_img, 
            grub_uint64_t first_sector){

    grub_uint8_t *boot_drive;
    void *kernel_sector;
    boot_drive = (grub_uint8_t *) (boot_img + GRUB_BOOT_MACHINE_BOOT_DRIVE);
    kernel_sector = (boot_img + GRUB_BOOT_MACHINE_KERNEL_SECTOR);
    *boot_drive = 0xFF;
    grub_set_unaligned64 (kernel_sector, grub_cpu_to_le64 (first_sector));
}

首先初始化boot_img中的GRUB_BOOT_MACHINE_BOOT_DRIVE地址处的值标识启动硬盘，GRUB_BOOT_MACHINE_KERNEL_SECTOR宏表示diskboot映像所在的扇区。