static int is_valid_diskfilter_name (const char *name) { return (grub_memcmp (name, "md", sizeof ("md") - 1) == 0 || grub_memcmp (name, "lvm/", sizeof ("lvm/") - 1) == 0 || grub_memcmp (name, "ldm/", sizeof ("ldm/") - 1) == 0); }
void grub_net_process_dhcp (struct grub_net_buff *nb, struct grub_net_card *card) { char *name; struct grub_net_network_level_interface *inf; name = grub_xasprintf ("%s:dhcp", card->name); if (!name) { grub_print_error (); return; } grub_net_configure_by_dhcp_ack (name, card, 0, (const struct grub_net_bootp_packet *) nb->data, (nb->tail - nb->data), 0, 0, 0); grub_free (name); if (grub_errno) grub_print_error (); else { FOR_NET_NETWORK_LEVEL_INTERFACES(inf) if (grub_memcmp (inf->name, card->name, grub_strlen (card->name)) == 0 && grub_memcmp (inf->name + grub_strlen (card->name), ":dhcp_tmp", sizeof (":dhcp_tmp") - 1) == 0) { grub_net_network_level_interface_unregister (inf); break; } } }
static struct grub_cpio_data * grub_cpio_mount (grub_disk_t disk) { struct head hd; struct grub_cpio_data *data; if (grub_disk_read (disk, 0, 0, sizeof (hd), &hd)) goto fail; if (grub_memcmp (hd.magic, MAGIC, sizeof (MAGIC) - 1) #ifdef MAGIC2 && grub_memcmp (hd.magic, MAGIC2, sizeof (MAGIC2) - 1) #endif ) goto fail; data = (struct grub_cpio_data *) grub_zalloc (sizeof (*data)); if (!data) goto fail; data->disk = disk; return data; fail: grub_error (GRUB_ERR_BAD_FS, "not a " #ifdef MODE_USTAR "tar" #else "cpio" #endif " filesystem"); return 0; }
static int grub_lvm_check_flag (char *p, const char *str, const char *flag) { int len_str = grub_strlen (str), len_flag = grub_strlen (flag); while (1) { char *q; p = grub_strstr (p, str); if (! p) return 0; p += len_str; if (grub_memcmp (p, " = [", sizeof (" = [") - 1) != 0) continue; q = p + sizeof (" = [") - 1; while (1) { while (grub_isspace (*q)) q++; if (*q != '"') return 0; q++; if (grub_memcmp (q, flag, len_flag) == 0 && q[len_flag] == '"') return 1; while (*q != '"') q++; q++; if (*q == ']') return 0; q++; } } }
/* Remove previously registered table from the list */ grub_err_t grub_efiemu_unregister_configuration_table (grub_efi_guid_t guid) { struct grub_efiemu_configuration_table *cur, *prev; /* Special treating if head is to remove */ while (efiemu_config_tables && !grub_memcmp (&(efiemu_config_tables->guid), &guid, sizeof (guid))) { if (efiemu_config_tables->unload) efiemu_config_tables->unload (efiemu_config_tables->data); cur = efiemu_config_tables->next; grub_free (efiemu_config_tables); efiemu_config_tables = cur; } if (!efiemu_config_tables) return GRUB_ERR_NONE; /* Remove from chain */ for (prev = efiemu_config_tables, cur = prev->next; cur;) if (grub_memcmp (&(cur->guid), &guid, sizeof (guid)) == 0) { if (cur->unload) cur->unload (cur->data); prev->next = cur->next; grub_free (cur); cur = prev->next; } else { prev = cur; cur = cur->next; } return GRUB_ERR_NONE; }
static grub_err_t grub_cmd_nthibr (grub_command_t cmd __attribute__ ((unused)), int argc, char **args) { grub_uint8_t hibr_file_magic[4]; grub_file_t hibr_file = 0; if (argc != 1) return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected")); hibr_file = grub_file_open (args[0]); if (!hibr_file) return grub_errno; /* Try to read magic number of 'hiberfil.sys' */ if (grub_file_read (hibr_file, hibr_file_magic, sizeof (hibr_file_magic)) != (grub_ssize_t) sizeof (hibr_file_magic)) { if (!grub_errno) grub_error (GRUB_ERR_TEST_FAILURE, "false"); goto exit; } if (!(grub_memcmp ("hibr", hibr_file_magic, sizeof (hibr_file_magic)) == 0 || grub_memcmp ("HIBR", hibr_file_magic, sizeof (hibr_file_magic)) == 0)) grub_error (GRUB_ERR_TEST_FAILURE, "false"); exit: grub_file_close (hibr_file); return grub_errno; }
void grub_acpi_halt (void) { struct grub_acpi_rsdp_v20 *rsdp2; struct grub_acpi_rsdp_v10 *rsdp1; struct grub_acpi_table_header *rsdt; grub_uint32_t *entry_ptr; rsdp2 = grub_acpi_get_rsdpv2 (); if (rsdp2) rsdp1 = &(rsdp2->rsdpv1); else rsdp1 = grub_acpi_get_rsdpv1 (); grub_dprintf ("acpi", "rsdp1=%p\n", rsdp1); if (!rsdp1) return; rsdt = (struct grub_acpi_table_header *) (grub_addr_t) rsdp1->rsdt_addr; for (entry_ptr = (grub_uint32_t *) (rsdt + 1); entry_ptr < (grub_uint32_t *) (((grub_uint8_t *) rsdt) + rsdt->length); entry_ptr++) { if (grub_memcmp ((void *) (grub_addr_t) *entry_ptr, "FACP", 4) == 0) { grub_uint32_t port; struct grub_acpi_fadt *fadt = ((struct grub_acpi_fadt *) (grub_addr_t) *entry_ptr); struct grub_acpi_table_header *dsdt = (struct grub_acpi_table_header *) (grub_addr_t) fadt->dsdt_addr; int sleep_type = -1; port = fadt->pm1a; grub_dprintf ("acpi", "PM1a port=%x\n", port); if (grub_memcmp (dsdt->signature, "DSDT", sizeof (dsdt->signature)) != 0) break; sleep_type = get_sleep_type ((grub_uint8_t *) dsdt, (grub_uint8_t *) dsdt + dsdt->length); if (sleep_type < 0 || sleep_type >= 8) break; grub_dprintf ("acpi", "SLP_TYP = %d, port = 0x%x\n", sleep_type, port); grub_outw (GRUB_ACPI_SLP_EN | (sleep_type << GRUB_ACPI_SLP_TYP_OFFSET), port & 0xffff); } } grub_millisleep (1500); /* TRANSLATORS: It's computer shutdown using ACPI, not disabling ACPI. */ grub_puts_ (N_("ACPI shutdown failed")); }
static grub_err_t grub_cpio_find_file (struct grub_archelp_data *data, char **name, grub_int32_t *mtime, grub_uint32_t *mode) { struct head hd; grub_size_t namesize; grub_uint32_t modeval; data->hofs = data->next_hofs; if (grub_disk_read (data->disk, 0, data->hofs, sizeof (hd), &hd)) return grub_errno; if (grub_memcmp (hd.magic, MAGIC, sizeof (hd.magic)) != 0 #ifdef MAGIC2 && grub_memcmp (hd.magic, MAGIC2, sizeof (hd.magic)) != 0 #endif ) return grub_error (GRUB_ERR_BAD_FS, "invalid cpio archive"); data->size = read_number (hd.filesize, ARRAY_SIZE (hd.filesize)); if (mtime) *mtime = read_number (hd.mtime, ARRAY_SIZE (hd.mtime)); modeval = read_number (hd.mode, ARRAY_SIZE (hd.mode)); namesize = read_number (hd.namesize, ARRAY_SIZE (hd.namesize)); if (mode) *mode = modeval; *name = grub_malloc (namesize + 1); if (*name == NULL) return grub_errno; if (grub_disk_read (data->disk, 0, data->hofs + sizeof (hd), namesize, *name)) { grub_free (*name); return grub_errno; } (*name)[namesize] = 0; if (data->size == 0 && modeval == 0 && namesize == 11 && grub_memcmp(*name, "TRAILER!!!", 11) == 0) { *mode = GRUB_ARCHELP_ATTR_END; grub_free (*name); return GRUB_ERR_NONE; } data->dofs = data->hofs + ALIGN_CPIO (sizeof (hd) + namesize); data->next_hofs = data->dofs + ALIGN_CPIO (data->size); return GRUB_ERR_NONE; }
static int grub_hfsplus_cmp_attrkey (struct grub_hfsplus_key *keya, struct grub_hfsplus_key_internal *keyb) { struct grub_hfsplus_attrkey *attrkey_a = &keya->attrkey; struct grub_hfsplus_attrkey_internal *attrkey_b = &keyb->attrkey; grub_uint32_t aparent = grub_be_to_cpu32 (attrkey_a->cnid); grub_size_t len; int diff; if (aparent > attrkey_b->cnid) return 1; if (aparent < attrkey_b->cnid) return -1; len = grub_be_to_cpu16 (attrkey_a->namelen); if (len > attrkey_b->namelen) len = attrkey_b->namelen; /* Since it's big-endian memcmp gives the same result as manually comparing uint16_t but may be faster. */ diff = grub_memcmp (attrkey_a->name, attrkey_b->name, len * sizeof (attrkey_a->name[0])); if (diff == 0) diff = grub_be_to_cpu16 (attrkey_a->namelen) - attrkey_b->namelen; return diff; }
static inline char * get_name_ptr (char *name) { char *p = name, *p2; /* Skip Info.plist. */ p2 = grub_strrchr (p, '/'); if (!p2) return name; if (p2 == name) return name + 1; p = p2 - 1; p2 = grub_strrchr (p, '/'); if (!p2) return name; if (p2 == name) return name + 1; if (grub_memcmp (p2, "/Contents/", sizeof ("/Contents/") - 1) != 0) return p2 + 1; p = p2 - 1; p2 = grub_strrchr (p, '/'); if (!p2) return name; return p2 + 1; }
static int grub_xnu_scan_dir_for_kexts_hook (const char *filename, const struct grub_dirhook_info *info, void *closure) { struct grub_xnu_scan_dir_for_kexts_closure *c = closure; char *newdirname; if (! info->dir) return 0; if (filename[0] == '.') return 0; if (grub_strlen (filename) < 5 || grub_memcmp (filename + grub_strlen (filename) - 5, ".kext", 5) != 0) return 0; newdirname = grub_malloc (grub_strlen (c->dirname) + grub_strlen (filename) + 2); /* It's a .kext. Try to load it. */ if (newdirname) { grub_strcpy (newdirname, c->dirname); newdirname[grub_strlen (newdirname) + 1] = 0; newdirname[grub_strlen (newdirname)] = '/'; grub_strcpy (newdirname + grub_strlen (newdirname), filename); grub_xnu_load_kext_from_dir (newdirname, c->osbundlerequired, c->maxrecursion); if (grub_errno == GRUB_ERR_BAD_OS) grub_errno = GRUB_ERR_NONE; grub_free (newdirname); } return 0; }
static grub_err_t read_sblock (grub_disk_t disk, struct grub_btrfs_superblock *sb) { unsigned i; grub_err_t err = GRUB_ERR_NONE; for (i = 0; i < ARRAY_SIZE (superblock_sectors); i++) { struct grub_btrfs_superblock sblock; err = grub_disk_read (disk, superblock_sectors[i], 0, sizeof (sblock), &sblock); if (err == GRUB_ERR_OUT_OF_RANGE) break; if (grub_memcmp ((char *) sblock.signature, GRUB_BTRFS_SIGNATURE, sizeof (GRUB_BTRFS_SIGNATURE) - 1) != 0) break; if (i == 0 || grub_le_to_cpu64 (sblock.generation) > grub_le_to_cpu64 (sb->generation)) grub_memcpy (sb, &sblock, sizeof (sblock)); } if ((err == GRUB_ERR_OUT_OF_RANGE || !err) && i == 0) return grub_error (GRUB_ERR_BAD_FS, "not a Btrfs filesystem"); if (err == GRUB_ERR_OUT_OF_RANGE) grub_errno = err = GRUB_ERR_NONE; return err; }
/* 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_uint8_t computed_hash[GRUB_CRYPTO_MAX_MDLEN]; if (lzopio->ccheck_fun->mdlen > GRUB_CRYPTO_MAX_MDLEN) return -1; grub_crypto_hash (lzopio->ccheck_fun, computed_hash, lzopio->block.cdata, lzopio->block.csize); if (grub_memcmp (computed_hash, &lzopio->block.ccheck, sizeof (lzopio->block.ccheck)) != 0) return -1; } return 0; }
static struct grub_archelp_data * grub_cbfs_mount (grub_disk_t disk) { struct cbfs_file hd; struct grub_archelp_data *data = NULL; grub_uint32_t ptr; grub_off_t header_off; struct cbfs_header head; if (grub_disk_get_size (disk) == GRUB_DISK_SIZE_UNKNOWN) goto fail; if (grub_disk_read (disk, grub_disk_get_size (disk) - 1, GRUB_DISK_SECTOR_SIZE - sizeof (ptr), sizeof (ptr), &ptr)) goto fail; ptr = grub_cpu_to_le32 (ptr); header_off = (grub_disk_get_size (disk) << GRUB_DISK_SECTOR_BITS) + (grub_int32_t) ptr; if (grub_disk_read (disk, 0, header_off, sizeof (head), &head)) goto fail; if (!validate_head (&head)) goto fail; data = (struct grub_archelp_data *) grub_zalloc (sizeof (*data)); if (!data) goto fail; data->cbfs_start = (grub_disk_get_size (disk) << GRUB_DISK_SECTOR_BITS) - (grub_be_to_cpu32 (head.romsize) - grub_be_to_cpu32 (head.offset)); data->cbfs_end = (grub_disk_get_size (disk) << GRUB_DISK_SECTOR_BITS) - grub_be_to_cpu32 (head.bootblocksize); data->cbfs_align = grub_be_to_cpu32 (head.align); if (data->cbfs_start >= (grub_disk_get_size (disk) << GRUB_DISK_SECTOR_BITS)) goto fail; if (data->cbfs_end > (grub_disk_get_size (disk) << GRUB_DISK_SECTOR_BITS)) data->cbfs_end = (grub_disk_get_size (disk) << GRUB_DISK_SECTOR_BITS); data->next_hofs = data->cbfs_start; if (grub_disk_read (disk, 0, data->cbfs_start, sizeof (hd), &hd)) goto fail; if (grub_memcmp (hd.magic, CBFS_FILE_MAGIC, sizeof (CBFS_FILE_MAGIC) - 1)) goto fail; data->disk = disk; return data; fail: grub_free (data); grub_error (GRUB_ERR_BAD_FS, "not a cbfs filesystem"); return 0; }
static grub_err_t grub_dmraid_nv_detect (grub_disk_t disk, struct grub_raid_array *array) { grub_disk_addr_t sector; struct grub_nv_super sb; if (disk->partition) return grub_error (GRUB_ERR_OUT_OF_RANGE, "skip partition"); sector = grub_disk_get_size (disk) - 2; if (grub_disk_read (disk, sector, 0, sizeof (sb), &sb)) return grub_errno; if (grub_memcmp (sb.vendor, NV_ID_STRING, 6)) return grub_error (GRUB_ERR_OUT_OF_RANGE, "not raid"); if (sb.version != NV_VERSION) return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, "unknown version: %d.%d", sb.version); switch (sb.array.raid_level) { case NV_LEVEL_0: array->level = 0; array->disk_size = sb.capacity / sb.array.total_volumes; break; case NV_LEVEL_1: array->level = 1; array->disk_size = sb.capacity; break; case NV_LEVEL_5: array->level = 5; array->layout = GRUB_RAID_LAYOUT_LEFT_ASYMMETRIC; array->disk_size = sb.capacity / (sb.array.total_volumes - 1); break; default: return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, "unsupported RAID level: %d", sb.array.raid_level); } array->number = 0; array->total_devs = sb.array.total_volumes; array->chunk_size = sb.array.stripe_block_size; array->disk_offset = 0; array->index = sb.unit_number; array->uuid_len = sizeof (sb.array.signature); array->uuid = grub_malloc (sizeof (sb.array.signature)); if (! array->uuid) return grub_errno; grub_memcpy (array->uuid, (char *) &sb.array.signature, sizeof (sb.array.signature)); return 0; }
/* Helper for grub_linuxbios_table_iterate. */ static int check_signature (grub_linuxbios_table_header_t tbl_header) { if (! grub_memcmp (tbl_header->signature, "LBIO", 4)) return 1; return 0; }
static int check_name_real (const grub_uint8_t *name_at, const grub_uint8_t *head, const grub_uint8_t *tail, const char *check_with, int *length, char *set) { const char *readable_ptr = check_with; const grub_uint8_t *ptr; char *optr = set; int bytes_processed = 0; if (length) *length = 0; for (ptr = name_at; ptr < tail && bytes_processed < tail - head + 2; ) { /* End marker. */ if (!*ptr) { if (length && *length) (*length)--; if (optr && optr != set) optr--; if (optr) *optr = 0; return !readable_ptr || (*readable_ptr == 0); } if (*ptr & 0xc0) { bytes_processed += 2; if (ptr + 1 >= tail) return 0; ptr = head + (((ptr[0] & 0x3f) << 8) | ptr[1]); continue; } if (readable_ptr && grub_memcmp (ptr + 1, readable_ptr, *ptr) != 0) return 0; if (grub_memchr (ptr + 1, 0, *ptr) || grub_memchr (ptr + 1, '.', *ptr)) return 0; if (readable_ptr) readable_ptr += *ptr; if (readable_ptr && *readable_ptr != '.' && *readable_ptr != 0) return 0; bytes_processed += *ptr + 1; if (length) *length += *ptr + 1; if (optr) { grub_memcpy (optr, ptr + 1, *ptr); optr += *ptr; } if (optr) *optr++ = '.'; if (readable_ptr && *readable_ptr) readable_ptr++; ptr += *ptr + 1; } return 0; }
/* Try to find out size of uncompressed data, * also do some footer sanity checks. */ static int test_footer (grub_file_t file) { grub_xzio_t xzio = file->data; grub_uint8_t footer[FOOTER_MAGIC_SIZE]; grub_uint32_t backsize; grub_uint8_t imarker; grub_uint64_t uncompressed_size_total = 0; grub_uint64_t uncompressed_size; grub_uint64_t records; grub_file_seek (xzio->file, xzio->file->size - FOOTER_MAGIC_SIZE); if (grub_file_read (xzio->file, footer, FOOTER_MAGIC_SIZE) != FOOTER_MAGIC_SIZE || grub_memcmp (footer, FOOTER_MAGIC, FOOTER_MAGIC_SIZE) != 0) goto ERROR; grub_file_seek (xzio->file, xzio->file->size - 8); if (grub_file_read (xzio->file, &backsize, sizeof (backsize)) != sizeof (backsize)) goto ERROR; /* Calculate real backward size. */ backsize = (grub_le_to_cpu32 (backsize) + 1) * 4; /* Set file to the beginning of stream index. */ grub_file_seek (xzio->file, xzio->file->size - XZ_STREAM_FOOTER_SIZE - backsize); /* Test index marker. */ if (grub_file_read (xzio->file, &imarker, sizeof (imarker)) != sizeof (imarker) && imarker != 0x00) goto ERROR; if (read_vli (xzio->file, &records) <= 0) goto ERROR; for (; records != 0; records--) { if (read_vli (xzio->file, &uncompressed_size) <= 0) /* Ignore unpadded. */ goto ERROR; if (read_vli (xzio->file, &uncompressed_size) <= 0) /* Uncompressed. */ goto ERROR; uncompressed_size_total += uncompressed_size; } file->size = uncompressed_size_total; grub_file_seek (xzio->file, STREAM_HEADER_SIZE); return 1; ERROR: grub_error (GRUB_ERR_BAD_COMPRESSED_DATA, "bad footer magic"); return 0; }
static void probe_abstraction (grub_disk_t disk) { grub_disk_memberlist_t list = NULL, tmp; int raid_level; if (disk->dev->memberlist) list = disk->dev->memberlist (disk); while (list) { probe_abstraction (list->disk); tmp = list->next; free (list); list = tmp; } if (disk->dev->id == GRUB_DISK_DEVICE_DISKFILTER_ID && (grub_memcmp (disk->name, "lvm/", sizeof ("lvm/") - 1) == 0 || grub_memcmp (disk->name, "lvmid/", sizeof ("lvmid/") - 1) == 0)) printf ("lvm "); if (disk->dev->id == GRUB_DISK_DEVICE_DISKFILTER_ID && grub_memcmp (disk->name, "ldm/", sizeof ("ldm/") - 1) == 0) printf ("ldm "); if (disk->dev->id == GRUB_DISK_DEVICE_CRYPTODISK_ID) grub_util_cryptodisk_get_abstraction (disk, do_print); raid_level = probe_raid_level (disk); if (raid_level >= 0) { printf ("diskfilter "); if (disk->dev->raidname) printf ("%s ", disk->dev->raidname (disk)); } if (raid_level == 5) printf ("raid5rec "); if (raid_level == 6) printf ("raid6rec "); }
static int grub_lvm_checkvalue (char **p, char *str, char *tmpl) { int tmpllen = grub_strlen (tmpl); *p = grub_strstr (*p, str); if (! *p) return 0; *p += grub_strlen (str); if (**p != '"') return 0; return (grub_memcmp (*p + 1, tmpl, tmpllen) == 0 && (*p)[tmpllen + 1] == '"'); }
/* 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_uint8_t computed_hash[GRUB_CRYPTO_MAX_MDLEN]; if (lzopio->ucheck_fun->mdlen > GRUB_CRYPTO_MAX_MDLEN) return -1; grub_crypto_hash (lzopio->ucheck_fun, computed_hash, lzopio->block.udata, lzopio->block.usize); if (grub_memcmp (computed_hash, &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; }
int grub_util_is_ldm (grub_disk_t disk) { int i; int has_ldm = msdos_has_ldm_partition (disk); for (i = 0; i < 3; i++) { grub_disk_addr_t sector = LDM_LABEL_SECTOR; grub_err_t err; struct grub_ldm_label label; switch (i) { case 0: if (!has_ldm) continue; sector = LDM_LABEL_SECTOR; break; case 1: /* LDM is never inside a partition. */ if (!has_ldm || disk->partition) continue; sector = grub_disk_get_size (disk); if (sector == GRUB_DISK_SIZE_UNKNOWN) continue; sector--; break; /* FIXME: try the third copy. */ case 2: sector = gpt_ldm_sector (disk); if (!sector) continue; break; } err = grub_disk_read (disk, sector, 0, sizeof(label), &label); if (err) { grub_errno = GRUB_ERR_NONE; return 0; } /* This check is more relaxed on purpose. */ if (grub_memcmp (label.magic, LDM_MAGIC, sizeof (label.magic)) == 0) return 1; } return 0; }
struct grub_acpi_rsdp_v20 * grub_machine_acpi_get_rsdpv2 (void) { unsigned i; static grub_efi_packed_guid_t acpi20_guid = GRUB_EFI_ACPI_20_TABLE_GUID; for (i = 0; i < grub_efi_system_table->num_table_entries; i++) { grub_efi_packed_guid_t *guid = &grub_efi_system_table->configuration_table[i].vendor_guid; if (! grub_memcmp (guid, &acpi20_guid, sizeof (grub_efi_packed_guid_t))) return (struct grub_acpi_rsdp_v20 *) grub_efi_system_table->configuration_table[i].vendor_table; } return 0; }
/* Compare device paths. */ int grub_efi_compare_device_paths (const grub_efi_device_path_t *dp1, const grub_efi_device_path_t *dp2) { if (! dp1 || ! dp2) /* Return non-zero. */ return 1; while (1) { grub_efi_uint8_t type1, type2; grub_efi_uint8_t subtype1, subtype2; grub_efi_uint16_t len1, len2; int ret; type1 = GRUB_EFI_DEVICE_PATH_TYPE (dp1); type2 = GRUB_EFI_DEVICE_PATH_TYPE (dp2); if (type1 != type2) return (int) type2 - (int) type1; subtype1 = GRUB_EFI_DEVICE_PATH_SUBTYPE (dp1); subtype2 = GRUB_EFI_DEVICE_PATH_SUBTYPE (dp2); if (subtype1 != subtype2) return (int) subtype1 - (int) subtype2; len1 = GRUB_EFI_DEVICE_PATH_LENGTH (dp1); len2 = GRUB_EFI_DEVICE_PATH_LENGTH (dp2); if (len1 != len2) return (int) len1 - (int) len2; ret = grub_memcmp (dp1, dp2, len1); if (ret != 0) return ret; if (GRUB_EFI_END_ENTIRE_DEVICE_PATH (dp1)) break; dp1 = (grub_efi_device_path_t *) ((char *) dp1 + len1); dp2 = (grub_efi_device_path_t *) ((char *) dp2 + len2); } return 0; }
static grub_device_t 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); int hook (const char *name) { grub_device_t dev; grub_err_t err; struct grub_btrfs_superblock sb; dev = grub_device_open (name); if (!dev) return 0; if (!dev->disk) { grub_device_close (dev); return 0; } err = read_sblock (dev->disk, &sb); 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; } if (grub_memcmp (data->sblock.uuid, sb.uuid, sizeof (sb.uuid)) != 0 || sb.this_device.device_id != id) { grub_device_close (dev); return 0; } dev_found = dev; return 1; }
static grub_size_t insert_dir (const char *name, struct dir **root, grub_uint8_t *ptr) { struct dir *cur, **head = root; const char *cb, *ce = name; grub_size_t size = 0; while (1) { for (cb = ce; *cb == '/'; cb++); for (ce = cb; *ce && *ce != '/'; ce++); if (!*ce) break; for (cur = *root; cur; cur = cur->next) if (grub_memcmp (cur->name, cb, ce - cb) && cur->name[ce - cb] == 0) break; if (!cur) { struct dir *n; n = grub_zalloc (sizeof (*n)); if (!n) return 0; n->next = *head; n->name = grub_strndup (cb, ce - cb); if (ptr) { grub_dprintf ("linux", "Creating directory %s, %s\n", name, ce); ptr = make_header (ptr, name, ce - name, 040777, 0); } size += ALIGN_UP ((ce - (char *) name) + sizeof (struct newc_head), 4); *head = n; cur = n; } root = &cur->next; } return size; }
void * grub_efi_get_firmware_fdt (void) { grub_efi_configuration_table_t *tables; grub_efi_guid_t fdt_guid = GRUB_EFI_DEVICE_TREE_GUID; void *firmware_fdt = NULL; unsigned int i; /* Look for FDT in UEFI config tables. */ tables = grub_efi_system_table->configuration_table; for (i = 0; i < grub_efi_system_table->num_table_entries; i++) if (grub_memcmp (&tables[i].vendor_guid, &fdt_guid, sizeof (fdt_guid)) == 0) { firmware_fdt = tables[i].vendor_table; grub_dprintf ("linux", "found registered FDT @ %p\n", firmware_fdt); break; } return firmware_fdt; }
/* Helper for gpt_ldm_sector. */ static int gpt_ldm_sector_iter (grub_disk_t disk, const grub_partition_t p, void *data) { grub_disk_addr_t *sector = data; struct grub_gpt_partentry gptdata; grub_partition_t p2; p2 = disk->partition; disk->partition = p->parent; if (grub_disk_read (disk, p->offset, p->index, sizeof (gptdata), &gptdata)) { disk->partition = p2; return 0; } disk->partition = p2; if (! grub_memcmp (&gptdata.type, &ldm_type, 16)) { *sector = p->start + p->len - 1; return 1; } return 0; }
static int match_string (grub_uitree_t node, const char *str) { grub_uitree_t child; char *cmd; child = node->child; while (child) { int len; len = grub_strlen (child->name); if (! grub_memcmp (child->name, str, len)) { const char *p; p = str + len; if ((*p == '.') || (*p == '-')) p++; if (match_string (child, p)) return 1; } child = child->next; } cmd = grub_uitree_get_prop (node, "command"); if (cmd) { grub_parser_execute (cmd); return 1; } return 0; }
static struct grub_archelp_data * grub_cpio_mount (grub_disk_t disk) { struct head hd; struct grub_archelp_data *data; if (grub_disk_read (disk, 0, 0, sizeof (hd), &hd)) goto fail; if (grub_memcmp (hd.magic, MAGIC, sizeof (MAGIC) - 1)) goto fail; data = (struct grub_archelp_data *) grub_zalloc (sizeof (*data)); if (!data) goto fail; data->disk = disk; return data; fail: grub_error (GRUB_ERR_BAD_FS, "not a tarfs filesystem"); return 0; }