static dev_t fs_get_disk(struct libmnt_fs *fs, int check)
{
struct fsck_fs_data *data;
const char *device;
struct stat st;
data = mnt_fs_get_userdata(fs);
if (data && data->disk)
return data->disk;
if (!check)
return 0;
if (mnt_fs_is_netfs(fs) || mnt_fs_is_pseudofs(fs))
return 0;
device = fs_get_device(fs);
if (!device)
return 0;
data = fs_create_data(fs);
if (!stat(device, &st) &&
!blkid_devno_to_wholedisk(st.st_rdev, NULL, 0, &data->disk)) {
if (data->disk)
data->stacked = count_slaves(data->disk) > 0 ? 1 : 0;
return data->disk;
}
return 0;
}
int rm_mounts_devno_to_wholedisk(_U RmMountEntry *entry, _U dev_t rdev, _U char *disk, _U size_t disk_size, _U dev_t *result) {
#if HAVE_BLKID
return blkid_devno_to_wholedisk(rdev, disk, sizeof(disk_size), result);
#elif HAVE_SYSCTL
if(DISK_TABLE == NULL) {
rm_mounts_freebsd_list_disks();
}
GHashTableIter iter;
g_hash_table_iter_init(&iter, DISK_TABLE);
gpointer key = NULL;
gpointer value = NULL;
while(g_hash_table_iter_next(&iter, &key, &value)) {
char *str_key = key;
if(g_str_has_prefix(str_key, entry->fsname)) {
strncpy(disk, strrchr(str_key, '/'), disk_size);
*result = (dev_t)GPOINTER_TO_UINT(value);
return 0;
}
}
#endif
return -1;
}
/* Find the whole disk device path for a partition.
* The resulting string must be freed. */
char * dev_to_wholedevname(blkid_dev dev) {
dev_t devno, whole;
if ((devno = dev_to_devno(dev)) < 0)
return NULL;
if (blkid_devno_to_wholedisk(devno, NULL, 0, &whole) < 0)
return NULL;
return blkid_devno_to_devname(whole);
}
/* Utility for easily accepting whole disk or partition devices.
* If drive path is set but partition is 0 the drive path will be checked
* to see if it is a partition device instead of a whole disk. If it is a
* partition device it is changed to the whole disk device and the partition
* number is filled in. */
int translate_partition_dev(char **devname, uint32_t *partition) {
struct stat dev_stat;
dev_t whole_devno;
char *whole_devname;
int partno;
require(devname && *devname && partition);
if (!strlen(*devname)) {
Error("empty drive argument\n");
return CGPT_FAILED;
}
if (stat(*devname, &dev_stat) < 0) {
Error("unable to access drvice %s: %s\n", *devname, strerror(errno));
return CGPT_FAILED;
}
/* No magic to be done if this isn't a block device */
if (!S_ISBLK(dev_stat.st_mode))
return CGPT_OK;
if (blkid_devno_to_wholedisk(dev_stat.st_rdev, NULL, 0, &whole_devno) < 0) {
Error("unable to map %s to a whole disk device\n", *devname);
return CGPT_FAILED;
}
/* Nothing to check or translate if we already have the whole disk */
if (dev_stat.st_rdev == whole_devno)
return CGPT_OK;
if ((partno = devno_to_partno(dev_stat.st_rdev)) < 0) {
Error("unable to look up partition number for %s\n", *devname);
return CGPT_FAILED;
}
if (*partition && *partition != partno) {
Error("device %s is partition %d but %d was specified\n",
*devname, partno, *partition);
return CGPT_FAILED;
}
if ((whole_devname = blkid_devno_to_devname(whole_devno)) == NULL) {
Error("unable to map %s to a whole disk device name\n", *devname);
return CGPT_FAILED;
}
free(*devname);
*devname = whole_devname;
*partition = partno;
return CGPT_OK;
}
static int is_ssd(const char *file)
{
blkid_probe probe;
char wholedisk[32];
char sysfs_path[PATH_MAX];
dev_t devno;
int fd;
char rotational;
int ret;
probe = blkid_new_probe_from_filename(file);
if (!probe)
return 0;
/* Device number of this disk (possibly a partition) */
devno = blkid_probe_get_devno(probe);
if (!devno) {
blkid_free_probe(probe);
return 0;
}
/* Get whole disk name (not full path) for this devno */
ret = blkid_devno_to_wholedisk(devno,
wholedisk, sizeof(wholedisk), NULL);
if (ret) {
blkid_free_probe(probe);
return 0;
}
snprintf(sysfs_path, PATH_MAX, "/sys/block/%s/queue/rotational",
wholedisk);
blkid_free_probe(probe);
fd = open(sysfs_path, O_RDONLY);
if (fd < 0) {
return 0;
}
if (read(fd, &rotational, sizeof(char)) < sizeof(char)) {
close(fd);
return 0;
}
close(fd);
return !atoi((const char *)&rotational);
}
int main(int argc, char** argv)
{
char *devname, *tmp;
char diskname[PATH_MAX];
int major, minor;
dev_t devno, disk_devno;
const char *errmsg = "Couldn't parse %s: %s\n";
blkid_init_debug(BLKID_DEBUG_ALL);
if ((argc != 2) && (argc != 3)) {
fprintf(stderr, "Usage:\t%s device_number\n\t%s major minor\n"
"Resolve a device number to a device name\n",
argv[0], argv[0]);
exit(1);
}
if (argc == 2) {
devno = strtoul(argv[1], &tmp, 0);
if (*tmp) {
fprintf(stderr, errmsg, "device number", argv[1]);
exit(1);
}
} else {
major = strtoul(argv[1], &tmp, 0);
if (*tmp) {
fprintf(stderr, errmsg, "major number", argv[1]);
exit(1);
}
minor = strtoul(argv[2], &tmp, 0);
if (*tmp) {
fprintf(stderr, errmsg, "minor number", argv[2]);
exit(1);
}
devno = makedev(major, minor);
}
printf("Looking for device 0x%04llx\n", (long long)devno);
devname = blkid_devno_to_devname(devno);
free(devname);
printf("Looking for whole-device for 0x%04llx\n", (long long)devno);
if (blkid_devno_to_wholedisk(devno, diskname,
sizeof(diskname), &disk_devno) == 0)
printf("found devno 0x%04llx as /dev/%s\n", (long long) disk_devno, diskname);
return 0;
}
char *disk_for_path(const gchar* path) {
char diskname[NAME_MAX];
struct stat st = { 0 };
dev_t disk;
if (!path) {
LOG(MOD "Path is empty\n");
return NULL;
}
if (stat(path, &st) != 0) {
LOG(MOD "Cannot stat '%s'\n", path);
return NULL;
}
if (blkid_devno_to_wholedisk(st.st_dev, diskname, sizeof(diskname), &disk) != 0) {
LOG(MOD "Cannot convert devno to wholedisk\n");
return NULL;
}
return blkid_devno_to_devname(disk);
}
int rm_mounts_devno_to_wholedisk(_U RmMountEntry *entry, _U dev_t rdev, _U char *disk,
_U size_t disk_size, _U dev_t *result) {
return blkid_devno_to_wholedisk(rdev, disk, disk_size, result);
}
