grub-install源码分析—2
上一章分析了grub-install源码的第一部分，该部分的主要功能是处理命令行参数，并初始化一些文件和变量，紧接下来的一部分代码用于处理即将安装的存储设备，下面来看。
grub2-install第四部分
util/grub-install.c
...
size_t ndev = 0;
grub_devices = grub_guess_root_devices (grubdir);
for (curdev = grub_devices; *curdev; curdev++){
grub_util_pull_device (*curdev);
ndev++;
}
grub_drives = xmalloc (sizeof (grub_drives[0]) * (ndev + 1));
for (curdev = grub_devices, curdrive = grub_drives; *curdev; curdev++,
curdrive++){
*curdrive = grub_util_get_grub_dev (*curdev);
}
*curdrive = 0;
grub_dev = grub_device_open (grub_drives[0]);
...变量grubdir表示grub文件所在目录，例如”/boot/grub”，首先通过grub_guess_root_devices函数找到该目录所在的根设备文件名，例如”/dev/sda3”，然后调用grub_util_pull_device函数读取设备以及设备中的分区信息，接着通过grub_util_get_grub_dev函数获取设备文件对应的驱动名，例如第一块硬盘对应的设备文件为”/dev/sda”，则其驱动名为hd0，最后调用grub_device_open函数打开该设备，返回的grub_dev结构中保存了对应的设备信息，例如硬盘的磁道数，扇区数等等。grub_device_open函数内部主要通过grub_disk_open函数打开指定设备，grub_disk_open函数在后面会分析。
grub2-install->grub_guess_root_devices
grub-core/osdep/unix/getroot.c
char ** grub_guess_root_devices (const char *dir_in){
char **os_dev = NULL;
struct stat st;
dev_t dev;
char *dir = grub_canonicalize_file_name (dir_in);
if (!os_dev)
os_dev = grub_find_root_devices_from_mountinfo (dir, NULL);
if (!os_dev)
os_dev = find_root_devices_from_libzfs (dir);
...
stat (dir, &st);
dev = st.st_dev;
os_dev = xmalloc (2 * sizeof (os_dev[0]));
os_dev[0] = grub_find_device ("/dev", dev);
if (!os_dev[0]){
free (os_dev);
return 0;
}
os_dev[1] = 0;
return os_dev;
}传入的参数dir_in为grub目录，默认为”/boot/grub”。grub_canonicalize_file_name函数用于规范目录名，例如解析链接文件，删除一些不必要的文件分隔符，等等。
通过文件名获取根设备信息的方式有很多，接下来一一尝试。首先通过grub_find_root_devices_from_mountinfo函数尝试在linux系统下的”/proc/self/mountinfo”文件中获得根设备信息，如果获取失败，再尝试通过find_root_devices_from_libzfs函数从zfs文件系统中获取根设备信息。假设前两者都没找到，就通过stat函数获取”/boot/grub”文件信息，返回的stat结构体中的st_dev成员变量包含了根设备的主次设备号，根据该主次设备号，通过grub_find_device函数遍历”/dev”目录，查找对应的设备文件。例如stat函数返回0x0803，表示sda的第3个分区，grub_find_device函数最终返回”/dev/sda3”。
grub2-install->grub_guess_root_devices->grub_find_device
grub-core/osdep/unix/getroot.c
char * grub_find_device (const char *dir, dev_t dev){
DIR *dp;
char *saved_cwd;
struct dirent *ent;
dp = opendir (dir);
saved_cwd = xgetcwd ();
chdir (dir);
while ((ent = readdir (dp)) != 0){
struct stat st;
if (ent->d_name[0] == '.')
continue;
if (lstat (ent->d_name, &st) < 0)
continue;
if (S_ISLNK (st.st_mode)) {
if (strcmp (dir, "mapper") == 0 || strcmp (dir, "/dev/mapper") == 0) {
if (stat (ent->d_name, &st) < 0)
continue;
} else
continue;
}
if (S_ISDIR (st.st_mode)){
char *res;
res = grub_find_device (ent->d_name, dev);
if (res){
free (saved_cwd);
closedir (dp);
return res;
}
}
if (S_ISBLK (st.st_mode) && st.st_rdev == dev){
if (ent->d_name[0] == 'd' &&
ent->d_name[1] == 'm' &&
ent->d_name[2] == '-' &&
ent->d_name[3] >= '0' &&
ent->d_name[3] <= '9')
continue;
char *res;
char *cwd;
cwd = xgetcwd ();
res = xmalloc (strlen (cwd) + strlen (ent->d_name) + 3);
sprintf (res, "%s/%s",cwd, ent->d_name);
strip_extra_slashes (res);
free (cwd);
if (strcmp(res, "/dev/root") == 0){
free (res);
continue;
}
chdir (saved_cwd);
free (saved_cwd);
closedir (dp);
return res;
}
}
chdir (saved_cwd);
free (saved_cwd);
closedir (dp);
return 0;
}传入的参数dir为”/dev”，因此接下来就会在该目录下根据另一个参数，也即主次设备号dev查找对应的设备文件。
首先通过opendir函数打开”/dev”文件，xgetcwd函数返回当前工作目录的绝对路径，保存到saved_cwd中，然后通过chdir函数将当前工作目录切换到”/dev”中。
接下来通过while循环遍历”/dev”文件夹下的每个文件，readdir文件读取目录，返回dirent结构体，其中的d_name成员变量表示文件名，这里忽略文件名以点开始的文件（即当前目录”.”或上级目录”..”），lstat函数和前面的stat函数类似，用于获取文件信息。
如果通过S_ISLNK宏判断该文件是一个链接，此处mapper文件和linux的device mapper机制相关，此时需要重新读取文件信息，本章不关心，继续读取下一个文件。如果通过S_ISDIR判断该文件是一个目录，则递归调用grub_find_device函数在子目录下查找对应的根设备。如果通过S_ISBLK判断该文件是一个块设备，此时就要和传入的参数对比主次设备号了，如果相等，但是块设备对应的文件名为dm-数字，则该设备是lvm中的逻辑卷编号，此时忽略；否则，拷贝找到的设备文件名到res中，并返回。最后”/dev/root”表示根文件系统设备，此时也无效。
grub2-install->grub_util_pull_device
util/getroot.c
void grub_util_pull_device (const char *os_dev){
enum grub_dev_abstraction_types ab;
ab = grub_util_get_dev_abstraction (os_dev);
switch (ab){
case GRUB_DEV_ABSTRACTION_LVM:
grub_util_pull_lvm_by_command (os_dev);
case GRUB_DEV_ABSTRACTION_LUKS:
grub_util_pull_devmapper (os_dev);
return;
default:
if (grub_util_pull_device_os (os_dev, ab))
return;
case GRUB_DEV_ABSTRACTION_NONE:
free (grub_util_biosdisk_get_grub_dev (os_dev));
return;
}
}假设grub_util_get_dev_abstraction函数返回GRUB_DEV_ABSTRACTION_NONE，因此接下来执行grub_util_pull_device_os，默认情况下该函数返回0。再往下执行grub_util_pull_device_os函数，该函数默认返回0，最后执行grub_util_biosdisk_get_grub_dev函数，该函数用于查找设备文件os_dev对应的硬盘设备和分区信息，返回设备名，例如fd0、fd1等等。该函数此时只是起到了检测作用。
下面看几个重要的函数。
grub2-install->grub_util_pull_device->grub_util_get_dev_abstraction
util/getroot.c
int grub_util_get_dev_abstraction (const char *os_dev){
enum grub_dev_abstraction_types ret;
if (grub_util_biosdisk_is_present (os_dev))
return GRUB_DEV_ABSTRACTION_NONE;
...
}
int grub_util_biosdisk_is_present (const char *os_dev){
int ret = (find_system_device (os_dev) != NULL);
return ret;
}grub_util_biosdisk_is_present函数用于判断设备文件对应的设备是否能找到，假设能，最终返回GRUB_DEV_ABSTRACTION_NONE，表示普通的硬盘设备。
grub2-install->grub_util_pull_device->grub_util_get_dev_abstraction->grub_util_biosdisk_is_present->find_system_device
util/getroot.c
static const char * find_system_device (const char *os_dev){
char *os_disk;
const char *drive;
int is_part;
os_disk = convert_system_partition_to_system_disk (os_dev, &is_part);
if (! os_disk)
return NULL;
drive = grub_hostdisk_os_dev_to_grub_drive (os_disk, 0);
free (os_disk);
return drive;
}首先通过convert_system_partition_to_system_disk函数根据包含了分区号的设备文件名获取具体的硬盘文件路径。然后通过grub_hostdisk_os_dev_to_grub_drive函数根据硬盘文件路径获得具体的设备名，下面依次来看。
grub2-install->grub_util_pull_device->grub_util_get_dev_abstraction->grub_util_biosdisk_is_present->find_system_device->convert_system_partition_to_system_disk->grub_util_part_to_disk
grub-core/osdep/linux/getroot.c
static char * convert_system_partition_to_system_disk (const char *os_dev, int *is_part){
struct stat st;
stat (os_dev, &st);
*is_part = 0;
return grub_util_part_to_disk (os_dev, &st, is_part);
}
char * grub_util_part_to_disk (const char *os_dev, struct stat *st, int *is_part){
char *path;
...
path = xmalloc (PATH_MAX);
if (! realpath (os_dev, path))
return NULL;
if (strncmp ("/dev/", path, 5) == 0){
char *p = path + 5;
...
if ((strncmp ("hd", p, 2) == 0
|| strncmp ("vd", p, 2) == 0
|| strncmp ("sd", p, 2) == 0)
&& p[2] >= 'a' && p[2] <= 'z'){
char *pp = p + 2;
while (*pp >= 'a' && *pp <= 'z')
pp++;
if (*pp)
*is_part = 1;
*pp = '\0';
return path;
}
...
}
return path;
}convert_system_partition_to_system_disk函数进而调用grub_util_part_to_disk函数，首先通过realpath函数将文件路径os_dev转化为绝对路径path，然后开始分析该路径。首先检查路径是否以”/dev/”开头，然后检查接下来的字符是否已hd、vd和sd开头，再跳过之后的字母，最后将第一个非字母位置上的字符设置为空字符”\0”，因此最后返回未带分区信息的硬盘文件名。例如”/dev/sda1”经过该函数就变为”/dev/sda”。
grub2-install->grub_util_pull_device->grub_util_get_dev_abstraction->grub_util_biosdisk_is_present->find_system_device->grub_hostdisk_os_dev_to_grub_drive
grub-core/kern/emu/hostdisk.c
const char * grub_hostdisk_os_dev_to_grub_drive (const char *os_disk, int add){
unsigned int i;
char *canon;
canon = grub_canonicalize_file_name (os_disk);
if (!canon)
canon = xstrdup (os_disk);
for (i = 0; i < ARRAY_SIZE (map); i++)
if (! map[i].device)
break;
else if (strcmp (map[i].device, canon) == 0){
free (canon);
return map[i].drive;
}
if (!add){
free (canon);
return NULL;
}
...
}全局的map数组在上一章分析的grub_util_biosdisk_init函数中初始化，该函数会读取device.map文件，将该文件的device和drive的对应关系存储到该数组中。grub_hostdisk_os_dev_to_grub_drive函数就是在该map数组中查找device，并返回对应的drive值。例如device为”/dev/sda”，其对应的drive值为”hd0”。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev
util/getroot.c
char * grub_util_biosdisk_get_grub_dev (const char *os_dev){
const char *drive;
char *sys_disk;
int is_part;
sys_disk = convert_system_partition_to_system_disk (os_dev, &is_part);
drive = grub_hostdisk_os_dev_to_grub_drive (sys_disk, 1);
char *name;
grub_disk_t disk;
struct grub_util_biosdisk_get_grub_dev_ctx ctx;
name = make_device_name (drive);
ctx.start = grub_util_find_partition_start (os_dev);
disk = grub_disk_open (name);
free (name);
ctx.partname = NULL;
grub_partition_iterate (disk, find_partition, &ctx);
if (ctx.partname == NULL){
...
return 0;
}
free (ctx.partname);
grub_disk_close (disk);
return name;
}首先通过convert_system_partition_to_system_disk函数获取不带分区信息的设备文件名，前面分析过了。然后通过grub_hostdisk_os_dev_to_grub_drive函数查找设备文件对应的驱动号，前面也分析过了，这里不同之处在于传入的add参数为真，表示当在全局的map数组中找不到对应设备的驱动号时，需要在hostdisk目录下添加设备，下面假设找到了。
make_device_name主要用于规范路径中的分隔号。接下来通过grub_util_find_partition_start函数，进而通过grub_util_find_partition_start_os函数查找grub目录对应分区的起始偏移扇区数。然后通过grub_disk_open打开设备，返回的参数disk保存了硬盘的基本信息。最后调用grub_partition_iterate函数在硬盘中查找该分区，返回分区名。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_util_find_partition_start_os
grub-core/osdep/linux/hostdisk.c
grub_disk_addr_t grub_util_find_partition_start_os (const char *dev){
grub_disk_addr_t start = 0;
grub_util_fd_t fd;
struct hd_geometry hdg;
if (sysfs_partition_start (dev, &start))
return start;
fd = open (dev, O_RDONLY);
ioctl (fd, HDIO_GETGEO, &hdg);
close (fd);
return hdg.start;
}首先通过sysfs_partition_start函数在sysfs文件系统查找设备信息，sysfs文件系统在较早的linux内核中不存在，sysfs_partition_start函数简而言之就是在该文件系统下找到对应的设备目录，在该设备目录下读取start属性。
如果sysfs_partition_start函数获取成功则直接返回结果，否则通过open函数打开设备文件dev，再通过HDIO_GETGEO指令获取块设备的信息，其中包括heads磁头数，sectors每磁道扇区数，cylinders柱面数，以及start表示该分区的起始扇区。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_disk_open
util/getroot.c
grub_disk_t grub_disk_open (const char *name){
const char *p;
grub_disk_t disk;
grub_disk_dev_t dev;
char *raw = (char *) name;
grub_uint64_t current_time;
disk = (grub_disk_t) grub_zalloc (sizeof (*disk));
disk->log_sector_size = GRUB_DISK_SECTOR_BITS;
disk->max_agglomerate = 1048576 >> (GRUB_DISK_SECTOR_BITS
+ GRUB_DISK_CACHE_BITS);
disk->name = grub_strdup (name);
for (dev = grub_disk_dev_list; dev; dev = dev->next){
if ((dev->open) (raw, disk) == GRUB_ERR_NONE)
break;
else if (grub_errno == GRUB_ERR_UNKNOWN_DEVICE)
grub_errno = GRUB_ERR_NONE;
else
goto fail;
}
disk->dev = dev;
return disk;
}GRUB_DISK_SECTOR_BITS宏是表示扇区大小需要的比特数，一个扇区的默认大小为512字节，因此需要9比特。GRUB_DISK_CACHE_BITS宏是表示缓存大小需要的比特数，缓存的最小单元为一个扇区，默认的最大值为最大扇区占用的比特数，例如最大扇区为16kB，因此其为16kB/512B，需要6个比特表示。两者相加就是每块缓存占用的字节数。因此max_agglomerate就是计算缓存个数的最大值。传入的参数name为设备对应的驱动号，例如fd0、fd1、hd0、hd1，等等。根据前面的分析，正常情况下，这里只能是fd0或hd0的其中一种。
接下来遍历grub_disk_dev_list列表，该列表中保存了不同设备类型的打开函数，调用open打开该设备，这里假设最终通过grub_disk_dev_list列表中的grub_biosdisk_dev结构打开该设备，该结构对应的open函数为grub_biosdisk_open，最后的信息保存在disk中并返回。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_disk_open->grub_biosdisk_open
grub-core/disk/i386/pc/biosdisk.c
static grub_err_t grub_biosdisk_open (const char *name, grub_disk_t disk){
grub_uint64_t total_sectors = 0;
int drive;
struct grub_biosdisk_data *data;
drive = grub_biosdisk_get_drive (name);
disk->id = drive;
data = (struct grub_biosdisk_data *) grub_zalloc (sizeof (*data));
data->drive = drive;
if ((cd_drive) && (drive == cd_drive)){
...
}else{
int version;
disk->log_sector_size = 9;
version = grub_biosdisk_check_int13_extensions (drive);
if (version){
struct grub_biosdisk_drp *drp
= (struct grub_biosdisk_drp *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR;
grub_memset (drp, 0, sizeof (*drp));
drp->size = sizeof (*drp);
if (! grub_biosdisk_get_diskinfo_int13_extensions (drive, drp)){
data->flags = GRUB_BIOSDISK_FLAG_LBA;
if (drp->total_sectors)
total_sectors = drp->total_sectors;
else
total_sectors = ((grub_uint64_t) 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++);
}
}
}
}
if (! (data->flags & GRUB_BIOSDISK_FLAG_CDROM)){
if (grub_biosdisk_get_diskinfo_standard (drive,
&data->cylinders,
&data->heads,
&data->sectors) != 0){
...
}
}
disk->total_sectors = total_sectors;
disk->max_agglomerate = 0x7f >> GRUB_DISK_CACHE_BITS;
disk->data = data;
return GRUB_ERR_NONE;
}假设传入的参数name为hd0，首先通过grub_biosdisk_get_drive函数获取硬盘的最终驱动号drive。然后调用grub_biosdisk_check_int13_extensions利用BIOS的int 13中断获得硬盘LBA模式的主版本号version。如果version不为空，就通过参数为0x42的int 0x13中断获取硬盘信息。GRUB_MEMORY_MACHINE_SCRATCH_ADDR为从硬盘中读取的信息的存放地址，默认为0x68000，在该地址上的结构体grub_biosdisk_drp用于保存硬盘的基本信息。
接下来调用grub_biosdisk_get_diskinfo_int13_extensions函数，进而调用参数为0x48的int 0x13中断，读取硬盘信息，将结果保存在drp结构中。如果读取成功返回0，设置flags为GRUB_BIOSDISK_FLAG_LBA，表示LBA模式。
读取的信息中，total_sectors表示硬盘的总扇区数，如果中断没有返回，就自行计算。正常情况下扇区的字节数bytes_per_sector为512字节，转化为比特数log_sector_size默认为9，如果bytes_per_sector不为512字节，就要对该字节数占用的比特数log_sector_size进行相应的调整。
获取完硬盘的总扇区数后，接下来通过grub_biosdisk_get_diskinfo_standard函数获取磁盘的cylinders、heads和sectors参数，其中heads表示有几个磁头，即几个盘面，cylinders表示每个盘面的磁道数，sectors表示每个磁道的扇区数。该函数内部通过参数为0x8的int 13中断读取磁盘参数，和前面的grub_biosdisk_check_int13_extensions函数类似，这里就不往下分析了。这里注意一下，传统的硬盘每磁道的扇区数都相同，例如都为64，这样外圈的磁道的存储密度会低于内圈的存储密度，使用LBA相对寻址技术后，能保证扇区在不论外圈还是内圈都均匀分布，因此外圈的扇区数会明显大于内存的扇区数，此时通过grub_biosdisk_get_diskinfo_standard函数读取出来的sectors参数是一个每磁道扇区数的平均值。
最后将这些结果保存在disk中并返回。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_disk_open->grub_biosdisk_open->grub_biosdisk_get_drive
grub-core/disk/i386/pc/biosdisk.c
static int grub_biosdisk_get_drive (const char *name) {
unsigned long drive;
if ((name[0] != 'f' && name[0] != 'h') || name[1] != 'd')
goto fail;
drive = grub_strtoul (name + 2, 0, 10);
if (name[0] == 'h')
drive += 0x80;
return (int) drive ;
}假设传入的参数name为hd0。首先通过grub_strtoul函数获得hd后面跟着的数字0。如果是以hd开头的硬盘，则需要将驱动号加上0x80，即hd0最终对应的驱动号为0x80，类推hd1，最终的驱动号为0x81。从该函数也可以看出，SCSI和IDE类型的硬盘都是从0x80开始计数，系统并没有区分该类型。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_disk_open->grub_biosdisk_open->grub_biosdisk_get_drive->grub_strtoull
grub-core/kern/misc.c
unsigned long long grub_strtoull (const char *str, char **end, int base){
unsigned long long num = 0;
int found = 0;
while (grub_isspace (*str))
str++;
if (str[0] == '0'){
if (str[1] == 'x'){
if (base == 0 || base == 16){
base = 16;
str += 2;
}
} else if (base == 0 && str[1] >= '0' && str[1] <= '7')
base = 8;
}
if (base == 0)
base = 10;
while (*str){
unsigned long digit;
digit = grub_tolower (*str) - '0';
if (digit > 9){
digit += '0' - 'a' + 10;
if (digit >= (unsigned long) base)
break;
}
found = 1;
num = num * base + digit;
str++;
}
if (end)
*end = (char *) str;
return num;
}首先略过字符串中的起始空格。第一个if判断hd后面跟着的是八进制数或者十六进制数，并设置base为8或者16，
默认base为10，表示10进制。grub_tolower通过字符获得具体的数字，如果该数字大于9，表示是16进制数，也表示后面跟着的是英文字母，需要从9开始计算。num最后统计hd后面跟着的数字是多少，最后的end设置字符串的结尾。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_disk_open->grub_biosdisk_open->grub_biosdisk_check_int13_extensions
grub-core/disk/i386/pc/biosdisk.c
static int grub_biosdisk_check_int13_extensions (int drive){
struct grub_bios_int_registers regs;
regs.edx = drive & 0xff;
regs.eax = 0x4100;
regs.ebx = 0x55aa;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x13, ®s);
if (regs.flags & GRUB_CPU_INT_FLAGS_CARRY)
return 0;
if ((regs.ebx & 0xffff) != 0xaa55)
return 0;
if (!(regs.ecx & 1))
return 0;
return (regs.eax >> 8) & 0xff;
}该函数主要通过grub_bios_interrupt函数进入实模式，调用BIOS的int 0x13中断，参数ah为0x41，该中断用于检查磁盘拓展模式。硬盘有LBA和CHS两种模式，简单说CHS模式支持的硬盘容量较小，并且完全按照硬盘的硬件结构进行寻址并读写，LBA模式采用逻辑寻址，支持的硬盘容量多达TB级别，因此现在大多都使用LBA模式了。
返回结果ebx保存了魔数0xaa55，ecx保存了位图信息，表示当参数为0x42时，int 0x13中断是否可用。最终返回的ah寄存器中保存了LBA模式的主版本号。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_disk_open->grub_biosdisk_open->grub_biosdisk_get_diskinfo_int13_extensions
grub-core/disk/i386/pc/biosdisk.c
static int grub_biosdisk_get_diskinfo_int13_extensions (int drive, void *drp){
return grub_biosdisk_get_diskinfo_real (drive, drp, 0x4800);
}
static int grub_biosdisk_get_diskinfo_real (int drive, void *drp, grub_uint16_t ax){
struct grub_bios_int_registers regs;
regs.eax = ax;
regs.esi = ((grub_addr_t) drp) & 0xf;
regs.ds = ((grub_addr_t) drp) >> 4;
regs.edx = drive & 0xff;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x13, ®s);
if ((regs.flags & GRUB_CPU_INT_FLAGS_CARRY) && ((regs.eax & 0xff00) != 0))
return (regs.eax & 0xff00) >> 8;
return 0;
}ah寄存器为0x48表示读取硬盘参数，ds:esi是接收数据存放的实模式下的地址，32位edx寄存器的低8位，也即dx寄存器表示硬盘号，也即前面的drive，例如0x80，最后返回的ah寄存器存放了返回码。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_partition_iterate
grub-core/kern/partition.c
int grub_partition_iterate (struct grub_disk *disk,
grub_partition_iterate_hook_t hook, void *hook_data){
struct grub_partition_iterate_ctx ctx = {
.ret = 0,
.hook = hook,
.hook_data = hook_data
};
const struct grub_partition_map *partmap;
FOR_PARTITION_MAPS(partmap){
grub_err_t err;
err = partmap->iterate (disk, part_iterate, &ctx);
if (err)
grub_errno = GRUB_ERR_NONE;
if (ctx.ret)
break;
}
return ctx.ret;
}创建的ctx是上下文，用来保存返回的数据，hook_data包含了分区的参数，也用于保存最终的分区名partname。FOR_PARTITION_MAPS宏用于遍历grub_partition_map_list列表，执行相应分区类型对应的iterate函数。下面假设执行了grub_partition_msdos_iterate函数。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_partition_iterate->grub_partition_msdos_iterate
grub-core/partmap/mdsoc.c
grub_err_t grub_partition_msdos_iterate (grub_disk_t disk,
grub_partition_iterate_hook_t hook, void *hook_data){
struct grub_partition p;
struct grub_msdos_partition_mbr mbr;
int labeln = 0;
grub_disk_addr_t lastaddr;
grub_disk_addr_t ext_offset;
grub_disk_addr_t delta = 0;
p.offset = 0;
ext_offset = 0;
p.number = -1;
p.partmap = &grub_msdos_partition_map;
lastaddr = !p.offset;
while (1){
int i;
struct grub_msdos_partition_entry *e;
if (grub_disk_read (disk, p.offset, 0, sizeof (mbr), &mbr))
goto finish;
if (p.offset == 0)
for (i = 0; i < 4; i++)
if (mbr.entries[i].type == GRUB_PC_PARTITION_TYPE_GPT_DISK)
return grub_error (GRUB_ERR_BAD_PART_TABLE, "dummy mbr");
if (labeln && lastaddr == p.offset)
return grub_error (GRUB_ERR_BAD_PART_TABLE, "loop detected");
labeln++;
if ((labeln & (labeln - 1)) == 0)
lastaddr = p.offset;
if (mbr.signature != grub_cpu_to_le16_compile_time (GRUB_PC_PARTITION_SIGNATURE))
return grub_error (GRUB_ERR_BAD_PART_TABLE, "no signature");
for (i = 0; i < 4; i++)
if (mbr.entries[i].flag & 0x7f)
return grub_error (GRUB_ERR_BAD_PART_TABLE, "bad boot flag");
for (p.index = 0; p.index < 4; p.index++){
e = mbr.entries + p.index;
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;
if (! grub_msdos_partition_is_empty (e->type)
&& ! grub_msdos_partition_is_extended (e->type)){
p.number++;
if (hook (disk, &p, hook_data))
return grub_errno;
}else if (p.number < 3)
p.number++;
}
for (i = 0; i < 4; i++){
e = mbr.entries + i;
if (grub_msdos_partition_is_extended (e->type)){
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;
break;
}
}
if (i == 4)
break;
}
finish:
return grub_errno;
}循环之前设置lastaddr是为了保证第一次循环时lastaddr的初始值和offset不相等，其实就是跳过loop检查，所谓loop检查，是为了防止分区表出现循环的现象。
接下来进入while循环，开始遍历分区表，首先通过grub_disk_read函数读取对应的引导扇区，第一次读取时offset为0，因此读取的是主引导扇区，之后的读取主要是在拓展分区中读取分区表形成的链表结构，此时读取的是拓展分区中对应逻辑分区的引导扇区。读取引导扇区mbr后，如果是主引导扇区，需要遍历分区表entries，如果分区表中的4个分区有某个分区的类型为GPT，则报错（GPT分区方式有对应的iterate函数处理）。接下来的lastaddr和labeln的计算用于检查loop，注意这里labeln的计算是为了后面比较本次读取的偏移地址，和前一个2的幂次方位置上读取时的偏移地址，举个例子，假设本次是第7次读取，则需要和第4次读取的偏移地址作比较，如果两者相等，即lastaddr和offset相等，则报错。然后比较签名mbr.signature，默认为0xaa55。flags指示该分区是否有效，默认为0x00，当该分区为可引导分区时，值为0x80。
再往下遍历刚刚读取到的分区表entries，分别计算分区的起始扇区偏移地址start，分区的总扇区数len和分区的类型msdostype。然后判断该分区类型，如果既不是一个无效分区，也不是一个拓展分区，则递增number的值，并调用hook函数，也即part_iterate函数在该分区中查找。
然后，再一次遍历分区表entries，判断如果该分区是一个拓展分区，则重新设置offset的值。其中，ext_offset初始值为0，第一次读取拓展分区后，便记录了拓展分区的起始地址，在后续的读取中，将其加上某个逻辑分区的相对起始地址start，便得到逻辑分区的绝对地址。
最后，如果i等于4，表示读取完了某个引导分区的所有分区表项，此时退出循环。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_partition_iterate->grub_partition_msdos_iterate->grub_disk_read
grub-core/kern/disk.c
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){
if (grub_disk_adjust_range (disk, §or, &offset, size) != GRUB_ERR_NONE){
...
}
while (size >= (GRUB_DISK_CACHE_SIZE << GRUB_DISK_SECTOR_BITS)){
char *data = NULL;
grub_disk_addr_t agglomerate;
grub_err_t err;
for (agglomerate = 0; agglomerate
< (size >> (GRUB_DISK_SECTOR_BITS + GRUB_DISK_CACHE_BITS))
&& agglomerate < disk->max_agglomerate;agglomerate++){
data = grub_disk_cache_fetch (disk->dev->id, disk->id,
sector + (agglomerate << GRUB_DISK_CACHE_BITS));
if (data)
break;
}
if (data){
grub_memcpy ((char *) buf + (agglomerate << (GRUB_DISK_CACHE_BITS +
GRUB_DISK_SECTOR_BITS)), data, GRUB_DISK_CACHE_SIZE << GRUB_DISK_SECTOR_BITS);
}
if (agglomerate){
grub_disk_addr_t i;
(disk->dev->read) (disk, transform_sector (disk, sector),
agglomerate << (GRUB_DISK_CACHE_BITS + GRUB_DISK_SECTOR_BITS
- disk->log_sector_size),buf);
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));
}
if (data){
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);
}
}
if (size){
grub_disk_read_small (disk, sector, 0, size, buf);
}
return grub_errno;
}传入的参数disk中保存了硬盘信息，sector表示从第几个扇区开始读，offset表示字节的偏移数，size表示需要读取的扇区数，buf指针用于保存返回结果。
首先通过grub_disk_adjust_range函数检查即将读取的扇区是否在drive指定的扇区范围内。
接下来通过循环读取数据，GRUB_DISK_CACHE_SIZE宏定义了一次读取最大的扇区数，默认为6，表示64个扇区，换算成字节数为16KB，为了方便说明，这里讲16KB的数据称为“块”。因此当size大于1块时，一次最大只能读取1块数据，agglomerate参数就表示是第几块，max_agglomerate参数则规定了最多读取的扇区数，由前面的定义可知，最多只能读取0x7f个扇区数据。
每次循环中首先通过grub_disk_cache_fetch函数获取缓存中的数据，传入的参数id假设为grub_biosdisk_dev中定义的GRUB_DISK_DEVICE_BIOSDISK_ID，disk->id是在grub_biosdisk_get_drive函数中计算的驱动号，例如第一个块硬盘为0x80。如果缓存中的值存在，则退出循环，并通过grub_memcpy函数将数据拷贝到buf中，注意这里是按块拷贝。
接下来如果agglomerate不为0，则说明agglomerate之前的数据在缓存中找不到。例如， 假设agglomerate为3，则表示可能在缓存中找到了3对应的块，此时0,1,2对应的块在缓存中肯定找不到。需要通过具体设备的read函数读取硬盘数据，读取的长度由agglomerate的值决定，例如agglomerate为3，就要读取3块数据。读取完成后，在buf中遍历每块数据，调用grub_disk_cache_store函数存入缓存，该函数和缓存的取函数grub_disk_cache_fetch类似，这里不往下看了，最后调整各个参数。
最后如果剩余大小不满足一个块的大小，即默认小于16KB，则调用grub_disk_read_small读取剩余数据，grub_disk_read_small和该函数类似，就不分析了。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_partition_iterate->grub_partition_msdos_iterate->grub_disk_read->grub_disk_adjust_range
grub-core/kern/disk-common.c
static grub_err_t grub_disk_adjust_range (grub_disk_t disk, grub_disk_addr_t *sector,
grub_off_t *offset, grub_size_t size)
{
grub_partition_t part;
grub_disk_addr_t total_sectors;
*sector += *offset >> GRUB_DISK_SECTOR_BITS;
*offset &= GRUB_DISK_SECTOR_SIZE - 1;
total_sectors = disk->total_sectors << (disk->log_sector_size - GRUB_DISK_SECTOR_BITS);
if ((total_sectors <= *sector || ((*offset + size + GRUB_DISK_SECTOR_SIZE - 1)
>> GRUB_DISK_SECTOR_BITS) > total_sectors - *sector))
return grub_error (GRUB_ERR_OUT_OF_RANGE, N_("attempt to read or write outside of disk `%s'"), disk->name);
return GRUB_ERR_NONE;
}首先将字节的偏移数offset右移得出offset对应的扇区数，加上sector表示最终读取的起始扇区位置。然后将offset作与运算，得到offset在扇区内的偏移。接下来如果有些硬盘的扇区大小不是512字节，则对总扇区数total_sectors进行相应的调整。 如果对应硬盘的总扇区数total_sectors小于读取的起始扇区sector，或者读取的结束位置大于total_sectors，则报错，否则返回GRUB_ERR_NONE。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_partition_iterate->grub_partition_msdos_iterate->grub_disk_read->grub_disk_cache_fetch
grub-core/kern/disk.c
static char * grub_disk_cache_fetch (unsigned long dev_id, unsigned long disk_id,
grub_disk_addr_t sector)
{
struct grub_disk_cache *cache;
unsigned cache_index;
cache_index = grub_disk_cache_get_index (dev_id, disk_id, sector);
cache = grub_disk_cache_table + cache_index;
if (cache->dev_id == dev_id && cache->disk_id == disk_id && cache->sector == sector){
cache->lock = 1;
return cache->data;
}
return 0;
}传入的参数dev_id是grub_biosdisk_dev中定义的GRUB_DISK_DEVICE_BIOSDISK_ID，代表设备类型，参数disk_id是通过grub_biosdisk_get_drive函数计算的硬盘最终驱动号，例如0x80。首先通过grub_disk_cache_get_index函数根据传入的参数计算缓存数组grub_disk_cache_table的索引cache_index，利用该索引获得对应位置的缓存cache，再比较之后返回对应的值data。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_partition_iterate->grub_partition_msdos_iterate->grub_disk_read->grub_biosdisk_read
grub-core/disk/i386/pc/biosdisk.c
static grub_err_t grub_biosdisk_read (grub_disk_t disk, grub_disk_addr_t sector,
grub_size_t size, char *buf){
while (size){
grub_size_t len;
len = get_safe_sectors (disk, sector);
if (len > size)
len = size;
if (grub_biosdisk_rw (GRUB_BIOSDISK_READ, disk, sector, len,
GRUB_MEMORY_MACHINE_SCRATCH_SEG))
return grub_errno;
grub_memcpy (buf, (void *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR, len << disk->log_sector_size);
buf += len << disk->log_sector_size;
sector += len;
size -= len;
}
return grub_errno;
}grub_biosdisk_read是硬盘设备具体的读取函数，传入的参数sector是读取的起始扇区数，size是读取的总扇区数，buf是读取数据的缓存地址。
进入循环后，首先通过get_safe_sectors函数获取单次读取的扇区数len，因为一次读取是按磁道读取，假设每个磁道包含扇区的平均值为64，当读取的偏移扇区数sector为0时，本次读取的扇区数len就为64-(0%64)为64个扇区，又例如，当读取的偏移扇区数sector为127时，本次读取的扇区数len就为64-(127%64)为1个扇区，这样保证每次读取的扇区数最大就为每磁道扇区数的平均值。如果本次读取的扇区数len大于需要读取的剩余扇区数size，就调整len参数。
grub_biosdisk_rw函数执行具体的读硬盘操作，因为是通过int 13中断在实模式下读取硬盘，为了防止buf缓存地址大于20位，这里需要先将读取到的数据保存到宏GRUB_MEMORY_MACHINE_SCRATCH_ADDR定义的地址处，宏GRUB_MEMORY_MACHINE_SCRATCH_SEG是该地址对应的段地址。
读取完成后，通过grub_memcpy函数将读取的数据从GRUB_MEMORY_MACHINE_SCRATCH_ADDR地址处拷贝到缓存buf中。
最后调整各个参数，循环进行下一次读取。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_partition_iterate->grub_partition_msdos_iterate->grub_disk_read->grub_biosdisk_read->grub_biosdisk_rw
grub-core/disk/i386/pc/biosdisk.c
static grub_err_t grub_biosdisk_rw (int cmd, grub_disk_t disk,
grub_disk_addr_t sector, grub_size_t size, unsigned segment){
struct grub_biosdisk_data *data = disk->data;
if (data->flags & GRUB_BIOSDISK_FLAG_LBA){
struct grub_biosdisk_dap *dap;
dap = (struct grub_biosdisk_dap *) (GRUB_MEMORY_MACHINE_SCRATCH_ADDR
+ (data->sectors << disk->log_sector_size));
dap->length = sizeof (*dap);
dap->reserved = 0;
dap->blocks = size;
dap->buffer = segment << 16;
dap->block = sector;
if (data->flags & GRUB_BIOSDISK_FLAG_CDROM){
...
}else if (grub_biosdisk_rw_int13_extensions (cmd + 0x42, data->drive, dap)){
data->flags &= ~GRUB_BIOSDISK_FLAG_LBA;
disk->total_sectors = data->cylinders * data->heads * data->sectors;
return grub_biosdisk_rw (cmd, disk, sector, size, segment);
}
}else{
...
}
return GRUB_ERR_NONE;
}grub_biosdisk_rw函数执行硬盘具体的读操作，下面只以LBA硬盘为例。首先将请求参数存入一个grub_biosdisk_dap结构中，注意在存储buffer的时候，将segment参数左移16位是将实模式下的段地址存储在buffer的高16位。
接下来通过grub_biosdisk_rw_int13_extensions函数，利用参数为0x42的int 13中断读取数据，如果成功则返回，如果失败，就利用传统的CHS模式再读取一次。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_partition_iterate->grub_partition_msdos_iterate->part_iterate
grub-core/kern/partition.c
static int part_iterate (grub_disk_t dsk, const grub_partition_t partition, void *data){
struct grub_partition_iterate_ctx *ctx = data;
struct grub_partition p = *partition;
p.parent = dsk->partition;
dsk->partition = 0;
if (ctx->hook (dsk, &p, ctx->hook_data)){
ctx->ret = 1;
return 1;
}
...
dsk->partition = p.parent;
return ctx->ret;
}part_iterate函数是传入前面grub_partition_msdos_iterate函数的钩子函数，ctx参数宏的hook函数为grub_util_biosdisk_get_grub_dev函数中设置的find_partition，最后如果找到了则返回1。省略的部分和某些分区类型中的循环遍历有关，本章不考虑。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_partition_iterate->grub_partition_msdos_iterate->part_iterate->find_partition
util/getroot.c
static int find_partition (grub_disk_t dsk __attribute__ ((unused)),
const grub_partition_t partition, void *data){
struct grub_util_biosdisk_get_grub_dev_ctx *ctx = data;
grub_disk_addr_t part_start = 0;
part_start = grub_partition_get_start (partition);
if (ctx->start == part_start){
ctx->partname = grub_partition_get_name (partition);
return 1;
}
return 0;
}首先通过grub_partition_get_start获得该分区的绝对起始扇区数，因为参数partition中的起始扇区数start已经在grub_partition_msdos_iterate函数中计算为绝对起始扇区数了，因此该函数这里什么也没做。接下来比较该分区的起始扇区数part_start和需要比较的起始扇区数start，需要比较的起始扇区数在grub_util_find_partition_start_os函数中获得，如果相等，就调用grub_partition_get_name函数获取分区名，并返回1。
grub2-install->grub_util_pull_device->grub_util_biosdisk_get_grub_dev->grub_partition_iterate->grub_partition_msdos_iterate->part_iterate->find_partition->grub_partition_get_name
grub-core/kern/parition.c
char * grub_partition_get_name (const grub_partition_t partition){
char *out = 0, *ptr;
grub_size_t needlen = 0;
grub_partition_t part;
needlen += grub_strlen (part->partmap->name) + 1 + 27;
out = grub_malloc (needlen + 1);
ptr = out + needlen;
*ptr = 0;
char buf[27];
grub_size_t len;
grub_snprintf (buf, sizeof (buf), "%d", part->number + 1);
len = grub_strlen (buf);
ptr -= len;
grub_memcpy (ptr, buf, len);
len = grub_strlen (part->partmap->name);
ptr -= len;
grub_memcpy (ptr, part->partmap->name, len);
*--ptr = ',';
grub_memmove (out, ptr + 1, out + needlen - ptr);
return out;
}首先分配长度为needlen的内存空间out，ptr指针指向该段内存的末尾，然后先向ptr指针处写入第几个分区，例如是第一个分区number，则写入1，再向其中写入partmap的name变量，这里假设partmap为grub_msdos_partition_map，则其name为msdos，不同的分区通过逗号分隔，最后通过grub_memmove函数将ptr起始处的内存搬到out上并返回。因此最后返回的分区名形如”msdos1，msdos2”。
grub2-install->grub_util_get_grub_dev
util/getroot.c
char * grub_util_get_grub_dev (const char *os_dev){
char *ret;
grub_util_pull_device (os_dev);
ret = grub_util_get_devmapper_grub_dev (os_dev);
if (ret)
return ret;
ret = grub_util_get_grub_dev_os (os_dev);
if (ret)
return ret;
return grub_util_biosdisk_get_grub_dev (os_dev);
}grub_util_get_grub_dev函数主要根据设备文件名，例如/dev/sda，获得对应额设备驱动名，例如hd0，
grub_util_pull_device主要起检测作用，前面分析过了，最后通过grub_util_biosdisk_get_grub_dev函数计算并返回设备驱动名。该函数在前面也分析过了。
扫一扫
2076
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
