blkid_free_probe ()

void
blkid_free_probe (blkid_probe pr);

Deallocates the probe struct, buffers and all allocated data that are associated with this probing control struct.

blkid_new_probe ()

blkid_probe
blkid_new_probe (void);

blkid_new_probe_from_filename ()

blkid_probe
blkid_new_probe_from_filename (const char *filename);

This function is same as call open(filename), blkid_new_probe() and blkid_probe_set_device(pr, fd, 0, 0).

The filename is closed by blkid_free_probe() or by the blkid_probe_set_device() call.

blkid_probe_get_devno ()

dev_t
blkid_probe_get_devno (blkid_probe pr);

blkid_probe_get_fd ()

int
blkid_probe_get_fd (blkid_probe pr);

blkid_probe_get_offset ()

blkid_loff_t
blkid_probe_get_offset (blkid_probe pr);

This function returns offset of probing area as defined by blkid_probe_set_device().

blkid_probe_get_sectors ()

blkid_loff_t
blkid_probe_get_sectors (blkid_probe pr);

blkid_probe_get_sectorsize ()

unsigned int
blkid_probe_get_sectorsize (blkid_probe pr);

blkid_probe_get_size ()

blkid_loff_t
blkid_probe_get_size (blkid_probe pr);

This function returns size of probing area as defined by blkid_probe_set_device(). If the size of the probing area is unrestricted then this function returns the real size of device. See also blkid_get_dev_size().

blkid_probe_get_wholedisk_devno ()

dev_t
blkid_probe_get_wholedisk_devno (blkid_probe pr);

blkid_probe_hide_range ()

int
blkid_probe_hide_range (blkid_probe pr,
                        uint64_t off,
                        uint64_t len);

This function modifies in-memory cached data from the device. The specified range is zeroized. This is usable together with blkid_probe_step_back(). The next blkid_do_probe() will not see specified area.

Note that this is usable for already (by library) read data, and this function is not a way how to hide any large areas on your device.

The function blkid_probe_reset_buffers() reverts all.

blkid_probe_is_wholedisk ()

int
blkid_probe_is_wholedisk (blkid_probe pr);

blkid_probe_reset_buffers ()

int
blkid_probe_reset_buffers (blkid_probe pr);

libblkid reuse all already read buffers from the device. The buffers may be modified by blkid_probe_hide_range(). This function reset and free all cached buffers. The next blkid_do_probe() will read all data from the device.

blkid_probe_set_device ()

int
blkid_probe_set_device (blkid_probe pr,
                        int fd,
                        blkid_loff_t off,
                        blkid_loff_t size);

Assigns the device to probe control struct, resets internal buffers, resets the current probing, and close previously associated device (if open by libblkid).

If fd is < 0 than only resets the prober and returns 1. Note that blkid_reset_probe() keeps the device associated with the prober, but blkid_probe_set_device() does complete reset.

blkid_probe_set_sectorsize ()

int
blkid_probe_set_sectorsize (blkid_probe pr,
                            unsigned int sz);

Note that blkid_probe_set_device() resets this setting. Use it after blkid_probe_set_device() and before any probing call.

Since: 2.30

blkid_probe_step_back ()

int
blkid_probe_step_back (blkid_probe pr);

This function move pointer to the probing chain one step back -- it means that the previously used probing function will be called again in the next blkid_do_probe() call.

This is necessary for example if you erase or modify on-disk superblock according to the current libblkid probing result.

Note that blkid_probe_hide_range() changes semantic of this function and cached buffers are not reset, but library uses in-memory modified buffers to call the next probing function.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

pr = blkid_new_probe_from_filename(devname);

blkid_probe_enable_superblocks(pr, 1);
blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_MAGIC);

blkid_probe_enable_partitions(pr, 1);
blkid_probe_set_partitions_flags(pr, BLKID_PARTS_MAGIC);

while (blkid_do_probe(pr) == 0) {
	const char *ostr = NULL;
	size_t len = 0;

	// superblocks
	if (blkid_probe_lookup_value(pr, "SBMAGIC_OFFSET", &ostr, NULL) == 0)
		blkid_probe_lookup_value(pr, "SBMAGIC", NULL, &len);

	// partition tables
	if (len == 0 && blkid_probe_lookup_value(pr, "PTMAGIC_OFFSET", &ostr, NULL) == 0)
		blkid_probe_lookup_value(pr, "PTMAGIC", NULL, &len);

	if (!len || !str)
		continue;

	// convert ostr to the real offset by off = strtoll(ostr, NULL, 10);
        // use your stuff to erase @len bytes at the @off
        ....

	// retry the last probing to check for backup superblocks ..etc.
        blkid_probe_step_back(pr);
}

blkid_reset_probe ()

void
blkid_reset_probe (blkid_probe pr);

Zeroize probing results and resets the current probing (this has impact to blkid_do_probe() only). This function does not touch probing filters and keeps assigned device.

blkid_probe

typedef struct blkid_struct_probe *blkid_probe;

low-level probing setting