From 279b07414ad464c30bdcf8010236a609a4de97b7821c6f687da5d4d8e79b6a62 Mon Sep 17 00:00:00 2001 From: Stephan Kulow Date: Tue, 22 Apr 2014 05:49:58 +0000 Subject: [PATCH] Accepting request 230697 from Base:System - Enable socket activation needed by systemd service (bnc#872807). - libblkid: Drop the broken ext2/ext3/ext4 discrimination logic (util-linux-libblkid-ext-probe.patch, bnc#864703). - Abort blkid probing on I/O errors (bnc#859062, blkid-stop-scanning-on-I-O-error.patch, blkid-convert-superblocks-to-new-calling-convention.patch, http://www.spinics.net/lists/util-linux-ng/msg08976.html) (forwarded request 230696 from sbrabec) OBS-URL: https://build.opensuse.org/request/show/230697 OBS-URL: https://build.opensuse.org/package/show/openSUSE:Factory/util-linux?expand=0&rev=184 --- ...uperblocks-to-new-calling-convention.patch | 2268 +++++++++++++++++ blkid-stop-scanning-on-I-O-error.patch | 138 + util-linux-libblkid-ext-probe.patch | 274 ++ util-linux.changes | 19 + util-linux.spec | 11 + 5 files changed, 2710 insertions(+) create mode 100644 blkid-convert-superblocks-to-new-calling-convention.patch create mode 100644 blkid-stop-scanning-on-I-O-error.patch create mode 100644 util-linux-libblkid-ext-probe.patch diff --git a/blkid-convert-superblocks-to-new-calling-convention.patch b/blkid-convert-superblocks-to-new-calling-convention.patch new file mode 100644 index 0000000..a4240f7 --- /dev/null +++ b/blkid-convert-superblocks-to-new-calling-convention.patch @@ -0,0 +1,2268 @@ +From 5cb7e4a24f8fb29ddf36309419aa1172f13f3310 Mon Sep 17 00:00:00 2001 +From: Hannes Reinecke +Date: Tue, 21 Jan 2014 10:10:19 +0100 +Subject: [PATCH] blkid: convert superblocks to new calling convention + +With the previous patch the scanning functions were +modified to return a differentiated return code. +To correctly abort scanning when an I/O error occurs +we need to differentiate between 'error' (= -1) and +'not found' (= 1) in the probe functions. +This patch updates all superblock scanning functions +to the new calling convention. + +Signed-off-by: Hannes Reinecke +--- + libblkid/src/partitions/aix.c | 2 +- + libblkid/src/partitions/bsd.c | 14 ++++++--- + libblkid/src/partitions/dos.c | 24 ++++++++++----- + libblkid/src/partitions/gpt.c | 26 +++++++++++----- + libblkid/src/partitions/mac.c | 19 ++++++++---- + libblkid/src/partitions/minix.c | 14 ++++++--- + libblkid/src/partitions/sgi.c | 14 ++++++--- + libblkid/src/partitions/solaris_x86.c | 14 ++++++--- + libblkid/src/partitions/sun.c | 14 ++++++--- + libblkid/src/partitions/ultrix.c | 16 ++++++---- + libblkid/src/partitions/unixware.c | 14 ++++++--- + libblkid/src/superblocks/adaptec_raid.c | 15 ++++----- + libblkid/src/superblocks/bcache.c | 4 +-- + libblkid/src/superblocks/befs.c | 24 +++++++-------- + libblkid/src/superblocks/btrfs.c | 2 +- + libblkid/src/superblocks/cramfs.c | 2 +- + libblkid/src/superblocks/ddf_raid.c | 19 +++++++----- + libblkid/src/superblocks/drbd.c | 8 ++--- + libblkid/src/superblocks/drbdproxy_datalog.c | 2 +- + libblkid/src/superblocks/exfat.c | 4 ++- + libblkid/src/superblocks/ext.c | 34 ++++++++++---------- + libblkid/src/superblocks/f2fs.c | 2 +- + libblkid/src/superblocks/gfs.c | 8 ++--- + libblkid/src/superblocks/hfs.c | 12 ++++---- + libblkid/src/superblocks/highpoint_raid.c | 12 ++++---- + libblkid/src/superblocks/hpfs.c | 8 ++--- + libblkid/src/superblocks/iso9660.c | 4 +-- + libblkid/src/superblocks/isw_raid.c | 13 ++++---- + libblkid/src/superblocks/jfs.c | 2 +- + libblkid/src/superblocks/jmicron_raid.c | 13 ++++---- + libblkid/src/superblocks/linux_raid.c | 46 ++++++++++++++++------------ + libblkid/src/superblocks/lsi_raid.c | 10 +++--- + libblkid/src/superblocks/luks.c | 2 +- + libblkid/src/superblocks/lvm.c | 6 ++-- + libblkid/src/superblocks/minix.c | 18 ++++++----- + libblkid/src/superblocks/netware.c | 2 +- + libblkid/src/superblocks/nilfs.c | 4 +-- + libblkid/src/superblocks/ntfs.c | 6 ++-- + libblkid/src/superblocks/nvidia_raid.c | 12 ++++---- + libblkid/src/superblocks/ocfs.c | 8 ++--- + libblkid/src/superblocks/promise_raid.c | 10 +++--- + libblkid/src/superblocks/reiserfs.c | 8 ++--- + libblkid/src/superblocks/romfs.c | 2 +- + libblkid/src/superblocks/silicon_raid.c | 10 +++--- + libblkid/src/superblocks/squashfs.c | 6 ++-- + libblkid/src/superblocks/swap.c | 24 +++++++-------- + libblkid/src/superblocks/sysv.c | 8 ++--- + libblkid/src/superblocks/ubifs.c | 2 +- + libblkid/src/superblocks/udf.c | 16 +++++----- + libblkid/src/superblocks/ufs.c | 4 +-- + libblkid/src/superblocks/vfat.c | 16 +++++----- + libblkid/src/superblocks/via_raid.c | 6 ++-- + libblkid/src/superblocks/vmfs.c | 4 +-- + libblkid/src/superblocks/vxfs.c | 2 +- + libblkid/src/superblocks/xfs.c | 6 ++-- + libblkid/src/superblocks/zfs.c | 6 ++-- + 56 files changed, 338 insertions(+), 265 deletions(-) + +diff --git a/libblkid/src/partitions/aix.c b/libblkid/src/partitions/aix.c +index de397bf..ded9dfd 100644 +--- a/libblkid/src/partitions/aix.c ++++ b/libblkid/src/partitions/aix.c +@@ -34,7 +34,7 @@ static int probe_aix_pt(blkid_probe pr, + + return 0; + err: +- return -1; ++ return 1; + } + + /* +diff --git a/libblkid/src/partitions/bsd.c b/libblkid/src/partitions/bsd.c +index 3de6a58..6fdb82f 100644 +--- a/libblkid/src/partitions/bsd.c ++++ b/libblkid/src/partitions/bsd.c +@@ -42,14 +42,18 @@ static int probe_bsd_pt(blkid_probe pr, const struct blkid_idmag *mag) + return 0; + + data = blkid_probe_get_sector(pr, BLKID_MAG_SECTOR(mag)); +- if (!data) +- goto nothing; ++ if (!data) { ++ if (errno) ++ goto err; ++ else ++ goto nothing; ++ } + + l = (struct bsd_disklabel *) data + BLKID_MAG_LASTOFFSET(mag); + + ls = blkid_probe_get_partlist(pr); + if (!ls) +- goto err; ++ goto nothing; + + /* try to determine the real type of BSD system according to + * (parental) primary partition */ +@@ -76,7 +80,7 @@ static int probe_bsd_pt(blkid_probe pr, const struct blkid_idmag *mag) + + tab = blkid_partlist_new_parttable(ls, name, BLKID_MAG_OFFSET(mag)); + if (!tab) +- goto err; ++ goto nothing; + + if (le16_to_cpu(l->d_npartitions) < BSD_MAXPARTITIONS) + nparts = le16_to_cpu(l->d_npartitions); +@@ -113,7 +117,7 @@ static int probe_bsd_pt(blkid_probe pr, const struct blkid_idmag *mag) + + par = blkid_partlist_add_partition(ls, tab, start, size); + if (!par) +- goto err; ++ goto nothing; + + blkid_partition_set_type(par, p->p_fstype); + } +diff --git a/libblkid/src/partitions/dos.c b/libblkid/src/partitions/dos.c +index 14f326d..8888c0c 100644 +--- a/libblkid/src/partitions/dos.c ++++ b/libblkid/src/partitions/dos.c +@@ -54,8 +54,12 @@ static int parse_dos_extended(blkid_probe pr, blkid_parttable tab, + if (++ct_nodata > 100) + return 0; + data = blkid_probe_get_sector(pr, cur_start); +- if (!data) +- goto leave; /* malformed partition? */ ++ if (!data) { ++ if (errno) ++ goto err; ++ else ++ goto leave; /* malformed partition? */ ++ } + + if (!mbr_is_valid_magic(data)) + goto leave; +@@ -98,7 +102,7 @@ static int parse_dos_extended(blkid_probe pr, blkid_parttable tab, + + par = blkid_partlist_add_partition(ls, tab, abs_start, size); + if (!par) +- goto err; ++ goto leave; + + blkid_partition_set_type(par, p->sys_ind); + blkid_partition_set_flags(par, p->boot_ind); +@@ -142,8 +146,12 @@ static int probe_dos_pt(blkid_probe pr, + + + data = blkid_probe_get_sector(pr, 0); +- if (!data) +- goto nothing; ++ if (!data) { ++ if (errno) ++ goto err; ++ else ++ goto nothing; ++ } + + /* ignore disks with AIX magic number -- for more details see aix.c */ + if (memcmp(data, BLKID_AIX_MAGIC_STRING, BLKID_AIX_MAGIC_STRLEN) == 0) +@@ -207,7 +215,7 @@ static int probe_dos_pt(blkid_probe pr, + /* allocate a new partition table */ + tab = blkid_partlist_new_parttable(ls, "dos", MBR_PT_OFFSET); + if (!tab) +- goto err; ++ goto nothing; + + if (id) + blkid_parttable_set_id(tab, (unsigned char *) idstr); +@@ -227,7 +235,7 @@ static int probe_dos_pt(blkid_probe pr, + } + par = blkid_partlist_add_partition(ls, tab, start, size); + if (!par) +- goto err; ++ goto nothing; + + blkid_partition_set_type(par, p->sys_ind); + blkid_partition_set_flags(par, p->boot_ind); +@@ -248,7 +256,7 @@ static int probe_dos_pt(blkid_probe pr, + continue; + if (is_extended(p) && + parse_dos_extended(pr, tab, start, size, ssf) == -1) +- goto err; ++ goto nothing; + } + + /* Parse subtypes (nested partitions) on large disks */ +diff --git a/libblkid/src/partitions/gpt.c b/libblkid/src/partitions/gpt.c +index 14a255a..79a4053 100644 +--- a/libblkid/src/partitions/gpt.c ++++ b/libblkid/src/partitions/gpt.c +@@ -168,8 +168,11 @@ static int is_pmbr_valid(blkid_probe pr, int *has) + goto ok; /* skip PMBR check */ + + data = blkid_probe_get_sector(pr, 0); +- if (!data) ++ if (!data) { ++ if (errno) ++ return -1; + goto failed; ++ } + + if (!mbr_is_valid_magic(data)) + goto failed; +@@ -302,26 +305,33 @@ static int probe_gpt_pt(blkid_probe pr, + uint64_t fu, lu; + uint32_t ssf, i; + efi_guid_t guid; ++ int ret; + + if (last_lba(pr, &lastlba)) + goto nothing; + +- if (!is_pmbr_valid(pr, NULL)) ++ ret = is_pmbr_valid(pr, NULL); ++ if (ret < 0) ++ goto err; ++ else if (ret == 0) + goto nothing; + + h = get_gpt_header(pr, &hdr, &e, (lba = GPT_PRIMARY_LBA), lastlba); +- if (!h) ++ if (!h && !errno) + h = get_gpt_header(pr, &hdr, &e, (lba = lastlba), lastlba); + +- if (!h) ++ if (!h) { ++ if (errno) ++ goto err; + goto nothing; ++ } + + blkid_probe_use_wiper(pr, lba * blkid_probe_get_size(pr), 8); + + if (blkid_probe_set_magic(pr, lba << 9, + sizeof(GPT_HEADER_SIGNATURE_STR) - 1, + (unsigned char *) GPT_HEADER_SIGNATURE_STR)) +- goto err; ++ goto nothing; + + guid = h->disk_guid; + swap_efi_guid(&guid); +@@ -335,11 +345,11 @@ static int probe_gpt_pt(blkid_probe pr, + + ls = blkid_probe_get_partlist(pr); + if (!ls) +- goto err; ++ goto nothing; + + tab = blkid_partlist_new_parttable(ls, "gpt", lba << 9); + if (!tab) +- goto err; ++ goto nothing; + + blkid_parttable_set_uuid(tab, (const unsigned char *) &guid); + +@@ -372,7 +382,7 @@ static int probe_gpt_pt(blkid_probe pr, + par = blkid_partlist_add_partition(ls, tab, + start * ssf, size * ssf); + if (!par) +- goto err; ++ goto nothing; + + blkid_partition_set_utf8name(par, + (unsigned char *) e->partition_name, +diff --git a/libblkid/src/partitions/mac.c b/libblkid/src/partitions/mac.c +index 7f8bb75..e64bde2 100644 +--- a/libblkid/src/partitions/mac.c ++++ b/libblkid/src/partitions/mac.c +@@ -87,8 +87,12 @@ static int probe_mac_pt(blkid_probe pr, + * the first block on the disk. + */ + md = (struct mac_driver_desc *) blkid_probe_get_sector(pr, 0); +- if (!md) +- goto nothing; ++ if (!md) { ++ if (errno) ++ goto err; ++ else ++ goto nothing; ++ } + + block_size = be16_to_cpu(md->block_size); + +@@ -96,8 +100,11 @@ static int probe_mac_pt(blkid_probe pr, + * the second block on the disk. + */ + p = (struct mac_partition *) get_mac_block(pr, block_size, 1); +- if (!p) ++ if (!p) { ++ if (errno) ++ goto err; + goto nothing; ++ } + + /* check the first partition signature */ + if (!has_part_signature(p)) +@@ -109,11 +116,11 @@ static int probe_mac_pt(blkid_probe pr, + + ls = blkid_probe_get_partlist(pr); + if (!ls) +- goto err; ++ goto nothing; + + tab = blkid_partlist_new_parttable(ls, "mac", 0); + if (!tab) +- goto err; ++ goto nothing; + + ssf = block_size / 512; + nblks = be32_to_cpu(p->map_count); +@@ -148,7 +155,7 @@ static int probe_mac_pt(blkid_probe pr, + + par = blkid_partlist_add_partition(ls, tab, start, size); + if (!par) +- goto err; ++ goto nothing; + + blkid_partition_set_name(par, (unsigned char *) p->name, + sizeof(p->name)); +diff --git a/libblkid/src/partitions/minix.c b/libblkid/src/partitions/minix.c +index 0a597fb..2f6f513 100644 +--- a/libblkid/src/partitions/minix.c ++++ b/libblkid/src/partitions/minix.c +@@ -25,12 +25,16 @@ static int probe_minix_pt(blkid_probe pr, + int i; + + data = blkid_probe_get_sector(pr, 0); +- if (!data) +- goto nothing; ++ if (!data) { ++ if (errno) ++ goto err; ++ else ++ goto nothing; ++ } + + ls = blkid_probe_get_partlist(pr); + if (!ls) +- goto err; ++ goto nothing; + + /* Parent is required, because Minix uses the same PT as DOS and + * difference is only in primary partition (parent) type. +@@ -48,7 +52,7 @@ static int probe_minix_pt(blkid_probe pr, + + tab = blkid_partlist_new_parttable(ls, "minix", MBR_PT_OFFSET); + if (!tab) +- goto err; ++ goto nothing; + + for (i = 0, p = mbr_get_partition(data, 0); + i < MINIX_MAXPARTITIONS; i++, p++) { +@@ -71,7 +75,7 @@ static int probe_minix_pt(blkid_probe pr, + + par = blkid_partlist_add_partition(ls, tab, start, size); + if (!par) +- goto err; ++ goto nothing; + + blkid_partition_set_type(par, p->sys_ind); + blkid_partition_set_flags(par, p->boot_ind); +diff --git a/libblkid/src/partitions/sgi.c b/libblkid/src/partitions/sgi.c +index bcde84f..b216340 100644 +--- a/libblkid/src/partitions/sgi.c ++++ b/libblkid/src/partitions/sgi.c +@@ -25,8 +25,12 @@ static int probe_sgi_pt(blkid_probe pr, + int i; + + l = (struct sgi_disklabel *) blkid_probe_get_sector(pr, 0); +- if (!l) +- goto nothing; ++ if (!l) { ++ if (errno) ++ goto err; ++ else ++ goto nothing; ++ } + + if (sgi_pt_checksum(l)) { + DBG(LOWPROBE, blkid_debug( +@@ -40,7 +44,7 @@ static int probe_sgi_pt(blkid_probe pr, + + ls = blkid_probe_get_partlist(pr); + if (!ls) +- goto err; ++ goto nothing; + + tab = blkid_partlist_new_parttable(ls, "sgi", 0); + if (!tab) +@@ -53,13 +57,13 @@ static int probe_sgi_pt(blkid_probe pr, + blkid_partition par; + + if (size == 0 || type == SGI_TYPE_ENTIRE_DISK || +- type == SGI_TYPE_VOLHDR) { ++ type == SGI_TYPE_VOLHDR) { + blkid_partlist_increment_partno(ls); + continue; + } + par = blkid_partlist_add_partition(ls, tab, start, size); + if (!par) +- goto err; ++ goto nothing; + + blkid_partition_set_type(par, type); + } +diff --git a/libblkid/src/partitions/solaris_x86.c b/libblkid/src/partitions/solaris_x86.c +index 4e08caf..d8fe859 100644 +--- a/libblkid/src/partitions/solaris_x86.c ++++ b/libblkid/src/partitions/solaris_x86.c +@@ -69,8 +69,12 @@ static int probe_solaris_pt(blkid_probe pr, + uint16_t nparts; + + l = (struct solaris_vtoc *) blkid_probe_get_sector(pr, SOLARIS_SECTOR); +- if (!l) +- goto nothing; ++ if (!l) { ++ if (errno) ++ goto err; ++ else ++ goto nothing; ++ } + + if (le32_to_cpu(l->v_version) != 1) { + DBG(LOWPROBE, blkid_debug( +@@ -85,13 +89,13 @@ static int probe_solaris_pt(blkid_probe pr, + + ls = blkid_probe_get_partlist(pr); + if (!ls) +- goto err; ++ goto nothing; + + parent = blkid_partlist_get_parent(ls); + + tab = blkid_partlist_new_parttable(ls, "solaris", SOLARIS_OFFSET); + if (!tab) +- goto err; ++ goto nothing; + + nparts = le16_to_cpu(l->v_nparts); + if (nparts > SOLARIS_MAXPARTITIONS) +@@ -120,7 +124,7 @@ static int probe_solaris_pt(blkid_probe pr, + + par = blkid_partlist_add_partition(ls, tab, start, size); + if (!par) +- goto err; ++ goto nothing; + + blkid_partition_set_type(par, le16_to_cpu(p->s_tag)); + blkid_partition_set_flags(par, le16_to_cpu(p->s_flag)); +diff --git a/libblkid/src/partitions/sun.c b/libblkid/src/partitions/sun.c +index ba7ca3a..83adf83 100644 +--- a/libblkid/src/partitions/sun.c ++++ b/libblkid/src/partitions/sun.c +@@ -27,8 +27,12 @@ static int probe_sun_pt(blkid_probe pr, + int i, use_vtoc; + + l = (struct sun_disklabel *) blkid_probe_get_sector(pr, 0); +- if (!l) +- goto nothing; ++ if (!l) { ++ if (errno) ++ goto err; ++ else ++ goto nothing; ++ } + + if (sun_pt_checksum(l)) { + DBG(LOWPROBE, blkid_debug( +@@ -42,11 +46,11 @@ static int probe_sun_pt(blkid_probe pr, + + ls = blkid_probe_get_partlist(pr); + if (!ls) +- goto err; ++ goto nothing; + + tab = blkid_partlist_new_parttable(ls, "sun", 0); + if (!tab) +- goto err; ++ goto nothing; + + /* sectors per cylinder (partition offset is in cylinders...) */ + spc = be16_to_cpu(l->nhead) * be16_to_cpu(l->nsect); +@@ -89,7 +93,7 @@ static int probe_sun_pt(blkid_probe pr, + } + par = blkid_partlist_add_partition(ls, tab, start, size); + if (!par) +- goto err; ++ goto nothing; + + if (type) + blkid_partition_set_type(par, type); +diff --git a/libblkid/src/partitions/ultrix.c b/libblkid/src/partitions/ultrix.c +index 853ae6e..fa08811 100644 +--- a/libblkid/src/partitions/ultrix.c ++++ b/libblkid/src/partitions/ultrix.c +@@ -44,8 +44,12 @@ static int probe_ultrix_pt(blkid_probe pr, + int i; + + data = blkid_probe_get_sector(pr, ULTRIX_SECTOR); +- if (!data) +- goto nothing; ++ if (!data) { ++ if (errno) ++ goto err; ++ else ++ goto nothing; ++ } + + l = (struct ultrix_disklabel *) (data + ULTRIX_OFFSET); + +@@ -55,7 +59,7 @@ static int probe_ultrix_pt(blkid_probe pr, + if (blkid_probe_set_magic(pr, (ULTRIX_SECTOR << 9) + ULTRIX_OFFSET, + sizeof(ULTRIX_MAGIC_STR) - 1, + (unsigned char *) ULTRIX_MAGIC_STR)) +- goto err; ++ goto nothing; + + if (blkid_partitions_need_typeonly(pr)) + /* caller does not ask for details about partitions */ +@@ -63,11 +67,11 @@ static int probe_ultrix_pt(blkid_probe pr, + + ls = blkid_probe_get_partlist(pr); + if (!ls) +- goto err; ++ goto nothing; + + tab = blkid_partlist_new_parttable(ls, "ultrix", 0); + if (!tab) +- goto err; ++ goto nothing; + + for (i = 0; i < ULTRIX_MAXPARTITIONS; i++) { + if (!l->pt_part[i].pi_nblocks) +@@ -76,7 +80,7 @@ static int probe_ultrix_pt(blkid_probe pr, + if (!blkid_partlist_add_partition(ls, tab, + l->pt_part[i].pi_blkoff, + l->pt_part[i].pi_nblocks)) +- goto err; ++ goto nothing; + } + } + +diff --git a/libblkid/src/partitions/unixware.c b/libblkid/src/partitions/unixware.c +index ce176b8..8cdae31 100644 +--- a/libblkid/src/partitions/unixware.c ++++ b/libblkid/src/partitions/unixware.c +@@ -106,8 +106,12 @@ static int probe_unixware_pt(blkid_probe pr, + + l = (struct unixware_disklabel *) + blkid_probe_get_sector(pr, UNIXWARE_SECTOR); +- if (!l) +- goto nothing; ++ if (!l) { ++ if (errno) ++ goto err; ++ else ++ goto nothing; ++ } + + if (le32_to_cpu(l->vtoc.v_magic) != UNIXWARE_VTOCMAGIC) + goto nothing; +@@ -118,13 +122,13 @@ static int probe_unixware_pt(blkid_probe pr, + + ls = blkid_probe_get_partlist(pr); + if (!ls) +- goto err; ++ goto nothing; + + parent = blkid_partlist_get_parent(ls); + + tab = blkid_partlist_new_parttable(ls, "unixware", UNIXWARE_OFFSET); + if (!tab) +- goto err; ++ goto nothing; + + /* Skip the first partition that describe whole disk + */ +@@ -155,7 +159,7 @@ static int probe_unixware_pt(blkid_probe pr, + + par = blkid_partlist_add_partition(ls, tab, start, size); + if (!par) +- goto err; ++ goto nothing; + + blkid_partition_set_type(par, tag); + blkid_partition_set_flags(par, flg); +diff --git a/libblkid/src/superblocks/adaptec_raid.c b/libblkid/src/superblocks/adaptec_raid.c +index 02e900d..eedf547 100644 +--- a/libblkid/src/superblocks/adaptec_raid.c ++++ b/libblkid/src/superblocks/adaptec_raid.c +@@ -80,10 +80,10 @@ static int probe_adraid(blkid_probe pr, + struct adaptec_metadata *ad; + + if (pr->size < 0x10000) +- return -1; ++ return 1; + + if (!S_ISREG(pr->mode) && !blkid_probe_is_wholedisk(pr)) +- return -1; ++ return 1; + + off = ((pr->size / 0x200)-1) * 0x200; + ad = (struct adaptec_metadata *) +@@ -91,16 +91,17 @@ static int probe_adraid(blkid_probe pr, + off, + sizeof(struct adaptec_metadata)); + if (!ad) +- return -1; ++ return errno ? -1 : 1; ++ + if (ad->smagic != be32_to_cpu(AD_SIGNATURE)) +- return -1; ++ return 1; + if (ad->b0idcode != be32_to_cpu(AD_MAGIC)) +- return -1; ++ return 1; + if (blkid_probe_sprintf_version(pr, "%u", ad->resver) != 0) +- return -1; ++ return 1; + if (blkid_probe_set_magic(pr, off, sizeof(ad->b0idcode), + (unsigned char *) &ad->b0idcode)) +- return -1; ++ return 1; + return 0; + } + +diff --git a/libblkid/src/superblocks/bcache.c b/libblkid/src/superblocks/bcache.c +index 303f7ee..a8f8fa6 100644 +--- a/libblkid/src/superblocks/bcache.c ++++ b/libblkid/src/superblocks/bcache.c +@@ -104,7 +104,7 @@ static int probe_bcache (blkid_probe pr, const struct blkid_idmag *mag) + + bcs = blkid_probe_get_sb(pr, mag, struct bcache_super_block); + if (!bcs) +- return -1; ++ return errno ? -1 : 1; + + if (le64_to_cpu(bcs->offset) != BCACHE_SB_OFF / 512) + return 1; +@@ -112,7 +112,7 @@ static int probe_bcache (blkid_probe pr, const struct blkid_idmag *mag) + return 1; + + if (blkid_probe_set_uuid(pr, bcs->uuid) < 0) +- return -1; ++ return 1; + + return 0; + }; +diff --git a/libblkid/src/superblocks/befs.c b/libblkid/src/superblocks/befs.c +index 452da1e..4bb260d 100644 +--- a/libblkid/src/superblocks/befs.c ++++ b/libblkid/src/superblocks/befs.c +@@ -264,7 +264,7 @@ static int64_t get_key_value(blkid_probe pr, const struct befs_super_block *bs, + bh = (struct bplustree_header *) get_tree_node(pr, bs, &bi->data, 0, + sizeof(struct bplustree_header), fs_le); + if (!bh) +- return -1; ++ return errno ? -1 : 1; + + if ((int32_t) FS32_TO_CPU(bh->magic, fs_le) != BPLUSTREE_MAGIC) + return -1; +@@ -275,7 +275,7 @@ static int64_t get_key_value(blkid_probe pr, const struct befs_super_block *bs, + bn = (struct bplustree_node *) get_tree_node(pr, bs, &bi->data, + node_pointer, FS32_TO_CPU(bh->node_size, fs_le), fs_le); + if (!bn) +- return -1; ++ return errno ? -1 : 1; + + keylengths = (uint16_t *) ((uint8_t *) bn + + ((sizeof(struct bplustree_node) +@@ -336,10 +336,10 @@ static int get_uuid(blkid_probe pr, const struct befs_super_block *bs, + + bi = (struct befs_inode *) get_block_run(pr, bs, &bs->root_dir, fs_le); + if (!bi) +- return -1; ++ return errno ? -1 : 1; + + if (FS32_TO_CPU(bi->magic1, fs_le) != INODE_MAGIC1) +- return -1; ++ return 1; + + sd = (struct small_data *) bi->small_data; + +@@ -376,10 +376,10 @@ static int get_uuid(blkid_probe pr, const struct befs_super_block *bs, + bi = (struct befs_inode *) get_block_run(pr, bs, + &bi->attributes, fs_le); + if (!bi) +- return -1; ++ return errno ? -1 : 1; + + if (FS32_TO_CPU(bi->magic1, fs_le) != INODE_MAGIC1) +- return -1; ++ return 1; + + value = get_key_value(pr, bs, bi, KEY_NAME, fs_le); + +@@ -390,10 +390,10 @@ static int get_uuid(blkid_probe pr, const struct befs_super_block *bs, + value << FS32_TO_CPU(bs->block_shift, fs_le), + FS32_TO_CPU(bs->block_size, fs_le)); + if (!bi) +- return -1; ++ return errno ? -1 : 1; + + if (FS32_TO_CPU(bi->magic1, fs_le) != INODE_MAGIC1) +- return -1; ++ return 1; + + if (FS32_TO_CPU(bi->type, fs_le) == B_UINT64_TYPE + && FS64_TO_CPU(bi->data.size, fs_le) == KEY_SIZE +@@ -404,7 +404,7 @@ static int get_uuid(blkid_probe pr, const struct befs_super_block *bs, + attr_data = (uint64_t *) get_block_run(pr, bs, + &bi->data.direct[0], fs_le); + if (!attr_data) +- return -1; ++ return errno ? -1 : 1; + + *uuid = *attr_data; + } +@@ -424,7 +424,7 @@ static int probe_befs(blkid_probe pr, const struct blkid_idmag *mag) + mag->sboff - B_OS_NAME_LENGTH, + sizeof(struct befs_super_block)); + if (!bs) +- return -1; ++ return errno ? -1 : 1; + + if (le32_to_cpu(bs->magic1) == SUPER_BLOCK_MAGIC1 + && le32_to_cpu(bs->magic2) == SUPER_BLOCK_MAGIC2 +@@ -439,11 +439,11 @@ static int probe_befs(blkid_probe pr, const struct blkid_idmag *mag) + fs_le = 0; + version = "big-endian"; + } else +- return -1; ++ return 1; + + ret = get_uuid(pr, bs, &volume_id, fs_le); + +- if (ret < 0) ++ if (ret != 0) + return ret; + + /* +diff --git a/libblkid/src/superblocks/btrfs.c b/libblkid/src/superblocks/btrfs.c +index 034683b..3c5c151 100644 +--- a/libblkid/src/superblocks/btrfs.c ++++ b/libblkid/src/superblocks/btrfs.c +@@ -70,7 +70,7 @@ static int probe_btrfs(blkid_probe pr, const struct blkid_idmag *mag) + + bfs = blkid_probe_get_sb(pr, mag, struct btrfs_super_block); + if (!bfs) +- return -1; ++ return errno ? -1 : 1; + + if (*bfs->label) + blkid_probe_set_label(pr, +diff --git a/libblkid/src/superblocks/cramfs.c b/libblkid/src/superblocks/cramfs.c +index b58ed08..cb7273f 100644 +--- a/libblkid/src/superblocks/cramfs.c ++++ b/libblkid/src/superblocks/cramfs.c +@@ -40,7 +40,7 @@ static int probe_cramfs(blkid_probe pr, const struct blkid_idmag *mag) + + cs = blkid_probe_get_sb(pr, mag, struct cramfs_super); + if (!cs) +- return -1; ++ return errno ? -1 : 1; + + blkid_probe_set_label(pr, cs->name, sizeof(cs->name)); + return 0; +diff --git a/libblkid/src/superblocks/ddf_raid.c b/libblkid/src/superblocks/ddf_raid.c +index 24df421..90820f8 100644 +--- a/libblkid/src/superblocks/ddf_raid.c ++++ b/libblkid/src/superblocks/ddf_raid.c +@@ -81,7 +81,7 @@ static int probe_ddf(blkid_probe pr, + uint64_t off, lba; + + if (pr->size < 0x30000) +- return -1; ++ return 1; + + for (i = 0; i < ARRAY_SIZE(hdrs); i++) { + off = ((pr->size / 0x200) - hdrs[i]) * 0x200; +@@ -90,8 +90,7 @@ static int probe_ddf(blkid_probe pr, + off, + sizeof(struct ddf_header)); + if (!ddf) +- return -1; +- ++ return errno ? -1 : 1; + if (ddf->signature == cpu_to_be32(DDF_MAGIC) || + ddf->signature == cpu_to_le32(DDF_MAGIC)) + break; +@@ -99,7 +98,7 @@ static int probe_ddf(blkid_probe pr, + } + + if (!ddf) +- return -1; ++ return 1; + + lba = ddf->signature == cpu_to_be32(DDF_MAGIC) ? + be64_to_cpu(ddf->primary_lba) : +@@ -111,8 +110,12 @@ static int probe_ddf(blkid_probe pr, + + buf = blkid_probe_get_buffer(pr, + lba << 9, sizeof(ddf->signature)); +- if (!buf || memcmp(buf, &ddf->signature, 4)) +- return -1; ++ if (!buf) { ++ if (errno) ++ return -1; ++ if (memcmp(buf, &ddf->signature, 4)) ++ return 1; ++ } + } + + blkid_probe_strncpy_uuid(pr, ddf->guid, sizeof(ddf->guid)); +@@ -121,11 +124,11 @@ static int probe_ddf(blkid_probe pr, + *(version + sizeof(ddf->ddf_rev)) = '\0'; + + if (blkid_probe_set_version(pr, version) != 0) +- return -1; ++ return 1; + if (blkid_probe_set_magic(pr, off, + sizeof(ddf->signature), + (unsigned char *) &ddf->signature)) +- return -1; ++ return 1; + return 0; + } + +diff --git a/libblkid/src/superblocks/drbd.c b/libblkid/src/superblocks/drbd.c +index 43e544e..d8309da 100644 +--- a/libblkid/src/superblocks/drbd.c ++++ b/libblkid/src/superblocks/drbd.c +@@ -75,18 +75,18 @@ static int probe_drbd(blkid_probe pr, + + /* Small devices cannot be drbd (?) */ + if (pr->size < 0x10000) +- return -1; ++ return 1; + + md = (struct md_on_disk_08 *) + blkid_probe_get_buffer(pr, + off, + sizeof(struct md_on_disk_08)); + if (!md) +- return -1; ++ return errno ? -1 : 1; + + if (be32_to_cpu(md->magic) != DRBD_MD_MAGIC_08 && + be32_to_cpu(md->magic) != DRBD_MD_MAGIC_84_UNCLEAN) +- return -1; ++ return 1; + + /* + * DRBD does not have "real" uuids; the following resembles DRBD's +@@ -102,7 +102,7 @@ static int probe_drbd(blkid_probe pr, + off + offsetof(struct md_on_disk_08, magic), + sizeof(md->magic), + (unsigned char *) &md->magic)) +- return -1; ++ return 1; + + return 0; + } +diff --git a/libblkid/src/superblocks/drbdproxy_datalog.c b/libblkid/src/superblocks/drbdproxy_datalog.c +index afe4725..2b76fe4 100644 +--- a/libblkid/src/superblocks/drbdproxy_datalog.c ++++ b/libblkid/src/superblocks/drbdproxy_datalog.c +@@ -33,7 +33,7 @@ static int probe_drbdproxy_datalog(blkid_probe pr, + + lh = (struct log_header_t *) blkid_probe_get_buffer(pr, 0, sizeof(*lh)); + if (!lh) +- return -1; ++ return errno ? -1 : 1; + + blkid_probe_set_uuid(pr, lh->uuid); + blkid_probe_sprintf_version(pr, "v%jd", le64_to_cpu(lh->version)); +diff --git a/libblkid/src/superblocks/exfat.c b/libblkid/src/superblocks/exfat.c +index 215c671..e684875 100644 +--- a/libblkid/src/superblocks/exfat.c ++++ b/libblkid/src/superblocks/exfat.c +@@ -115,12 +115,14 @@ static int probe_exfat(blkid_probe pr, const struct blkid_idmag *mag) + + sb = blkid_probe_get_sb(pr, mag, struct exfat_super_block); + if (!sb) +- return -1; ++ return errno ? -1 : 1; + + label = find_label(pr, sb); + if (label) + blkid_probe_set_utf8label(pr, label->name, + min(label->length * 2, 30), BLKID_ENC_UTF16LE); ++ else if (errno) ++ return -1; + + blkid_probe_sprintf_uuid(pr, sb->volume_serial, 4, + "%02hhX%02hhX-%02hhX%02hhX", +diff --git a/libblkid/src/superblocks/ext.c b/libblkid/src/superblocks/ext.c +index 8d57cb5..0b391c7 100644 +--- a/libblkid/src/superblocks/ext.c ++++ b/libblkid/src/superblocks/ext.c +@@ -328,9 +328,9 @@ static int probe_jbd(blkid_probe pr, + + es = ext_get_super(pr, NULL, &fi, NULL); + if (!es) +- return -BLKID_ERR_PARAM; ++ return errno ? -1 : 1; + if (!(fi & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) +- return -BLKID_ERR_PARAM; ++ return 1; + + ext_get_info(pr, 2, es); + blkid_probe_set_uuid_as(pr, es->s_uuid, "LOGUUID"); +@@ -346,16 +346,16 @@ static int probe_ext2(blkid_probe pr, + + es = ext_get_super(pr, &fc, &fi, &frc); + if (!es) +- return -BLKID_ERR_PARAM; ++ return errno ? -1 : 1; + + /* Distinguish between ext3 and ext2 */ + if (fc & EXT3_FEATURE_COMPAT_HAS_JOURNAL) +- return -BLKID_ERR_PARAM; ++ return 1; + + /* Any features which ext2 doesn't understand */ + if ((frc & EXT2_FEATURE_RO_COMPAT_UNSUPPORTED) || + (fi & EXT2_FEATURE_INCOMPAT_UNSUPPORTED)) +- return -BLKID_ERR_PARAM; ++ return 1; + + /* + * If ext2 is not present, but ext4 or ext4dev are, then +@@ -364,7 +364,7 @@ static int probe_ext2(blkid_probe pr, + if (!system_supports_ext2() && + (system_supports_ext4() || system_supports_ext4dev()) && + system_supports_ext4_ext2()) +- return -BLKID_ERR_PARAM; ++ return 1; + + ext_get_info(pr, 2, es); + return 0; +@@ -378,16 +378,16 @@ static int probe_ext3(blkid_probe pr, + + es = ext_get_super(pr, &fc, &fi, &frc); + if (!es) +- return -BLKID_ERR_PARAM; ++ return errno ? -1 : 1; + + /* ext3 requires journal */ + if (!(fc & EXT3_FEATURE_COMPAT_HAS_JOURNAL)) +- return -BLKID_ERR_PARAM; ++ return 1; + + /* Any features which ext3 doesn't understand */ + if ((frc & EXT3_FEATURE_RO_COMPAT_UNSUPPORTED) || + (fi & EXT3_FEATURE_INCOMPAT_UNSUPPORTED)) +- return -BLKID_ERR_PARAM; ++ return 1; + + ext_get_info(pr, 3, es); + return 0; +@@ -402,11 +402,11 @@ static int probe_ext4dev(blkid_probe pr, + + es = ext_get_super(pr, &fc, &fi, &frc); + if (!es) +- return -BLKID_ERR_PARAM; ++ return errno ? -1 : 1; + + /* Distinguish from jbd */ + if (fi & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) +- return -BLKID_ERR_PARAM; ++ return 1; + + /* + * If the filesystem does not have a journal and ext2 and ext4 +@@ -431,9 +431,9 @@ static int probe_ext4dev(blkid_probe pr, + */ + if (le32_to_cpu(es->s_flags) & EXT2_FLAGS_TEST_FILESYS) { + if (!system_supports_ext4dev() && system_supports_ext4()) +- return -BLKID_ERR_PARAM; ++ return 1; + } else +- return -BLKID_ERR_PARAM; ++ return 1; + + force_ext4dev: + ext_get_info(pr, 4, es); +@@ -448,11 +448,11 @@ static int probe_ext4(blkid_probe pr, + + es = ext_get_super(pr, &fc, &fi, &frc); + if (!es) +- return -1; ++ return errno ? -1 : 1; + + /* Distinguish from jbd */ + if (fi & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) +- return -BLKID_ERR_PARAM; ++ return 1; + + /* + * If the filesystem does not have a journal and ext2 is not +@@ -467,7 +467,7 @@ static int probe_ext4(blkid_probe pr, + /* Ext4 has at least one feature which ext3 doesn't understand */ + if (!(frc & EXT3_FEATURE_RO_COMPAT_UNSUPPORTED) && + !(fi & EXT3_FEATURE_INCOMPAT_UNSUPPORTED)) +- return -BLKID_ERR_PARAM; ++ return 1; + + force_ext4: + /* +@@ -482,7 +482,7 @@ force_ext4: + */ + if (le32_to_cpu(es->s_flags) & EXT2_FLAGS_TEST_FILESYS) { + if (system_supports_ext4dev() || !system_supports_ext4()) +- return -BLKID_ERR_PARAM; ++ return 1; + } + + ext_get_info(pr, 4, es); +diff --git a/libblkid/src/superblocks/f2fs.c b/libblkid/src/superblocks/f2fs.c +index 1543a7a..e798952 100644 +--- a/libblkid/src/superblocks/f2fs.c ++++ b/libblkid/src/superblocks/f2fs.c +@@ -62,7 +62,7 @@ static int probe_f2fs(blkid_probe pr, const struct blkid_idmag *mag) + + sb = blkid_probe_get_sb(pr, mag, struct f2fs_super_block); + if (!sb) +- return -1; ++ return errno ? -1 : 1; + + major = le16_to_cpu(sb->major_ver); + minor = le16_to_cpu(sb->minor_ver); +diff --git a/libblkid/src/superblocks/gfs.c b/libblkid/src/superblocks/gfs.c +index b2c0163..1ca74a5 100644 +--- a/libblkid/src/superblocks/gfs.c ++++ b/libblkid/src/superblocks/gfs.c +@@ -64,7 +64,7 @@ static int probe_gfs(blkid_probe pr, const struct blkid_idmag *mag) + + sbd = blkid_probe_get_sb(pr, mag, struct gfs2_sb); + if (!sbd) +- return -1; ++ return errno ? -1 : 1; + + if (be32_to_cpu(sbd->sb_fs_format) == GFS_FORMAT_FS && + be32_to_cpu(sbd->sb_multihost_format) == GFS_FORMAT_MULTI) +@@ -78,7 +78,7 @@ static int probe_gfs(blkid_probe pr, const struct blkid_idmag *mag) + return 0; + } + +- return -1; ++ return 1; + } + + static int probe_gfs2(blkid_probe pr, const struct blkid_idmag *mag) +@@ -87,7 +87,7 @@ static int probe_gfs2(blkid_probe pr, const struct blkid_idmag *mag) + + sbd = blkid_probe_get_sb(pr, mag, struct gfs2_sb); + if (!sbd) +- return -1; ++ return errno ? -1 : 1; + + if (be32_to_cpu(sbd->sb_fs_format) == GFS2_FORMAT_FS && + be32_to_cpu(sbd->sb_multihost_format) == GFS2_FORMAT_MULTI) +@@ -100,7 +100,7 @@ static int probe_gfs2(blkid_probe pr, const struct blkid_idmag *mag) + blkid_probe_set_version(pr, "1"); + return 0; + } +- return -1; ++ return 1; + } + + const struct blkid_idinfo gfs_idinfo = +diff --git a/libblkid/src/superblocks/hfs.c b/libblkid/src/superblocks/hfs.c +index 6d960e9..c04b176 100644 +--- a/libblkid/src/superblocks/hfs.c ++++ b/libblkid/src/superblocks/hfs.c +@@ -154,7 +154,7 @@ static int probe_hfs(blkid_probe pr, const struct blkid_idmag *mag) + + hfs = blkid_probe_get_sb(pr, mag, struct hfs_mdb); + if (!hfs) +- return -1; ++ return errno ? -1 : 1; + + if ((memcmp(hfs->embed_sig, "H+", 2) == 0) || + (memcmp(hfs->embed_sig, "HX", 2) == 0)) +@@ -193,7 +193,7 @@ static int probe_hfsplus(blkid_probe pr, const struct blkid_idmag *mag) + + sbd = blkid_probe_get_sb(pr, mag, struct hfs_mdb); + if (!sbd) +- return -1; ++ return errno ? -1 : 1; + + /* Check for a HFS+ volume embedded in a HFS volume */ + if (memcmp(sbd->signature, "BD", 2) == 0) { +@@ -218,7 +218,7 @@ static int probe_hfsplus(blkid_probe pr, const struct blkid_idmag *mag) + struct hfsplus_vol_header); + + if (!hfsplus) +- return -1; ++ return errno ? -1 : 1; + + if ((memcmp(hfsplus->signature, "H+", 2) != 0) && + (memcmp(hfsplus->signature, "HX", 2) != 0)) +@@ -228,7 +228,7 @@ static int probe_hfsplus(blkid_probe pr, const struct blkid_idmag *mag) + + blocksize = be32_to_cpu(hfsplus->blocksize); + if (blocksize < HFSPLUS_SECTOR_SIZE) +- return -1; ++ return 1; + + memcpy(extents, hfsplus->cat_file.extents, sizeof(extents)); + cat_block = be32_to_cpu(extents[0].start_block); +@@ -236,7 +236,7 @@ static int probe_hfsplus(blkid_probe pr, const struct blkid_idmag *mag) + buf = blkid_probe_get_buffer(pr, + off + ((blkid_loff_t) cat_block * blocksize), 0x2000); + if (!buf) +- return 0; ++ return errno ? -1 : 0; + + bnode = (struct hfsplus_bheader_record *) + &buf[sizeof(struct hfsplus_bnode_descriptor)]; +@@ -271,7 +271,7 @@ static int probe_hfsplus(blkid_probe pr, const struct blkid_idmag *mag) + (blkid_loff_t) off + leaf_off, + leaf_node_size); + if (!buf) +- return 0; ++ return errno ? -1 : 0; + + descr = (struct hfsplus_bnode_descriptor *) buf; + record_count = be16_to_cpu(descr->num_recs); +diff --git a/libblkid/src/superblocks/highpoint_raid.c b/libblkid/src/superblocks/highpoint_raid.c +index 0b41344..1e242d8 100644 +--- a/libblkid/src/superblocks/highpoint_raid.c ++++ b/libblkid/src/superblocks/highpoint_raid.c +@@ -30,9 +30,9 @@ static int probe_highpoint45x(blkid_probe pr, + uint32_t magic; + + if (pr->size < 0x10000) +- return -1; ++ return 1; + if (!S_ISREG(pr->mode) && !blkid_probe_is_wholedisk(pr)) +- return -1; ++ return 1; + + off = ((pr->size / 0x200) - 11) * 0x200; + hpt = (struct hpt45x_metadata *) +@@ -40,13 +40,13 @@ static int probe_highpoint45x(blkid_probe pr, + off, + sizeof(struct hpt45x_metadata)); + if (!hpt) +- return -1; ++ return errno ? -1 : 1; + magic = le32_to_cpu(hpt->magic); + if (magic != HPT45X_MAGIC_OK && magic != HPT45X_MAGIC_BAD) +- return -1; ++ return 1; + if (blkid_probe_set_magic(pr, off, sizeof(hpt->magic), + (unsigned char *) &hpt->magic)) +- return -1; ++ return 1; + return 0; + } + +@@ -54,7 +54,7 @@ static int probe_highpoint37x(blkid_probe pr, + const struct blkid_idmag *mag __attribute__((__unused__))) + { + if (!S_ISREG(pr->mode) && !blkid_probe_is_wholedisk(pr)) +- return -1; ++ return 1; + return 0; + } + +diff --git a/libblkid/src/superblocks/hpfs.c b/libblkid/src/superblocks/hpfs.c +index f9b851a..48a0192 100644 +--- a/libblkid/src/superblocks/hpfs.c ++++ b/libblkid/src/superblocks/hpfs.c +@@ -68,7 +68,7 @@ static int probe_hpfs(blkid_probe pr, const struct blkid_idmag *mag) + /* super block */ + hs = blkid_probe_get_sb(pr, mag, struct hpfs_super_block); + if (!hs) +- return -1; ++ return errno ? -1 : 1; + version = hs->version; + + /* spare super block */ +@@ -77,9 +77,9 @@ static int probe_hpfs(blkid_probe pr, const struct blkid_idmag *mag) + HPFS_SBSPARE_OFFSET, + sizeof(struct hpfs_spare_super)); + if (!hss) +- return -1; ++ return errno ? -1 : 1; + if (memcmp(hss->magic, "\x49\x18\x91\xf9", 4) != 0) +- return -1; ++ return 1; + + /* boot block (with UUID and LABEL) */ + hbb = (struct hpfs_boot_block *) +@@ -87,7 +87,7 @@ static int probe_hpfs(blkid_probe pr, const struct blkid_idmag *mag) + 0, + sizeof(struct hpfs_boot_block)); + if (!hbb) +- return -1; ++ return errno ? -1 : 1; + if (memcmp(hbb->magic, "\x55\xaa", 2) == 0 && + memcmp(hbb->sig_hpfs, "HPFS", 4) == 0 && + hbb->sig_28h == 0x28) { +diff --git a/libblkid/src/superblocks/iso9660.c b/libblkid/src/superblocks/iso9660.c +index 148587b..911fcc0 100644 +--- a/libblkid/src/superblocks/iso9660.c ++++ b/libblkid/src/superblocks/iso9660.c +@@ -100,7 +100,7 @@ static int probe_iso9660_hsfs(blkid_probe pr, const struct blkid_idmag *mag) + + iso = blkid_probe_get_sb(pr, mag, struct high_sierra_volume_descriptor); + if (!iso) +- return -1; ++ return errno ? -1 : 1; + + blkid_probe_set_version(pr, "High Sierra"); + blkid_probe_set_label(pr, iso->volume_id, sizeof(iso->volume_id)); +@@ -178,7 +178,7 @@ int probe_iso9660(blkid_probe pr, const struct blkid_idmag *mag) + + iso = blkid_probe_get_sb(pr, mag, struct iso_volume_descriptor); + if (!iso) +- return -1; ++ return errno ? -1 : 1; + + memcpy(label, iso->volume_id, sizeof(label)); + +diff --git a/libblkid/src/superblocks/isw_raid.c b/libblkid/src/superblocks/isw_raid.c +index 755c1b6..4491cda 100644 +--- a/libblkid/src/superblocks/isw_raid.c ++++ b/libblkid/src/superblocks/isw_raid.c +@@ -33,9 +33,9 @@ static int probe_iswraid(blkid_probe pr, + struct isw_metadata *isw; + + if (pr->size < 0x10000) +- return -1; ++ return 1; + if (!S_ISREG(pr->mode) && !blkid_probe_is_wholedisk(pr)) +- return -1; ++ return 1; + + off = ((pr->size / 0x200) - 2) * 0x200; + isw = (struct isw_metadata *) +@@ -43,15 +43,16 @@ static int probe_iswraid(blkid_probe pr, + off, + sizeof(struct isw_metadata)); + if (!isw) +- return -1; ++ return errno ? -1 : 1; ++ + if (memcmp(isw->sig, ISW_SIGNATURE, sizeof(ISW_SIGNATURE)-1) != 0) +- return -1; ++ return 1; + if (blkid_probe_sprintf_version(pr, "%6s", + &isw->sig[sizeof(ISW_SIGNATURE)-1]) != 0) +- return -1; ++ return 1; + if (blkid_probe_set_magic(pr, off, sizeof(isw->sig), + (unsigned char *) isw->sig)) +- return -1; ++ return 1; + return 0; + } + +diff --git a/libblkid/src/superblocks/jfs.c b/libblkid/src/superblocks/jfs.c +index 78c018c..6f1bf1c 100644 +--- a/libblkid/src/superblocks/jfs.c ++++ b/libblkid/src/superblocks/jfs.c +@@ -40,7 +40,7 @@ static int probe_jfs(blkid_probe pr, const struct blkid_idmag *mag) + + js = blkid_probe_get_sb(pr, mag, struct jfs_super_block); + if (!js) +- return -1; ++ return errno ? -1 : 1; + if (le32_to_cpu(js->js_bsize) != (1U << le16_to_cpu(js->js_l2bsize))) + return 1; + if (le32_to_cpu(js->js_pbsize) != (1U << le16_to_cpu(js->js_l2pbsize))) +diff --git a/libblkid/src/superblocks/jmicron_raid.c b/libblkid/src/superblocks/jmicron_raid.c +index c708078..60ee187 100644 +--- a/libblkid/src/superblocks/jmicron_raid.c ++++ b/libblkid/src/superblocks/jmicron_raid.c +@@ -32,9 +32,9 @@ static int probe_jmraid(blkid_probe pr, + struct jm_metadata *jm; + + if (pr->size < 0x10000) +- return -1; ++ return 1; + if (!S_ISREG(pr->mode) && !blkid_probe_is_wholedisk(pr)) +- return -1; ++ return 1; + + off = ((pr->size / 0x200) - 1) * 0x200; + jm = (struct jm_metadata *) +@@ -42,15 +42,16 @@ static int probe_jmraid(blkid_probe pr, + off, + sizeof(struct jm_metadata)); + if (!jm) +- return -1; ++ return errno ? -1 : 1; ++ + if (memcmp(jm->signature, JM_SIGNATURE, sizeof(JM_SIGNATURE) - 1) != 0) +- return -1; ++ return 1; + if (blkid_probe_sprintf_version(pr, "%u.%u", + jm->major_version, jm->minor_version) != 0) +- return -1; ++ return 1; + if (blkid_probe_set_magic(pr, off, sizeof(jm->signature), + (unsigned char *) jm->signature)) +- return -1; ++ return 1; + return 0; + } + +diff --git a/libblkid/src/superblocks/linux_raid.c b/libblkid/src/superblocks/linux_raid.c +index a3f9d67..2c36b6e 100644 +--- a/libblkid/src/superblocks/linux_raid.c ++++ b/libblkid/src/superblocks/linux_raid.c +@@ -110,13 +110,13 @@ static int probe_raid0(blkid_probe pr, blkid_loff_t off) + uint64_t size; + + if (pr->size < MD_RESERVED_BYTES) +- return -1; ++ return 1; + mdp0 = (struct mdp0_super_block *) + blkid_probe_get_buffer(pr, + off, + sizeof(struct mdp0_super_block)); + if (!mdp0) +- return -1; ++ return errno ? -1 : 1; + + memset(uuid.ints, 0, sizeof(uuid.ints)); + +@@ -173,12 +173,12 @@ static int probe_raid0(blkid_probe pr, blkid_loff_t off) + } + + if (blkid_probe_sprintf_version(pr, "%u.%u.%u", ma, mi, pa) != 0) +- return -1; ++ return 1; + if (blkid_probe_set_uuid(pr, (unsigned char *) uuid.bytes) != 0) +- return -1; ++ return 1; + if (blkid_probe_set_magic(pr, off, sizeof(mdp0->md_magic), + (unsigned char *) &mdp0->md_magic)) +- return -1; ++ return 1; + return 0; + } + +@@ -191,24 +191,24 @@ static int probe_raid1(blkid_probe pr, off_t off) + off, + sizeof(struct mdp1_super_block)); + if (!mdp1) +- return -1; ++ return errno ? -1 : 1; + if (le32_to_cpu(mdp1->magic) != MD_SB_MAGIC) +- return -1; ++ return 1; + if (le32_to_cpu(mdp1->major_version) != 1U) +- return -1; ++ return 1; + if (le64_to_cpu(mdp1->super_offset) != (uint64_t) off >> 9) +- return -1; ++ return 1; + if (blkid_probe_set_uuid(pr, (unsigned char *) mdp1->set_uuid) != 0) +- return -1; ++ return 1; + if (blkid_probe_set_uuid_as(pr, + (unsigned char *) mdp1->device_uuid, "UUID_SUB") != 0) +- return -1; ++ return 1; + if (blkid_probe_set_label(pr, mdp1->set_name, + sizeof(mdp1->set_name)) != 0) +- return -1; ++ return 1; + if (blkid_probe_set_magic(pr, off, sizeof(mdp1->magic), + (unsigned char *) &mdp1->magic)) +- return -1; ++ return 1; + return 0; + } + +@@ -216,23 +216,31 @@ int probe_raid(blkid_probe pr, + const struct blkid_idmag *mag __attribute__((__unused__))) + { + const char *ver = NULL; ++ int ret; + + if (pr->size > MD_RESERVED_BYTES) { + /* version 0 at the end of the device */ + uint64_t sboff = (pr->size & ~(MD_RESERVED_BYTES - 1)) +- - MD_RESERVED_BYTES; +- if (probe_raid0(pr, sboff) == 0) +- return 0; ++ - MD_RESERVED_BYTES; ++ ret = probe_raid0(pr, sboff); ++ if (ret < 1) ++ return ret; + + /* version 1.0 at the end of the device */ + sboff = (pr->size & ~(0x1000 - 1)) - 0x2000; +- if (probe_raid1(pr, sboff) == 0) ++ ret = probe_raid1(pr, sboff); ++ if (ret < 0) ++ return ret; ++ if (ret == 0) + ver = "1.0"; + } + + if (!ver) { + /* version 1.1 at the start of the device */ +- if (probe_raid1(pr, 0) == 0) ++ ret = probe_raid1(pr, 0); ++ if (ret < 0) ++ return ret; ++ if (ret == 0) + ver = "1.1"; + + /* version 1.2 at 4k offset from the start */ +@@ -244,7 +252,7 @@ int probe_raid(blkid_probe pr, + blkid_probe_set_version(pr, ver); + return 0; + } +- return -1; ++ return 1; + } + + +diff --git a/libblkid/src/superblocks/lsi_raid.c b/libblkid/src/superblocks/lsi_raid.c +index 56721dd..5bfbe15 100644 +--- a/libblkid/src/superblocks/lsi_raid.c ++++ b/libblkid/src/superblocks/lsi_raid.c +@@ -30,9 +30,9 @@ static int probe_lsiraid(blkid_probe pr, + struct lsi_metadata *lsi; + + if (pr->size < 0x10000) +- return -1; ++ return 1; + if (!S_ISREG(pr->mode) && !blkid_probe_is_wholedisk(pr)) +- return -1; ++ return 1; + + off = ((pr->size / 0x200) - 1) * 0x200; + lsi = (struct lsi_metadata *) +@@ -40,13 +40,13 @@ static int probe_lsiraid(blkid_probe pr, + off, + sizeof(struct lsi_metadata)); + if (!lsi) +- return -1; ++ return errno ? -1 : 1; + + if (memcmp(lsi->sig, LSI_SIGNATURE, sizeof(LSI_SIGNATURE)-1) != 0) +- return -1; ++ return 1; + if (blkid_probe_set_magic(pr, off, sizeof(lsi->sig), + (unsigned char *) lsi->sig)) +- return -1; ++ return 1; + return 0; + } + +diff --git a/libblkid/src/superblocks/luks.c b/libblkid/src/superblocks/luks.c +index f716e31..420eaa0 100644 +--- a/libblkid/src/superblocks/luks.c ++++ b/libblkid/src/superblocks/luks.c +@@ -45,7 +45,7 @@ static int probe_luks(blkid_probe pr, const struct blkid_idmag *mag) + + header = blkid_probe_get_sb(pr, mag, struct luks_phdr); + if (header == NULL) +- return -1; ++ return errno ? -1 : 1; + + blkid_probe_strncpy_uuid(pr, (unsigned char *) header->uuid, + sizeof(header->uuid)); +diff --git a/libblkid/src/superblocks/lvm.c b/libblkid/src/superblocks/lvm.c +index 65c7c35..d956beb 100644 +--- a/libblkid/src/superblocks/lvm.c ++++ b/libblkid/src/superblocks/lvm.c +@@ -82,7 +82,7 @@ static int probe_lvm2(blkid_probe pr, const struct blkid_idmag *mag) + mag->kboff << 10, + 512 + sizeof(struct lvm2_pv_label_header)); + if (!buf) +- return -1; ++ return errno ? -1 : 1; + + /* buf is at 0k or 1k offset; find label inside */ + if (memcmp(buf, "LABELONE", 8) == 0) { +@@ -128,7 +128,7 @@ static int probe_lvm1(blkid_probe pr, const struct blkid_idmag *mag) + + label = blkid_probe_get_sb(pr, mag, struct lvm1_pv_label_header); + if (!label) +- return -1; ++ return errno ? -1 : 1; + + version = le16_to_cpu(label->version); + if (version != 1 && version != 2) +@@ -163,7 +163,7 @@ static int probe_verity(blkid_probe pr, const struct blkid_idmag *mag) + + sb = blkid_probe_get_sb(pr, mag, struct verity_sb); + if (sb == NULL) +- return -1; ++ return errno ? -1 : 1; + + version = le32_to_cpu(sb->version); + if (version != 1) +diff --git a/libblkid/src/superblocks/minix.c b/libblkid/src/superblocks/minix.c +index 0e7cd93..3aa236a 100644 +--- a/libblkid/src/superblocks/minix.c ++++ b/libblkid/src/superblocks/minix.c +@@ -80,17 +80,17 @@ static int probe_minix(blkid_probe pr, const struct blkid_idmag *mag) + max(sizeof(struct minix_super_block), + sizeof(struct minix3_super_block))); + if (!data) +- return -1; ++ return errno ? -1 : 1; + version = get_minix_version(data, &swabme); + if (version < 1) +- return -1; ++ return 1; + + if (version <= 2) { + struct minix_super_block *sb = (struct minix_super_block *) data; + int zones, ninodes, imaps, zmaps, firstz; + + if (sb->s_imap_blocks == 0 || sb->s_zmap_blocks == 0) +- return -1; ++ return 1; + + zones = version == 2 ? minix_swab32(swabme, sb->s_zones) : + minix_swab16(swabme, sb->s_nzones); +@@ -101,15 +101,15 @@ static int probe_minix(blkid_probe pr, const struct blkid_idmag *mag) + + /* sanity checks to be sure that the FS is really minix */ + if (imaps * MINIX_BLOCK_SIZE * 8 < ninodes + 1) +- return -1; ++ return 1; + if (zmaps * MINIX_BLOCK_SIZE * 8 < zones - firstz + 1) +- return -1; ++ return 1; + + } else if (version == 3) { + struct minix3_super_block *sb = (struct minix3_super_block *) data; + + if (sb->s_imap_blocks == 0 || sb->s_zmap_blocks == 0) +- return -1; ++ return 1; + } + + /* unfortunately, some parts of ext3 is sometimes possible to +@@ -117,8 +117,10 @@ static int probe_minix(blkid_probe pr, const struct blkid_idmag *mag) + * string. (For extN magic string and offsets see ext.c.) + */ + ext = blkid_probe_get_buffer(pr, 0x400 + 0x38, 2); +- if (ext && memcmp(ext, "\123\357", 2) == 0) +- return -1; ++ if (!ext) ++ return errno ? -1 : 1; ++ else if (memcmp(ext, "\123\357", 2) == 0) ++ return 1; + + blkid_probe_sprintf_version(pr, "%d", version); + return 0; +diff --git a/libblkid/src/superblocks/netware.c b/libblkid/src/superblocks/netware.c +index 7ef2162..9e2801b 100644 +--- a/libblkid/src/superblocks/netware.c ++++ b/libblkid/src/superblocks/netware.c +@@ -71,7 +71,7 @@ static int probe_netware(blkid_probe pr, const struct blkid_idmag *mag) + + nw = blkid_probe_get_sb(pr, mag, struct netware_super_block); + if (!nw) +- return -1; ++ return errno ? -1 : 1; + + blkid_probe_set_uuid(pr, nw->SBH_PoolID); + +diff --git a/libblkid/src/superblocks/nilfs.c b/libblkid/src/superblocks/nilfs.c +index 24ccf63..41c5066 100644 +--- a/libblkid/src/superblocks/nilfs.c ++++ b/libblkid/src/superblocks/nilfs.c +@@ -93,12 +93,12 @@ static int probe_nilfs2(blkid_probe pr, const struct blkid_idmag *mag) + sbp = (struct nilfs_super_block *) blkid_probe_get_buffer( + pr, NILFS_SB_OFFSET, sizeof(struct nilfs_super_block)); + if (!sbp) +- return -1; ++ return errno ? -1 : 1; + /* backup */ + sbb = (struct nilfs_super_block *) blkid_probe_get_buffer( + pr, ((pr->size / 0x200) - 8) * 0x200, sizeof(struct nilfs_super_block)); + if (!sbp) +- return -1; ++ return errno ? -1 : 1; + + /* + * Compare two super blocks and set 1 in swp if the secondary +diff --git a/libblkid/src/superblocks/ntfs.c b/libblkid/src/superblocks/ntfs.c +index d767cb4..3f62bbc 100644 +--- a/libblkid/src/superblocks/ntfs.c ++++ b/libblkid/src/superblocks/ntfs.c +@@ -91,7 +91,7 @@ static int probe_ntfs(blkid_probe pr, const struct blkid_idmag *mag) + + ns = blkid_probe_get_sb(pr, mag, struct ntfs_super_block); + if (!ns) +- return -1; ++ return errno ? -1 : 1; + + /* + * Check bios parameters block +@@ -158,7 +158,7 @@ static int probe_ntfs(blkid_probe pr, const struct blkid_idmag *mag) + + buf_mft = blkid_probe_get_buffer(pr, off, mft_record_size); + if (!buf_mft) +- return 1; ++ return errno ? -1 : 1; + + if (memcmp(buf_mft, "FILE", 4)) + return 1; +@@ -167,7 +167,7 @@ static int probe_ntfs(blkid_probe pr, const struct blkid_idmag *mag) + + buf_mft = blkid_probe_get_buffer(pr, off, mft_record_size); + if (!buf_mft) +- return 1; ++ return errno ? -1 : 1; + + if (memcmp(buf_mft, "FILE", 4)) + return 1; +diff --git a/libblkid/src/superblocks/nvidia_raid.c b/libblkid/src/superblocks/nvidia_raid.c +index dd86cdc..54038e7 100644 +--- a/libblkid/src/superblocks/nvidia_raid.c ++++ b/libblkid/src/superblocks/nvidia_raid.c +@@ -32,9 +32,9 @@ static int probe_nvraid(blkid_probe pr, + struct nv_metadata *nv; + + if (pr->size < 0x10000) +- return -1; ++ return 1; + if (!S_ISREG(pr->mode) && !blkid_probe_is_wholedisk(pr)) +- return -1; ++ return 1; + + off = ((pr->size / 0x200) - 2) * 0x200; + nv = (struct nv_metadata *) +@@ -42,15 +42,15 @@ static int probe_nvraid(blkid_probe pr, + off, + sizeof(struct nv_metadata)); + if (!nv) +- return -1; ++ return errno ? -1 : 1; + + if (memcmp(nv->vendor, NVIDIA_SIGNATURE, sizeof(NVIDIA_SIGNATURE)-1) != 0) +- return -1; ++ return 1; + if (blkid_probe_sprintf_version(pr, "%u", le16_to_cpu(nv->version)) != 0) +- return -1; ++ return 1; + if (blkid_probe_set_magic(pr, off, sizeof(nv->vendor), + (unsigned char *) nv->vendor)) +- return -1; ++ return 1; + return 0; + } + +diff --git a/libblkid/src/superblocks/ocfs.c b/libblkid/src/superblocks/ocfs.c +index 82170ac..f537db4 100644 +--- a/libblkid/src/superblocks/ocfs.c ++++ b/libblkid/src/superblocks/ocfs.c +@@ -109,14 +109,14 @@ static int probe_ocfs(blkid_probe pr, const struct blkid_idmag *mag) + buf = blkid_probe_get_buffer(pr, mag->kboff << 10, + sizeof(struct ocfs_volume_header)); + if (!buf) +- return -1; ++ return errno ? -1 : 1; + memcpy(&ovh, buf, sizeof(ovh)); + + /* label */ + buf = blkid_probe_get_buffer(pr, (mag->kboff << 10) + 512, + sizeof(struct ocfs_volume_label)); + if (!buf) +- return -1; ++ return errno ? -1 : 1; + memcpy(&ovl, buf, sizeof(ovl)); + + maj = ocfsmajor(ovh); +@@ -144,7 +144,7 @@ static int probe_ocfs2(blkid_probe pr, const struct blkid_idmag *mag) + + osb = blkid_probe_get_sb(pr, mag, struct ocfs2_super_block); + if (!osb) +- return -1; ++ return errno ? -1 : 1; + + blkid_probe_set_label(pr, (unsigned char *) osb->s_label, sizeof(osb->s_label)); + blkid_probe_set_uuid(pr, osb->s_uuid); +@@ -162,7 +162,7 @@ static int probe_oracleasm(blkid_probe pr, const struct blkid_idmag *mag) + + dl = blkid_probe_get_sb(pr, mag, struct oracle_asm_disk_label); + if (!dl) +- return -1; ++ return errno ? -1 : 1; + + blkid_probe_set_label(pr, (unsigned char *) dl->dl_id, sizeof(dl->dl_id)); + return 0; +diff --git a/libblkid/src/superblocks/promise_raid.c b/libblkid/src/superblocks/promise_raid.c +index 01e4e37..d56560c 100644 +--- a/libblkid/src/superblocks/promise_raid.c ++++ b/libblkid/src/superblocks/promise_raid.c +@@ -33,9 +33,9 @@ static int probe_pdcraid(blkid_probe pr, + }; + + if (pr->size < 0x40000) +- return -1; ++ return 1; + if (!S_ISREG(pr->mode) && !blkid_probe_is_wholedisk(pr)) +- return -1; ++ return 1; + + for (i = 0; sectors[i] != 0; i++) { + uint64_t off; +@@ -47,18 +47,18 @@ static int probe_pdcraid(blkid_probe pr, + off, + sizeof(struct promise_metadata)); + if (!pdc) +- return -1; ++ return errno ? -1 : 1; + + if (memcmp(pdc->sig, PDC_SIGNATURE, + sizeof(PDC_SIGNATURE) - 1) == 0) { + + if (blkid_probe_set_magic(pr, off, sizeof(pdc->sig), + (unsigned char *) pdc->sig)) +- return -1; ++ return 1; + return 0; + } + } +- return -1; ++ return 1; + } + + const struct blkid_idinfo pdcraid_idinfo = { +diff --git a/libblkid/src/superblocks/reiserfs.c b/libblkid/src/superblocks/reiserfs.c +index 152571f..247891a 100644 +--- a/libblkid/src/superblocks/reiserfs.c ++++ b/libblkid/src/superblocks/reiserfs.c +@@ -45,17 +45,17 @@ static int probe_reiser(blkid_probe pr, const struct blkid_idmag *mag) + + rs = blkid_probe_get_sb(pr, mag, struct reiserfs_super_block); + if (!rs) +- return -1; ++ return errno ? -1 : 1; + + blocksize = le16_to_cpu(rs->rs_blocksize); + + /* The blocksize must be at least 512B */ + if ((blocksize >> 9) == 0) +- return -BLKID_ERR_PARAM; ++ return 1; + + /* If the superblock is inside the journal, we have the wrong one */ + if (mag->kboff / (blocksize >> 9) > le32_to_cpu(rs->rs_journal_block) / 2) +- return -BLKID_ERR_BIG; ++ return 1; + + /* LABEL/UUID are only valid for later versions of Reiserfs v3.6. */ + if (mag->magic[6] == '2' || mag->magic[6] == '3') { +@@ -82,7 +82,7 @@ static int probe_reiser4(blkid_probe pr, const struct blkid_idmag *mag) + + rs4 = blkid_probe_get_sb(pr, mag, struct reiser4_super_block); + if (!rs4) +- return -1; ++ return errno ? -1 : 1; + + if (*rs4->rs4_label) + blkid_probe_set_label(pr, rs4->rs4_label, sizeof(rs4->rs4_label)); +diff --git a/libblkid/src/superblocks/romfs.c b/libblkid/src/superblocks/romfs.c +index 91ef996..6f339c0 100644 +--- a/libblkid/src/superblocks/romfs.c ++++ b/libblkid/src/superblocks/romfs.c +@@ -29,7 +29,7 @@ static int probe_romfs(blkid_probe pr, const struct blkid_idmag *mag) + + ros = blkid_probe_get_sb(pr, mag, struct romfs_super_block); + if (!ros) +- return -1; ++ return errno ? -1 : 1; + + if (strlen((char *) ros->ros_volume)) + blkid_probe_set_label(pr, ros->ros_volume, +diff --git a/libblkid/src/superblocks/silicon_raid.c b/libblkid/src/superblocks/silicon_raid.c +index 10a3023..e38606c 100644 +--- a/libblkid/src/superblocks/silicon_raid.c ++++ b/libblkid/src/superblocks/silicon_raid.c +@@ -88,9 +88,9 @@ static int probe_silraid(blkid_probe pr, + struct silicon_metadata *sil; + + if (pr->size < 0x10000) +- return -1; ++ return 1; + if (!S_ISREG(pr->mode) && !blkid_probe_is_wholedisk(pr)) +- return -1; ++ return 1; + + off = ((pr->size / 0x200) - 1) * 0x200; + +@@ -98,7 +98,7 @@ static int probe_silraid(blkid_probe pr, + blkid_probe_get_buffer(pr, off, + sizeof(struct silicon_metadata)); + if (!sil) +- return -1; ++ return errno ? -1 : 1; + + if (le32_to_cpu(sil->magic) != SILICON_MAGIC) + return 1; +@@ -110,13 +110,13 @@ static int probe_silraid(blkid_probe pr, + if (blkid_probe_sprintf_version(pr, "%u.%u", + le16_to_cpu(sil->major_ver), + le16_to_cpu(sil->minor_ver)) != 0) +- return -1; ++ return 1; + + if (blkid_probe_set_magic(pr, + off + offsetof(struct silicon_metadata, magic), + sizeof(sil->magic), + (unsigned char *) &sil->magic)) +- return -1; ++ return 1; + return 0; + } + +diff --git a/libblkid/src/superblocks/squashfs.c b/libblkid/src/superblocks/squashfs.c +index f8ac95e..6b2f1b1 100644 +--- a/libblkid/src/superblocks/squashfs.c ++++ b/libblkid/src/superblocks/squashfs.c +@@ -36,7 +36,7 @@ static int probe_squashfs(blkid_probe pr, const struct blkid_idmag *mag) + + sq = blkid_probe_get_sb(pr, mag, struct sqsh_super_block); + if (!sq) +- return -1; ++ return errno ? -1 : 1; + + major = le16_to_cpu(sq->s_major); + minor = le16_to_cpu(sq->s_minor); +@@ -56,7 +56,7 @@ static int probe_squashfs3(blkid_probe pr, const struct blkid_idmag *mag) + + sq = blkid_probe_get_sb(pr, mag, struct sqsh_super_block); + if (!sq) +- return -1; ++ return errno ? -1 : 1; + + if (strcmp(mag->magic, "sqsh") == 0) { + major = be16_to_cpu(sq->s_major); +@@ -67,7 +67,7 @@ static int probe_squashfs3(blkid_probe pr, const struct blkid_idmag *mag) + } + + if (major > 3) +- return -1; ++ return 1; + + blkid_probe_sprintf_version(pr, "%u.%u", major, minor); + +diff --git a/libblkid/src/superblocks/swap.c b/libblkid/src/superblocks/swap.c +index 4297a9c..2ea94d2 100644 +--- a/libblkid/src/superblocks/swap.c ++++ b/libblkid/src/superblocks/swap.c +@@ -44,27 +44,27 @@ static int swap_set_info(blkid_probe pr, const char *version) + hdr = (struct swap_header_v1_2 *) blkid_probe_get_buffer(pr, 1024, + sizeof(struct swap_header_v1_2)); + if (!hdr) +- return -1; ++ return errno ? -1 : 1; + + /* SWAPSPACE2 - check for wrong version or zeroed pagecount */ +- if (strcmp(version, "1") == 0) { ++ if (strcmp(version, "2") == 0) { + if (hdr->version != 1 && swab32(hdr->version) != 1) { + DBG(LOWPROBE, blkid_debug("incorrect swap version")); +- return -1; ++ return 1; + } + if (hdr->lastpage == 0) { + DBG(LOWPROBE, blkid_debug("not set last swap page")); +- return -1; ++ return 1; + } +- } ++ } + + /* arbitrary sanity check.. is there any garbage down there? */ + if (hdr->padding[32] == 0 && hdr->padding[33] == 0) { + if (hdr->volume[0] && blkid_probe_set_label(pr, hdr->volume, + sizeof(hdr->volume)) < 0) +- return -1; ++ return 1; + if (blkid_probe_set_uuid(pr, hdr->uuid) < 0) +- return -1; ++ return 1; + } + + blkid_probe_set_version(pr, version); +@@ -76,12 +76,12 @@ static int probe_swap(blkid_probe pr, const struct blkid_idmag *mag) + unsigned char *buf; + + if (!mag) +- return -1; ++ return 1; + + /* TuxOnIce keeps valid swap header at the end of the 1st page */ + buf = blkid_probe_get_buffer(pr, 0, TOI_MAGIC_STRLEN); + if (!buf) +- return -1; ++ return errno ? -1 : 1; + + if (memcmp(buf, TOI_MAGIC_STRING, TOI_MAGIC_STRLEN) == 0) + return 1; /* Ignore swap signature, it's TuxOnIce */ +@@ -94,13 +94,13 @@ static int probe_swap(blkid_probe pr, const struct blkid_idmag *mag) + } else if (!memcmp(mag->magic, "SWAPSPACE2", mag->len)) + return swap_set_info(pr, "1"); + +- return -1; ++ return 1; + } + + static int probe_swsuspend(blkid_probe pr, const struct blkid_idmag *mag) + { + if (!mag) +- return -1; ++ return 1; + if (!memcmp(mag->magic, "S1SUSPEND", mag->len)) + return swap_set_info(pr, "s1suspend"); + if (!memcmp(mag->magic, "S2SUSPEND", mag->len)) +@@ -112,7 +112,7 @@ static int probe_swsuspend(blkid_probe pr, const struct blkid_idmag *mag) + if (!memcmp(mag->magic, "LINHIB0001", mag->len)) + return swap_set_info(pr, "linhib0001"); + +- return -1; /* no signature detected */ ++ return 1; /* no signature detected */ + } + + const struct blkid_idinfo swap_idinfo = +diff --git a/libblkid/src/superblocks/sysv.c b/libblkid/src/superblocks/sysv.c +index 80b0cc5..528e8f9 100644 +--- a/libblkid/src/superblocks/sysv.c ++++ b/libblkid/src/superblocks/sysv.c +@@ -80,7 +80,7 @@ static int probe_xenix(blkid_probe pr, const struct blkid_idmag *mag) + + sb = blkid_probe_get_sb(pr, mag, struct xenix_super_block); + if (!sb) +- return -1; ++ return errno ? -1 : 1; + blkid_probe_set_label(pr, sb->s_fname, sizeof(sb->s_fname)); + return 0; + } +@@ -105,21 +105,21 @@ static int probe_sysv(blkid_probe pr, + off, + sizeof(struct sysv_super_block)); + if (!sb) +- return -1; ++ return errno ? -1 : 1; + + if (sb->s_magic == cpu_to_le32(0xfd187e20) || + sb->s_magic == cpu_to_be32(0xfd187e20)) { + + if (blkid_probe_set_label(pr, sb->s_fname, + sizeof(sb->s_fname))) +- return -1; ++ return 1; + + if (blkid_probe_set_magic(pr, + off + offsetof(struct sysv_super_block, + s_magic), + sizeof(sb->s_magic), + (unsigned char *) &sb->s_magic)) +- return -1; ++ return 1; + + return 0; + } +diff --git a/libblkid/src/superblocks/ubifs.c b/libblkid/src/superblocks/ubifs.c +index ef84f53..761f3db 100644 +--- a/libblkid/src/superblocks/ubifs.c ++++ b/libblkid/src/superblocks/ubifs.c +@@ -99,7 +99,7 @@ static int probe_ubifs(blkid_probe pr, const struct blkid_idmag *mag) + + sb = blkid_probe_get_sb(pr, mag, struct ubifs_sb_node); + if (!sb) +- return -1; ++ return errno ? -1 : 1; + + blkid_probe_set_uuid(pr, sb->uuid); + blkid_probe_sprintf_version(pr, "w%dr%d", +diff --git a/libblkid/src/superblocks/udf.c b/libblkid/src/superblocks/udf.c +index 8702dd0..e3b38c2 100644 +--- a/libblkid/src/superblocks/udf.c ++++ b/libblkid/src/superblocks/udf.c +@@ -85,11 +85,11 @@ static int probe_udf(blkid_probe pr, + UDF_VSD_OFFSET + b, + sizeof(*vsd)); + if (!vsd) +- return 1; ++ return errno ? -1 : 1; + if (vsd->id[0] != '\0') + goto nsr; + } +- return -1; ++ return 1; + + nsr: + /* search the list of VSDs for a NSR descriptor */ +@@ -99,15 +99,15 @@ nsr: + UDF_VSD_OFFSET + ((blkid_loff_t) b * 0x800), + sizeof(*vsd)); + if (!vsd) +- return -1; ++ return errno ? -1 : 1; + if (vsd->id[0] == '\0') +- return -1; ++ return 1; + if (memcmp(vsd->id, "NSR02", 5) == 0) + goto anchor; + if (memcmp(vsd->id, "NSR03", 5) == 0) + goto anchor; + } +- return -1; ++ return 1; + + anchor: + /* read Anchor Volume Descriptor (AVDP), checking block size */ +@@ -115,7 +115,7 @@ anchor: + vd = (struct volume_descriptor *) + blkid_probe_get_buffer(pr, 256 * pbs[i], sizeof(*vd)); + if (!vd) +- return -1; ++ return errno ? -1 : 1; + + type = le16_to_cpu(vd->tag.id); + if (type == 2) /* TAG_ID_AVDP */ +@@ -138,7 +138,7 @@ real_blksz: + (blkid_loff_t) (loc + b) * bs, + sizeof(*vd)); + if (!vd) +- return -1; ++ return errno ? -1 : 1; + } + + /* Try extract all possible ISO9660 information -- if there is +@@ -155,7 +155,7 @@ real_blksz: + (blkid_loff_t) (loc + b) * bs, + sizeof(*vd)); + if (!vd) +- return -1; ++ return errno ? -1 : 1; + type = le16_to_cpu(vd->tag.id); + if (type == 0) + break; +diff --git a/libblkid/src/superblocks/ufs.c b/libblkid/src/superblocks/ufs.c +index 673a528..999fd90 100644 +--- a/libblkid/src/superblocks/ufs.c ++++ b/libblkid/src/superblocks/ufs.c +@@ -185,7 +185,7 @@ static int probe_ufs(blkid_probe pr, + offsets[i] * 1024, + sizeof(struct ufs_super_block)); + if (!ufs) +- return -1; ++ return errno ? -1 : 1; + + magBE = be32_to_cpu(ufs->fs_magic); + magLE = le32_to_cpu(ufs->fs_magic); +@@ -231,7 +231,7 @@ found: + offsetof(struct ufs_super_block, fs_magic), + sizeof(ufs->fs_magic), + (unsigned char *) &ufs->fs_magic)) +- return -1; ++ return 1; + + return 0; + } +diff --git a/libblkid/src/superblocks/vfat.c b/libblkid/src/superblocks/vfat.c +index 8ff241b..3e278e7 100644 +--- a/libblkid/src/superblocks/vfat.c ++++ b/libblkid/src/superblocks/vfat.c +@@ -261,10 +261,10 @@ int blkid_probe_is_vfat(blkid_probe pr) + + ms = blkid_probe_get_sb(pr, mag, struct msdos_super_block); + if (!ms) +- return 0; ++ return errno ? -1 : 0; + vs = blkid_probe_get_sb(pr, mag, struct vfat_super_block); + if (!vs) +- return 0; ++ return errno ? -1 : 0; + + return fat_valid_superblock(mag, ms, vs, NULL, NULL); + } +@@ -283,10 +283,12 @@ static int probe_vfat(blkid_probe pr, const struct blkid_idmag *mag) + + ms = blkid_probe_get_sb(pr, mag, struct msdos_super_block); + if (!ms) +- return 0; ++ return errno ? -1 : 1; ++ + vs = blkid_probe_get_sb(pr, mag, struct vfat_super_block); + if (!vs) +- return 0; ++ return errno ? -1 : 1; ++ + if (!fat_valid_superblock(mag, ms, vs, &cluster_count, &fat_size)) + return 1; + +@@ -376,16 +378,16 @@ static int probe_vfat(blkid_probe pr, const struct blkid_idmag *mag) + (blkid_loff_t) fsinfo_sect * sector_size, + sizeof(struct fat32_fsinfo)); + if (buf == NULL) +- return -1; ++ return errno ? -1 : 1; + + fsinfo = (struct fat32_fsinfo *) buf; + if (memcmp(fsinfo->signature1, "\x52\x52\x61\x41", 4) != 0 && + memcmp(fsinfo->signature1, "\x52\x52\x64\x41", 4) != 0 && + memcmp(fsinfo->signature1, "\x00\x00\x00\x00", 4) != 0) +- return -1; ++ return 1; + if (memcmp(fsinfo->signature2, "\x72\x72\x41\x61", 4) != 0 && + memcmp(fsinfo->signature2, "\x00\x00\x00\x00", 4) != 0) +- return -1; ++ return 1; + } + } + +diff --git a/libblkid/src/superblocks/via_raid.c b/libblkid/src/superblocks/via_raid.c +index 5c15167..ff7a965 100644 +--- a/libblkid/src/superblocks/via_raid.c ++++ b/libblkid/src/superblocks/via_raid.c +@@ -63,7 +63,7 @@ static int probe_viaraid(blkid_probe pr, + off, + sizeof(struct via_metadata)); + if (!v) +- return -1; ++ return errno ? -1 : 1; + + if (le16_to_cpu(v->signature) != VIA_SIGNATURE) + return 1; +@@ -73,11 +73,11 @@ static int probe_viaraid(blkid_probe pr, + return 1; + + if (blkid_probe_sprintf_version(pr, "%u", v->version_number) != 0) +- return -1; ++ return 1; + if (blkid_probe_set_magic(pr, off, + sizeof(v->signature), + (unsigned char *) &v->signature)) +- return -1; ++ return 1; + return 0; + } + +diff --git a/libblkid/src/superblocks/vmfs.c b/libblkid/src/superblocks/vmfs.c +index ead09a8..27d0888 100644 +--- a/libblkid/src/superblocks/vmfs.c ++++ b/libblkid/src/superblocks/vmfs.c +@@ -28,7 +28,7 @@ static int probe_vmfs_fs(blkid_probe pr, const struct blkid_idmag *mag) + + header = blkid_probe_get_sb(pr, mag, struct vmfs_fs_info); + if (header == NULL) +- return -1; ++ return errno ? -1 : 1; + + blkid_probe_sprintf_uuid(pr, (unsigned char *) header->uuid, 16, + "%02x%02x%02x%02x-%02x%02x%02x%02x-" +@@ -53,7 +53,7 @@ static int probe_vmfs_volume(blkid_probe pr, const struct blkid_idmag *mag) + + header = blkid_probe_get_sb(pr, mag, struct vmfs_volume_info); + if (header == NULL) +- return -1; ++ return errno ? -1 : 1; + + blkid_probe_sprintf_value(pr, "UUID_SUB", + "%02x%02x%02x%02x-%02x%02x%02x%02x-" +diff --git a/libblkid/src/superblocks/vxfs.c b/libblkid/src/superblocks/vxfs.c +index fdab85a..4537560 100644 +--- a/libblkid/src/superblocks/vxfs.c ++++ b/libblkid/src/superblocks/vxfs.c +@@ -20,7 +20,7 @@ static int probe_vxfs(blkid_probe pr, const struct blkid_idmag *mag) + + vxs = blkid_probe_get_sb(pr, mag, struct vxfs_super_block); + if (!vxs) +- return -1; ++ return errno ? -1 : 1; + + blkid_probe_sprintf_version(pr, "%u", (unsigned int) vxs->vs_version); + return 0; +diff --git a/libblkid/src/superblocks/xfs.c b/libblkid/src/superblocks/xfs.c +index b485917..3c8b5ea 100644 +--- a/libblkid/src/superblocks/xfs.c ++++ b/libblkid/src/superblocks/xfs.c +@@ -41,7 +41,7 @@ static int probe_xfs(blkid_probe pr, const struct blkid_idmag *mag) + + xs = blkid_probe_get_sb(pr, mag, struct xfs_super_block); + if (!xs) +- return -1; ++ return errno ? -1 : 1; + + if (strlen(xs->xs_fname)) + blkid_probe_set_label(pr, (unsigned char *) xs->xs_fname, +@@ -123,7 +123,7 @@ static int probe_xfs_log(blkid_probe pr, const struct blkid_idmag *mag) + + buf = blkid_probe_get_buffer(pr, 0, 256*1024); + if (!buf) +- return -1; ++ return errno ? -1 : 1; + + if (memcmp(buf, "XFSB", 4) == 0) + return 1; /* this is regular XFS, ignore */ +@@ -138,7 +138,7 @@ static int probe_xfs_log(blkid_probe pr, const struct blkid_idmag *mag) + } + } + +- return -1; ++ return 1; + } + + const struct blkid_idinfo xfs_log_idinfo = +diff --git a/libblkid/src/superblocks/zfs.c b/libblkid/src/superblocks/zfs.c +index fb86aec..d28786b 100644 +--- a/libblkid/src/superblocks/zfs.c ++++ b/libblkid/src/superblocks/zfs.c +@@ -185,7 +185,7 @@ static int probe_zfs(blkid_probe pr, + blkid_probe_get_buffer(pr, offset, + sizeof(struct zfs_uberblock)); + if (ub == NULL) +- return -1; ++ return errno ? -1 : 1; + + if (ub->ub_magic == UBERBLOCK_MAGIC) { + ub_offset = offset; +@@ -202,7 +202,7 @@ static int probe_zfs(blkid_probe pr, + } + + if (found < 4) +- return -1; ++ return 1; + + /* If we found the 4th uberblock, then we will have exited from the + * scanning loop immediately, and ub will be a valid uberblock. */ +@@ -214,7 +214,7 @@ static int probe_zfs(blkid_probe pr, + if (blkid_probe_set_magic(pr, ub_offset, + sizeof(ub->ub_magic), + (unsigned char *) &ub->ub_magic)) +- return -1; ++ return 1; + + return 0; + } +-- +1.8.1.4 + diff --git a/blkid-stop-scanning-on-I-O-error.patch b/blkid-stop-scanning-on-I-O-error.patch new file mode 100644 index 0000000..f34927a --- /dev/null +++ b/blkid-stop-scanning-on-I-O-error.patch @@ -0,0 +1,138 @@ +From 65245d440656a8df4352f9a5b9ec047bf4b6a663 Mon Sep 17 00:00:00 2001 +From: Hannes Reinecke +Date: Tue, 21 Jan 2014 09:16:46 +0100 +Subject: [PATCH] blkid: stop scanning on I/O error + +Whenever we fail to read from a device it's pointless to +continue with probing; we should be failing immediately. +Otherwise the system will continue logging I/O errors. + +This patch updates the probe functions to return -1 +on error and 1 if not found. + +Signed-off-by: Hannes Reinecke +--- + libblkid/src/partitions/partitions.c | 13 +++++++++---- + libblkid/src/probe.c | 13 +++++++++++-- + libblkid/src/superblocks/superblocks.c | 13 ++++++++++--- + 3 files changed, 30 insertions(+), 9 deletions(-) + +diff --git a/libblkid/src/partitions/partitions.c b/libblkid/src/partitions/partitions.c +index 6c915d9..98baece 100644 +--- a/libblkid/src/partitions/partitions.c ++++ b/libblkid/src/partitions/partitions.c +@@ -540,7 +540,8 @@ static int idinfo_probe(blkid_probe pr, const struct blkid_idinfo *id, + if (pr->size <= 0 || (id->minsz && id->minsz > pr->size)) + goto nothing; /* the device is too small */ + +- if (blkid_probe_get_idmag(pr, id, &off, &mag)) ++ rc = blkid_probe_get_idmag(pr, id, &off, &mag); ++ if (rc != 0) + goto nothing; + + /* final check by probing function */ +@@ -548,12 +549,13 @@ static int idinfo_probe(blkid_probe pr, const struct blkid_idinfo *id, + DBG(LOWPROBE, blkid_debug( + "%s: ---> call probefunc()", id->name)); + rc = id->probefunc(pr, mag); +- if (rc == -1) { ++ if (rc != 0) { + /* reset after error */ + reset_partlist(blkid_probe_get_partlist(pr)); + if (chn && !chn->binary) + blkid_probe_chain_reset_vals(pr, chn); +- DBG(LOWPROBE, blkid_debug("%s probefunc failed", id->name)); ++ DBG(LOWPROBE, blkid_debug("%s probefunc failed, rc %d", ++ id->name, rc)); + } + if (rc == 0 && mag && chn && !chn->binary) + rc = blkid_probe_set_magic(pr, off, mag->len, +@@ -599,7 +601,10 @@ static int partitions_probe(blkid_probe pr, struct blkid_chain *chn) + continue; + + /* apply checks from idinfo */ +- if (idinfo_probe(pr, idinfos[i], chn) != 0) ++ rc = idinfo_probe(pr, idinfos[i], chn); ++ if (rc < 0) ++ return rc; ++ if (rc > 0) + continue; + + name = idinfos[i]->name; +diff --git a/libblkid/src/probe.c b/libblkid/src/probe.c +index 4b0c997..452c743 100644 +--- a/libblkid/src/probe.c ++++ b/libblkid/src/probe.c +@@ -569,13 +569,17 @@ unsigned char *blkid_probe_get_buffer(blkid_probe pr, + if (!bf) { + ssize_t ret; + +- if (blkid_llseek(pr->fd, pr->off + off, SEEK_SET) < 0) ++ if (blkid_llseek(pr->fd, pr->off + off, SEEK_SET) < 0) { ++ errno = 0; + return NULL; ++ } + + /* allocate info and space for data by why call */ + bf = calloc(1, sizeof(struct blkid_bufinfo) + len); +- if (!bf) ++ if (!bf) { ++ errno = 0; + return NULL; ++ } + + bf->data = ((unsigned char *) bf) + sizeof(struct blkid_bufinfo); + bf->len = len; +@@ -587,7 +591,10 @@ unsigned char *blkid_probe_get_buffer(blkid_probe pr, + + ret = read(pr->fd, bf->data, len); + if (ret != (ssize_t) len) { ++ DBG(LOWPROBE, blkid_debug("\tbuffer read: return %d error %d", ret, errno)); + free(bf); ++ if (ret >= 0 || errno != EIO) ++ errno = 0; + return NULL; + } + list_add_tail(&bf->bufs, &pr->buffers); +@@ -794,6 +801,8 @@ int blkid_probe_get_idmag(blkid_probe pr, const struct blkid_idinfo *id, + off = (mag->kboff + (mag->sboff >> 10)) << 10; + buf = blkid_probe_get_buffer(pr, off, 1024); + ++ if (!buf && errno) ++ return -1; + if (buf && !memcmp(mag->magic, + buf + (mag->sboff & 0x3ff), mag->len)) { + DBG(LOWPROBE, blkid_debug("\tmagic sboff=%u, kboff=%ld", +diff --git a/libblkid/src/superblocks/superblocks.c b/libblkid/src/superblocks/superblocks.c +index 565daf2..ad93b4e 100644 +--- a/libblkid/src/superblocks/superblocks.c ++++ b/libblkid/src/superblocks/superblocks.c +@@ -380,15 +380,22 @@ static int superblocks_probe(blkid_probe pr, struct blkid_chain *chn) + + DBG(LOWPROBE, blkid_debug("[%zd] %s:", i, id->name)); + +- if (blkid_probe_get_idmag(pr, id, &off, &mag)) ++ rc = blkid_probe_get_idmag(pr, id, &off, &mag); ++ if (rc < 0) ++ break; ++ if (rc > 0) + continue; + + /* final check by probing function */ + if (id->probefunc) { + DBG(LOWPROBE, blkid_debug("\tcall probefunc()")); +- if (id->probefunc(pr, mag) != 0) { ++ rc = id->probefunc(pr, mag); ++ if (rc != 0) { + blkid_probe_chain_reset_vals(pr, chn); +- continue; ++ if (rc < 0) ++ break; ++ else ++ continue; + } + } + +-- +1.8.1.4 + diff --git a/util-linux-libblkid-ext-probe.patch b/util-linux-libblkid-ext-probe.patch new file mode 100644 index 0000000..7212335 --- /dev/null +++ b/util-linux-libblkid-ext-probe.patch @@ -0,0 +1,274 @@ +This is a backport of patch from master branch. + +commit a1ca32fb3862ccac7275d6b342805b6d99f20e39 +Author: Lukas Czerner +Date: Tue Dec 3 16:24:44 2013 +0100 + + libblkid: Identify extN file system properly + + Currently when trying to identify extN file system we're playing games + with searching for kernel modules and parsing /proc/filesystem. All of + this just because ext4 module can be used to mount ext3 and ext2 file + systems on recent kernel and also because of ext4dev. + + However all of this is not necessary. Ext4 module which does support + mounting ext2 and ext3 file system is able to recognize and mount ext2 + and ext3 type so there is no need to disguise it and ext4dev should only + be ever used for testing and not as fallback when other modules are + missing (use -t instead). + + This also introduces a bug when in situation that we only have ext4 + modules with ext2/ext3 support which is not loaded and we try to mount + ext2 file system we will mount it incorrectly as ext4. This will not + happen if the ext4 module is already loaded. + + With this patch we remove all the unnecessary checks and return the real + type of the file system which is on the device. This fixes the issue. + However on the kernel which was not compiled with EXT4_USE_FOR_EXT23 + support one would have to provide file system type (-t) to be able to + mount the file system with ext4 driver. + + Signed-off-by: Lukas Czerner + Signed-off-by: Karel Zak + +Index: util-linux-2.24.1/libblkid/src/superblocks/ext.c +=================================================================== +--- util-linux-2.24.1.orig/libblkid/src/superblocks/ext.c ++++ util-linux-2.24.1/libblkid/src/superblocks/ext.c +@@ -18,7 +18,6 @@ + #endif + #include + +-#include "linux_version.h" + #include "superblocks.h" + + struct ext2_super_block { +@@ -132,140 +131,11 @@ struct ext2_super_block { + #define EXT3_FEATURE_RO_COMPAT_UNSUPPORTED ~EXT3_FEATURE_RO_COMPAT_SUPP + + /* +- * Check to see if a filesystem is in /proc/filesystems. +- * Returns 1 if found, 0 if not +- */ +-static int fs_proc_check(const char *fs_name) +-{ +- FILE *f; +- char buf[80], *cp, *t; +- +- f = fopen("/proc/filesystems", "r" UL_CLOEXECSTR); +- if (!f) +- return 0; +- while (!feof(f)) { +- if (!fgets(buf, sizeof(buf), f)) +- break; +- cp = buf; +- if (!isspace(*cp)) { +- while (*cp && !isspace(*cp)) +- cp++; +- } +- while (*cp && isspace(*cp)) +- cp++; +- if ((t = strchr(cp, '\n')) != NULL) +- *t = 0; +- if ((t = strchr(cp, '\t')) != NULL) +- *t = 0; +- if ((t = strchr(cp, ' ')) != NULL) +- *t = 0; +- if (!strcmp(fs_name, cp)) { +- fclose(f); +- return 1; +- } +- } +- fclose(f); +- return (0); +-} +- +-/* +- * Check to see if a filesystem is available as a module +- * Returns 1 if found, 0 if not +- */ +-static int check_for_modules(const char *fs_name) +-{ +-#ifdef __linux__ +- struct utsname uts; +- FILE *f; +- char buf[1024], *cp; +- int namesz; +- +- if (uname(&uts)) +- return 0; +- snprintf(buf, sizeof(buf), "/lib/modules/%s/modules.dep", uts.release); +- +- f = fopen(buf, "r" UL_CLOEXECSTR); +- if (!f) +- return 0; +- +- namesz = strlen(fs_name); +- +- while (!feof(f)) { +- if (!fgets(buf, sizeof(buf), f)) +- break; +- if ((cp = strchr(buf, ':')) != NULL) +- *cp = 0; +- else +- continue; +- if ((cp = strrchr(buf, '/')) == NULL) +- continue; +- cp++; +- +- if (!strncmp(cp, fs_name, namesz) && +- (!strcmp(cp + namesz, ".ko") || +- !strcmp(cp + namesz, ".ko.gz"))) { +- fclose(f); +- return 1; +- } +- } +- fclose(f); +-#endif /* __linux__ */ +- return 0; +-} +- +-/* + * Starting in 2.6.29, ext4 can be used to support filesystems + * without a journal. + */ + #define EXT4_SUPPORTS_EXT2 KERNEL_VERSION(2, 6, 29) + +-static int system_supports_ext2(void) +-{ +- static time_t last_check = 0; +- static int ret = -1; +- time_t now = time(0); +- +- if (ret != -1 || (now - last_check) < 5) +- return ret; +- last_check = now; +- ret = (fs_proc_check("ext2") || check_for_modules("ext2")); +- return ret; +-} +- +-static int system_supports_ext4(void) +-{ +- static time_t last_check = 0; +- static int ret = -1; +- time_t now = time(0); +- +- if (ret != -1 || (now - last_check) < 5) +- return ret; +- last_check = now; +- ret = (fs_proc_check("ext4") || check_for_modules("ext4")); +- return ret; +-} +- +-static int system_supports_ext4dev(void) +-{ +- static time_t last_check = 0; +- static int ret = -1; +- time_t now = time(0); +- +- if (ret != -1 || (now - last_check) < 5) +- return ret; +- last_check = now; +- ret = (fs_proc_check("ext4dev") || check_for_modules("ext4dev")); +- return ret; +-} +- +-static int system_supports_ext4_ext2(void) +-{ +-#ifdef __linux__ +- return get_linux_version() >= EXT4_SUPPORTS_EXT2; +-#else +- return 0; +-#endif +-} + /* + * reads superblock and returns: + * fc = feature_compat +@@ -357,15 +227,6 @@ static int probe_ext2(blkid_probe pr, + (fi & EXT2_FEATURE_INCOMPAT_UNSUPPORTED)) + return 1; + +- /* +- * If ext2 is not present, but ext4 or ext4dev are, then +- * disclaim we are ext2 +- */ +- if (!system_supports_ext2() && +- (system_supports_ext4() || system_supports_ext4dev()) && +- system_supports_ext4_ext2()) +- return 1; +- + ext_get_info(pr, 2, es); + return 0; + } +@@ -408,34 +269,9 @@ static int probe_ext4dev(blkid_probe pr, + if (fi & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) + return 1; + +- /* +- * If the filesystem does not have a journal and ext2 and ext4 +- * is not present, then force this to be detected as an +- * ext4dev filesystem. +- */ +- if (!(fc & EXT3_FEATURE_COMPAT_HAS_JOURNAL) && +- !system_supports_ext2() && !system_supports_ext4() && +- system_supports_ext4dev() && +- system_supports_ext4_ext2()) +- goto force_ext4dev; +- +- /* +- * If the filesystem is marked as OK for use by in-development +- * filesystem code, but ext4dev is not supported, and ext4 is, +- * then don't call ourselves ext4dev, since we should be +- * detected as ext4 in that case. +- * +- * If the filesystem is marked as in use by production +- * filesystem, then it can only be used by ext4 and NOT by +- * ext4dev, so always disclaim we are ext4dev in that case. +- */ +- if (le32_to_cpu(es->s_flags) & EXT2_FLAGS_TEST_FILESYS) { +- if (!system_supports_ext4dev() && system_supports_ext4()) +- return 1; +- } else ++ if (!(le32_to_cpu(es->s_flags) & EXT2_FLAGS_TEST_FILESYS)) + return 1; + +-force_ext4dev: + ext_get_info(pr, 4, es); + return 0; + } +@@ -454,22 +290,11 @@ static int probe_ext4(blkid_probe pr, + if (fi & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) + return 1; + +- /* +- * If the filesystem does not have a journal and ext2 is not +- * present, then force this to be detected as an ext2 +- * filesystem. +- */ +- if (!(fc & EXT3_FEATURE_COMPAT_HAS_JOURNAL) && +- !system_supports_ext2() && system_supports_ext4() && +- system_supports_ext4_ext2()) +- goto force_ext4; +- + /* Ext4 has at least one feature which ext3 doesn't understand */ + if (!(frc & EXT3_FEATURE_RO_COMPAT_UNSUPPORTED) && + !(fi & EXT3_FEATURE_INCOMPAT_UNSUPPORTED)) + return 1; + +-force_ext4: + /* + * If the filesystem is a OK for use by in-development + * filesystem code, and ext4dev is supported or ext4 is not +@@ -480,10 +305,8 @@ force_ext4: + * filesystem, then it can only be used by ext4 and NOT by + * ext4dev. + */ +- if (le32_to_cpu(es->s_flags) & EXT2_FLAGS_TEST_FILESYS) { +- if (system_supports_ext4dev() || !system_supports_ext4()) +- return 1; +- } ++ if (le32_to_cpu(es->s_flags) & EXT2_FLAGS_TEST_FILESYS) ++ return 1; + + ext_get_info(pr, 4, es); + return 0; diff --git a/util-linux.changes b/util-linux.changes index 4d4112d..d7f92fe 100644 --- a/util-linux.changes +++ b/util-linux.changes @@ -1,3 +1,22 @@ +------------------------------------------------------------------- +Thu Apr 17 22:43:31 CEST 2014 - sbrabec@suse.cz + +- Enable socket activation needed by systemd service (bnc#872807). + +------------------------------------------------------------------- +Fri Apr 11 16:45:03 CEST 2014 - sbrabec@suse.cz + +- libblkid: Drop the broken ext2/ext3/ext4 discrimination logic + (util-linux-libblkid-ext-probe.patch, bnc#864703). + +------------------------------------------------------------------- +Fri Apr 11 16:27:11 CEST 2014 - hare@suse.de + +- Abort blkid probing on I/O errors (bnc#859062, + blkid-stop-scanning-on-I-O-error.patch, + blkid-convert-superblocks-to-new-calling-convention.patch, + http://www.spinics.net/lists/util-linux-ng/msg08976.html) + ------------------------------------------------------------------- Tue Apr 1 18:49:26 UTC 2014 - sweet_f_a@gmx.de diff --git a/util-linux.spec b/util-linux.spec index 14528d4..44cfade 100644 --- a/util-linux.spec +++ b/util-linux.spec @@ -124,6 +124,13 @@ Patch21: util-linux-ng-2.16-squashfs3-detect.patch Patch23: util-linux-ng-2.19.1-barrier_documentation.patch # PATCH-FEATURE-SLES util-linux-lscpu-improve-hypervisor-detection.patch fate310255 puzel@novell.com -- Improve hypervisor detection. Patch24: util-linux-lscpu-improve-hypervisor-detection.patch +# PATH-FIX-SLES blkid-stop-scanning-on-I-O-error.patch bnc859062 hare@suse.de -- Abort blkid probing on I/O errors +Patch30: blkid-stop-scanning-on-I-O-error.patch +# PATH-FIX-SLES lkid-convert-superblocks-to-new-calling-convention.patch bnc859062 hare@suse.de -- convert blkid probing functions to new calling sequence +Patch31: blkid-convert-superblocks-to-new-calling-convention.patch +# PATH-FIX-UPSTREAM util-linux-libblkid-ext-probe.patch bnc864703 sbrabec@suse.cz -- libblkid: Drop the broken ext2/ext3/ext4 discrimination logic. +Patch32: util-linux-libblkid-ext-probe.patch + ## ## klogconsole ## @@ -256,6 +263,9 @@ xzcat %{S:0} | %gpg_verify %{S:12} - %patch21 -p1 %patch23 -p1 %patch24 -p1 +%patch30 -p1 +%patch31 -p1 +%patch32 -p1 # # setctsid cp -p %{S:22} %{S:23} . @@ -311,6 +321,7 @@ export SUID_LDFLAGS="-pie" --enable-new-mount \ --enable-login-utils \ --enable-tunelp \ + --enable-socket-activation \ %if %{with enable_last} --enable-last \ %else