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; }
/* Print the swap partition information */ static int print_info(blkid_probe pr) { const char *data; if (!blkid_probe_lookup_value(pr, "LABEL", &data, NULL)) printf("LABEL: %s\n", data); if (!blkid_probe_lookup_value(pr, "UUID", &data, NULL)) printf("UUID: %s\n", data); return 0; }
static struct wipe_desc * get_desc_for_probe(struct wipe_desc *wp, blkid_probe pr) { const char *off, *type, *mag, *p, *usage = NULL; size_t len; loff_t offset; int rc, ispt = 0; /* superblocks */ if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) == 0) { rc = blkid_probe_lookup_value(pr, "SBMAGIC_OFFSET", &off, NULL); if (!rc) rc = blkid_probe_lookup_value(pr, "SBMAGIC", &mag, &len); if (rc) return wp; /* partitions */ } else if (blkid_probe_lookup_value(pr, "PTTYPE", &type, NULL) == 0) { rc = blkid_probe_lookup_value(pr, "PTMAGIC_OFFSET", &off, NULL); if (!rc) rc = blkid_probe_lookup_value(pr, "PTMAGIC", &mag, &len); if (rc) return wp; usage = N_("partition table"); ispt = 1; } else return wp; if (type_pattern && !match_fstype(type, type_pattern)) return wp; offset = strtoll(off, NULL, 10); wp = add_offset(wp, offset, 0); if (!wp) return NULL; if (usage || blkid_probe_lookup_value(pr, "USAGE", &usage, NULL) == 0) wp->usage = xstrdup(usage); wp->type = xstrdup(type); wp->on_disk = 1; wp->is_parttable = ispt ? 1 : 0; wp->magic = xmalloc(len); memcpy(wp->magic, mag, len); wp->len = len; if (blkid_probe_lookup_value(pr, "LABEL", &p, NULL) == 0) wp->label = xstrdup(p); if (blkid_probe_lookup_value(pr, "UUID", &p, NULL) == 0) wp->uuid = xstrdup(p); return wp; }
/* returns device LABEL, UUID, FSTYPE, ... by low-level * probing interface */ static char * fsprobe_get_value(const char *name, const char *devname) { int fd; const char *data = NULL; if (!devname || !name) return NULL; fd = open_device(devname); if (fd < 0) return NULL; if (!blprobe) blprobe = blkid_new_probe(); if (!blprobe) goto done; if (blkid_probe_set_device(blprobe, fd, 0, 0)) goto done; blkid_probe_enable_superblocks(blprobe, 1); blkid_probe_set_superblocks_flags(blprobe, BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID | BLKID_SUBLKS_TYPE); if (blkid_do_safeprobe(blprobe)) goto done; if (blkid_probe_lookup_value(blprobe, name, &data, NULL)) goto done; done: close(fd); return data ? strdup((char *) data) : NULL; }
static int check_partition_table(const char *device) { blkid_probe pr; const char *value; int ret; pr = blkid_new_probe_from_filename(device); if (!pr) return -1; ret = blkid_probe_enable_partitions(pr, 1); if (ret < 0) goto errout; ret = blkid_probe_enable_superblocks(pr, 0); if (ret < 0) goto errout; ret = blkid_do_fullprobe(pr); if (ret < 0) goto errout; ret = blkid_probe_lookup_value(pr, "PTTYPE", &value, NULL); if (ret == 0) fprintf(stderr, _("Found a %s partition table in %s\n"), value, device); else ret = 1; errout: blkid_free_probe(pr); return ret; }
gboolean type_by_device(const gchar* device, gchar** type) { gboolean result = false; const char *devtype = NULL; blkid_probe probe = NULL; *type = NULL; probe = blkid_new_probe_from_filename(device); if(!probe) { LOG(MOD "Probe from filename failed!\n"); return false; } if (blkid_probe_enable_partitions(probe, true) != 0) { LOG(MOD "Enable partitions failed!\n"); goto fail; } if (blkid_do_fullprobe(probe) != 0) { LOG(MOD "Fullprobe failed!\n"); goto fail; } if (blkid_probe_lookup_value(probe, "TYPE", &devtype, NULL) != 0) { LOG(MOD "Lookup value failed!\n"); goto fail; } *type = g_strdup(devtype); result = true; fail: blkid_free_probe(probe); return result; }
/** * mnt_get_fstype: * @devname: device name * @ambi: returns TRUE if probing result is ambivalent (optional argument) * @cache: cache for results or NULL * * Returns: filesystem type or NULL in case of error. The result has to be * deallocated by free() if @cache is NULL. */ char *mnt_get_fstype(const char *devname, int *ambi, struct libmnt_cache *cache) { blkid_probe pr; const char *data; char *type = NULL; int rc; DBG(CACHE, mnt_debug_h(cache, "get %s FS type", devname)); if (cache) return mnt_cache_find_tag_value(cache, devname, "TYPE"); if (cache_get_probe(NULL, devname, &pr)) return NULL; blkid_probe_enable_superblocks(pr, 1); blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_TYPE); rc = blkid_do_safeprobe(pr); if (!rc && !blkid_probe_lookup_value(pr, "TYPE", &data, NULL)) type = strdup(data); if (ambi) *ambi = rc == -2 ? TRUE : FALSE; blkid_free_probe(pr); return type; }
static char* get_uuid(char *device) { char path[PATH_MAX]; int fd; blkid_probe pr = NULL; uint64_t size; const char *uuid; char *ret; if(!device || !strlen(device)) return NULL; fd = open(device, O_RDONLY); if (fd < 0) return NULL; pr = blkid_new_probe(); blkid_probe_set_request (pr, BLKID_PROBREQ_UUID); ioctl(fd, BLKGETSIZE64, &size); blkid_probe_set_device(pr, fd, 0, size); blkid_do_safeprobe(pr); blkid_probe_lookup_value(pr, "UUID", &uuid, NULL); snprintf(path, PATH_MAX, "/dev/disk/by-uuid/%s", uuid); ret = strdup(path); blkid_free_probe(pr); close(fd); return ret; }
static int probe_and_add_mount( const char *id, const char *what, const char *where, bool rw, const char *description, const char *post) { _cleanup_blkid_free_probe_ blkid_probe b = NULL; const char *fstype; int r; assert(id); assert(what); assert(where); assert(description); if (path_is_mount_point(where, true) <= 0 && dir_is_empty(where) <= 0) { log_debug("%s already populated, ignoring.", where); return 0; } /* Let's check the partition type here, so that we know * whether to do LUKS magic. */ errno = 0; b = blkid_new_probe_from_filename(what); if (!b) { if (errno == 0) return log_oom(); log_error_errno(errno, "Failed to allocate prober: %m"); return -errno; } blkid_probe_enable_superblocks(b, 1); blkid_probe_set_superblocks_flags(b, BLKID_SUBLKS_TYPE); errno = 0; r = blkid_do_safeprobe(b); if (r == -2 || r == 1) /* no result or uncertain */ return 0; else if (r != 0) { if (errno == 0) errno = EIO; log_error_errno(errno, "Failed to probe %s: %m", what); return -errno; } blkid_probe_lookup_value(b, "TYPE", &fstype, NULL); return add_mount( id, what, where, fstype, rw, description, post); }
static char* get_blkid(char *device) { int fd; blkid_probe pr = NULL; uint64_t size; const char *label; char *ret; char path[PATH_MAX]; if(!device || !strlen(device)) return NULL; snprintf(path, PATH_MAX, "/dev/%s", device); fd = open(path, O_RDONLY); if(fd<0) return NULL; pr = blkid_new_probe (); blkid_probe_set_request (pr, BLKID_PROBREQ_LABEL); ioctl(fd, BLKGETSIZE64, &size); blkid_probe_set_device (pr, fd, 0, size); blkid_do_safeprobe (pr); blkid_probe_lookup_value(pr, "LABEL", &label, NULL); ret = strdup(label); blkid_free_probe (pr); close(fd); return ret; }
static int probe_superblocks(blkid_probe pr) { struct stat st; int rc; if (fstat(blkid_probe_get_fd(pr), &st)) return -1; blkid_probe_enable_partitions(pr, 1); if (!S_ISCHR(st.st_mode) && blkid_probe_get_size(pr) <= 1024 * 1440 && blkid_probe_is_wholedisk(pr)) { /* * check if the small disk is partitioned, if yes then * don't probe for filesystems. */ blkid_probe_enable_superblocks(pr, 0); rc = blkid_do_fullprobe(pr); if (rc < 0) return rc; /* -1 = error, 1 = nothing, 0 = success */ if (blkid_probe_lookup_value(pr, "PTTYPE", NULL, NULL) == 0) return 0; /* partition table detected */ } blkid_probe_set_partitions_flags(pr, BLKID_PARTS_ENTRY_DETAILS); blkid_probe_enable_superblocks(pr, 1); return blkid_do_safeprobe(pr); }
/* * This function prints a warning if the device is not wiped (e.g. wipefs(8). * Please don't call this function if there is already a PT. * * Returns: 0 if nothing found, < 0 on error, 1 if found a signature */ static int warn_wipe(struct fdisk_context *cxt) { #ifdef HAVE_LIBBLKID blkid_probe pr; #endif int rc = 0; assert(cxt); if (fdisk_dev_has_disklabel(cxt) || cxt->dev_fd < 0) return -EINVAL; #ifdef HAVE_LIBBLKID DBG(LABEL, dbgprint("wipe check: initialize libblkid prober")); pr = blkid_new_probe(); if (!pr) return -ENOMEM; rc = blkid_probe_set_device(pr, cxt->dev_fd, 0, 0); if (rc) return rc; blkid_probe_enable_superblocks(pr, 1); blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_TYPE); blkid_probe_enable_partitions(pr, 1); /* we care about the first found FS/raid, so don't call blkid_do_probe() * in loop or don't use blkid_do_fullprobe() ... */ rc = blkid_do_probe(pr); if (rc == 0) { const char *name = NULL; if (blkid_probe_lookup_value(pr, "TYPE", &name, 0) == 0 || blkid_probe_lookup_value(pr, "PTTYPE", &name, 0) == 0) { fdisk_warnx(cxt, _( "%s: device contains a valid '%s' signature, it's " "strongly recommended to wipe the device by command wipefs(8) " "if this setup is unexpected to avoid " "possible collisions."), cxt->dev_path, name); rc = 1; } } blkid_free_probe(pr); #endif return rc; }
/* * This function prints a warning if the device is not wiped (e.g. wipefs(8). * Please don't call this function if there is already a PT. * * Returns: 0 if nothing found, < 0 on error, 1 if found a signature */ static int check_collisions(struct fdisk_context *cxt) { #ifdef HAVE_LIBBLKID int rc = 0; blkid_probe pr; assert(cxt); assert(cxt->dev_fd >= 0); DBG(CXT, ul_debugobj(cxt, "wipe check: initialize libblkid prober")); pr = blkid_new_probe(); if (!pr) return -ENOMEM; rc = blkid_probe_set_device(pr, cxt->dev_fd, 0, 0); if (rc) return rc; blkid_probe_enable_superblocks(pr, 1); blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_TYPE); blkid_probe_enable_partitions(pr, 1); /* we care about the first found FS/raid, so don't call blkid_do_probe() * in loop or don't use blkid_do_fullprobe() ... */ rc = blkid_do_probe(pr); if (rc == 0) { const char *name = NULL; if (blkid_probe_lookup_value(pr, "TYPE", &name, 0) == 0 || blkid_probe_lookup_value(pr, "PTTYPE", &name, 0) == 0) { cxt->collision = strdup(name); if (!cxt->collision) rc = -ENOMEM; } } blkid_free_probe(pr); return rc; #else return 0; #endif }
/* * Compose and print ID_FS_AMBIVALENT for udev */ static int print_udev_ambivalent(blkid_probe pr) { char *val = NULL; size_t valsz = 0; int count = 0, rc = -1; while (!blkid_do_probe(pr)) { const char *usage = NULL, *type = NULL, *version = NULL; char enc[256]; blkid_probe_lookup_value(pr, "USAGE", &usage, NULL); blkid_probe_lookup_value(pr, "TYPE", &type, NULL); blkid_probe_lookup_value(pr, "VERSION", &version, NULL); if (!usage || !type) continue; blkid_encode_string(usage, enc, sizeof(enc)); if (append_str(&val, &valsz, enc, ":")) goto done; blkid_encode_string(type, enc, sizeof(enc)); if (append_str(&val, &valsz, enc, version ? ":" : " ")) goto done; if (version) { blkid_encode_string(version, enc, sizeof(enc)); if (append_str(&val, &valsz, enc, " ")) goto done; } count++; } if (count > 1) { *(val + valsz - 1) = '\0'; /* rem tailing whitespace */ printf("ID_FS_AMBIVALEN=%s\n", val); rc = 0; } done: free(val); return rc; }
static struct wipe_desc * get_offset_from_probe(struct wipe_desc *wp, blkid_probe pr, int zap) { const char *off, *type, *usage, *mag; size_t len; if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) == 0 && blkid_probe_lookup_value(pr, "SBMAGIC_OFFSET", &off, NULL) == 0 && blkid_probe_lookup_value(pr, "SBMAGIC", &mag, &len) == 0 && blkid_probe_lookup_value(pr, "USAGE", &usage, NULL) == 0) { loff_t offset = strtoll(off, NULL, 10); const char *p; wp = add_offset(wp, offset, zap); if (!wp) return NULL; wp->usage = xstrdup(usage); wp->type = xstrdup(type); wp->magic = xmalloc(len); memcpy(wp->magic, mag, len); wp->len = len; if (blkid_probe_lookup_value(pr, "LABEL", &p, NULL) == 0) wp->label = xstrdup(p); if (blkid_probe_lookup_value(pr, "UUID", &p, NULL) == 0) wp->uuid = xstrdup(p); } return wp; }
static char * _get_uuid_from_device( const char * device ) { char * r = NULL ; const char * e = NULL ; blkid_probe blkid = blkid_new_probe_from_filename( device ) ; if( blkid != NULL ){ blkid_do_probe( blkid ) ; blkid_probe_lookup_value( blkid,"UUID",&e,NULL ) ; r = StringCopy_2( e ) ; blkid_free_probe( blkid ) ; } return r ; }
string_t zuluCryptGetFileSystemFromDevice( const char * device ) { string_t st = StringVoid ; const char * cf = NULL ; blkid_probe blkid = blkid_new_probe_from_filename( device ) ; if( blkid != NULL ){ blkid_do_probe( blkid ) ; blkid_probe_lookup_value( blkid,"TYPE",&cf,NULL ) ; st = String( cf ) ; blkid_free_probe( blkid ) ; } return st ; }
static int probe_filesystem(const char *node, char **ret_fstype) { #ifdef HAVE_BLKID _cleanup_blkid_free_probe_ blkid_probe b = NULL; const char *fstype; int r; b = blkid_new_probe_from_filename(node); if (!b) return -ENOMEM; blkid_probe_enable_superblocks(b, 1); blkid_probe_set_superblocks_flags(b, BLKID_SUBLKS_TYPE); errno = 0; r = blkid_do_safeprobe(b); if (r == -2 || r == 1) { log_debug("Failed to identify any partition type on partition %s", node); goto not_found; } if (r != 0) { if (errno == 0) return -EIO; return -errno; } (void) blkid_probe_lookup_value(b, "TYPE", &fstype, NULL); if (fstype) { char *t; t = strdup(fstype); if (!t) return -ENOMEM; *ret_fstype = t; return 1; } not_found: *ret_fstype = NULL; return 0; #else return -EOPNOTSUPP; #endif }
/* * This function works like mnt_resolve_tag(), but it's able to read UUiD/LABEL * from regular swap files too (according to entries in /proc/swaps). Note that * mnt_resolve_tag() and mnt_resolve_spec() works with system visible block * devices only. */ static char *swapoff_resolve_tag(const char *name, const char *value, struct libmnt_cache *cache) { char *path; struct libmnt_table *tb; struct libmnt_iter *itr; struct libmnt_fs *fs; /* this is usual case for block devices (and it's really fast as it uses * udev /dev/disk/by-* symlinks by default */ path = mnt_resolve_tag(name, value, cache); if (path) return path; /* try regular files from /proc/swaps */ tb = get_swaps(); if (!tb) return NULL; itr = mnt_new_iter(MNT_ITER_BACKWARD); if (!itr) err(EXIT_FAILURE, _("failed to initialize libmount iterator")); while (tb && mnt_table_next_fs(tb, itr, &fs) == 0) { blkid_probe pr = NULL; const char *src = mnt_fs_get_source(fs); const char *type = mnt_fs_get_swaptype(fs); const char *data = NULL; if (!src || !type || strcmp(type, "file") != 0) continue; pr = get_swap_prober(src); if (!pr) continue; blkid_probe_lookup_value(pr, name, &data, NULL); if (data && strcmp(data, value) == 0) path = xstrdup(src); blkid_free_probe(pr); if (path) break; } mnt_free_iter(itr); return path; }
static inline void probe_filesystem(struct format *target) { blkid_probe probe = 0; static char *filesystems[] = { "ext2", "ext3", "ext4", "reiserfs", "jfs", "xfs", "btrfs", "swap", 0 }; const char *filesystem = "unknown"; const char *result = 0; if((probe = blkid_new_probe_from_filename(target->devicepath)) == 0) goto bail; if(blkid_probe_enable_superblocks(probe,true) == -1) goto bail; if(blkid_probe_filter_superblocks_type(probe,BLKID_FLTR_ONLYIN,filesystems) == -1) goto bail; if(blkid_probe_set_superblocks_flags(probe,BLKID_SUBLKS_TYPE) == -1) goto bail; if(blkid_do_probe(probe) == -1) goto bail; if(blkid_probe_lookup_value(probe,"TYPE",&result,0) == -1) goto bail; filesystem = result; bail: if(probe != 0) blkid_free_probe(probe); target->filesystem = strdup(filesystem); }
int zuluCryptFileSystemIsFUSEbased( const char * device ) { const char * cf = NULL ; int st ; blkid_probe blkid = blkid_new_probe_from_filename( device ) ; if( blkid != NULL ){ blkid_do_probe( blkid ) ; blkid_probe_lookup_value( blkid,"TYPE",&cf,NULL ) ; #if 1 st = StringAtLeastOneMatch_1( cf,"ntfs","exfat",NULL ) ; #else st = StringAtLeastOneMatch_1( cf,"ntfs",NULL ) ; #endif blkid_free_probe( blkid ) ; return st ; }else{ return 0 ; } }
/* * Returns new libblkid prober. This function call exit() on error. */ static blkid_probe get_swap_prober(const char *devname) { blkid_probe pr; int rc; const char *version = NULL; char *swap_filter[] = { "swap", NULL }; pr = blkid_new_probe_from_filename(devname); if (!pr) { warn(_("%s: unable to probe device"), devname); return NULL; } blkid_probe_enable_superblocks(pr, TRUE); blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID | BLKID_SUBLKS_VERSION); blkid_probe_filter_superblocks_type(pr, BLKID_FLTR_ONLYIN, swap_filter); rc = blkid_do_safeprobe(pr); if (rc == -1) warn(_("%s: unable to probe device"), devname); else if (rc == -2) warnx(_("%s: ambivalent probing result, use wipefs(8)"), devname); else if (rc == 1) warnx(_("%s: not a valid swap partition"), devname); if (rc == 0) { /* supported is SWAPSPACE2 only */ if (blkid_probe_lookup_value(pr, "VERSION", &version, NULL) == 0 && version && strcmp(version, "2")) warnx(_("%s: unsupported swap version '%s'"), devname, version); else return pr; } blkid_free_probe(pr); return NULL; }
/* returns zero when the device has NAME=value (LABEL/UUID) */ static int verify_tag(const char *devname, const char *name, const char *value) { blkid_probe pr; int fd = -1, rc = -1; size_t len; const char *data; int errsv = 0; pr = blkid_new_probe(); if (!pr) return -1; blkid_probe_enable_superblocks(pr, TRUE); blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID); blkid_probe_enable_partitions(pr, TRUE); blkid_probe_set_partitions_flags(pr, BLKID_PARTS_ENTRY_DETAILS); fd = open(devname, O_RDONLY|O_CLOEXEC); if (fd < 0) { errsv = errno; goto done; } if (blkid_probe_set_device(pr, fd, 0, 0)) goto done; rc = blkid_do_safeprobe(pr); if (rc) goto done; rc = blkid_probe_lookup_value(pr, name, &data, &len); if (!rc) rc = memcmp(value, data, len); done: DBG(EVALUATE, ul_debug("%s: %s verification %s", devname, name, rc == 0 ? "PASS" : "FAILED")); if (fd >= 0) close(fd); blkid_free_probe(pr); /* for non-root users we use unverified udev links */ return errsv == EACCES ? 0 : rc; }
/** * mnt_get_fstype: * @devname: device name * @ambi: returns TRUE if probing result is ambivalent (optional argument) * @cache: cache for results or NULL * * Returns: filesystem type or NULL in case of error. The result has to be * deallocated by free() if @cache is NULL. */ char *mnt_get_fstype(const char *devname, int *ambi, struct libmnt_cache *cache) { blkid_probe pr; const char *data; char *type = NULL; int rc; DBG(CACHE, ul_debugobj(cache, "get %s FS type", devname)); if (cache) { char *val = NULL; rc = __mnt_cache_find_tag_value(cache, devname, "TYPE", &val); if (ambi) *ambi = rc == -2 ? TRUE : FALSE; return rc ? NULL : val; } /* * no cache, probe directly */ pr = blkid_new_probe_from_filename(devname); if (!pr) return NULL; blkid_probe_enable_superblocks(pr, 1); blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_TYPE); rc = blkid_do_safeprobe(pr); DBG(CACHE, ul_debugobj(cache, "libblkid rc=%d", rc)); if (!rc && !blkid_probe_lookup_value(pr, "TYPE", &data, NULL)) type = strdup(data); if (ambi) *ambi = rc == -2 ? TRUE : FALSE; blkid_free_probe(pr); return type; }
static struct wipe_desc * read_offsets(struct wipe_desc *wp, const char *fname, int zap) { blkid_probe pr; int rc; if (!fname) return NULL; pr = blkid_new_probe_from_filename(fname); if (!pr) errx(EXIT_FAILURE, _("error: %s: probing initialization failed"), fname); blkid_probe_enable_superblocks(pr, 0); /* enabled by default ;-( */ blkid_probe_enable_partitions(pr, 1); rc = blkid_do_fullprobe(pr); blkid_probe_enable_partitions(pr, 0); if (rc == 0) { const char *type = NULL; blkid_probe_lookup_value(pr, "PTTYPE", &type, NULL); warnx(_("WARNING: %s: appears to contain '%s' " "partition table"), fname, type); } blkid_probe_enable_superblocks(pr, 1); blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_MAGIC | BLKID_SUBLKS_TYPE | BLKID_SUBLKS_USAGE | BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID); while (blkid_do_probe(pr) == 0) { wp = get_offset_from_probe(wp, pr, zap); if (!wp) break; } blkid_free_probe(pr); return wp; }
void zuluCryptFileSystemProperties( string_t p,const char * mapper,const char * m_point ) { const char * e ; blkid_probe blkid ; struct statvfs vfs ; u_int64_t total ; u_int64_t used ; u_int64_t unused ; u_int64_t block_size ; char buff[ SIZE ] ; char * buffer = buff ; string_t q ; ssize_t index ; struct stat statstr ; blkid = blkid_new_probe_from_filename( mapper ) ; if( blkid == NULL ){ return ; } blkid_do_probe( blkid ) ; if( blkid_probe_lookup_value( blkid,"TYPE",&e,NULL ) == 0 ){ StringMultipleAppend( p,"\n file system:\t",e,NULL ) ; }else{ StringAppend( p,"\n file system:\tNil" ) ; } blkid_free_probe( blkid ) ; if( statvfs( m_point,&vfs ) != 0 ){ return ; } block_size = vfs.f_frsize ; total = block_size * vfs.f_blocks ; unused = block_size * vfs.f_bavail ; used = total - unused ; zuluCryptFormatSize( total,buffer,SIZE ) ; StringMultipleAppend( p,"\n total space:\t",buffer,NULL ) ; zuluCryptFormatSize( used,buffer,SIZE ) ; StringMultipleAppend( p,"\n used space:\t",buffer,NULL ) ; zuluCryptFormatSize( unused,buffer,SIZE ) ; StringMultipleAppend( p,"\n free space:\t",buffer,NULL ) ; if( used == total ){ StringAppend( p,"\n used%: \t100%\n" ) ; }else if( used == 0 ){ StringAppend( p,"\n used%: \t0%\n" ) ; }else{ snprintf( buff,SIZE,"%.2f%%",100 * ( ( float ) used / ( float ) total ) ) ; StringMultipleAppend( p,"\n used%: \t",buff,"\n",NULL ) ; } buffer = zuluCryptGetUUIDFromMapper( mapper ) ; StringAppend( p,buffer ) ; StringFree( buffer ) ; StringMultipleAppend( p,"\n mount point1:\t",m_point,NULL ) ; q = String( m_point ) ; index = StringLastIndexOfChar( q,'/' ) ; if( index == -1 ){ StringAppend( p,"\n mount point2:\tNil" ) ; }else{ StringRemoveLeft( q,index ) ; e = StringPrepend( q,"/run/media/public" ) ; if( stat( e,&statstr ) == 0 ){ StringMultipleAppend( p,"\n mount point2:\t",e,NULL ) ; }else{ StringAppend( p,"\n mount point2:\tNil" ) ; } } StringDelete( &q ) ; }
/** * mnt_cache_read_tags * @cache: pointer to struct libmnt_cache instance * @devname: path device * * Reads @devname LABEL and UUID to the @cache. * * Returns: 0 if at least one tag was added, 1 if no tag was added or * negative number in case of error. */ int mnt_cache_read_tags(struct libmnt_cache *cache, const char *devname) { blkid_probe pr; size_t i, ntags = 0; int rc; const char *tags[] = { "LABEL", "UUID", "TYPE", "PARTUUID", "PARTLABEL" }; const char *blktags[] = { "LABEL", "UUID", "TYPE", "PART_ENTRY_UUID", "PART_ENTRY_NAME" }; if (!cache || !devname) return -EINVAL; DBG(CACHE, ul_debugobj(cache, "tags for %s requested", devname)); /* check if device is already cached */ for (i = 0; i < cache->nents; i++) { struct mnt_cache_entry *e = &cache->ents[i]; if (!(e->flag & MNT_CACHE_TAGREAD)) continue; if (strcmp(e->value, devname) == 0) /* tags have already been read */ return 0; } pr = blkid_new_probe_from_filename(devname); if (!pr) return -1; blkid_probe_enable_superblocks(pr, 1); blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID | BLKID_SUBLKS_TYPE); blkid_probe_enable_partitions(pr, 1); blkid_probe_set_partitions_flags(pr, BLKID_PARTS_ENTRY_DETAILS); rc = blkid_do_safeprobe(pr); if (rc) goto error; DBG(CACHE, ul_debugobj(cache, "reading tags for: %s", devname)); for (i = 0; i < ARRAY_SIZE(tags); i++) { const char *data; char *dev; if (cache_find_tag_value(cache, devname, tags[i])) { DBG(CACHE, ul_debugobj(cache, "\ntag %s already cached", tags[i])); continue; } if (blkid_probe_lookup_value(pr, blktags[i], &data, NULL)) continue; dev = strdup(devname); if (!dev) goto error; if (cache_add_tag(cache, tags[i], data, dev, MNT_CACHE_TAGREAD)) { free(dev); goto error; } ntags++; } DBG(CACHE, ul_debugobj(cache, "\tread %zd tags", ntags)); blkid_free_probe(pr); return ntags ? 0 : 1; error: blkid_free_probe(pr); return rc < 0 ? rc : -1; }
/** * mnt_cache_read_tags * @cache: pointer to struct libmnt_cache instance * @devname: path device * * Reads @devname LABEL and UUID to the @cache. * * Returns: 0 if at least one tag was added, 1 if no tag was added or * negative number in case of error. */ int mnt_cache_read_tags(struct libmnt_cache *cache, const char *devname) { size_t i, ntags = 0; int rc; const char *tags[] = { "LABEL", "UUID", "TYPE" }; assert(cache); assert(devname); if (!cache || !devname) return -EINVAL; DBG(CACHE, mnt_debug_h(cache, "tags for %s requested", devname)); /* check is device is already cached */ for (i = 0; i < cache->nents; i++) { struct mnt_cache_entry *e = &cache->ents[i]; if (!(e->flag & MNT_CACHE_TAGREAD)) continue; if (strcmp(e->value, devname) == 0) /* tags has been already read */ return 0; } rc = cache_get_probe(cache, devname, NULL); if (rc) return rc; blkid_probe_enable_superblocks(cache->pr, 1); blkid_probe_set_superblocks_flags(cache->pr, BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID | BLKID_SUBLKS_TYPE); if (blkid_do_safeprobe(cache->pr)) goto error; DBG(CACHE, mnt_debug_h(cache, "reading tags for: %s", devname)); for (i = 0; i < ARRAY_SIZE(tags); i++) { const char *data; char *dev; if (cache_find_tag_value(cache, devname, tags[i])) { DBG(CACHE, mnt_debug_h(cache, "\ntag %s already cached", tags[i])); continue; } if (blkid_probe_lookup_value(cache->pr, tags[i], &data, NULL)) continue; dev = strdup(devname); if (!dev) goto error; if (cache_add_tag(cache, tags[i], data, dev, MNT_CACHE_TAGREAD)) { free(dev); goto error; } ntags++; } DBG(CACHE, mnt_debug_h(cache, "\tread %zd tags", ntags)); return ntags ? 0 : 1; error: return -1; }
static virStoragePoolProbeResult virStorageBackendFileSystemProbe(const char *device, const char *format) { virStoragePoolProbeResult ret = FILESYSTEM_PROBE_ERROR; blkid_probe probe = NULL; const char *fstype = NULL; char *names[2], *libblkid_format = NULL; VIR_DEBUG("Probing for existing filesystem of type %s on device %s", format, device); if (blkid_known_fstype(format) == 0) { virStorageReportError(VIR_ERR_STORAGE_PROBE_FAILED, _("Not capable of probing for " "filesystem of type %s"), format); goto error; } probe = blkid_new_probe_from_filename(device); if (probe == NULL) { virStorageReportError(VIR_ERR_STORAGE_PROBE_FAILED, _("Failed to create filesystem probe " "for device %s"), device); goto error; } if ((libblkid_format = strdup(format)) == NULL) { virReportOOMError(); goto error; } names[0] = libblkid_format; names[1] = NULL; blkid_probe_filter_superblocks_type(probe, BLKID_FLTR_ONLYIN, names); if (blkid_do_probe(probe) != 0) { VIR_INFO("No filesystem of type '%s' found on device '%s'", format, device); ret = FILESYSTEM_PROBE_NOT_FOUND; } else if (blkid_probe_lookup_value(probe, "TYPE", &fstype, NULL) == 0) { virStorageReportError(VIR_ERR_STORAGE_POOL_BUILT, _("Existing filesystem of type '%s' found on " "device '%s'"), fstype, device); ret = FILESYSTEM_PROBE_FOUND; } if (blkid_do_probe(probe) != 1) { virStorageReportError(VIR_ERR_STORAGE_PROBE_FAILED, _("Found additional probes to run, " "filesystem probing may be incorrect")); ret = FILESYSTEM_PROBE_ERROR; } error: VIR_FREE(libblkid_format); if (probe != NULL) { blkid_free_probe(probe); } return ret; }
static void wipe_device(int fd, const char *devname, int force) { char *type = NULL; int zap = 1; #ifdef HAVE_LIBBLKID blkid_probe pr = NULL; #endif if (!force) { if (lseek(fd, 0, SEEK_SET) != 0) errx(EXIT_FAILURE, _("unable to rewind swap-device")); #ifdef HAVE_LIBBLKID pr = new_prober(fd); blkid_probe_enable_partitions(pr, 1); blkid_probe_enable_superblocks(pr, 0); if (blkid_do_fullprobe(pr) == 0 && blkid_probe_lookup_value(pr, "PTTYPE", (const char **) &type, NULL) == 0 && type) { type = xstrdup(type); zap = 0; } #else /* don't zap if compiled without libblkid */ zap = 0; #endif } if (zap) { /* * Wipe boodbits */ char buf[1024]; const char *data = NULL; if (lseek(fd, 0, SEEK_SET) != 0) errx(EXIT_FAILURE, _("unable to rewind swap-device")); memset(buf, 0, sizeof(buf)); if (write_all(fd, buf, sizeof(buf))) errx(EXIT_FAILURE, _("unable to erase bootbits sectors")); #ifdef HAVE_LIBBLKID /* * Wipe rest of the device */ if (!pr) pr = new_prober(fd); blkid_probe_enable_superblocks(pr, 1); blkid_probe_enable_partitions(pr, 0); blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_MAGIC|BLKID_SUBLKS_TYPE); while (blkid_do_probe(pr) == 0) { if (blkid_probe_lookup_value(pr, "TYPE", &data, NULL) == 0 && data) warnx(_("%s: warning: wiping old %s signature."), devname, data); blkid_do_wipe(pr, 0); } #endif } else { warnx(_("%s: warning: don't erase bootbits sectors"), devname); if (type) fprintf(stderr, _(" (%s partition table detected). "), type); else fprintf(stderr, _(" (compiled without libblkid). ")); fprintf(stderr, _("Use -f to force.\n")); } #ifdef HAVE_LIBBLKID blkid_free_probe(pr); #endif }