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); }