blkid: move to misc-utils/ directory

The others utilities are in one of the top-level directories. That's
confusing to have blkid(8) and findfs(8) in shlibs/ tree.

Signed-off-by: Karel Zak <kzak@redhat.com>

6 files changed, 958 insertions, 0 deletions

diff --git a/misc-utils/.gitignore b/misc-utils/.gitignore
index e58c93015..2242b9201 100644
--- a/misc-utils/.gitignore
+++ b/misc-utils/.gitignore
@@ -14,3 +14,5 @@ kill
 write
 uuidgen
 uuidd
+findfs
+blkid
diff --git a/misc-utils/Makefile.am b/misc-utils/Makefile.am
index 272ef75d0..7c4561c4b 100644
--- a/misc-utils/Makefile.am
+++ b/misc-utils/Makefile.am
@@ -3,6 +3,7 @@ include $(top_srcdir)/config/include-Makefile.am
 EXTRA_DIST = README.flushb uuidd.rc
 
 bin_PROGRAMS =
+sbin_PROGRAMS =
 usrsbinexec_PROGRAMS =
 
 usrbinexec_PROGRAMS = cal ddate logger look mcookie \
@@ -31,6 +32,22 @@ uuidd_CFLAGS = -I$(ul_libuuid_srcdir)
 endif
 endif
 
+if BUILD_LIBBLKID
+sbin_PROGRAMS += blkid findfs
+dist_man_MANS += blkid.8 findfs.8
+blkid_LDADD = $(ul_libblkid_la)
+blkid_CFLAGS = -I$(ul_libblkid_srcdir)
+findfs_LDADD = $(ul_libblkid_la)
+findfs_CFLAGS = -I$(ul_libblkid_srcdir)
+if HAVE_STATIC_BLKID
+sbin_PROGRAMS += blkid.static
+blkid_static_SOURCES = $(blkid_SOURCES)
+blkid_static_LDFLAGS = "-all-static"		# libtool option
+blkid_static_LDADD = $(ul_libblkid_la)
+blkid_static_CFLAGS = -I$(ul_libblkid_srcdir)
+endif
+endif
+
 if HAVE_TINFO
 cal_LDADD = -ltinfo @NCURSES_LIBS@
 else
diff --git a/misc-utils/blkid.8 b/misc-utils/blkid.8
new file mode 100644
index 000000000..ff8e8e570
--- /dev/null
+++ b/misc-utils/blkid.8
@@ -0,0 +1,211 @@
+.\" Copyright 2000 Andreas Dilger (adilger@turbolinux.com)
+.\"
+.\" This man page was created for blkid from e2fsprogs-1.25.
+.\"
+.\" This file may be copied under the terms of the GNU Public License.
+.\"
+.\" Based on uuidgen, Mon Sep 17 10:42:12 2000, Andreas Dilger
+.TH BLKID 8 "February 2009" "Linux" "MAINTENANCE COMMANDS"
+.SH NAME
+blkid \- command\-line utility to locate/print block device attributes
+.SH SYNOPSIS
+.B blkid
+.RB \-L
+.IR label " | "
+.RB \-U
+.IR uuid
+
+.B blkid
+.RB [ \-ghlv ]
+.RB [ \-c
+.IR file ]
+.RB [ \-w
+.IR file ]
+.RB [ \-o
+.IR format ]
+.in +6
+.RB [ \-s
+.IR tag ]
+.RB [ \-t
+.IR NAME=value ]
+.I device
+[\fIdevice\fR ...]
+.in -6
+
+.B blkid
+.RB -p
+.RB [ \-O
+.IR offset ]
+.RB [ \-S
+.IR size ]
+.RB [ \-o
+.IR format ]
+.RB [ \-u
+.IR list ]
+.I device
+[\fIdevice\fR ...]
+
+.SH DESCRIPTION
+The
+.B blkid
+program is the command-line interface to working with
+.BR libblkid (3)
+library.  It can determine the type of content (e.g. filesystem, swap)
+a block device holds, and also attributes (tokens, NAME=value pairs)
+from the content metadata (e.g. LABEL or UUID fields).
+.PP
+.B blkid
+has two main forms of operation: either searching for a device with a
+specific NAME=value pair, or displaying NAME=value pairs for one or
+more devices.
+.SH OPTIONS
+.TP
+.BI \-c " cachefile"
+Read from
+.I cachefile
+instead of reading from the default cache file
+.IR /etc/blkid.tab .
+If you want to start with a clean cache (i.e. don't report devices previously
+scanned but not necessarily available at this time), specify
+.IR /dev/null .
+.TP
+.B \-g
+Perform a garbage collection pass on the blkid cache to remove
+devices which no longer exist.
+.TP
+.B \-h
+Display a usage message and exit.
+.TP
+.B \-l
+Look up one device that matches the search parameter specified using
+the
+.B \-t
+option.  If there are multiple devices that match the specified search
+parameter, then the device with the highest priority is returned, and/or
+the first device found at a given priority.  Device types in order of
+decreasing priority are Device Mapper, EVMS, LVM, MD, and finally regular
+block devices.  If this option is not specified,
+.B blkid
+will print all of the devices that match the search parameter.
+.TP
+.B \-L " label "
+Look up one device that uses the label (same as: -l -o device -t
+LABEL=<label>).  This look up method is able to reliable use /dev/disk/by-label
+udev symlinks (depends on setting in /etc/blkid.conf). Avoid to use the
+symlinks directly. It is not reliable to use the symlinks without verification.
+The \fB-L\fR option is portable and works on systems with and without udev.
+.TP
+.B \-u " list "
+Restrict probing functions to defined (comma separated) list of "usage" types.
+Supported usage types are: filesystem, raid, crypto and other. The list can be
+prefixed with "no" to specify the usage types which should be ignored. For example:
+.sp
+  blkid -p -u filesystem,other /dev/sda1
+.sp
+probes for all filesystems and others (e.g. swap) formats, and
+.sp
+  blkid -p -u noraid /dev/sda1
+.sp
+probes for all supported formats exclude RAIDs. This option is useful with
+\fB-p\fR only.
+.TP
+.B \-U " uuid "
+Look up one device that uses the uuid. For more details see the \fB-L\fR option.
+.TP
+.BI \-o " format"
+Display
+.BR blkid 's
+output using the specified format.  The
+.I format
+parameter may be:
+.RS
+.TP
+.B full
+print all tags (the default)
+.TP
+.B value
+print the value of the tags
+.TP
+.B list
+print the devices in a user-friendly format
+.TP
+.B device
+print the device name only
+.TP
+.B udev
+vol_id compatible mode; usable in udev rules
+.RE
+.TP
+.BI \-O " bytes"
+Probe at the given offset (only useful with \fB-p\fR).
+.TP
+.BI \-p
+Switch to low-level probing mode (bypass cache)"
+.TP
+.BI \-s " tag"
+For each (specified) device, show only the tags that match
+.IR tag .
+It is possible to specify multiple
+.B \-s
+options.  If no tag is specified, then all tokens are shown for all
+(specified) devices.
+In order to just refresh the cache without showing any tokens, use
+.B "-s none"
+with no other options.
+.TP
+.BI \-S " bytes"
+Overwrite device/file size (only useful with \fB-p\fR).
+.TP
+.BI \-t " NAME" = "value"
+Search for block devices with tokens named
+.I NAME
+that have the value
+.IR value ,
+and display any devices which are found.
+Common values for
+.I NAME
+include
+.BR TYPE ,
+.BR LABEL ,
+and
+.BR UUID .
+If there are no devices specified on the command line, all block devices
+will be searched; otherwise only the specified devices are searched.
+.TP
+.B \-v
+Display version number and exit.
+.TP
+.BI \-w " writecachefile"
+Write the device cache to
+.I writecachefile
+instead of writing it to the default cache file
+.IR /etc/blkid.tab .
+If you don't want to save the cache to the default file, specify
+.IR /dev/null.
+If not specified it will be the same file as that given by the
+.B \-c
+option.
+.TP
+.I device
+Display tokens from only the specified device.  It is possible to
+give multiple
+.I device
+options on the command line.  If none is given, all devices which
+appear in
+.I /proc/partitions
+are shown, if they are recognized.
+.SH "RETURN CODE"
+If the specified token was found, or if any tags were shown from (specified)
+devices, 0 is returned.  If the specified token was not found, or no
+(specified) devices could be identified, an exit code of 2 is returned.
+For usage or other errors, an exit code of 4 is returned.
+.SH AUTHOR
+.B blkid
+was written by Andreas Dilger for libblkid and improved by Theodore Ts'o
+and Karel Zak.
+.SH AVAILABILITY
+The blkid command is part of the util-linux-ng package and is available from
+ftp://ftp.kernel.org/pub/linux/utils/util-linux-ng/.
+.SH "SEE ALSO"
+.BR libblkid (3)
+.BR findfs (8)
diff --git a/misc-utils/blkid.c b/misc-utils/blkid.c
new file mode 100644
index 000000000..528e4a222
--- /dev/null
+++ b/misc-utils/blkid.c
@@ -0,0 +1,633 @@
+/*
+ * blkid.c - User command-line interface for libblkid
+ *
+ * Copyright (C) 2001 Andreas Dilger
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the
+ * GNU Lesser General Public License.
+ * %End-Header%
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#ifdef HAVE_TERMIOS_H
+#include <termios.h>
+#endif
+#ifdef HAVE_TERMIO_H
+#include <termio.h>
+#endif
+#ifdef HAVE_SYS_IOCTL_H
+#include <sys/ioctl.h>
+#endif
+#ifdef HAVE_GETOPT_H
+#include <getopt.h>
+#else
+extern int getopt(int argc, char * const argv[], const char *optstring);
+extern char *optarg;
+extern int optind;
+#endif
+
+#define OUTPUT_VALUE_ONLY	0x0001
+#define OUTPUT_DEVICE_ONLY	0x0002
+#define OUTPUT_PRETTY_LIST	0x0004
+#define OUTPUT_UDEV_LIST	0x0008
+
+#include <blkid.h>
+
+const char *progname = "blkid";
+
+static void print_version(FILE *out)
+{
+	fprintf(out, "%s from %s (libblkid %s, %s)\n",
+		progname, PACKAGE_STRING, LIBBLKID_VERSION, LIBBLKID_DATE);
+}
+
+static void usage(int error)
+{
+	FILE *out = error ? stderr : stdout;
+
+	print_version(out);
+	fprintf(out,
+		"Usage:\n"
+		"  %1$s -L <label> | -U <uuid>\n\n"
+		"  %1$s [-c <file>] [-ghlLv] [-o format] [-s <tag>] \n"
+		"        [-t <token>] [-w <file>] [dev ...]\n\n"
+		"  %1$s -p [-O <offset>] [-S <size>] [-o format] <dev> [dev ...]\n\n"
+		"Options:\n"
+		"  -c <file>   cache file (default: /etc/blkid.tab, /dev/null = none)\n"
+		"  -h          print this usage message and exit\n"
+		"  -g          garbage collect the blkid cache\n"
+		"  -o <format> output format; can be one of:\n"
+		"              value, device, list, udev or full; (default: full)\n"
+		"  -s <tag>    show specified tag(s) (default show all tags)\n"
+		"  -t <token>  find device with a specific token (NAME=value pair)\n"
+		"  -l          lookup the the first device with arguments specified by -t\n"
+		"  -L <label>  convert LABEL to device name\n"
+		"  -U <uuid>   convert UUID to device name\n"
+		"  -v          print version and exit\n"
+		"  -w <file>   write cache to different file (/dev/null = no write)\n"
+		"  <dev>       specify device(s) to probe (default: all devices)\n\n"
+		"Low-level probing options:\n"
+		"  -p          switch to low-level mode (bypass cache)\n"
+		"  -S <bytes>  overwrite device size\n"
+		"  -O <bytes>  probe at the given offset\n"
+		"  -u <list>   filter by \"usage\" (e.g. -u filesystem,raid)\n"
+		"\n",
+				progname);
+
+	exit(error);
+}
+
+/*
+ * This function does "safe" printing.  It will convert non-printable
+ * ASCII characters using '^' and M- notation.
+ */
+static void safe_print(const char *cp, int len)
+{
+	unsigned char	ch;
+
+	if (len < 0)
+		len = strlen(cp);
+
+	while (len--) {
+		ch = *cp++;
+		if (ch > 128) {
+			fputs("M-", stdout);
+			ch -= 128;
+		}
+		if ((ch < 32) || (ch == 0x7f)) {
+			fputc('^', stdout);
+			ch ^= 0x40; /* ^@, ^A, ^B; ^? for DEL */
+		}
+		fputc(ch, stdout);
+	}
+}
+
+static int get_terminal_width(void)
+{
+#ifdef TIOCGSIZE
+	struct ttysize	t_win;
+#endif
+#ifdef TIOCGWINSZ
+	struct winsize	w_win;
+#endif
+        const char	*cp;
+
+#ifdef TIOCGSIZE
+	if (ioctl (0, TIOCGSIZE, &t_win) == 0)
+		return (t_win.ts_cols);
+#endif
+#ifdef TIOCGWINSZ
+	if (ioctl (0, TIOCGWINSZ, &w_win) == 0)
+		return (w_win.ws_col);
+#endif
+        cp = getenv("COLUMNS");
+	if (cp)
+		return strtol(cp, NULL, 10);
+	return 80;
+}
+
+static int pretty_print_word(const char *str, int max_len,
+			     int left_len, int overflow_nl)
+{
+	int len = strlen(str) + left_len;
+	int ret = 0;
+
+	fputs(str, stdout);
+	if (overflow_nl && len > max_len) {
+		fputc('\n', stdout);
+		len = 0;
+	} else if (len > max_len)
+		ret = len - max_len;
+	do
+		fputc(' ', stdout);
+	while (len++ < max_len);
+	return ret;
+}
+
+static void pretty_print_line(const char *device, const char *fs_type,
+			      const char *label, const char *mtpt,
+			      const char *uuid)
+{
+	static int device_len = 10, fs_type_len = 7;
+	static int label_len = 8, mtpt_len = 14;
+	static int term_width = -1;
+	int len, w;
+
+	if (term_width < 0)
+		term_width = get_terminal_width();
+
+	if (term_width > 80) {
+		term_width -= 80;
+		w = term_width / 10;
+		if (w > 8)
+			w = 8;
+		term_width -= 2*w;
+		label_len += w;
+		fs_type_len += w;
+		w = term_width/2;
+		device_len += w;
+		mtpt_len +=w;
+	}
+
+	len = pretty_print_word(device, device_len, 0, 1);
+	len = pretty_print_word(fs_type, fs_type_len, len, 0);
+	len = pretty_print_word(label, label_len, len, 0);
+	len = pretty_print_word(mtpt, mtpt_len, len, 0);
+	fputs(uuid, stdout);
+	fputc('\n', stdout);
+}
+
+static void pretty_print_dev(blkid_dev dev)
+{
+	fprintf(stderr, "pretty print not implemented yet\n");
+
+#ifdef NOT_IMPLEMENTED
+	blkid_tag_iterate	iter;
+	const char		*type, *value, *devname;
+	const char		*uuid = "", *fs_type = "", *label = "";
+	char			*cp;
+	int			len, mount_flags;
+	char			mtpt[80];
+	errcode_t		retval;
+
+	if (dev == NULL) {
+		pretty_print_line("device", "fs_type", "label",
+				  "mount point", "UUID");
+		for (len=get_terminal_width()-1; len > 0; len--)
+			fputc('-', stdout);
+		fputc('\n', stdout);
+		return;
+	}
+
+	devname = blkid_dev_devname(dev);
+	if (access(devname, F_OK))
+		return;
+
+	/* Get the uuid, label, type */
+	iter = blkid_tag_iterate_begin(dev);
+	while (blkid_tag_next(iter, &type, &value) == 0) {
+		if (!strcmp(type, "UUID"))
+			uuid = value;
+		if (!strcmp(type, "TYPE"))
+			fs_type = value;
+		if (!strcmp(type, "LABEL"))
+			label = value;
+	}
+	blkid_tag_iterate_end(iter);
+
+	/* Get the mount point */
+	mtpt[0] = 0;
+	retval = ext2fs_check_mount_point(devname, &mount_flags,
+					  mtpt, sizeof(mtpt));
+	if (retval == 0) {
+		if (mount_flags & EXT2_MF_MOUNTED) {
+			if (!mtpt[0])
+				strcpy(mtpt, "(mounted, mtpt unknown)");
+		} else if (mount_flags & EXT2_MF_BUSY)
+			strcpy(mtpt, "(in use)");
+		else
+			strcpy(mtpt, "(not mounted)");
+	}
+
+	pretty_print_line(devname, fs_type, label, mtpt, uuid);
+#endif
+}
+
+static void print_udev_format(const char *name, const char *value, size_t sz)
+{
+	char enc[265], safe[256];
+
+	*safe = *enc = '\0';
+
+	if (!strcmp(name, "TYPE") || !strcmp(name, "VERSION")) {
+		blkid_encode_string(value, enc, sizeof(enc));
+		printf("ID_FS_%s=%s\n", name, enc);
+
+	} else if (!strcmp(name, "UUID") ||
+		 !strcmp(name, "LABEL") ||
+		 !strcmp(name, "UUID_SUB")) {
+
+		blkid_safe_string(value, safe, sizeof(safe));
+		printf("ID_FS_%s=%s\n", name, safe);
+
+		blkid_encode_string(value, enc, sizeof(enc));
+		printf("ID_FS_%s_ENC=%s\n", name, enc);
+	}
+	else
+		printf("ID_FS_%s=%s\n", name, value);
+}
+
+static void print_value(int output, int num, const char *devname,
+			const char *value, const char *name, size_t valsz)
+{
+	if (output & OUTPUT_VALUE_ONLY) {
+		fputs(value, stdout);
+		fputc('\n', stdout);
+
+	} else if (output & OUTPUT_UDEV_LIST) {
+		print_udev_format(name, value, valsz);
+
+	} else {
+		if (num == 1 && devname)
+			printf("%s: ", devname);
+		fputs(name, stdout);
+		fputs("=\"", stdout);
+		safe_print(value, valsz);
+		fputs("\" ", stdout);
+	}
+}
+
+static void print_tags(blkid_dev dev, char *show[], int numtag, int output)
+{
+	blkid_tag_iterate	iter;
+	const char		*type, *value, *devname;
+	int			i, num = 1;
+
+	if (!dev)
+		return;
+
+	if (output & OUTPUT_PRETTY_LIST) {
+		pretty_print_dev(dev);
+		return;
+	}
+
+	devname = blkid_dev_devname(dev);
+
+	if (output & OUTPUT_DEVICE_ONLY) {
+		printf("%s\n", devname);
+		return;
+	}
+
+	iter = blkid_tag_iterate_begin(dev);
+	while (blkid_tag_next(iter, &type, &value) == 0) {
+		if (numtag && show) {
+			for (i=0; i < numtag; i++)
+				if (!strcmp(type, show[i]))
+					break;
+			if (i >= numtag)
+				continue;
+		}
+		print_value(output, num++, devname, value, type, strlen(value));
+	}
+	blkid_tag_iterate_end(iter);
+
+	if (num > 1 && !(output & (OUTPUT_VALUE_ONLY | OUTPUT_UDEV_LIST)))
+		printf("\n");
+}
+
+static int lowprobe_device(blkid_probe pr, const char *devname, int output,
+		blkid_loff_t offset, blkid_loff_t size)
+{
+	const char *data;
+	const char *name;
+	int nvals = 0, n;
+	size_t len;
+	int fd;
+	int rc = 0;
+
+	fd = open(devname, O_RDONLY);
+	if (fd < 0)
+		return 2;
+
+	if (blkid_probe_set_device(pr, fd, offset, size))
+		goto done;
+	rc = blkid_do_safeprobe(pr);
+	if (rc)
+		goto done;
+
+	nvals = blkid_probe_numof_values(pr);
+
+	if (output & OUTPUT_DEVICE_ONLY) {
+		printf("%s\n", devname);
+		goto done;
+	}
+
+	for (n = 0; n < nvals; n++) {
+		if (blkid_probe_get_value(pr, n, &name, &data, &len))
+			continue;
+
+		len = strnlen((char *) data, len);
+		print_value(output, n + 1, devname, (char *) data, name, len);
+	}
+
+	if (nvals > 1 && !(output & (OUTPUT_VALUE_ONLY | OUTPUT_UDEV_LIST)))
+		printf("\n");
+done:
+	if (rc == -2)
+		fprintf(stderr, "%s: ambivalent result "
+				"(probably more filesystems on the device)\n",
+				devname);
+	close(fd);
+	return !nvals ? 2 : 0;
+}
+
+/* converts comma separated list to BLKID_USAGE_* mask */
+static int list_to_usage(const char *list, int *flag)
+{
+	int mask = 0;
+	const char *word, *p = list;
+
+	if (p && strncmp(p, "no", 2) == 0) {
+		*flag = BLKID_FLTR_NOTIN;
+		p += 2;
+	}
+
+	for (word = p; p && *p; p++) {
+		if (*p == ',' || *(p + 1) == '\0') {
+			if (!strncmp(word, "filesystem", 10))
+				mask |= BLKID_USAGE_FILESYSTEM;
+			else if (!strncmp(word, "raid", 4))
+				mask |= BLKID_USAGE_RAID;
+			else if (!strncmp(word, "crypto", 6))
+				mask |= BLKID_USAGE_CRYPTO;
+			else if (!strncmp(word, "other", 5))
+				mask |= BLKID_USAGE_OTHER;
+			else {
+				fprintf(stderr, "unknown usage keyword '%*s'\n",
+						(int) (p - word), word);
+				exit(4);
+			}
+			word = p + 1;
+		}
+	}
+	return mask;
+}
+
+int main(int argc, char **argv)
+{
+	blkid_cache cache = NULL;
+	char *devices[128] = { NULL, };
+	char *show[128] = { NULL, };
+	char *search_type = NULL, *search_value = NULL;
+	char *read = NULL;
+	char *write = NULL;
+	int fltr_usage = 0;
+	int fltr_flag = BLKID_FLTR_ONLYIN;
+	unsigned int numdev = 0, numtag = 0;
+	int version = 0;
+	int err = 4;
+	unsigned int i;
+	int output_format = 0;
+	int lookup = 0, gc = 0, lowprobe = 0, eval = 0;
+	int c;
+	blkid_loff_t offset = 0, size = 0;
+
+	while ((c = getopt (argc, argv, "c:f:ghlL:o:O:ps:S:t:u:U:w:v")) != EOF)
+		switch (c) {
+		case 'c':
+			if (optarg && !*optarg)
+				read = NULL;
+			else
+				read = optarg;
+			if (!write)
+				write = read;
+			break;
+		case 'L':
+			eval++;
+			search_value = strdup(optarg);
+			search_type = strdup("LABEL");
+			break;
+		case 'u':
+			fltr_usage = list_to_usage(optarg, &fltr_flag);
+			break;
+		case 'U':
+			eval++;
+			search_value = strdup(optarg);
+			search_type = strdup("UUID");
+			break;
+		case 'l':
+			lookup++;
+			break;
+		case 'g':
+			gc = 1;
+			break;
+		case 'o':
+			if (!strcmp(optarg, "value"))
+				output_format = OUTPUT_VALUE_ONLY;
+			else if (!strcmp(optarg, "device"))
+				output_format = OUTPUT_DEVICE_ONLY;
+			else if (!strcmp(optarg, "list"))
+				output_format = OUTPUT_PRETTY_LIST;
+			else if (!strcmp(optarg, "udev"))
+				output_format = OUTPUT_UDEV_LIST;
+			else if (!strcmp(optarg, "full"))
+				output_format = 0;
+			else {
+				fprintf(stderr, "Invalid output format %s. "
+					"Choose from value,\n\t"
+					"device, list, udev or full\n", optarg);
+				exit(4);
+			}
+			break;
+		case 'O':
+			offset = strtoll(optarg, NULL, 10);
+			break;
+		case 'p':
+			lowprobe++;
+			break;
+		case 's':
+			if (numtag >= sizeof(show) / sizeof(*show)) {
+				fprintf(stderr, "Too many tags specified\n");
+				usage(err);
+			}
+			show[numtag++] = optarg;
+			break;
+		case 'S':
+			size = strtoll(optarg, NULL, 10);
+			break;
+		case 't':
+			if (search_type) {
+				fprintf(stderr, "Can only search for "
+						"one NAME=value pair\n");
+				usage(err);
+			}
+			if (blkid_parse_tag_string(optarg,
+						   &search_type,
+						   &search_value)) {
+				fprintf(stderr, "-t needs NAME=value pair\n");
+				usage(err);
+			}
+			break;
+		case 'v':
+			version = 1;
+			break;
+		case 'w':
+			if (optarg && !*optarg)
+				write = NULL;
+			else
+				write = optarg;
+			break;
+		case 'h':
+			err = 0;
+		default:
+			usage(err);
+		}
+
+	while (optind < argc)
+		devices[numdev++] = argv[optind++];
+
+	if (version) {
+		print_version(stdout);
+		goto exit;
+	}
+
+	/* convert LABEL/UUID lookup to evaluate request */
+	if (lookup && output_format == OUTPUT_DEVICE_ONLY && search_type &&
+	    (!strcmp(search_type, "LABEL") || !strcmp(search_type, "UUID"))) {
+		eval++;
+		lookup = 0;
+	}
+
+	if (!lowprobe && !eval && blkid_get_cache(&cache, read) < 0)
+		goto exit;
+
+	if (gc) {
+		blkid_gc_cache(cache);
+		err = 0;
+		goto exit;
+	}
+	err = 2;
+
+	if (output_format & OUTPUT_PRETTY_LIST)
+		pretty_print_dev(NULL);
+
+	if (lowprobe) {
+		/*
+		 * Low-level API
+		 */
+		blkid_probe pr;
+
+		if (!numdev) {
+			fprintf(stderr, "The low-probe option requires a device\n");
+			exit(4);
+		}
+		pr = blkid_new_probe();
+		if (!pr)
+			goto exit;
+		blkid_probe_set_request(pr,
+				BLKID_PROBREQ_LABEL | BLKID_PROBREQ_UUID |
+				BLKID_PROBREQ_TYPE | BLKID_PROBREQ_SECTYPE |
+				BLKID_PROBREQ_USAGE | BLKID_PROBREQ_VERSION);
+		if (fltr_usage &&
+		    blkid_probe_filter_usage(pr, fltr_flag, fltr_usage))
+			goto exit;
+
+		for (i = 0; i < numdev; i++)
+			err = lowprobe_device(pr, devices[i],
+					output_format, offset, size);
+		blkid_free_probe(pr);
+	} else if (eval) {
+		/*
+		 * Evaluate API
+		 */
+		char *res = blkid_evaluate_tag(search_type, search_value, NULL);
+		if (res) {
+			err = 0;
+			printf("%s\n", res);
+		}
+	} else if (lookup) {
+		/*
+		 * Classic (cache based) API
+		 */
+		blkid_dev dev;
+
+		if (!search_type) {
+			fprintf(stderr, "The lookup option requires a "
+				"search type specified using -t\n");
+			exit(4);
+		}
+		/* Load any additional devices not in the cache */
+		for (i = 0; i < numdev; i++)
+			blkid_get_dev(cache, devices[i], BLKID_DEV_NORMAL);
+
+		if ((dev = blkid_find_dev_with_tag(cache, search_type,
+						   search_value))) {
+			print_tags(dev, show, numtag, output_format);
+			err = 0;
+		}
+	/* If we didn't specify a single device, show all available devices */
+	} else if (!numdev) {
+		blkid_dev_iterate	iter;
+		blkid_dev		dev;
+
+		blkid_probe_all(cache);
+
+		iter = blkid_dev_iterate_begin(cache);
+		blkid_dev_set_search(iter, search_type, search_value);
+		while (blkid_dev_next(iter, &dev) == 0) {
+			dev = blkid_verify(cache, dev);
+			if (!dev)
+				continue;
+			print_tags(dev, show, numtag, output_format);
+			err = 0;
+		}
+		blkid_dev_iterate_end(iter);
+	/* Add all specified devices to cache (optionally display tags) */
+	} else for (i = 0; i < numdev; i++) {
+		blkid_dev dev = blkid_get_dev(cache, devices[i],
+						  BLKID_DEV_NORMAL);
+
+		if (dev) {
+			if (search_type &&
+			    !blkid_dev_has_tag(dev, search_type,
+					       search_value))
+				continue;
+			print_tags(dev, show, numtag, output_format);
+			err = 0;
+		}
+	}
+
+exit:
+	free(search_type);
+	free(search_value);
+	if (!lowprobe && !eval)
+		blkid_put_cache(cache);
+	return err;
+}
diff --git a/misc-utils/findfs.8 b/misc-utils/findfs.8
new file mode 100644
index 000000000..e93fe5421
--- /dev/null
+++ b/misc-utils/findfs.8
@@ -0,0 +1,35 @@
+.\" -*- nroff -*-
+.\" Copyright 1993, 1994, 1995 by Theodore Ts'o.  All Rights Reserved.
+.\" This file may be copied under the terms of the GNU Public License.
+.\"
+.TH FINDFS 8 "February 2009" "Linux" "MAINTENANCE COMMANDS"
+.SH NAME
+findfs \- Find a filesystem by label or UUID
+.SH SYNOPSIS
+.B findfs
+.BI LABEL= label
+.sp
+.B findfs
+.BI UUID= uuid
+.SH DESCRIPTION
+.B findfs
+will search the disks in the system looking for a filesystem which has
+a label matching
+.I label
+or a UUID equal to
+.IR uuid .
+If the filesystem is found, the device name for the filesystem will
+be printed on stdout.
+.PP
+.SH AUTHOR
+.B findfs
+was originally written by Theodore Ts'o (tytso@mit.edu) and re-written for
+util-linux-ng package by Karel Zak (kzak@redhat.com).
+.SH AVAILABILITY
+.B findfs
+The blkid command is part of the util-linux-ng package and is available from
+ftp://ftp.kernel.org/pub/linux/utils/util-linux-ng/.
+.SH SEE ALSO
+.BR blkid (8)
+.BR fsck (8)
+
diff --git a/misc-utils/findfs.c b/misc-utils/findfs.c
new file mode 100644
index 000000000..18608b470
--- /dev/null
+++ b/misc-utils/findfs.c
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2009 Karel Zak <kzak@redhat.com>
+ *
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <err.h>
+
+#include <blkid.h>
+
+#include "nls.h"
+
+static void __attribute__((__noreturn__)) usage(int rc)
+{
+	const char *p = program_invocation_short_name;
+
+	if (!p)
+		p = "findfs";
+
+	fprintf(stderr, _("Usage: %s LABEL=<label>|UUID=<uuid>\n"), p);
+	exit(rc);
+}
+
+int main(int argc, char **argv)
+{
+	char	*dev, *tk, *vl;
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+
+	if (argc != 2)
+		/* we return '2' for backward compatibility
+		 * with version from e2fsprogs */
+		usage(2);
+
+	if (!strncmp(argv[1], "LABEL=", 6)) {
+		tk = "LABEL";
+		vl = argv[1] + 6;
+	} else if (!strncmp(argv[1], "UUID=", 5)) {
+		tk = "UUID";
+		vl = argv[1] + 5;
+	} else if (!strcmp(argv[1], "-h") == 0 ||
+		   !strcmp(argv[1], "--help") == 0) {
+		usage(EXIT_SUCCESS);
+	} else
+		usage(2);
+
+	dev = blkid_evaluate_tag(tk, vl, NULL);
+	if (!dev)
+		errx(EXIT_FAILURE, _("unable to resolve '%s'"),	argv[1]);
+
+	puts(dev);
+	exit(EXIT_SUCCESS);
+}
+