int main(int argc, char *argv[])
{
int rc;
char *devname;
blkid_probe pr;
blkid_topology tp;
if (argc < 2) {
fprintf(stderr, "usage: %s <device> "
"-- checks based on libblkid for mkfs-like programs.\n",
program_invocation_short_name);
return EXIT_FAILURE;
}
devname = argv[1];
pr = blkid_new_probe_from_filename(devname);
if (!pr)
err(EXIT_FAILURE, "%s: faild to create a new libblkid probe",
devname);
/*
* check Filesystems / Partitions overwrite
*/
/* enable partitions probing (superblocks are enabled by default) */
blkid_probe_enable_partitions(pr, TRUE);
rc = blkid_do_fullprobe(pr);
if (rc == -1)
errx(EXIT_FAILURE, "%s: blkid_do_fullprobe() failed", devname);
else if (rc == 0) {
const char *type;
if (!blkid_probe_lookup_value(pr, "TYPE", &type, NULL))
errx(EXIT_FAILURE, "%s: appears to contain an existing "
"%s superblock", devname, type);
if (!blkid_probe_lookup_value(pr, "PTTYPE", &type, NULL))
errx(EXIT_FAILURE, "%s: appears to contain an partition "
"table (%s)", devname, type);
}
/*
* get topology details
*/
tp = blkid_probe_get_topology(pr);
if (!tp)
errx(EXIT_FAILURE, "%s: failed to read topology", devname);
/* ... your mkfs.<type> code or so ...
off = blkid_topology_get_alignment_offset(tp);
*/
blkid_free_probe(pr);
return EXIT_SUCCESS;
}
static lgfs2_rgrps_t rgrps_init(struct gfs2_sbd *sdp)
{
int ret;
int error;
uint64_t al_base = 0;
uint64_t al_off = 0;
struct stat st;
blkid_probe pr = blkid_new_probe();
if (pr == NULL || blkid_probe_set_device(pr, sdp->device_fd, 0, 0) != 0
|| blkid_probe_enable_superblocks(pr, TRUE) != 0
|| blkid_probe_enable_partitions(pr, TRUE) != 0) {
fprintf(stderr, _("Failed to create probe\n"));
return NULL;
}
error = fstat(sdp->device_fd, &st);
if (error < 0) {
fprintf(stderr, _("fstat failed\n"));
return NULL;
}
if (!S_ISREG(st.st_mode) && blkid_probe_enable_topology(pr, TRUE) != 0) {
fprintf(stderr, _("Failed to create probe\n"));
return NULL;
}
ret = blkid_do_fullprobe(pr);
if (ret == 0 && !S_ISREG(st.st_mode)) {
blkid_topology tp = blkid_probe_get_topology(pr);
if (tp != NULL) {
unsigned long min_io_sz = blkid_topology_get_minimum_io_size(tp);
unsigned long opt_io_sz = blkid_topology_get_optimal_io_size(tp);
unsigned long phy_sector_sz = blkid_topology_get_physical_sector_size(tp);
if ((min_io_sz > phy_sector_sz) &&
(opt_io_sz > phy_sector_sz)) {
al_base = opt_io_sz / sdp->bsize;
al_off = min_io_sz / sdp->bsize;
}
}
}
blkid_free_probe(pr);
return lgfs2_rgrps_init(sdp, al_base, al_off);
}
static int set_disk_properties(struct sync_disk *disk)
{
blkid_probe probe;
blkid_topology topo;
uint32_t sector_size, ss_logical, ss_physical;
probe = blkid_new_probe_from_filename(disk->path);
if (!probe) {
log_error("cannot get blkid probe %s", disk->path);
return -1;
}
topo = blkid_probe_get_topology(probe);
if (!topo) {
log_error("cannot get blkid topology %s", disk->path);
blkid_free_probe(probe);
return -1;
}
sector_size = blkid_probe_get_sectorsize(probe);
ss_logical = blkid_topology_get_logical_sector_size(topo);
ss_physical = blkid_topology_get_physical_sector_size(topo);
blkid_free_probe(probe);
if ((sector_size != ss_logical) ||
(sector_size != ss_physical) ||
(sector_size % 512)) {
log_error("invalid disk sector size %u logical %u "
"physical %u %s", sector_size, ss_logical,
ss_physical, disk->path);
return -1;
}
disk->sector_size = sector_size;
return 0;
}
int main(int argc, char *argv[])
{
int rc;
char *devname;
blkid_probe pr;
blkid_topology tp;
if (argc < 2) {
fprintf(stderr, "usage: %s <device> "
"-- prints topology details about the device\n",
program_invocation_short_name);
return EXIT_FAILURE;
}
devname = argv[1];
pr = blkid_new_probe_from_filename(devname);
if (!pr)
err(EXIT_FAILURE, "%s: failed to create a new libblkid probe",
devname);
/*
* Binary interface
*/
tp = blkid_probe_get_topology(pr);
if (tp) {
printf("----- binary interface:\n");
printf("\talignment offset : %lu\n",
blkid_topology_get_alignment_offset(tp));
printf("\tminimum io size : %lu\n",
blkid_topology_get_minimum_io_size(tp));
printf("\toptimal io size : %lu\n",
blkid_topology_get_optimal_io_size(tp));
printf("\tlogical sector size : %lu\n",
blkid_topology_get_logical_sector_size(tp));
printf("\tphysical sector size : %lu\n",
blkid_topology_get_physical_sector_size(tp));
}
/*
* NAME=value interface
*/
/* enable topology probing */
blkid_probe_enable_topology(pr, TRUE);
/* disable superblocks probing (enabled by default) */
blkid_probe_enable_superblocks(pr, FALSE);
rc = blkid_do_fullprobe(pr);
if (rc == -1)
errx(EXIT_FAILURE, "%s: blkid_do_fullprobe() failed", devname);
else if (rc == 1)
warnx("%s: missing topology information", devname);
else {
int i, nvals = blkid_probe_numof_values(pr);
printf("----- NAME=value interface (values: %d):\n", nvals);
for (i = 0; i < nvals; i++) {
const char *name, *data;
blkid_probe_get_value(pr, i, &name, &data, NULL);
printf("\t%s = %s\n", name, data);
}
}
blkid_free_probe(pr);
return EXIT_SUCCESS;
}
