static int swap_set_info(blkid_probe pr, const char *version)
{
struct swap_header_v1_2 *hdr;
/* Swap header always located at offset of 1024 bytes */
hdr = (struct swap_header_v1_2 *) blkid_probe_get_buffer(pr, 1024,
sizeof(struct swap_header_v1_2));
if (!hdr)
return -1;
/* SWAPSPACE2 - check for wrong version or zeroed pagecount */
if (strcmp(version, "1") == 0) {
if (hdr->version != 1 && swab32(hdr->version) != 1) {
DBG(LOWPROBE, blkid_debug("incorrect swap version"));
return -1;
}
if (hdr->lastpage == 0) {
DBG(LOWPROBE, blkid_debug("not set last swap page"));
return -1;
}
}
/* arbitrary sanity check.. is there any garbage down there? */
if (hdr->padding[32] == 0 && hdr->padding[33] == 0) {
if (hdr->volume[0] && blkid_probe_set_label(pr, hdr->volume,
sizeof(hdr->volume)) < 0)
return -1;
if (blkid_probe_set_uuid(pr, hdr->uuid) < 0)
return -1;
}
blkid_probe_set_version(pr, version);
return 0;
}
/**
* blkid_init_debug:
* @mask: debug mask (0xffff to enable full debuging)
*
* If the @mask is not specified then this function reads
* LIBBLKID_DEBUG environment variable to get the mask.
*
* Already initialized debugging stuff cannot be changed. It does not
* have effect to call this function twice.
*/
void blkid_init_debug(int mask)
{
if (libblkid_debug_mask & BLKID_DEBUG_INIT)
return;
if (!mask) {
char *str = getenv("LIBBLKID_DEBUG");
if (str)
libblkid_debug_mask = strtoul(str, 0, 0);
} else
libblkid_debug_mask = mask;
libblkid_debug_mask |= BLKID_DEBUG_INIT;
if (libblkid_debug_mask && libblkid_debug_mask != BLKID_DEBUG_INIT) {
const char *ver = NULL;
const char *date = NULL;
DBG(INIT, blkid_debug("library debug mask: 0x%04x",
libblkid_debug_mask));
blkid_get_library_version(&ver, &date);
DBG(INIT, blkid_debug("library version: %s [%s]", ver, date));
}
}
/*
* Reads GPT header to @hdr and returns a pointer to @hdr or NULL in case of
* error. The function also returns GPT entries in @ents.
*
* Note, this function does not allocate any memory. The GPT header has fixed
* size so we use stack, and @ents returns memory from libblkid buffer (so the
* next blkid_probe_get_buffer() will overwrite this buffer).
*
* This function checks validity of header and entries array. A corrupted
* header is not returned.
*/
static struct gpt_header *get_gpt_header(
blkid_probe pr, struct gpt_header *hdr,
struct gpt_entry **ents, uint64_t lba,
uint64_t lastlba)
{
struct gpt_header *h;
uint32_t crc, orgcrc;
uint64_t lu, fu;
size_t esz;
uint32_t hsz, ssz;
ssz = blkid_probe_get_sectorsize(pr);
/* whole sector is allocated for GPT header */
h = (struct gpt_header *) get_lba_buffer(pr, lba, ssz);
if (!h)
return NULL;
if (le64_to_cpu(h->signature) != GPT_HEADER_SIGNATURE)
return NULL;
hsz = le32_to_cpu(h->header_size);
/* EFI: The HeaderSize must be greater than 92 and must be less
* than or equal to the logical block size.
*/
if (hsz > ssz || hsz < sizeof(*h))
return NULL;
/* Header has to be verified when header_crc32 is zero */
orgcrc = h->header_crc32;
h->header_crc32 = 0;
crc = count_crc32((unsigned char *) h, hsz);
h->header_crc32 = orgcrc;
if (crc != le32_to_cpu(orgcrc)) {
DBG(LOWPROBE, blkid_debug("GPT header corrupted"));
return NULL;
}
/* Valid header has to be at MyLBA */
if (le64_to_cpu(h->my_lba) != lba) {
DBG(LOWPROBE, blkid_debug(
"GPT->MyLBA mismatch with real position"));
return NULL;
}
fu = le64_to_cpu(h->first_usable_lba);
lu = le64_to_cpu(h->last_usable_lba);
/* Check if First and Last usable LBA makes sense */
if (lu < fu || fu > lastlba || lu > lastlba) {
DBG(LOWPROBE, blkid_debug(
"GPT->{First,Last}UsableLBA out of range"));
return NULL;
}
/* The header has to be outside usable range */
if (fu < lba && lba < lu) {
DBG(LOWPROBE, blkid_debug("GPT header is inside usable area"));
return NULL;
}
/* Size of blocks with GPT entries */
esz = le32_to_cpu(h->num_partition_entries) *
le32_to_cpu(h->sizeof_partition_entry);
if (!esz) {
DBG(LOWPROBE, blkid_debug("GPT entries undefined"));
return NULL;
}
/* The header seems valid, save it
* (we don't care about zeros in hdr->reserved2 area) */
memcpy(hdr, h, sizeof(*h));
h = hdr;
/* Read GPT entries */
*ents = (struct gpt_entry *) get_lba_buffer(pr,
le64_to_cpu(h->partition_entries_lba), esz);
if (!*ents) {
DBG(LOWPROBE, blkid_debug("GPT entries unreadable"));
return NULL;
}
/* Validate entries */
crc = count_crc32((unsigned char *) *ents, esz);
if (crc != le32_to_cpu(h->partition_entry_array_crc32)) {
DBG(LOWPROBE, blkid_debug("GPT entries corrupted"));
return NULL;
}
return h;
}
