Adding upstream version 2.36.1.upstream/2.36.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

55 files changed, 20973 insertions, 0 deletions

diff --git a/misc-utils/Makemodule.am b/misc-utils/Makemodule.am
new file mode 100644
index 0000000..56f9a41
--- /dev/null
+++ b/misc-utils/Makemodule.am
@@ -0,0 +1,232 @@
+if BUILD_CAL
+usrbin_exec_PROGRAMS += cal
+dist_man_MANS += misc-utils/cal.1
+cal_SOURCES = misc-utils/cal.c
+cal_CFLAGS = $(AM_CFLAGS)
+cal_LDADD = $(LDADD) libcommon.la libtcolors.la
+# tinfo or ncurses are optional
+if HAVE_TINFO
+cal_LDADD += $(TINFO_LIBS)
+cal_CFLAGS += $(TINFO_CFLAGS)
+else
+if HAVE_NCURSES
+cal_LDADD += $(NCURSES_LIBS)
+cal_CFLAGS += $(NCURSES_CFLAGS)
+endif
+endif # !HAVE_TINFO
+
+check_PROGRAMS += test_cal
+test_cal_SOURCES = $(cal_SOURCES)
+test_cal_LDADD = $(cal_LDADD)
+test_cal_CFLAGS = -DTEST_CAL $(cal_CFLAGS)
+endif # BUILD_CAL
+
+
+if BUILD_LOGGER
+usrbin_exec_PROGRAMS += logger
+dist_man_MANS += misc-utils/logger.1
+logger_SOURCES = misc-utils/logger.c lib/strutils.c lib/strv.c
+logger_LDADD = $(LDADD)
+logger_CFLAGS = $(AM_CFLAGS)
+if HAVE_SYSTEMD
+logger_LDADD += $(SYSTEMD_LIBS) $(SYSTEMD_DAEMON_LIBS) $(SYSTEMD_JOURNAL_LIBS)
+logger_CFLAGS += $(SYSTEMD_CFLAGS) $(SYSTEMD_DAEMON_CFLAGS) $(SYSTEMD_JOURNAL_CFLAGS)
+endif
+
+check_PROGRAMS += test_logger
+test_logger_SOURCES = $(logger_SOURCES)
+test_logger_LDADD = $(logger_LDADD)
+test_logger_CFLAGS = -DTEST_LOGGER $(logger_CFLAGS)
+endif # BUILD_LOGGER
+
+
+if BUILD_LOOK
+usrbin_exec_PROGRAMS += look
+dist_man_MANS += misc-utils/look.1
+look_SOURCES = misc-utils/look.c
+endif
+
+if BUILD_MCOOKIE
+usrbin_exec_PROGRAMS += mcookie
+dist_man_MANS += misc-utils/mcookie.1
+mcookie_SOURCES = misc-utils/mcookie.c lib/md5.c
+mcookie_LDADD = $(LDADD) libcommon.la
+endif
+
+if BUILD_NAMEI
+usrbin_exec_PROGRAMS += namei
+dist_man_MANS += misc-utils/namei.1
+namei_SOURCES = misc-utils/namei.c lib/strutils.c lib/idcache.c
+endif
+
+if BUILD_WHEREIS
+usrbin_exec_PROGRAMS += whereis
+dist_man_MANS += misc-utils/whereis.1
+whereis_SOURCES = misc-utils/whereis.c
+whereis_LDADD = $(LDADD) libcommon.la
+endif
+
+if BUILD_LSLOCKS
+usrbin_exec_PROGRAMS += lslocks
+dist_man_MANS += misc-utils/lslocks.8
+lslocks_LDADD = $(LDADD) libcommon.la libmount.la libsmartcols.la
+lslocks_SOURCES = misc-utils/lslocks.c
+lslocks_CFLAGS = $(AM_CFLAGS) -I$(ul_libmount_incdir) -I$(ul_libsmartcols_incdir)
+endif
+
+if BUILD_LSBLK
+bin_PROGRAMS += lsblk
+dist_man_MANS += misc-utils/lsblk.8
+lsblk_SOURCES = \
+	misc-utils/lsblk.c \
+	misc-utils/lsblk-mnt.c \
+	misc-utils/lsblk-properties.c \
+	misc-utils/lsblk-devtree.c \
+	misc-utils/lsblk.h
+lsblk_LDADD = $(LDADD) libblkid.la libmount.la libcommon.la libsmartcols.la
+lsblk_CFLAGS = $(AM_CFLAGS) -I$(ul_libblkid_incdir) -I$(ul_libmount_incdir) -I$(ul_libsmartcols_incdir)
+if HAVE_UDEV
+lsblk_LDADD += -ludev
+endif
+endif # BUILD_LSBLK
+
+if BUILD_UUIDGEN
+usrbin_exec_PROGRAMS += uuidgen
+dist_man_MANS += misc-utils/uuidgen.1
+uuidgen_SOURCES = misc-utils/uuidgen.c
+uuidgen_LDADD = $(LDADD) libuuid.la
+uuidgen_CFLAGS = $(AM_CFLAGS) -I$(ul_libuuid_incdir)
+endif
+
+if BUILD_UUIDPARSE
+usrbin_exec_PROGRAMS += uuidparse
+dist_man_MANS += misc-utils/uuidparse.1
+uuidparse_SOURCES = misc-utils/uuidparse.c
+uuidparse_LDADD = $(LDADD) libcommon.la libuuid.la libsmartcols.la
+uuidparse_CFLAGS = $(AM_CFLAGS) -I$(ul_libuuid_incdir) -I$(ul_libsmartcols_incdir)
+endif
+
+if BUILD_UUIDD
+usrsbin_exec_PROGRAMS += uuidd
+dist_man_MANS += misc-utils/uuidd.8
+uuidd_LDADD = $(LDADD) libuuid.la libcommon.la $(REALTIME_LIBS)
+uuidd_CFLAGS = $(DAEMON_CFLAGS) $(AM_CFLAGS) -I$(ul_libuuid_incdir)
+uuidd_LDFLAGS = $(DAEMON_LDFLAGS) $(AM_LDFLAGS)
+uuidd_SOURCES = misc-utils/uuidd.c lib/monotonic.c lib/timer.c
+if HAVE_SYSTEMD
+uuidd_LDADD += $(SYSTEMD_LIBS) $(SYSTEMD_DAEMON_LIBS)
+uuidd_CFLAGS += $(SYSTEMD_CFLAGS) $(SYSTEMD_DAEMON_CFLAGS)
+systemdsystemunit_DATA += \
+	misc-utils/uuidd.service \
+	misc-utils/uuidd.socket
+endif
+
+check_PROGRAMS += test_uuidd
+test_uuidd_SOURCES = misc-utils/test_uuidd.c
+test_uuidd_LDADD =  $(LDADD) libcommon.la libuuid.la -lpthread
+test_uuidd_CFLAGS = $(AM_CFLAGS) -I$(ul_libuuid_incdir)
+endif # BUILD_UUIDD
+
+PATHFILES += \
+	misc-utils/uuidd.8 \
+	misc-utils/uuidd.rc \
+	misc-utils/uuidd.service \
+	misc-utils/uuidd.socket
+
+if BUILD_BLKID
+sbin_PROGRAMS += blkid
+dist_man_MANS += misc-utils/blkid.8
+blkid_SOURCES = misc-utils/blkid.c \
+		lib/ismounted.c
+blkid_LDADD = $(LDADD) libblkid.la libcommon.la
+blkid_CFLAGS = $(AM_CFLAGS) -I$(ul_libblkid_incdir)
+
+if HAVE_STATIC_BLKID
+sbin_PROGRAMS += blkid.static
+blkid_static_SOURCES = $(blkid_SOURCES)
+blkid_static_LDFLAGS = -all-static
+blkid_static_LDADD = $(LDADD) libblkid.la
+blkid_static_CFLAGS = $(AM_CFLAGS) -I$(ul_libblkid_incdir)
+endif
+endif # BUILD_BLKID
+
+
+if BUILD_FINDFS
+sbin_PROGRAMS += findfs
+dist_man_MANS += misc-utils/findfs.8
+findfs_LDADD = $(LDADD) libblkid.la
+findfs_SOURCES = misc-utils/findfs.c
+findfs_CFLAGS = $(AM_CFLAGS) -I$(ul_libblkid_incdir)
+endif
+
+if BUILD_WIPEFS
+sbin_PROGRAMS += wipefs
+dist_man_MANS += misc-utils/wipefs.8
+wipefs_SOURCES = misc-utils/wipefs.c
+wipefs_LDADD = $(LDADD) libblkid.la libcommon.la libsmartcols.la
+wipefs_CFLAGS = $(AM_CFLAGS) -I$(ul_libblkid_incdir) -I$(ul_libsmartcols_incdir)
+endif
+
+if BUILD_FINDMNT
+bin_PROGRAMS += findmnt
+dist_man_MANS += misc-utils/findmnt.8
+findmnt_LDADD = $(LDADD) libmount.la \
+		libcommon.la \
+		libsmartcols.la \
+		libblkid.la
+findmnt_CFLAGS = $(AM_CFLAGS) \
+		-I$(ul_libmount_incdir) \
+		-I$(ul_libsmartcols_incdir) \
+		-I$(ul_libblkid_incdir)
+findmnt_SOURCES = misc-utils/findmnt.c \
+		  misc-utils/findmnt-verify.c \
+		  misc-utils/findmnt.h
+if HAVE_UDEV
+findmnt_LDADD += -ludev
+endif
+endif # BUILD_FINDMNT
+
+
+if BUILD_KILL
+bin_PROGRAMS += kill
+kill_SOURCES = misc-utils/kill.c
+kill_LDADD = $(LDADD) libcommon.la
+dist_man_MANS += misc-utils/kill.1
+endif
+
+if BUILD_RENAME
+usrbin_exec_PROGRAMS += rename
+dist_man_MANS += misc-utils/rename.1
+rename_SOURCES = misc-utils/rename.c
+endif
+
+if BUILD_GETOPT
+usrbin_exec_PROGRAMS += getopt
+dist_man_MANS += misc-utils/getopt.1
+PATHFILES += misc-utils/getopt.1
+getopt_SOURCES = misc-utils/getopt.c
+getoptexampledir = $(docdir)/getopt/
+dist_getoptexample_SCRIPTS = \
+	misc-utils/getopt-parse.bash \
+	misc-utils/getopt-parse.tcsh
+endif
+
+if BUILD_FINCORE
+usrbin_exec_PROGRAMS += fincore
+dist_man_MANS += misc-utils/fincore.1
+fincore_SOURCES = misc-utils/fincore.c
+fincore_LDADD = $(LDADD) libsmartcols.la libcommon.la
+fincore_CFLAGS = $(AM_CFLAGS) -I$(ul_libsmartcols_incdir)
+endif
+
+if BUILD_HARDLINK
+usrbin_exec_PROGRAMS += hardlink
+hardlink_SOURCES = misc-utils/hardlink.c
+hardlink_LDADD = $(LDADD) libcommon.la
+hardlink_CFLAGS = $(AM_CFLAGS)
+if HAVE_PCRE
+hardlink_LDADD += $(PCRE_LIBS)
+hardlink_CFLAGS += $(PCRE_CFLAGS)
+endif
+dist_man_MANS += misc-utils/hardlink.1
+endif
diff --git a/misc-utils/blkid.8 b/misc-utils/blkid.8
new file mode 100644
index 0000000..57a3b75
--- /dev/null
+++ b/misc-utils/blkid.8
@@ -0,0 +1,343 @@
+.\" Copyright 2000 Andreas Dilger (adilger@turbolinux.com)
+.\"
+.\" This file may be copied under the terms of the GNU Public License.
+.TH BLKID 8 "March 2013" "util-linux" "System Administration"
+.SH NAME
+blkid \- locate/print block device attributes
+.SH SYNOPSIS
+.IP \fBblkid\fR
+.BI \-\-label " label"
+|
+.BI \-\-uuid " uuid"
+
+.IP \fBblkid\fR
+.RB [ \-\-no\-encoding
+.B \-\-garbage\-collect \-\-list\-one \-\-cache\-file
+.IR file ]
+.RB [ \-\-output
+.IR format ]
+.RB [ \-\-match\-tag
+.IR tag ]
+.RB [ \-\-match\-token
+.IR NAME=value ]
+.RI [ device " ...]"
+
+.IP \fBblkid\fR
+.BR \-\-probe " [" \-\-offset
+.IR offset ]
+.RB [ \-\-output
+.IR format ]
+.RB [ \-\-size
+.IR size ]
+.RB [ \-\-match\-tag
+.IR tag ]
+.RB [ \-\-match\-types
+.IR list ]
+.RB [ \-\-usages
+.IR list ]
+.RB [ \-\-no\-part\-details ]
+.IR device " ..."
+
+.IP \fBblkid\fR
+.BR \-\-info " [" \-\-output
+.IR format ]
+.RB [ \-\-match\-tag
+.IR tag ]
+.IR device " ..."
+
+.SH DESCRIPTION
+The
+.B blkid
+program is the command-line interface to working with the
+.BR libblkid (3)
+library.  It can determine the type of content (e.g., filesystem or swap)
+that a block device holds, and also the attributes (tokens, NAME=value pairs)
+from the content metadata (e.g., LABEL or UUID fields).
+.PP
+.B It is recommended to use
+.BR lsblk (8)
+.B command to get information about block devices, or lsblk \-\-fs to get an overview of filesystems, or
+.BR findmnt (8)
+.B to search in already mounted filesystems.
+.PP
+.RS
+.BR lsblk (8)
+provides more information, better control on output formatting, easy to use in
+scripts and it does not require root permissions to get actual information.
+.B blkid
+reads information directly from devices and for non-root users
+it returns cached unverified information.
+.B blkid
+is mostly designed for system services and to test libblkid functionality.
+.RE
+
+.PP
+When
+.I device
+is specified, tokens from only this device are displayed.
+It is possible to specify multiple
+.I device
+arguments on the command line.
+If none is given, all partitions or unpartitioned devices which appear in
+.I /proc/partitions
+are shown, if they are recognized.
+.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 specified devices.
+
+For security reasons
+.B blkid
+silently ignores all devices where the probing result is ambivalent (multiple
+colliding filesystems are detected).  The low-level probing mode (\fB\-p\fR)
+provides more information and extra exit status in this case.
+It's recommended to use
+.BR wipefs (8)
+to get a detailed overview and to erase obsolete stuff (magic strings) from the device.
+
+.SH OPTIONS
+The \fIsize\fR and \fIoffset\fR arguments may be followed by the multiplicative
+suffixes like KiB (=1024), MiB (=1024*1024), and so on for GiB, TiB, PiB, EiB, ZiB and YiB
+(the "iB" is optional, e.g., "K" has the same meaning as "KiB"), or the suffixes
+KB (=1000), MB (=1000*1000), and so on for GB, TB, PB, EB, ZB and YB.
+.TP
+\fB\-c\fR, \fB\-\-cache\-file\fR \fIcachefile\fR
+Read from
+.I cachefile
+instead of reading from the default cache file (see the CONFIGURATION FILE section
+for more details).  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
+\fB\-d\fR, \fB\-\-no\-encoding\fR
+Don't encode non-printing characters.  The non-printing characters are encoded
+by ^ and M- notation by default.  Note that the \fB\-\-output udev\fR output format uses
+a different encoding which cannot be disabled.
+.TP
+\fB\-D\fR, \fB\-\-no\-part\-details\fR
+Don't print information (PART_ENTRY_* tags) from partition table in low-level probing mode.
+.TP
+\fB\-g\fR, \fB\-\-garbage\-collect\fR
+Perform a garbage collection pass on the blkid cache to remove
+devices which no longer exist.
+.TP
+\fB\-h\fR, \fB\-\-help\fR
+Display a usage message and exit.
+.TP
+\fB\-i\fR, \fB\-\-info\fR
+Display information about I/O Limits (aka I/O topology).  The 'export' output format is
+automatically enabled.  This option can be used together with the \fB\-\-probe\fR option.
+.TP
+\fB\-k\fR, \fB\-\-list\-filesystems\fR
+List all known filesystems and RAIDs and exit.
+.TP
+\fB\-l\fR, \fB\-\-list\-one\fR
+Look up only one device that matches the search parameter specified with the \fB\-\-match\-token\fR
+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 (but see below note about udev).
+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.
+.sp
+This option forces
+.B blkid
+to use udev when used for LABEL or UUID tokens in \fB\-\-match\-token\fR. The
+goal is to provide output consistent with other utils (like mount, etc.)
+on systems where the same tag is used for multiple devices.
+.TP
+\fB\-L\fR, \fB\-\-label\fR \fIlabel\fR
+Look up the device that uses this filesystem \fIlabel\fR; this is equal to
+.BR "\-\-list-one \-\-output device \-\-match-token LABEL=\fIlabel\fR" .
+This lookup method is able to reliably use /dev/disk/by-label
+udev symlinks (dependent on a setting in /etc/blkid.conf).  Avoid using the
+symlinks directly; it is not reliable to use the symlinks without verification.
+The \fB-\-label\fR option works on systems with and without udev.
+
+Unfortunately, the original
+.BR blkid (8)
+from e2fsprogs uses the \fB\-L\fR option as a
+synonym for \fB\-o list\fR.  For better portability, use \fB\-l \-o device
+\-t LABEL=\fIlabel\fR and \fB\-o list\fR in your scripts rather than the \fB\-L\fR option.
+.TP
+\fB\-n\fR, \fB\-\-match\-types\fR \fIlist\fR
+Restrict the probing functions to the specified (comma-separated) \fIlist\fR of
+superblock types (names).
+The list items may be prefixed with "no" to specify the types which should be ignored.
+For example:
+.sp
+  blkid \-\-probe \-\-match-types vfat,ext3,ext4 /dev/sda1
+.sp
+probes for vfat, ext3 and ext4 filesystems, and
+.sp
+  blkid \-\-probe \-\-match-types nominix /dev/sda1
+.sp
+probes for all supported formats except minix filesystems.
+This option is only useful together with \fB\-\-probe\fR.
+.TP
+\fB\-o\fR, \fB\-\-output\fR \fIformat\fR
+Use the specified output format.  Note that the order of variables and
+devices is not fixed.  See also option \fB\-s\fR.  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; this output format is unsupported
+for low-level probing (\fB\-\-probe\fR or \fB\-\-info\fR).
+
+This output format is \fBDEPRECATED\fR in favour of the
+.BR lsblk (8)
+command.
+.TP
+.B device
+print the device name only; this output format is always enabled for the \fB\-\-label\fR
+and \fB\-\-uuid\fR options
+.TP
+.B udev
+print key="value" pairs for easy import into the udev environment; the keys are
+prefixed by ID_FS_ or ID_PART_ prefixes.  The value may be modified to be
+safe for udev environment; allowed is plain ASCII, hex-escaping and valid UTF-8,
+everything else (including whitespaces) is replaced with '_'. The keys with
+_ENC postfix use hex-escaping for unsafe chars.
+
+The udev output returns the ID_FS_AMBIVALENT tag if more superblocks are detected,
+and ID_PART_ENTRY_* tags are always returned for all partitions including empty
+partitions.
+
+This output format is \fBDEPRECATED\fR.
+.TP
+.B export
+print key=value pairs for easy import into the environment; this output format
+is automatically enabled when I/O Limits (\fB\-\-info\fR option) are requested.
+
+The non-printing characters are encoded by ^ and M- notation and all
+potentially unsafe characters are escaped.
+.RE
+.TP
+\fB\-O\fR, \fB\-\-offset\fR \fIoffset\fR
+Probe at the given \fIoffset\fR (only useful with \fB\-\-probe\fR).  This option can be
+used together with the \fB\-\-info\fR option.
+.TP
+\fB\-p\fR, \fB\-\-probe\fR
+Switch to low-level superblock probing mode (bypassing the cache).
+
+Note that low-level probing also returns information about partition table type
+(PTTYPE tag) and partitions (PART_ENTRY_* tags). The tag names produced by
+low-level probing are based on names used internally by libblkid and it may be
+different than when executed without \fB\-\-probe\fR (for example PART_ENTRY_UUID= vs
+PARTUUID=). See also \fB\-\-no\-part\-details\fR.
+.TP
+\fB\-s\fR, \fB\-\-match\-tag\fR \fItag\fR
+For each (specified) device, show only the tags that match
+.IR tag .
+It is possible to specify multiple
+.B \-\-match\-tag
+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 "\-\-match\-tag none"
+with no other options.
+.TP
+\fB\-S\fR, \fB\-\-size\fR \fIsize\fR
+Override the size of device/file (only useful with \fB\-\-probe\fR).
+.TP
+\fB\-t\fR, \fB\-\-match\-token\fR \fINAME=value\fR
+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
+\fB\-u\fR, \fB\-\-usages\fR \fIlist\fR
+Restrict the probing functions to the specified (comma-separated) \fIlist\fR of "usage" types.
+Supported usage types are: filesystem, raid, crypto and other.  The list items may be
+prefixed with "no" to specify the usage types which should be ignored.  For example:
+.sp
+  blkid \-\-probe \-\-usages filesystem,other /dev/sda1
+.sp
+probes for all filesystem and other (e.g., swap) formats, and
+.sp
+  blkid \-\-probe \-\-usages noraid /dev/sda1
+.sp
+probes for all supported formats except RAIDs.
+This option is only useful together with \fB\-\-probe\fR.
+.TP
+\fB\-U\fR, \fB\-\-uuid\fR \fIuuid\fR
+Look up the device that uses this filesystem \fIuuid\fR.  For more details see the
+\fB\-\-label\fR option.
+.TP
+\fB\-V\fR, \fB\-\-version\fR
+Display version number and exit.
+.SH EXIT STATUS
+If the specified device or device addressed by specified token (option
+\fB\-\-match\-token\fR) was found and it's possible to gather any information about the
+device, an exit status 0 is returned.  Note the option \fB\-\-match\-tag\fR filters output
+tags, but it does not affect exit status.
+
+If the specified token was not found, or no (specified) devices could be
+identified, or it is impossible to gather any information about the device
+identifiers or device content an exit status of 2 is returned.
+
+For usage or other errors, an exit status of 4 is returned.
+
+If an ambivalent probing result was detected by low-level probing mode (\fB\-p\fR), an exit status of 8 is
+returned.
+.SH CONFIGURATION FILE
+The standard location of the
+.I /etc/blkid.conf
+config file can be overridden by the environment variable BLKID_CONF.
+The following options control the libblkid library:
+.TP
+.I SEND_UEVENT=<yes|not>
+Sends uevent when
+.I /dev/disk/by-{label,uuid,partuuid,partlabel}/
+symlink does not match with LABEL, UUID, PARTUUID or PARTLABEL on the device.  Default is "yes".
+.TP
+.I CACHE_FILE=<path>
+Overrides the standard location of the cache file.  This setting can be
+overridden by the environment variable BLKID_FILE.  Default is
+.IR /run/blkid/blkid.tab ,
+or
+.I /etc/blkid.tab
+on systems without a /run directory.
+.TP
+.I EVALUATE=<methods>
+Defines LABEL and UUID evaluation method(s).  Currently, the libblkid library
+supports the "udev" and "scan" methods.  More than one method may be specified in
+a comma-separated list.  Default is "udev,scan".  The "udev" method uses udev
+.I /dev/disk/by-*
+symlinks and the "scan" method scans all block devices from the
+.I /proc/partitions
+file.
+.SH ENVIRONMENT
+.IP "Setting LIBBLKID_DEBUG=all enables debug output."
+.SH AUTHORS
+.B blkid
+was written by Andreas Dilger for libblkid and improved by Theodore Ts'o
+and Karel Zak.
+.SH SEE ALSO
+.BR libblkid (3),
+.BR findfs (8),
+.BR lsblk (8),
+.BR wipefs (8)
+.SH AVAILABILITY
+The blkid command is part of the util-linux package and is available from
+https://www.kernel.org/pub/linux/utils/util-linux/.
diff --git a/misc-utils/blkid.c b/misc-utils/blkid.c
new file mode 100644
index 0000000..dba3bb7
--- /dev/null
+++ b/misc-utils/blkid.c
@@ -0,0 +1,963 @@
+/*
+ * 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>
+#include <errno.h>
+#include <getopt.h>
+
+#define OUTPUT_FULL		(1 << 0)
+#define OUTPUT_VALUE_ONLY	(1 << 1)
+#define OUTPUT_DEVICE_ONLY	(1 << 2)
+#define OUTPUT_PRETTY_LIST	(1 << 3)		/* deprecated */
+#define OUTPUT_UDEV_LIST	(1 << 4)		/* deprecated */
+#define OUTPUT_EXPORT_LIST	(1 << 5)
+
+#define BLKID_EXIT_NOTFOUND	2	/* token or device not found */
+#define BLKID_EXIT_OTHER	4	/* bad usage or other error */
+#define BLKID_EXIT_AMBIVAL	8	/* ambivalent low-level probing detected */
+
+#include <blkid.h>
+
+#include "ismounted.h"
+
+#include "strutils.h"
+#define OPTUTILS_EXIT_CODE	BLKID_EXIT_OTHER	/* exclusive_option() */
+#include "optutils.h"
+#define CLOSE_EXIT_CODE		BLKID_EXIT_OTHER	/* close_stdout() */
+#include "closestream.h"
+
+#include "nls.h"
+#include "ttyutils.h"
+
+#define XALLOC_EXIT_CODE    BLKID_EXIT_OTHER    /* x.*alloc(), xstrndup() */
+#include "xalloc.h"
+
+struct blkid_control {
+	int output;
+	uintmax_t offset;
+	uintmax_t size;
+	char *show[128];
+	unsigned int
+		eval:1,
+		gc:1,
+		lookup:1,
+		lowprobe:1,
+		lowprobe_superblocks:1,
+		lowprobe_topology:1,
+		no_part_details:1,
+		raw_chars:1;
+};
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+
+	fputs(USAGE_HEADER, out);
+	fprintf(out, _(	" %s --label <label> | --uuid <uuid>\n\n"), program_invocation_short_name);
+	fprintf(out, _(	" %s [--cache-file <file>] [-ghlLv] [--output <format>] [--match-tag <tag>] \n"
+			"       [--match-token <token>] [<dev> ...]\n\n"), program_invocation_short_name);
+	fprintf(out, _(	" %s -p [--match-tag <tag>] [--offset <offset>] [--size <size>] \n"
+			"       [--output <format>] <dev> ...\n\n"), program_invocation_short_name);
+	fprintf(out, _(	" %s -i [--match-tag <tag>] [--output <format>] <dev> ...\n"), program_invocation_short_name);
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(	" -c, --cache-file <file>    read from <file> instead of reading from the default\n"
+			"                              cache file (-c /dev/null means no cache)\n"), out);
+	fputs(_(	" -d, --no-encoding          don't encode non-printing characters\n"), out);
+	fputs(_(	" -g, --garbage-collect      garbage collect the blkid cache\n"), out);
+	fputs(_(	" -o, --output <format>      output format; can be one of:\n"
+			"                              value, device, export or full; (default: full)\n"), out);
+	fputs(_(	" -k, --list-filesystems     list all known filesystems/RAIDs and exit\n"), out);
+	fputs(_(	" -s, --match-tag <tag>      show specified tag(s) (default show all tags)\n"), out);
+	fputs(_(	" -t, --match-token <token>  find device with a specific token (NAME=value pair)\n"), out);
+	fputs(_(	" -l, --list-one             look up only first device with token specified by -t\n"), out);
+	fputs(_(	" -L, --label <label>        convert LABEL to device name\n"), out);
+	fputs(_(	" -U, --uuid <uuid>          convert UUID to device name\n"), out);
+	fputs(          "\n", out);
+	fputs(_(	"Low-level probing options:\n"), out);
+	fputs(_(	" -p, --probe                low-level superblocks probing (bypass cache)\n"), out);
+	fputs(_(	" -i, --info                 gather information about I/O limits\n"), out);
+	fputs(_(	" -S, --size <size>          overwrite device size\n"), out);
+	fputs(_(	" -O, --offset <offset>      probe at the given offset\n"), out);
+	fputs(_(	" -u, --usages <list>        filter by \"usage\" (e.g. -u filesystem,raid)\n"), out);
+	fputs(_(	" -n, --match-types <list>   filter by filesystem type (e.g. -n vfat,ext3)\n"), out);
+	fputs(_(	" -D, --no-part-details      don't print info from partition table\n"), out);
+
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(28));
+
+	fputs(USAGE_ARGUMENTS, out);
+	printf(USAGE_ARG_SIZE(_("<size> and <offset>")));
+	fputs(USAGE_ARG_SEPARATOR, out);
+	fputs(_(" <dev> specify device(s) to probe (default: all devices)\n"), out);
+
+	printf(USAGE_MAN_TAIL("blkid(8)"));
+	exit(EXIT_SUCCESS);
+}
+
+/*
+ * This function does "safe" printing.  It will convert non-printable
+ * ASCII characters using '^' and M- notation.
+ *
+ * If 'esc' is defined then escape all chars from esc by \.
+ */
+static void safe_print(const struct blkid_control *ctl, const char *cp, int len,
+		       const char *esc)
+{
+	unsigned char	ch;
+
+	if (len < 0)
+		len = strlen(cp);
+
+	while (len--) {
+		ch = *cp++;
+		if (!ctl->raw_chars) {
+			if (ch >= 128) {
+				fputs("M-", stdout);
+				ch -= 128;
+			}
+			if ((ch < 32) || (ch == 0x7f)) {
+				fputc('^', stdout);
+				ch ^= 0x40; /* ^@, ^A, ^B; ^? for DEL */
+
+			} else if (esc && strchr(esc, ch))
+				fputc('\\', stdout);
+		}
+		fputc(ch, stdout);
+	}
+}
+
+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(80);
+	}
+	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);
+	pretty_print_word(mtpt, mtpt_len, len, 0);
+
+	fputs(uuid, stdout);
+	fputc('\n', stdout);
+}
+
+static void pretty_print_dev(blkid_dev dev)
+{
+	blkid_tag_iterate	iter;
+	const char		*type, *value, *devname;
+	const char		*uuid = "", *fs_type = "", *label = "";
+	int			len, mount_flags;
+	char			mtpt[80];
+	int			retval;
+
+	if (dev == NULL) {
+		pretty_print_line("device", "fs_type", "label",
+				  "mount point", "UUID");
+		for (len=get_terminal_width(0)-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 = check_mount_point(devname, &mount_flags, mtpt, sizeof(mtpt));
+	if (retval == 0) {
+		const char *msg = NULL;
+
+		if (mount_flags & MF_MOUNTED) {
+			if (!mtpt[0])
+				msg = _("(mounted, mtpt unknown)");
+		} else if (mount_flags & MF_BUSY)
+			msg = _("(in use)");
+		else
+			msg = _("(not mounted)");
+
+		if (msg)
+			xstrncpy(mtpt, msg, sizeof(mtpt));
+	}
+
+	pretty_print_line(devname, fs_type, label, mtpt, uuid);
+}
+
+static void print_udev_format(const char *name, const char *value)
+{
+	char enc[265], safe[256];
+	size_t namelen = strlen(name);
+
+	*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") ||
+		 !strncmp(name, "LABEL", 5) ||
+		 !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 if (!strcmp(name, "PTUUID")) {
+		printf("ID_PART_TABLE_UUID=%s\n", value);
+
+	} else if (!strcmp(name, "PTTYPE")) {
+		printf("ID_PART_TABLE_TYPE=%s\n", value);
+
+	} else if (!strcmp(name, "PART_ENTRY_NAME") ||
+		  !strcmp(name, "PART_ENTRY_TYPE")) {
+
+		blkid_encode_string(value, enc, sizeof(enc));
+		printf("ID_%s=%s\n", name, enc);
+
+	} else if (!strncmp(name, "PART_ENTRY_", 11))
+		printf("ID_%s=%s\n", name, value);
+
+	else if (namelen >= 15 && (
+		   !strcmp(name + (namelen - 12), "_SECTOR_SIZE") ||
+		   !strcmp(name + (namelen - 8), "_IO_SIZE") ||
+		   !strcmp(name, "ALIGNMENT_OFFSET")))
+			printf("ID_IOLIMIT_%s=%s\n", name, value);
+	else
+		printf("ID_FS_%s=%s\n", name, value);
+}
+
+static int has_item(const struct blkid_control *ctl, const char *item)
+{
+	char * const *p;
+
+	for (p = ctl->show; *p != NULL; p++)
+		if (!strcmp(item, *p))
+			return 1;
+	return 0;
+}
+
+static void print_value(const struct blkid_control *ctl, int num,
+			const char *devname, const char *value,
+			const char *name, size_t valsz)
+{
+	if (ctl->output & OUTPUT_VALUE_ONLY) {
+		fputs(value, stdout);
+		fputc('\n', stdout);
+
+	} else if (ctl->output & OUTPUT_UDEV_LIST) {
+		print_udev_format(name, value);
+
+	} else if (ctl->output & OUTPUT_EXPORT_LIST) {
+		if (num == 1 && devname)
+			printf("DEVNAME=%s\n", devname);
+		fputs(name, stdout);
+		fputs("=", stdout);
+		safe_print(ctl, value, valsz, " \\\"'$`<>");
+		fputs("\n", stdout);
+
+	} else {
+		if (num == 1 && devname)
+			printf("%s:", devname);
+		fputs(" ", stdout);
+		fputs(name, stdout);
+		fputs("=\"", stdout);
+		safe_print(ctl, value, valsz, "\"\\");
+		fputs("\"", stdout);
+	}
+}
+
+static void print_tags(const struct blkid_control *ctl, blkid_dev dev)
+{
+	blkid_tag_iterate	iter;
+	const char		*type, *value, *devname;
+	int			num = 1;
+	static int		first = 1;
+
+	if (!dev)
+		return;
+
+	if (ctl->output & OUTPUT_PRETTY_LIST) {
+		pretty_print_dev(dev);
+		return;
+	}
+
+	devname = blkid_dev_devname(dev);
+
+	if (ctl->output & OUTPUT_DEVICE_ONLY) {
+		printf("%s\n", devname);
+		return;
+	}
+
+	iter = blkid_tag_iterate_begin(dev);
+	while (blkid_tag_next(iter, &type, &value) == 0) {
+		if (ctl->show[0] && !has_item(ctl, type))
+			continue;
+
+		if (num == 1 && !first &&
+		    (ctl->output & (OUTPUT_UDEV_LIST | OUTPUT_EXPORT_LIST)))
+			/* add extra line between output from more devices */
+			fputc('\n', stdout);
+
+		print_value(ctl, num++, devname, value, type, strlen(value));
+	}
+	blkid_tag_iterate_end(iter);
+
+	if (num > 1) {
+		if (!(ctl->output & (OUTPUT_VALUE_ONLY | OUTPUT_UDEV_LIST |
+						OUTPUT_EXPORT_LIST)))
+			printf("\n");
+		first = 0;
+	}
+}
+
+
+static int append_str(char **res, size_t *sz, const char *a, const char *b)
+{
+	char *str = *res;
+	size_t asz = a ? strlen(a) : 0;
+	size_t bsz = b ? strlen(b) : 0;
+	size_t len = *sz + asz + bsz;
+
+	if (!len)
+		return -1;
+
+	*res = str = xrealloc(str, len + 1);
+	str += *sz;
+
+	if (a) {
+		memcpy(str, a, asz);
+		str += asz;
+	}
+	if (b) {
+		memcpy(str, b, bsz);
+		str += bsz;
+	}
+	*str = '\0';
+	*sz = len;
+	return 0;
+}
+
+/*
+ * Compose and print ID_FS_AMBIVALENT for udev
+ */
+static int print_udev_ambivalent(blkid_probe pr)
+{
+	char *val = NULL;
+	size_t valsz = 0;
+	int count = 0, rc = -1;
+
+	while (!blkid_do_probe(pr)) {
+		const char *usage_txt = NULL, *type = NULL, *version = NULL;
+		char enc[256];
+
+		blkid_probe_lookup_value(pr, "USAGE", &usage_txt, NULL);
+		blkid_probe_lookup_value(pr, "TYPE", &type, NULL);
+		blkid_probe_lookup_value(pr, "VERSION", &version, NULL);
+
+		if (!usage_txt || !type)
+			continue;
+
+		blkid_encode_string(usage_txt, enc, sizeof(enc));
+		if (append_str(&val, &valsz, enc, ":"))
+			goto done;
+
+		blkid_encode_string(type, enc, sizeof(enc));
+		if (append_str(&val, &valsz, enc, version ? ":" : " "))
+			goto done;
+
+		if (version) {
+			blkid_encode_string(version, enc, sizeof(enc));
+			if (append_str(&val, &valsz, enc, " "))
+				goto done;
+		}
+		count++;
+	}
+
+	if (count > 1) {
+		*(val + valsz - 1) = '\0';		/* rem tailing whitespace */
+		printf("ID_FS_AMBIVALENT=%s\n", val);
+		rc = 0;
+	}
+done:
+	free(val);
+	return rc;
+}
+
+static int lowprobe_superblocks(blkid_probe pr, struct blkid_control *ctl)
+{
+	struct stat st;
+	int rc, fd = blkid_probe_get_fd(pr);
+
+	if (fd < 0 || fstat(fd, &st))
+		return -1;
+
+	blkid_probe_enable_partitions(pr, 1);
+
+	if (!S_ISCHR(st.st_mode) && blkid_probe_get_size(pr) <= 1024 * 1440 &&
+	    blkid_probe_is_wholedisk(pr)) {
+		/*
+		 * check if the small disk is partitioned, if yes then
+		 * don't probe for filesystems.
+		 */
+		blkid_probe_enable_superblocks(pr, 0);
+
+		rc = blkid_do_fullprobe(pr);
+		if (rc < 0)
+			return rc;	/* -1 = error, 1 = nothing, 0 = success */
+
+		if (blkid_probe_lookup_value(pr, "PTTYPE", NULL, NULL) == 0)
+			return 0;	/* partition table detected */
+	}
+
+	if (!ctl->no_part_details)
+		blkid_probe_set_partitions_flags(pr, BLKID_PARTS_ENTRY_DETAILS);
+	blkid_probe_enable_superblocks(pr, 1);
+
+	return blkid_do_safeprobe(pr);
+}
+
+static int lowprobe_topology(blkid_probe pr)
+{
+	/* enable topology probing only */
+	blkid_probe_enable_topology(pr, 1);
+
+	blkid_probe_enable_superblocks(pr, 0);
+	blkid_probe_enable_partitions(pr, 0);
+
+	return blkid_do_fullprobe(pr);
+}
+
+static int lowprobe_device(blkid_probe pr, const char *devname,
+			   struct blkid_control *ctl)
+{
+	const char *data;
+	const char *name;
+	int nvals = 0, n, num = 1;
+	size_t len;
+	int fd;
+	int rc = 0;
+	static int first = 1;
+
+	fd = open(devname, O_RDONLY|O_CLOEXEC|O_NONBLOCK);
+	if (fd < 0) {
+		warn(_("error: %s"), devname);
+		return BLKID_EXIT_NOTFOUND;
+	}
+	errno = 0;
+	if (blkid_probe_set_device(pr, fd, ctl->offset, ctl->size)) {
+		if (errno)
+			warn(_("error: %s"), devname);
+		goto done;
+	}
+
+	if (ctl->lowprobe_topology)
+		rc = lowprobe_topology(pr);
+	if (rc >= 0 && ctl->lowprobe_superblocks)
+		rc = lowprobe_superblocks(pr, ctl);
+	if (rc < 0)
+		goto done;
+
+	if (!rc)
+		nvals = blkid_probe_numof_values(pr);
+
+	if (nvals && !first && ctl->output & (OUTPUT_UDEV_LIST | OUTPUT_EXPORT_LIST))
+		/* add extra line between output from devices */
+		fputc('\n', stdout);
+
+	if (nvals && (ctl->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;
+		if (ctl->show[0] && !has_item(ctl, name))
+			continue;
+		len = strnlen(data, len);
+		print_value(ctl, num++, devname, data, name, len);
+	}
+
+	if (first)
+		first = 0;
+
+	if (nvals >= 1 && !(ctl->output & (OUTPUT_VALUE_ONLY |
+					OUTPUT_UDEV_LIST | OUTPUT_EXPORT_LIST)))
+		printf("\n");
+done:
+	if (rc == -2) {
+		if (ctl->output & OUTPUT_UDEV_LIST)
+			print_udev_ambivalent(pr);
+		else
+			warnx(_("%s: ambivalent result (probably more "
+				"filesystems on the device, use wipefs(8) "
+				"to see more details)"),
+				devname);
+	}
+	close(fd);
+
+	if (rc == -2)
+		return BLKID_EXIT_AMBIVAL;	/* ambivalent probing result */
+	if (!nvals)
+		return BLKID_EXIT_NOTFOUND;	/* nothing detected */
+
+	return 0;		/* success */
+}
+
+/* converts comma separated list to BLKID_USAGE_* mask */
+static int list_to_usage(const char *list, int *flag)
+{
+	int mask = 0;
+	const char *word = NULL, *p = list;
+
+	if (p && strncmp(p, "no", 2) == 0) {
+		*flag = BLKID_FLTR_NOTIN;
+		p += 2;
+	}
+	if (!p || !*p)
+		goto err;
+	while(p) {
+		word = p;
+		p = strchr(p, ',');
+		if (p)
+			p++;
+		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
+			goto err;
+	}
+	return mask;
+err:
+	*flag = 0;
+	warnx(_("unknown keyword in -u <list> argument: '%s'"),
+			word ? word : list);
+	exit(BLKID_EXIT_OTHER);
+}
+
+/* converts comma separated list to types[] */
+static char **list_to_types(const char *list, int *flag)
+{
+	int i;
+	const char *p = list;
+	char **res = NULL;
+
+	if (p && strncmp(p, "no", 2) == 0) {
+		*flag = BLKID_FLTR_NOTIN;
+		p += 2;
+	}
+	if (!p || !*p) {
+		warnx(_("error: -u <list> argument is empty"));
+		goto err;
+	}
+	for (i = 1; p && (p = strchr(p, ',')); i++, p++);
+
+	res = xcalloc(i + 1, sizeof(char *));
+	p = *flag & BLKID_FLTR_NOTIN ? list + 2 : list;
+	i = 0;
+
+	while(p) {
+		const char *word = p;
+		p = strchr(p, ',');
+		res[i++] = p ? xstrndup(word, p - word) : xstrdup(word);
+		if (p)
+			p++;
+	}
+	res[i] = NULL;
+	return res;
+err:
+	*flag = 0;
+	free(res);
+	exit(BLKID_EXIT_OTHER);
+}
+
+static void free_types_list(char *list[])
+{
+	char **n;
+
+	if (!list)
+		return;
+	for (n = list; *n; n++)
+		free(*n);
+	free(list);
+}
+
+int main(int argc, char **argv)
+{
+	struct blkid_control ctl = { .output = OUTPUT_FULL, 0 };
+	blkid_cache cache = NULL;
+	char **devices = NULL;
+	char *search_type = NULL, *search_value = NULL;
+	char *read = NULL;
+	int fltr_usage = 0;
+	char **fltr_type = NULL;
+	int fltr_flag = BLKID_FLTR_ONLYIN;
+	unsigned int numdev = 0, numtag = 0;
+	int err = BLKID_EXIT_OTHER;
+	unsigned int i;
+	int c;
+
+	static const struct option longopts[] = {
+		{ "cache-file",	      required_argument, NULL, 'c' },
+		{ "no-encoding",      no_argument,	 NULL, 'd' },
+		{ "no-part-details",  no_argument,       NULL, 'D' },
+		{ "garbage-collect",  no_argument,	 NULL, 'g' },
+		{ "output",	      required_argument, NULL, 'o' },
+		{ "list-filesystems", no_argument,	 NULL, 'k' },
+		{ "match-tag",	      required_argument, NULL, 's' },
+		{ "match-token",      required_argument, NULL, 't' },
+		{ "list-one",	      no_argument,	 NULL, 'l' },
+		{ "label",	      required_argument, NULL, 'L' },
+		{ "uuid",	      required_argument, NULL, 'U' },
+		{ "probe",	      no_argument,	 NULL, 'p' },
+		{ "info",	      no_argument,	 NULL, 'i' },
+		{ "size",	      required_argument, NULL, 'S' },
+		{ "offset",	      required_argument, NULL, 'O' },
+		{ "usages",	      required_argument, NULL, 'u' },
+		{ "match-types",      required_argument, NULL, 'n' },
+		{ "version",	      no_argument,	 NULL, 'V' },
+		{ "help",	      no_argument,       NULL, 'h' },
+		{ NULL, 0, NULL, 0 }
+	};
+
+	static const ul_excl_t excl[] = {       /* rows and cols in ASCII order */
+		{ 'n','u' },
+		{ 0 }
+	};
+	int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	strutils_set_exitcode(BLKID_EXIT_OTHER);
+
+	while ((c = getopt_long (argc, argv,
+			    "c:DdghilL:n:ko:O:ps:S:t:u:U:w:Vv", longopts, NULL)) != -1) {
+
+		err_exclusive_options(c, NULL, excl, excl_st);
+
+		switch (c) {
+		case 'c':
+			read = optarg;
+			break;
+		case 'd':
+			ctl.raw_chars = 1;
+			break;
+		case 'D':
+			ctl.no_part_details = 1;
+			break;
+		case 'L':
+			ctl.eval = 1;
+			search_value = xstrdup(optarg);
+			search_type = xstrdup("LABEL");
+			break;
+		case 'n':
+			fltr_type = list_to_types(optarg, &fltr_flag);
+			break;
+		case 'u':
+			fltr_usage = list_to_usage(optarg, &fltr_flag);
+			break;
+		case 'U':
+			ctl.eval = 1;
+			search_value = xstrdup(optarg);
+			search_type = xstrdup("UUID");
+			break;
+		case 'i':
+			ctl.lowprobe_topology = 1;
+			break;
+		case 'l':
+			ctl.lookup = 1;
+			break;
+		case 'g':
+			ctl.gc = 1;
+			break;
+		case 'k':
+		{
+			size_t idx = 0;
+			const char *name = NULL;
+
+			while (blkid_superblocks_get_name(idx++, &name, NULL) == 0)
+				printf("%s\n", name);
+			exit(EXIT_SUCCESS);
+		}
+		case 'o':
+			if (!strcmp(optarg, "value"))
+				ctl.output = OUTPUT_VALUE_ONLY;
+			else if (!strcmp(optarg, "device"))
+				ctl.output = OUTPUT_DEVICE_ONLY;
+			else if (!strcmp(optarg, "list"))
+				ctl.output = OUTPUT_PRETTY_LIST;	/* deprecated */
+			else if (!strcmp(optarg, "udev"))
+				ctl.output = OUTPUT_UDEV_LIST;
+			else if (!strcmp(optarg, "export"))
+				ctl.output = OUTPUT_EXPORT_LIST;
+			else if (!strcmp(optarg, "full"))
+				ctl.output = 0;
+			else
+				errx(BLKID_EXIT_OTHER, _("unsupported output format %s"), optarg);
+			break;
+		case 'O':
+			ctl.offset = strtosize_or_err(optarg, _("invalid offset argument"));
+			break;
+		case 'p':
+			ctl.lowprobe_superblocks = 1;
+			break;
+		case 's':
+			if (numtag + 1 >= sizeof(ctl.show) / sizeof(*ctl.show)) {
+				warnx(_("Too many tags specified"));
+				errtryhelp(err);
+			}
+			ctl.show[numtag++] = optarg;
+			break;
+		case 'S':
+			ctl.size = strtosize_or_err(optarg, _("invalid size argument"));
+			break;
+		case 't':
+			if (search_type) {
+				warnx(_("Can only search for "
+					"one NAME=value pair"));
+				errtryhelp(err);
+			}
+			if (blkid_parse_tag_string(optarg,
+						   &search_type,
+						   &search_value)) {
+				warnx(_("-t needs NAME=value pair"));
+				errtryhelp(err);
+			}
+			break;
+		case 'V':
+		case 'v':
+			fprintf(stdout, _("%s from %s  (libblkid %s, %s)\n"),
+				program_invocation_short_name, PACKAGE_STRING,
+				LIBBLKID_VERSION, LIBBLKID_DATE);
+			err = 0;
+			goto exit;
+		case 'w':
+			/* ignore - backward compatibility */
+			break;
+		case 'h':
+			usage();
+			break;
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+
+	if (ctl.lowprobe_topology || ctl.lowprobe_superblocks)
+		ctl.lowprobe = 1;
+
+	/* The rest of the args are device names */
+	if (optind < argc) {
+		devices = xcalloc(argc - optind, sizeof(char *));
+		while (optind < argc)
+			devices[numdev++] = argv[optind++];
+	}
+
+	/* convert LABEL/UUID lookup to evaluate request */
+	if (ctl.lookup && ctl.output == OUTPUT_DEVICE_ONLY && search_type &&
+	    (!strcmp(search_type, "LABEL") || !strcmp(search_type, "UUID"))) {
+		ctl.eval = 1;
+		ctl.lookup = 0;
+	}
+
+	if (!ctl.lowprobe && !ctl.eval && blkid_get_cache(&cache, read) < 0)
+		goto exit;
+
+	if (ctl.gc) {
+		blkid_gc_cache(cache);
+		err = 0;
+		goto exit;
+	}
+	err = BLKID_EXIT_NOTFOUND;
+
+	if (ctl.eval == 0 && (ctl.output & OUTPUT_PRETTY_LIST)) {
+		if (ctl.lowprobe)
+			errx(BLKID_EXIT_OTHER,
+			     _("The low-level probing mode does not "
+			       "support 'list' output format"));
+		pretty_print_dev(NULL);
+	}
+
+	if (ctl.lowprobe) {
+		/*
+		 * Low-level API
+		 */
+		blkid_probe pr;
+
+		if (!numdev)
+			errx(BLKID_EXIT_OTHER,
+			     _("The low-level probing mode "
+			       "requires a device"));
+
+		/* automatically enable 'export' format for I/O Limits */
+		if (!ctl.output  && ctl.lowprobe_topology)
+			ctl.output = OUTPUT_EXPORT_LIST;
+
+		pr = blkid_new_probe();
+		if (!pr)
+			goto exit;
+
+		if (ctl.lowprobe_superblocks) {
+			blkid_probe_set_superblocks_flags(pr,
+				BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID |
+				BLKID_SUBLKS_TYPE | BLKID_SUBLKS_SECTYPE |
+				BLKID_SUBLKS_USAGE | BLKID_SUBLKS_VERSION);
+
+
+			if (fltr_usage &&
+			    blkid_probe_filter_superblocks_usage(pr, fltr_flag, fltr_usage))
+				goto exit;
+
+			else if (fltr_type &&
+				 blkid_probe_filter_superblocks_type(pr, fltr_flag, fltr_type))
+				goto exit;
+		}
+
+		for (i = 0; i < numdev; i++) {
+			err = lowprobe_device(pr, devices[i], &ctl);
+			if (err)
+				break;
+		}
+		blkid_free_probe(pr);
+	} else if (ctl.eval) {
+		/*
+		 * Evaluate API
+		 */
+		char *res = blkid_evaluate_tag(search_type, search_value, NULL);
+		if (res) {
+			err = 0;
+			printf("%s\n", res);
+		}
+	} else if (ctl.lookup) {
+		/*
+		 * Classic (cache based) API
+		 */
+		blkid_dev dev;
+
+		if (!search_type)
+			errx(BLKID_EXIT_OTHER,
+			     _("The lookup option requires a "
+			       "search type specified using -t"));
+		/* 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(&ctl, dev);
+			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(&ctl, dev);
+			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(&ctl, dev);
+			err = 0;
+		}
+	}
+
+exit:
+	free(search_type);
+	free(search_value);
+	free_types_list(fltr_type);
+	if (!ctl.lowprobe && !ctl.eval)
+		blkid_put_cache(cache);
+	free(devices);
+	return err;
+}
diff --git a/misc-utils/cal.1 b/misc-utils/cal.1
new file mode 100644
index 0000000..2115e9a
--- /dev/null
+++ b/misc-utils/cal.1
@@ -0,0 +1,233 @@
+.\" Copyright (c) 1989, 1990, 1993
+.\"	The Regents of the University of California.  All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Kim Letkeman.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. All advertising materials mentioning features or use of this software
+.\"    must display the following acknowledgement:
+.\"	This product includes software developed by the University of
+.\"	California, Berkeley and its contributors.
+.\" 4. Neither the name of the University nor the names of its contributors
+.\"    may be used to endorse or promote products derived from this software
+.\"    without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\"     @(#)cal.1	8.1 (Berkeley) 6/6/93
+.\"
+.TH CAL 1 "January 2018" "util-linux" "User Commands"
+.SH NAME
+cal \- display a calendar
+.SH SYNOPSIS
+.B cal
+[options]
+.RI [[[ day ] " month" ] " year" ]
+.br
+.B cal
+[options]
+.RI [ "timestamp" | "monthname" ]
+.SH DESCRIPTION
+.B cal
+displays a simple calendar.  If no arguments are specified, the current
+month is displayed.
+.sp
+The \fImonth\fR may be specified as a number (1-12), as a month name or as an
+abbreviated month name according to the current locales.
+.sp
+Two different calendar systems are used, Gregorian and Julian.  These are
+nearly identical systems with Gregorian making a small adjustment to the
+frequency of leap years; this facilitates improved synchronization with solar
+events like the equinoxes.  The Gregorian calendar reform was introduced in
+1582, but its adoption continued up to 1923.  By default
+.B cal
+uses the adoption date of 3 Sept 1752.  From that date forward the Gregorian
+calendar is displayed; previous dates use the Julian calendar system.  11 days
+were removed at the time of adoption to bring the calendar in sync with solar
+events.  So Sept 1752 has a mix of Julian and Gregorian dates by which the 2nd
+is followed by the 14th (the 3rd through the 13th are absent).
+.sp
+Optionally, either the proleptic Gregorian calendar or the Julian calendar may
+be used exclusively.
+.RB See\  \-\-reform\  below.
+.SH OPTIONS
+.TP
+\fB\-1\fR, \fB\-\-one\fR
+Display single month output.
+(This is the default.)
+.TP
+\fB\-3\fR, \fB\-\-three\fR
+Display three months spanning the date.
+.TP
+\fB\-n , \-\-months\fR \fInumber\fR
+Display \fInumber\fR of months, starting from the month containing the date.
+.TP
+\fB\-S, \fB\-\-span\fR
+Display months spanning the date.
+.TP
+\fB\-s\fR, \fB\-\-sunday\fR
+Display Sunday as the first day of the week.
+.TP
+\fB\-m\fR, \fB\-\-monday\fR
+Display Monday as the first day of the week.
+.TP
+\fB\-v\fR, \fB\-\-vertical\fR
+Display using a vertical layout (aka ncal mode).
+.TP
+.B \-\-iso
+Display the proleptic Gregorian calendar exclusively.  This option does not affect
+week numbers and the first day of the week.
+.RB See\  \-\-reform\  below.
+.TP
+\fB\-j\fR, \fB\-\-julian\fR
+Use day-of-year numbering for all calendars.  These are also called ordinal
+days.  Ordinal days range from 1 to 366.  This option does not switch from the
+Gregorian to the Julian calendar system, that is controlled by the
+.BR \-\-reform\  option.
+.sp
+Sometimes Gregorian calendars using ordinal dates are referred to as Julian
+calendars.  This can be confusing due to the many date related conventions that
+use Julian in their name: (ordinal) julian date, julian (calendar) date,
+(astronomical) julian date, (modified) julian date, and more.  This option is
+named julian, because ordinal days are identified as julian by the POSIX
+standard.  However, be aware that
+.B cal
+also uses the Julian calendar system.
+.RB See\  DESCRIPTION\  above.
+.TP
+.BI \-\-reform\  val
+This option sets the adoption date of the Gregorian calendar reform.  Calendar
+dates previous to reform use the Julian calendar system.  Calendar dates
+after reform use the Gregorian calendar system.  The argument
+.I val
+can be:
+.RS
+.IP \(bu 2
+.I 1752
+- sets 3 September 1752 as the reform date (default).
+This is when the Gregorian calendar reform was adopted by the British Empire.
+.IP \(bu 2
+.I gregorian
+- display Gregorian calendars exclusively.  This special placeholder sets the
+reform date below the smallest year that
+.B cal
+can use; meaning all calendar output uses the Gregorian calendar system.  This
+is called the proleptic Gregorian calendar, because dates prior to the calendar
+system's creation use extrapolated values.
+.IP \(bu 2
+.I iso
+- alias of
+.IR gregorian .
+The ISO 8601 standard for the representation of dates and times in information
+interchange requires using the proleptic Gregorian calendar.
+.IP \(bu 2
+.I julian
+- display Julian calendars exclusively.  This special placeholder sets the reform date above the largest year that
+.B cal
+can use; meaning all
+calendar output uses the Julian calendar system.
+.PP
+.RB See\  \%DESCRIPTION\  above.
+.RE
+.TP
+\fB\-y\fR, \fB\-\-year\fR
+Display a calendar for the whole year.
+.TP
+\fB\-Y, \fB\-\-twelve\fR
+Display a calendar for the next twelve months.
+.TP
+\fB\-w\fR, \fB\-\-week\fR[=\fInumber\fR]
+Display week numbers in the calendar (US or ISO-8601).  See NOTES section
+for more details.
+.TP
+\fB\-\-color\fR[=\fIwhen\fR]
+Colorize the output.  The optional argument \fIwhen\fP
+can be \fBauto\fR, \fBnever\fR or \fBalways\fR.  If the \fIwhen\fR argument is omitted,
+it defaults to \fBauto\fR.  The colors can be disabled; for the current built-in default
+see the \fB\-\-help\fR output.  See also the \fBCOLORS\fR section.
+.TP
+\fB\-V\fR, \fB\-\-version\fR
+Display version information and exit.
+.TP
+\fB\-h\fR, \fB\-\-help\fR
+Display help text and exit.
+.SH PARAMETERS
+.TP
+\fBSingle digits-only parameter (e.g., 'cal 2020')\fR
+Specifies the \fIyear\fR to be displayed; note the year must be fully specified:
+.B "cal 89"
+will not display a calendar for 1989.
+.TP
+\fBSingle string parameter (e.g., 'cal tomorrow' or 'cal August')\fR
+Specifies \fItimestamp\fR or a \fImonth name\fR (or abbreviated name) according to the current
+locales.
+.sp
+The special placeholders are accepted when parsing timestamp, "now" may be used
+to refer to the current time, "today", "yesterday", "tomorrow" refer to of the
+current day, the day before or the next day, respectively.
+.sp
+The relative date specifications are also accepted, in this case "+" is
+evaluated to the current time plus the specified time span. Correspondingly, a
+time span that is prefixed with "-" is evaluated to the current time minus the
+specified time span, for example '+2days'. Instead of prefixing the time span
+with "+" or "-", it may also be suffixed with a space and the word "left" or
+"ago" (for example '1 week ago').
+.TP
+\fBTwo parameters (e.g., 'cal 11 2020')\fR
+Denote the \fImonth\fR (1 - 12) and \fIyear\fR.
+.TP
+\fBThree parameters (e.g., 'cal 25 11 2020')\fR
+Denote the \fIday\fR (1-31), \fImonth and \fIyear\fR, and the day will be
+highlighted if the calendar is displayed on a terminal.  If no parameters are
+specified, the current month's calendar is displayed.
+.SH NOTES
+A year starts on January 1.  The first day of the week is determined by the
+locale or the
+.BR \-\-sunday \ and \ \-\-monday \ options.
+.PP
+The week numbering depends on the choice of the first day of the week.  If it
+is Sunday then the customary North American numbering is used, where 1 January
+is in week number 1.  If it is Monday (\fB\-m\fR) then the ISO 8601 standard week
+numbering is used, where the first Thursday is in week number 1.
+.SH COLORS
+Implicit coloring can be disabled as follows:
+.RS
+
+.B touch /etc/terminal-colors.d/cal.disable
+
+.RE
+See
+.BR terminal-colors.d (5)
+for more details about colorization configuration.
+.SH HISTORY
+A cal command appeared in Version 6 AT&T UNIX.
+.SH BUGS
+The default
+.B cal
+output uses 3 September 1752 as the Gregorian calendar reform date.  The
+historical reform  dates for the other locales, including its introduction in
+October 1582, are not implemented.
+.PP
+Alternative calendars, such as the Umm al-Qura, the Solar Hijri, the Ge'ez,
+or the lunisolar Hindu, are not supported.
+.SH AVAILABILITY
+The cal command is part of the util-linux package and is available from
+https://www.kernel.org/pub/linux/utils/util-linux/.
diff --git a/misc-utils/cal.c b/misc-utils/cal.c
new file mode 100644
index 0000000..0834be2
--- /dev/null
+++ b/misc-utils/cal.c
@@ -0,0 +1,1314 @@
+/*
+ * Copyright (c) 1989, 1993, 1994
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Kim Letkeman.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* 1999-02-01	Jean-Francois Bignolles: added option '-m' to display
+ *		monday as the first day of the week.
+ * 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
+ * - added Native Language Support
+ *
+ * 2000-09-01  Michael Charles Pruznick <dummy@netwiz.net>
+ *             Added "-3" option to print prev/next month with current.
+ *             Added overridable default MONTHS_IN_ROW and "-1" option to
+ *             get traditional output when -3 is the default.  I hope that
+ *             enough people will like -3 as the default that one day the
+ *             product can be shipped that way.
+ *
+ * 2001-05-07  Pablo Saratxaga <pablo@mandrakesoft.com>
+ *             Fixed the bugs with multi-byte charset (zg: cjk, utf-8)
+ *             displaying. made the 'month year' ("%s %d") header translatable
+ *             so it can be adapted to conventions used by different languages
+ *             added support to read "first_weekday" locale information
+ *             still to do: support for 'cal_direction' (will require a major
+ *             rewrite of the displaying) and proper handling of RTL scripts
+ */
+
+#include <sys/types.h>
+
+#include <ctype.h>
+#include <getopt.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include "c.h"
+#include "closestream.h"
+#include "colors.h"
+#include "nls.h"
+#include "mbsalign.h"
+#include "strutils.h"
+#include "optutils.h"
+#include "timeutils.h"
+#include "ttyutils.h"
+
+#define DOY_MONTH_WIDTH	27	/* -j month width */
+#define DOM_MONTH_WIDTH	20	/* month width */
+
+static int has_term = 0;
+static const char *Senter = "", *Sexit = "";	/* enter and exit standout mode */
+
+#if defined(HAVE_LIBNCURSES) || defined(HAVE_LIBNCURSESW)
+# if defined(HAVE_NCURSESW_TERM_H)
+#  include <ncursesw/term.h>
+# elif defined(HAVE_NCURSES_TERM_H)
+#  include <ncurses/term.h>
+# elif defined(HAVE_TERM_H)
+#  include <term.h>
+# endif
+#endif
+
+static int setup_terminal(char *term
+#if !defined(HAVE_LIBNCURSES) && !defined(HAVE_LIBNCURSESW)
+			__attribute__((__unused__))
+#endif
+		)
+{
+#if defined(HAVE_LIBNCURSES) || defined(HAVE_LIBNCURSESW)
+	int ret;
+
+	if (setupterm(term, STDOUT_FILENO, &ret) != 0 || ret != 1)
+		return -1;
+#endif
+	return 0;
+}
+
+static void my_putstring(const char *s)
+{
+#if defined(HAVE_LIBNCURSES) || defined(HAVE_LIBNCURSESW)
+	if (has_term)
+		putp(s);
+	else
+#endif
+		fputs(s, stdout);
+}
+
+static const char *my_tgetstr(char *ss
+#if !defined(HAVE_LIBNCURSES) && !defined(HAVE_LIBNCURSESW)
+			__attribute__((__unused__))
+#endif
+		)
+{
+	const char *ret = NULL;
+
+#if defined(HAVE_LIBNCURSES) || defined(HAVE_LIBNCURSESW)
+	if (has_term)
+		ret = tigetstr(ss);
+#endif
+	if (!ret || ret == (char *)-1)
+		return "";
+	return ret;
+}
+
+#include "widechar.h"
+
+enum {
+	GREGORIAN		= INT32_MIN,
+	ISO			= INT32_MIN,
+	GB1752			= 1752,
+	DEFAULT_REFORM_YEAR	= 1752,
+	JULIAN			= INT32_MAX
+};
+
+enum {
+	SUNDAY = 0,
+	MONDAY,
+	TUESDAY,
+	WEDNESDAY,
+	THURSDAY,
+	FRIDAY,
+	SATURDAY,
+	DAYS_IN_WEEK,
+	NONEDAY
+};
+
+enum {
+	JANUARY = 1,
+	FEBRUARY,
+	MARCH,
+	APRIL,
+	MAY,
+	JUNE,
+	JULY,
+	AUGUST,
+	SEPTEMBER,
+	OCTOBER,
+	NOVEMBER,
+	DECEMBER
+};
+
+#define REFORMATION_MONTH	SEPTEMBER
+#define	NUMBER_MISSING_DAYS	11		/* 11 day correction */
+#define YDAY_AFTER_MISSING	258             /* 14th in Sep 1752 */
+
+#define MONTHS_IN_YEAR		DECEMBER
+#define DAYS_IN_MONTH		31
+#define	MAXDAYS			42		/* slots in a month array */
+#define	SPACE			-1		/* used in day array */
+
+#define SMALLEST_YEAR		1
+
+#define	DAY_LEN			3		/* 3 spaces per day */
+#define	WEEK_LEN		(DAYS_IN_WEEK * DAY_LEN)
+#define MONTHS_IN_YEAR_ROW	3		/* month columns in year view */
+#define WNUM_LEN                3
+
+#define FMT_ST_CHARS 300	/* 90 suffices in most locales */
+
+static const int days_in_month[2][13] = {
+	{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
+	{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
+};
+
+enum {
+	WEEK_NUM_DISABLED = 0,
+	WEEK_NUM_MASK=0xff,
+	WEEK_NUM_ISO=0x100,
+	WEEK_NUM_US=0x200,
+};
+
+/* utf-8 can have up to 6 bytes per char; and an extra byte for ending \0 */
+static char day_headings[(WEEK_LEN + 1) * 6 + 1];
+
+struct cal_request {
+	int day;
+	int month;
+	int32_t year;
+	int week;
+	int start_month;
+};
+
+struct cal_control {
+	const char *full_month[MONTHS_IN_YEAR];	/* month names */
+	const char *abbr_month[MONTHS_IN_YEAR];	/* abbreviated month names */
+	const char *weekdays[DAYS_IN_WEEK];     /* day names */
+
+	int reform_year;		/* Gregorian reform year */
+	int colormode;			/* day and week number highlight */
+	int num_months;			/* number of requested months */
+	int span_months;		/* span the date */
+	int months_in_row;		/* number of months horizontally in print out */
+	int weekstart;			/* day the week starts, often Sun or Mon */
+	int weektype;			/* WEEK_TYPE_{NONE,ISO,US} */
+	size_t day_width;		/* day width in characters in printout */
+	size_t week_width;		/* 7 * day_width + possible week num */
+	size_t month_width;		/* width of a month (vertical mode) */
+	int gutter_width;		/* spaces in between horizontal month outputs */
+	struct cal_request req;		/* the times user is interested */
+	unsigned int	julian:1,	/* julian output */
+			header_year:1,	/* print year number */
+			header_hint:1,	/* does month name + year need two lines to fit */
+			vertical:1;	/* display the output in vertical */
+};
+
+struct cal_month {
+	int days[MAXDAYS];		/* the day numbers, or SPACE */
+	int weeks[MAXDAYS / DAYS_IN_WEEK];
+	int month;
+	int32_t year;
+	struct cal_month *next;
+};
+/* function prototypes */
+static int leap_year(const struct cal_control *ctl, int32_t year);
+static int monthname_to_number(struct cal_control *ctl, const char *name);
+static void weekdays_init(struct cal_control *ctl);
+static void headers_init(struct cal_control *ctl);
+static void cal_fill_month(struct cal_month *month, const struct cal_control *ctl);
+static void cal_output_header(struct cal_month *month, const struct cal_control *ctl);
+static void cal_output_months(struct cal_month *month, const struct cal_control *ctl);
+static void cal_vert_output_months(struct cal_month *month, const struct cal_control *ctl);
+static void monthly(const struct cal_control *ctl);
+static void yearly(const struct cal_control *ctl);
+static int day_in_year(const struct cal_control *ctl, int day,
+		       int month, int32_t year);
+static int day_in_week(const struct cal_control *ctl, int day,
+		       int month, int32_t year);
+static int week_number(int day, int month, int32_t year, const struct cal_control *ctl);
+static int week_to_day(const struct cal_control *ctl);
+static int center_str(const char *src, char *dest, size_t dest_size, size_t width);
+static void center(const char *str, size_t len, int separate);
+static int left_str(const char *src, char *dest, size_t dest_size, size_t width);
+static void left(const char *str, size_t len, int separate);
+static int parse_reform_year(const char *reform_year);
+static void __attribute__((__noreturn__)) usage(void);
+
+#ifdef TEST_CAL
+static time_t cal_time(time_t *t)
+{
+	char *str = getenv("CAL_TEST_TIME");
+
+	if (str) {
+		uint64_t x = strtou64_or_err(str, "failed to parse CAL_TEST_TIME");
+
+		*t = x;
+		return *t;
+	}
+
+	return time(t);
+}
+#else
+# define cal_time(t)	time(t)
+#endif
+
+int main(int argc, char **argv)
+{
+	struct tm local_time;
+	char *term;
+	time_t now;
+	int ch = 0, yflag = 0, Yflag = 0;
+
+	static struct cal_control ctl = {
+		.reform_year = DEFAULT_REFORM_YEAR,
+		.weekstart = SUNDAY,
+		.span_months = 0,
+		.colormode = UL_COLORMODE_UNDEF,
+		.weektype = WEEK_NUM_DISABLED,
+		.day_width = DAY_LEN,
+		.gutter_width = 2,
+		.req.day = 0,
+		.req.month = 0
+	};
+
+	enum {
+		OPT_COLOR = CHAR_MAX + 1,
+		OPT_ISO,
+		OPT_REFORM
+	};
+
+	static const struct option longopts[] = {
+		{"one", no_argument, NULL, '1'},
+		{"three", no_argument, NULL, '3'},
+		{"sunday", no_argument, NULL, 's'},
+		{"monday", no_argument, NULL, 'm'},
+		{"julian", no_argument, NULL, 'j'},
+		{"months", required_argument, NULL, 'n'},
+		{"span", no_argument, NULL, 'S'},
+		{"year", no_argument, NULL, 'y'},
+		{"week", optional_argument, NULL, 'w'},
+		{"color", optional_argument, NULL, OPT_COLOR},
+		{"reform", required_argument, NULL, OPT_REFORM},
+		{"iso", no_argument, NULL, OPT_ISO},
+		{"version", no_argument, NULL, 'V'},
+		{"twelve", no_argument, NULL, 'Y'},
+		{"help", no_argument, NULL, 'h'},
+		{"vertical", no_argument, NULL,'v'},
+		{NULL, 0, NULL, 0}
+	};
+
+	static const ul_excl_t excl[] = {       /* rows and cols in ASCII order */
+		{ 'Y','n','y' },
+		{ 0 }
+	};
+	int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	term = getenv("TERM");
+	if (term) {
+		has_term = setup_terminal(term) == 0;
+		if (has_term) {
+			Senter = my_tgetstr("smso");
+			Sexit = my_tgetstr("rmso");
+		}
+	}
+
+/*
+ * The traditional Unix cal utility starts the week at Sunday,
+ * while ISO 8601 starts at Monday. We read the start day from
+ * the locale database, which can be overridden with the
+ * -s (Sunday) or -m (Monday) options.
+ */
+#if HAVE_DECL__NL_TIME_WEEK_1STDAY
+	/*
+	 * You need to use 2 locale variables to get the first day of the week.
+	 * This is needed to support first_weekday=2 and first_workday=1 for
+	 * the rare case where working days span across 2 weeks.
+	 * This shell script shows the combinations and calculations involved:
+	 *
+	 * for LANG in en_US ru_RU fr_FR csb_PL POSIX; do
+	 *   printf "%s:\t%s + %s -1 = " $LANG $(locale week-1stday first_weekday)
+	 *   date -d"$(locale week-1stday) +$(($(locale first_weekday)-1))day" +%w
+	 * done
+	 *
+	 * en_US:  19971130 + 1 -1 = 0  #0 = sunday
+	 * ru_RU:  19971130 + 2 -1 = 1
+	 * fr_FR:  19971201 + 1 -1 = 1
+	 * csb_PL: 19971201 + 2 -1 = 2
+	 * POSIX:  19971201 + 7 -1 = 0
+	 */
+	{
+		int wfd;
+		union { unsigned int word; char *string; } val;
+		val.string = nl_langinfo(_NL_TIME_WEEK_1STDAY);
+
+		wfd = val.word;
+		wfd = day_in_week(&ctl, wfd % 100, (wfd / 100) % 100,
+				  wfd / (100 * 100));
+		ctl.weekstart = (wfd + *nl_langinfo(_NL_TIME_FIRST_WEEKDAY) - 1) % DAYS_IN_WEEK;
+	}
+#endif
+	while ((ch = getopt_long(argc, argv, "13mjn:sSywYvVh", longopts, NULL)) != -1) {
+
+		err_exclusive_options(ch, longopts, excl, excl_st);
+
+		switch(ch) {
+		case '1':
+			ctl.num_months = 1;
+			break;
+		case '3':
+			ctl.num_months = 3;
+			ctl.span_months = 1;
+			break;
+		case 's':
+			ctl.weekstart = SUNDAY;		/* default */
+			break;
+		case 'm':
+			ctl.weekstart = MONDAY;
+			break;
+		case 'j':
+			ctl.julian = 1;
+			ctl.day_width = DAY_LEN + 1;
+			break;
+		case 'y':
+			yflag = 1;
+			break;
+		case 'Y':
+			Yflag = 1;
+			break;
+		case 'n':
+			ctl.num_months = strtou32_or_err(optarg,
+						_("invalid month argument"));
+			break;
+		case 'S':
+			ctl.span_months = 1;
+			break;
+		case 'w':
+			if (optarg) {
+				ctl.req.week = strtos32_or_err(optarg,
+						_("invalid week argument"));
+				if (ctl.req.week < 1 || 54 < ctl.req.week)
+					errx(EXIT_FAILURE,_("illegal week value: use 1-54"));
+			}
+			ctl.weektype = WEEK_NUM_US;	/* default per weekstart */
+			break;
+		case OPT_COLOR:
+			ctl.colormode = UL_COLORMODE_AUTO;
+			if (optarg)
+				ctl.colormode = colormode_or_err(optarg,
+						_("unsupported color mode"));
+			break;
+		case OPT_REFORM:
+			ctl.reform_year = parse_reform_year(optarg);
+			break;
+		case OPT_ISO:
+			ctl.reform_year = ISO;
+			break;
+		case 'v':
+			ctl.vertical = 1;
+			break;
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		case 'h':
+			usage();
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+
+	argc -= optind;
+	argv += optind;
+
+	if (ctl.weektype) {
+		ctl.weektype = ctl.req.week & WEEK_NUM_MASK;
+		ctl.weektype |= (ctl.weekstart == MONDAY ? WEEK_NUM_ISO : WEEK_NUM_US);
+		ctl.week_width = (ctl.day_width * DAYS_IN_WEEK) + WNUM_LEN;
+	} else
+		ctl.week_width = ctl.day_width * DAYS_IN_WEEK;
+	/*
+	 * The day_width includes the space between days,
+	 * as there is no leading space, remove 1
+	 * */
+	ctl.week_width -= 1;
+
+	if (argc == 1 && !isdigit_string(*argv)) {
+		usec_t x;
+		/* cal <timestamp> */
+		if (parse_timestamp(*argv, &x) == 0)
+			now = (time_t) (x / 1000000);
+		/* cal <monthname> */
+		else if ((ctl.req.month = monthname_to_number(&ctl, *argv)) > 0)
+			cal_time(&now);	/* this year */
+		else
+			errx(EXIT_FAILURE, _("failed to parse timestamp or unknown month name: %s"), *argv);
+		argc = 0;
+	} else
+		cal_time(&now);
+
+	localtime_r(&now, &local_time);
+
+	switch(argc) {
+	case 3:
+		ctl.req.day = strtos32_or_err(*argv++, _("illegal day value"));
+		if (ctl.req.day < 1 || DAYS_IN_MONTH < ctl.req.day)
+			errx(EXIT_FAILURE, _("illegal day value: use 1-%d"), DAYS_IN_MONTH);
+		/* fallthrough */
+	case 2:
+		if (isdigit(**argv))
+			ctl.req.month = strtos32_or_err(*argv++, _("illegal month value: use 1-12"));
+		else {
+			ctl.req.month = monthname_to_number(&ctl, *argv);
+			if (ctl.req.month < 0)
+				errx(EXIT_FAILURE, _("unknown month name: %s"), *argv);
+			argv++;
+		}
+		if (ctl.req.month < 1 || MONTHS_IN_YEAR < ctl.req.month)
+			errx(EXIT_FAILURE, _("illegal month value: use 1-12"));
+		/* fallthrough */
+	case 1:
+		ctl.req.year = strtos32_or_err(*argv++, _("illegal year value"));
+		if (ctl.req.year < SMALLEST_YEAR)
+			errx(EXIT_FAILURE, _("illegal year value: use positive integer"));
+		if (ctl.req.year == JULIAN)
+			errx(EXIT_FAILURE, _("illegal year value"));
+		if (ctl.req.day) {
+			int dm = days_in_month[leap_year(&ctl, ctl.req.year)]
+					      [ctl.req.month];
+			if (ctl.req.day > dm)
+				errx(EXIT_FAILURE, _("illegal day value: use 1-%d"), dm);
+			ctl.req.day = day_in_year(&ctl, ctl.req.day,
+						  ctl.req.month, ctl.req.year);
+		} else if ((int32_t) (local_time.tm_year + 1900) == ctl.req.year) {
+			ctl.req.day = local_time.tm_yday + 1;
+		}
+		if (!ctl.req.month && !ctl.req.week) {
+			ctl.req.month = local_time.tm_mon + 1;
+			if (!ctl.num_months)
+				yflag = 1;
+		}
+		break;
+	case 0:
+		ctl.req.day = local_time.tm_yday + 1;
+		ctl.req.year = local_time.tm_year + 1900;
+		if (!ctl.req.month)
+			ctl.req.month = local_time.tm_mon + 1;
+		break;
+	default:
+		warnx(_("bad usage"));
+		errtryhelp(EXIT_FAILURE);
+	}
+
+	if (0 < ctl.req.week) {
+		int yday = week_to_day(&ctl);
+		int leap = leap_year(&ctl, ctl.req.year);
+		int m = 1;
+
+		if (yday < 1)
+			errx(EXIT_FAILURE, _("illegal week value: year %d "
+					     "doesn't have week %d"),
+					ctl.req.year, ctl.req.week);
+		while (m <= DECEMBER && yday > days_in_month[leap][m])
+			yday -= days_in_month[leap][m++];
+		if (DECEMBER < m && ctl.weektype & WEEK_NUM_ISO) {
+			/* In some years (e.g. 2010 in ISO mode) it's possible
+			 * to have a remnant of week 53 starting the year yet
+			 * the year in question ends during 52, in this case
+			 * we're assuming that early remnant is being referred
+			 * to if 53 is given as argument. */
+			if (ctl.req.week != week_number(31, DECEMBER, ctl.req.year - 1, &ctl))
+				errx(EXIT_FAILURE,
+					_("illegal week value: year %d "
+					  "doesn't have week %d"),
+					ctl.req.year, ctl.req.week);
+		}
+		if (!ctl.req.month)
+			ctl.req.month = MONTHS_IN_YEAR < m ? 1 : m;
+	}
+
+	weekdays_init(&ctl);
+	headers_init(&ctl);
+
+	if (colors_init(ctl.colormode, "cal") == 0) {
+		/*
+		 * If standout mode available (Senter and Sexit are set) and
+		 * user or terminal-colors.d do not disable colors than
+		 * ignore colors_init().
+		 */
+		if (*Senter && *Sexit && colors_mode() != UL_COLORMODE_NEVER) {
+			/* let use standout mode */
+			;
+		} else {
+			/* disable */
+			Senter = ""; Sexit = "";
+			ctl.req.day = 0;
+			ctl.weektype &= ~WEEK_NUM_MASK;
+		}
+	}
+
+	if (yflag || Yflag) {
+		ctl.gutter_width = 3;
+		if (!ctl.num_months)
+			ctl.num_months = MONTHS_IN_YEAR;
+		if (yflag) {
+			ctl.req.start_month = 1;	/* start from Jan */
+			ctl.header_year = 1;		/* print year number */
+		}
+	}
+
+	if (ctl.vertical)
+		ctl.gutter_width = 1;
+
+	if (ctl.num_months > 1 && ctl.months_in_row == 0) {
+		ctl.months_in_row = MONTHS_IN_YEAR_ROW;		/* default */
+
+		if (isatty(STDOUT_FILENO)) {
+			int w, mw, extra, new_n;
+
+			w = get_terminal_width(80);
+			mw = ctl.julian ? DOY_MONTH_WIDTH : DOM_MONTH_WIDTH;
+
+			if (w < mw)
+				w = mw;
+
+			extra = ((w / mw) - 1) * ctl.gutter_width;
+			new_n = (w - extra) / mw;
+
+			if (new_n < MONTHS_IN_YEAR_ROW)
+				ctl.months_in_row = new_n > 0 ? new_n : 1;
+		}
+	} else if (!ctl.months_in_row)
+		ctl.months_in_row = 1;
+
+	if (!ctl.num_months)
+		ctl.num_months = 1;		/* display at least one month */
+
+	if (yflag || Yflag)
+		yearly(&ctl);
+	else
+		monthly(&ctl);
+
+	return EXIT_SUCCESS;
+}
+
+/* leap year -- account for gregorian reformation in 1752 */
+static int leap_year(const struct cal_control *ctl, int32_t year)
+{
+	if (year <= ctl->reform_year)
+		return !(year % 4);
+
+	return ( !(year % 4) && (year % 100) ) || !(year % 400);
+}
+
+static void init_monthnames(struct cal_control *ctl)
+{
+	size_t i;
+
+	if (ctl->full_month[0] != NULL)
+		return;		/* already initialized */
+
+	for (i = 0; i < MONTHS_IN_YEAR; i++)
+		ctl->full_month[i] = nl_langinfo(ALTMON_1 + i);
+}
+
+static void init_abbr_monthnames(struct cal_control *ctl)
+{
+	size_t i;
+
+	if (ctl->abbr_month[0] != NULL)
+		return;		/* already initialized */
+
+	for (i = 0; i < MONTHS_IN_YEAR; i++)
+		ctl->abbr_month[i] = nl_langinfo(_NL_ABALTMON_1 + i);
+}
+
+static int monthname_to_number(struct cal_control *ctl, const char *name)
+{
+	size_t i;
+
+	init_monthnames(ctl);
+	for (i = 0; i < MONTHS_IN_YEAR; i++)
+		if (strcasecmp(ctl->full_month[i], name) == 0)
+			return i + 1;
+
+	init_abbr_monthnames(ctl);
+	for (i = 0; i < MONTHS_IN_YEAR; i++)
+		if (strcasecmp(ctl->abbr_month[i], name) == 0)
+			return i + 1;
+
+	return -EINVAL;
+}
+
+static void weekdays_init(struct cal_control *ctl)
+{
+	size_t wd;
+	for (int i = 0; i < DAYS_IN_WEEK; i++) {
+		wd = (i + ctl->weekstart) % DAYS_IN_WEEK;
+		ctl->weekdays[i] = nl_langinfo(ABDAY_1 + wd);
+	}
+}
+static void headers_init(struct cal_control *ctl)
+{
+	size_t i;
+	char *cur_dh = day_headings;
+	char tmp[FMT_ST_CHARS];
+	int year_len;
+
+	year_len = snprintf(tmp, sizeof(tmp), "%04d", ctl->req.year);
+
+	if (year_len < 0 || (size_t)year_len >= sizeof(tmp)) {
+		/* XXX impossible error */
+		return;
+	}
+
+	for (i = 0; i < DAYS_IN_WEEK; i++) {
+		size_t space_left;
+
+		if (i)
+			strcat(cur_dh++, " ");
+		space_left = sizeof(day_headings) - (cur_dh - day_headings);
+
+		if (space_left <= (ctl->day_width - 1))
+			break;
+		cur_dh += center_str(ctl->weekdays[i], cur_dh,
+				     space_left, ctl->day_width - 1);
+	}
+
+	init_monthnames(ctl);
+
+	for (i = 0; i < MONTHS_IN_YEAR; i++) {
+		/* The +1 after year_len is space in between month and year. */
+		if (ctl->week_width < strlen(ctl->full_month[i]) + year_len)
+			ctl->header_hint = 1;
+	}
+}
+
+static void cal_fill_month(struct cal_month *month, const struct cal_control *ctl)
+{
+	int first_week_day = day_in_week(ctl, 1, month->month, month->year);
+	int month_days;
+	int i, j, weeklines = 0;
+
+	if (ctl->julian)
+		j = day_in_year(ctl, 1, month->month, month->year);
+	else
+		j = 1;
+	month_days = j + days_in_month[leap_year(ctl, month->year)][month->month];
+
+	/* True when Sunday is not first day in the output week. */
+	if (ctl->weekstart) {
+		first_week_day -= ctl->weekstart;
+		if (first_week_day < 0)
+			first_week_day = DAYS_IN_WEEK - ctl->weekstart;
+		month_days += ctl->weekstart - 1;
+	}
+
+	/* Fill day array. */
+	for (i = 0; i < MAXDAYS; i++) {
+		if (0 < first_week_day) {
+			month->days[i] = SPACE;
+			first_week_day--;
+			continue;
+		}
+		if (j < month_days) {
+			if (month->year == ctl->reform_year &&
+			    month->month == REFORMATION_MONTH &&
+			    (j == 3 || j == 247))
+				j += NUMBER_MISSING_DAYS;
+			month->days[i] = j;
+			j++;
+			continue;
+		}
+		month->days[i] = SPACE;
+		weeklines++;
+	}
+
+	/* Add week numbers */
+	if (ctl->weektype) {
+		int weeknum = week_number(1, month->month, month->year, ctl);
+		weeklines = MAXDAYS / DAYS_IN_WEEK - weeklines / DAYS_IN_WEEK;
+		for (i = 0; i < MAXDAYS / DAYS_IN_WEEK; i++) {
+			if (0 < weeklines) {
+				if (52 < weeknum)
+					weeknum = week_number(month->days[i * DAYS_IN_WEEK], month->month, month->year, ctl);
+				month->weeks[i] = weeknum++;
+			} else
+				month->weeks[i] = SPACE;
+			weeklines--;
+		}
+	}
+}
+
+static void cal_output_header(struct cal_month *month, const struct cal_control *ctl)
+{
+	char out[FMT_ST_CHARS];
+	struct cal_month *i;
+
+	if (ctl->header_hint || ctl->header_year) {
+		for (i = month; i; i = i->next) {
+			snprintf(out, sizeof(out), "%s", ctl->full_month[i->month - 1]);
+			center(out, ctl->week_width, i->next == NULL ? 0 : ctl->gutter_width);
+		}
+		if (!ctl->header_year) {
+			my_putstring("\n");
+			for (i = month; i; i = i->next) {
+				snprintf(out, sizeof(out), "%04d", i->year);
+				center(out, ctl->week_width, i->next == NULL ? 0 : ctl->gutter_width);
+			}
+		}
+	} else {
+		for (i = month; i; i = i->next) {
+			snprintf(out, sizeof(out), "%s %04d", ctl->full_month[i->month - 1], i->year);
+			center(out, ctl->week_width, i->next == NULL ? 0 : ctl->gutter_width);
+		}
+	}
+	my_putstring("\n");
+	for (i = month; i; i = i->next) {
+		if (ctl->weektype) {
+			if (ctl->julian)
+				snprintf(out, sizeof(out), "%*s%s", (int)ctl->day_width - 1, "", day_headings);
+			else
+				snprintf(out, sizeof(out), "%*s%s", (int)ctl->day_width, "", day_headings);
+			my_putstring(out);
+		} else
+			my_putstring(day_headings);
+		if (i->next != NULL) {
+			snprintf(out, sizeof(out), "%*s", ctl->gutter_width, "");
+			my_putstring(out);
+		}
+	}
+	my_putstring("\n");
+}
+
+static void cal_vert_output_header(struct cal_month *month,
+				  const struct cal_control *ctl)
+{
+	char out[FMT_ST_CHARS];
+	struct cal_month *m;
+	int month_width;
+
+	month_width = ctl->day_width * (MAXDAYS / DAYS_IN_WEEK);
+	/* Padding for the weekdays */
+	snprintf(out, sizeof(out), "%*s", (int)ctl->day_width + 1, "");
+	my_putstring(out);
+	if (ctl->header_hint || ctl->header_year) {
+		for (m = month; m; m = m->next) {
+			snprintf(out, sizeof(out), "%s", ctl->full_month[m->month - 1]);
+			left(out, month_width, ctl->gutter_width);
+		}
+		if (!ctl->header_year) {
+			my_putstring("\n");
+			/* Padding for the weekdays */
+			snprintf(out, sizeof(out), "%*s", (int)ctl->day_width + 1, "");
+			my_putstring(out);
+			for (m = month; m; m = m->next) {
+				snprintf(out, sizeof(out), "%04d", m->year);
+				left(out, month_width, ctl->gutter_width);
+			}
+		}
+	} else {
+		for (m = month; m; m = m->next) {
+			snprintf(out, sizeof(out), "%s %04d", ctl->full_month[m->month - 1], m->year);
+			left(out, month_width, ctl->gutter_width);
+		}
+	}
+	my_putstring("\n");
+}
+
+static void cal_output_months(struct cal_month *month, const struct cal_control *ctl)
+{
+	char out[FMT_ST_CHARS];
+	int reqday, week_line, d;
+	int skip;
+	struct cal_month *i;
+
+	for (week_line = 0; week_line < MAXDAYS / DAYS_IN_WEEK; week_line++) {
+		for (i = month; i; i = i->next) {
+			/* Determine the day that should be highlighted. */
+			reqday = 0;
+			if (i->month == ctl->req.month && i->year == ctl->req.year) {
+				if (ctl->julian)
+					reqday = ctl->req.day;
+				else
+					reqday = ctl->req.day + 1 -
+						 day_in_year(ctl, 1, i->month,
+							     i->year);
+			}
+
+			if (ctl->weektype) {
+				if (0 < i->weeks[week_line]) {
+					if ((ctl->weektype & WEEK_NUM_MASK) ==
+					    i->weeks[week_line])
+						snprintf(out, sizeof(out), "%s%2d%s",
+								Senter, i->weeks[week_line],
+								Sexit);
+					else
+						snprintf(out, sizeof(out), "%2d", i->weeks[week_line]);
+				} else
+					snprintf(out, sizeof(out), "%2s", "");
+				my_putstring(out);
+				skip = ctl->day_width;
+			} else
+				/* First day of the week is one char narrower than the other days,
+				 * unless week number is printed.  */
+				skip = ctl->day_width - 1;
+
+			for (d = DAYS_IN_WEEK * week_line;
+			     d < DAYS_IN_WEEK * week_line + DAYS_IN_WEEK; d++) {
+				if (0 < i->days[d]) {
+					if (reqday == i->days[d])
+						snprintf(out, sizeof(out), "%*s%s%*d%s",
+						       skip - (ctl->julian ? 3 : 2),
+						       "", Senter, (ctl->julian ? 3 : 2),
+						       i->days[d], Sexit);
+					else
+						snprintf(out, sizeof(out), "%*d", skip, i->days[d]);
+				} else
+					snprintf(out, sizeof(out), "%*s", skip, "");
+				my_putstring(out);
+				if (skip < (int)ctl->day_width)
+					skip++;
+			}
+			if (i->next != NULL) {
+				snprintf(out, sizeof(out), "%*s", ctl->gutter_width, "");
+				my_putstring(out);
+			}
+		}
+		if (i == NULL)
+			my_putstring("\n");
+	}
+}
+
+static void
+cal_vert_output_months(struct cal_month *month, const struct cal_control *ctl)
+{
+	char out[FMT_ST_CHARS];
+	int i, reqday, week, d;
+	int skip;
+	struct cal_month *m;
+
+	skip = ctl->day_width;
+	for (i = 0; i < DAYS_IN_WEEK; i++) {
+		left(ctl->weekdays[i], ctl->day_width - 1, 0);
+		for (m = month; m; m = m->next) {
+			reqday = 0;
+			if (m->month == ctl->req.month && m->year == ctl->req.year) {
+				if (ctl->julian) {
+					reqday = ctl->req.day;
+				} else {
+					reqday = ctl->req.day + 1 -
+						 day_in_year(ctl, 1, m->month, m->year);
+				}
+			}
+			for (week = 0; week < MAXDAYS / DAYS_IN_WEEK; week++) {
+				d = i + DAYS_IN_WEEK * week;
+				if (0 < m->days[d]) {
+					if (reqday == m->days[d]) {
+						snprintf(out, sizeof(out), "%*s%s%*d%s",
+						       skip - (ctl->julian ? 3 : 2),
+						       "", Senter, (ctl->julian ? 3 : 2),
+						       m->days[d], Sexit);
+					} else {
+						snprintf(out, sizeof(out), "%*d",
+							 skip, m->days[d]);
+					}
+				} else {
+					snprintf(out, sizeof(out), "%*s",
+						 skip, "");
+				}
+				my_putstring(out);
+				skip = ctl->day_width;
+			}
+			if (m->next != NULL) {
+				snprintf(out, sizeof(out), "%*s", ctl->gutter_width, "");
+				my_putstring(out);
+			}
+		}
+		my_putstring("\n");
+	}
+	if (!ctl->weektype)
+		return;
+
+	snprintf(out, sizeof(out), "%*s", (int)ctl->day_width - 1, "");
+	my_putstring(out);
+	for (m = month; m; m = m->next) {
+		for (week = 0; week < MAXDAYS / DAYS_IN_WEEK; week++) {
+			if (0 < m->weeks[week]) {
+				if ((ctl->weektype & WEEK_NUM_MASK) ==
+				    m->weeks[week])
+				{
+					snprintf(out, sizeof(out), "%s%*d%s",
+						 Senter,
+						 skip - (ctl->julian ? 3 : 2),
+						 m->weeks[week], Sexit);
+				} else {
+					snprintf(out, sizeof(out), "%*d",
+						 skip, m->weeks[week]);
+				}
+			} else {
+				snprintf(out, sizeof(out), "%*s", skip, "");
+			}
+			my_putstring(out);
+		}
+		if (m->next != NULL) {
+			snprintf(out, sizeof(out), "%*s", ctl->gutter_width, "");
+			my_putstring(out);
+		}
+	}
+	my_putstring("\n");
+}
+
+
+static void monthly(const struct cal_control *ctl)
+{
+	struct cal_month m1,m2,m3, *m;
+	int i, rows, month = ctl->req.start_month ? ctl->req.start_month : ctl->req.month;
+	int32_t year = ctl->req.year;
+
+	/* cal -3, cal -Y --span, etc. */
+	if (ctl->span_months) {
+		int new_month = month - ctl->num_months / 2;
+		if (new_month < 1) {
+			new_month *= -1;
+			year -= (new_month / MONTHS_IN_YEAR) + 1;
+
+			if (new_month > MONTHS_IN_YEAR)
+				new_month %= MONTHS_IN_YEAR;
+			month = MONTHS_IN_YEAR - new_month;
+		} else
+			month = new_month;
+	}
+
+	m1.next = (ctl->months_in_row > 1) ? &m2 : NULL;
+	m2.next = (ctl->months_in_row > 2) ? &m3 : NULL;
+	m3.next = NULL;
+
+	rows = (ctl->num_months - 1) / ctl->months_in_row;
+	for (i = 0; i < rows + 1 ; i++){
+		if (i == rows){
+			switch (ctl->num_months % ctl->months_in_row){
+				case 1:
+					m1.next = NULL;
+					/* fallthrough */
+				case 2:
+					m2.next = NULL;
+					/* fallthrough */
+			}
+		}
+		for (m = &m1; m; m = m->next){
+			m->month = month++;
+			m->year = year;
+			if (MONTHS_IN_YEAR < month) {
+				year++;
+				month = 1;
+			}
+			cal_fill_month(m, ctl);
+		}
+		if (ctl->vertical) {
+			if (i > 0) {
+				/* Add a line between row */
+				my_putstring("\n");
+			}
+			cal_vert_output_header(&m1, ctl);
+			cal_vert_output_months(&m1, ctl);
+		} else {
+			cal_output_header(&m1, ctl);
+			cal_output_months(&m1, ctl);
+		}
+	}
+}
+
+static void yearly(const struct cal_control *ctl)
+{
+	char out[FMT_ST_CHARS];
+	size_t year_width;
+
+	year_width = (size_t) ctl->months_in_row * ctl->week_width
+		     + ((size_t) ctl->months_in_row - 1) * ctl->gutter_width;
+
+	if (ctl->header_year) {
+		snprintf(out, sizeof(out), "%04d", ctl->req.year);
+		center(out, year_width, 0);
+		my_putstring("\n\n");
+	}
+	monthly(ctl);
+}
+
+/*
+ * day_in_year --
+ *	return the 1 based day number within the year
+ */
+static int day_in_year(const struct cal_control *ctl,
+		       int day, int month, int32_t year)
+{
+	int i, leap;
+
+	leap = leap_year(ctl, year);
+	for (i = 1; i < month; i++)
+		day += days_in_month[leap][i];
+	return day;
+}
+
+/*
+ * day_in_week
+ *	return the 0 based day number for any date from 1 Jan. 1 to
+ *	31 Dec. 9999.  Assumes the Gregorian reformation eliminates
+ *	3 Sep. 1752 through 13 Sep. 1752, and returns invalid weekday
+ *	during the period of 11 days.
+ */
+static int day_in_week(const struct cal_control *ctl, int day,
+		       int month, int32_t year)
+{
+	/*
+	* The magic constants in the reform[] array are, in a simplified
+	* sense, the remaining days after slicing into one week periods the total
+	* days from the beginning of the year to the target month. That is,
+	* weeks + reform[] days gets us to the target month. The exception is,
+	* that for the months past February 'DOY - 1' must be used.
+	*
+	*   DoY (Day of Year): total days to the target month
+	*
+	*   Month            1  2  3  4   5   6   7   8   9  10  11  12
+	*   DoY              0 31 59 90 120 151 181 212 243 273 304 334
+	*   DoY % 7          0  3
+	*   DoY - 1 % 7      - --  2  5   0   3   5   1   4   6   2   4
+	*       reform[] = { 0, 3, 2, 5,  0,  3,  5,  1,  4,  6,  2,  4 };
+	*
+	*  Note: these calculations are for non leap years.
+	*/
+	static const int reform[] = { 0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4 };
+	static const int old[]    = { 5, 1, 0, 3, 5, 1, 3, 6, 2, 4, 0, 2 };
+
+	if (year != ctl->reform_year + 1)
+		year -= month < MARCH;
+	else
+		year -= (month < MARCH) + 14;
+	if (ctl->reform_year < year
+	    || (year == ctl->reform_year && REFORMATION_MONTH < month)
+	    || (year == ctl->reform_year
+		&& month == REFORMATION_MONTH && 13 < day)) {
+		return ((int64_t) year + (year / 4)
+			- (year / 100) + (year / 400)
+			+ reform[month - 1] + day) % DAYS_IN_WEEK;
+	}
+	if (year < ctl->reform_year
+	    || (year == ctl->reform_year && month < REFORMATION_MONTH)
+	    || (year == ctl->reform_year && month == REFORMATION_MONTH && day < 3))
+		return ((int64_t) year + year / 4 + old[month - 1] + day)
+			% DAYS_IN_WEEK;
+	return NONEDAY;
+}
+
+/*
+ * week_number
+ *      return the week number of a given date, 1..54.
+ *      Supports ISO-8601 and North American modes.
+ *      Day may be given as Julian day of the year mode, in which
+ *      case the month is disregarded entirely.
+ */
+static int week_number(int day, int month, int32_t year, const struct cal_control *ctl)
+{
+	int fday = 0, yday;
+	const int wday = day_in_week(ctl, 1, JANUARY, year);
+
+	if (ctl->weektype & WEEK_NUM_ISO)
+		fday = wday + (wday >= FRIDAY ? -2 : 5);
+	else {
+		/* WEEK_NUM_US: Jan 1 is always First week, that may
+		 * begin previous year.  That means there is very seldom
+		 * more than 52 weeks, */
+		fday = wday + 6;
+	}
+	/* For julian dates the month can be set to 1, the global julian
+	 * variable cannot be relied upon here, because we may recurse
+	 * internally for 31.12. which would not work. */
+	if (day > DAYS_IN_MONTH)
+		month = JANUARY;
+
+	yday = day_in_year(ctl, day, month, year);
+	if (year == ctl->reform_year && yday >= YDAY_AFTER_MISSING)
+		fday -= NUMBER_MISSING_DAYS;
+
+	/* Last year is last year */
+	if (yday + fday < DAYS_IN_WEEK)
+		return week_number(31, DECEMBER, year - 1, ctl);
+
+	/* Or it could be part of the next year.  The reformation year had less
+	 * days than 365 making this check invalid, but reformation year ended
+	 * on Sunday and in week 51, so it's ok here. */
+	if (ctl->weektype == WEEK_NUM_ISO && yday >= 363
+	    && day_in_week(ctl, day, month, year) >= MONDAY
+	    && day_in_week(ctl, day, month, year) <= WEDNESDAY
+	    && day_in_week(ctl, 31, DECEMBER, year) >= MONDAY
+	    && day_in_week(ctl, 31, DECEMBER, year) <= WEDNESDAY)
+		return week_number(1, JANUARY, year + 1, ctl);
+
+	return (yday + fday) / DAYS_IN_WEEK;
+}
+
+/*
+ * week_to_day
+ *      return the yday of the first day in a given week inside
+ *      the given year. This may be something other than Monday
+ *      for ISO-8601 modes. For North American numbering this
+ *      always returns a Sunday.
+ */
+static int week_to_day(const struct cal_control *ctl)
+{
+	int yday, wday;
+
+	wday = day_in_week(ctl, 1, JANUARY, ctl->req.year);
+	yday = ctl->req.week * DAYS_IN_WEEK - wday;
+
+	if (ctl->req.year == ctl->reform_year && yday >= YDAY_AFTER_MISSING)
+		yday += NUMBER_MISSING_DAYS;
+
+	if (ctl->weektype & WEEK_NUM_ISO)
+		yday -= (wday >= FRIDAY ? -2 : 5);
+	else
+		yday -= 6;	/* WEEK_NUM_US */
+	if (yday <= 0)
+		return 1;
+
+	return yday;
+}
+
+/*
+ * Center string, handling multibyte characters appropriately.
+ * In addition if the string is too large for the width it's truncated.
+ * The number of trailing spaces may be 1 less than the number of leading spaces.
+ */
+static int center_str(const char* src, char* dest,
+		      size_t dest_size, size_t width)
+{
+	return mbsalign(src, dest, dest_size, &width,
+			MBS_ALIGN_CENTER, MBA_UNIBYTE_FALLBACK);
+}
+
+static void center(const char *str, size_t len, int separate)
+{
+	char lineout[FMT_ST_CHARS];
+
+	center_str(str, lineout, ARRAY_SIZE(lineout), len);
+	my_putstring(lineout);
+
+	if (separate) {
+		snprintf(lineout, sizeof(lineout), "%*s", separate, "");
+		my_putstring(lineout);
+	}
+}
+static int left_str(const char* src, char* dest,
+		    size_t dest_size, size_t width)
+{
+	return mbsalign(src, dest, dest_size, &width,
+			MBS_ALIGN_LEFT, MBA_UNIBYTE_FALLBACK);
+}
+
+static void left(const char *str, size_t len, int separate)
+{
+	char lineout[FMT_ST_CHARS];
+
+	left_str(str, lineout, sizeof(lineout), len);
+	my_putstring(lineout);
+
+	if (separate) {
+		snprintf(lineout, sizeof(lineout), "%*s", separate, "");
+		my_putstring(lineout);
+	}
+}
+static int parse_reform_year(const char *reform_year)
+{
+	size_t i;
+
+	struct reform {
+		char *name;
+		int val;
+	};
+
+	struct reform years[] = {
+	{"gregorian",	GREGORIAN},
+	{"iso",		ISO},
+	{"1752",	GB1752},
+	{"julian",	JULIAN},
+	};
+
+	for (i = 0; i < ARRAY_SIZE(years); i++) {
+		if (strcasecmp(reform_year, years[i].name) == 0) {
+			return years[i].val;
+		}
+	}
+	errx(EXIT_FAILURE, "invalid --reform value: '%s'", reform_year);
+}
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+	fputs(USAGE_HEADER, out);
+	fprintf(out, _(" %s [options] [[[day] month] year]\n"), program_invocation_short_name);
+	fprintf(out, _(" %s [options] <timestamp|monthname>\n"), program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("Display a calendar, or some part of it.\n"), out);
+	fputs(_("Without any arguments, display the current month.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -1, --one             show only a single month (default)\n"), out);
+	fputs(_(" -3, --three           show three months spanning the date\n"), out);
+	fputs(_(" -n, --months <num>    show num months starting with date's month\n"), out);
+	fputs(_(" -S, --span            span the date when displaying multiple months\n"), out);
+	fputs(_(" -s, --sunday          Sunday as first day of week\n"), out);
+	fputs(_(" -m, --monday          Monday as first day of week\n"), out);
+	fputs(_(" -j, --julian          use day-of-year for all calendars\n"), out);
+	fputs(_("     --reform <val>    Gregorian reform date (1752|gregorian|iso|julian)\n"), out);
+	fputs(_("     --iso             alias for --reform=iso\n"), out);
+	fputs(_(" -y, --year            show the whole year\n"), out);
+	fputs(_(" -Y, --twelve          show the next twelve months\n"), out);
+	fputs(_(" -w, --week[=<num>]    show US or ISO-8601 week numbers\n"), out);
+	fputs(_(" -v, --vertical        show day vertically instead of line\n"), out);
+	fprintf(out,
+	      _("     --color[=<when>]  colorize messages (%s, %s or %s)\n"), "auto", "always", "never");
+	fprintf(out,
+	        "                         %s\n", USAGE_COLORS_DEFAULT);
+
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(23));
+	printf(USAGE_MAN_TAIL("cal(1)"));
+
+	exit(EXIT_SUCCESS);
+}
diff --git a/misc-utils/fincore.1 b/misc-utils/fincore.1
new file mode 100644
index 0000000..c01b5de
--- /dev/null
+++ b/misc-utils/fincore.1
@@ -0,0 +1,62 @@
+.\" Copyright 2017 Red Hat, Inc.
+.\"
+.\" This file may be copied under the terms of the GNU Public License.
+.TH FINCORE 1 "March 2017" "util-linux" "User Commands"
+.SH NAME
+fincore \- count pages of file contents in core
+.SH SYNOPSIS
+.B fincore
+[options]
+.I file ...
+.SH DESCRIPTION
+.B fincore
+counts pages of file contents being resident in memory (in core), and reports
+the numbers.  If an error occurs during counting, then an error message is
+printed to the stderr and
+.B fincore
+continues processing the rest of files listed in a command line.
+
+The default output is subject to change.  So whenever possible, you should
+avoid using default outputs in your scripts.  Always explicitly define expected
+columns by using
+.B \-\-output
+.I columns-list
+in environments where a stable output is required.
+.SH OPTIONS
+.TP
+.BR \-n , " \-\-noheadings"
+Do not print a header line in status output.
+.TP
+.BR \-b , " \-\-bytes"
+Print the SIZE column in bytes rather than in a human-readable format.
+.TP
+.BR \-o , " \-\-output \fIlist\fP"
+Define output columns.  See the \fB\-\-help\fP output to get a list of the
+currently supported columns. The default list of columns may be extended if \fIlist\fP is
+specified in the format \fI+list\fP.
+.TP
+.BR \-r , " \-\-raw"
+Produce output in raw format.  All potentially unsafe characters are hex-escaped
+(\\x<code>).
+.TP
+.BR \-J , " \-\-json"
+Use JSON output format.
+.TP
+\fB\-V\fR, \fB\-\-version\fR
+Display version information and exit.
+.TP
+\fB\-h\fR, \fB\-\-help\fR
+Display help text and exit.
+.SH AUTHORS
+.MT yamato@\:redhat.com
+Masatake YAMATO
+.ME
+.SH SEE ALSO
+.BR mincore (2),
+.BR getpagesize (2),
+.BR getconf (1p)
+.SH AVAILABILITY
+The fincore command is part of the util-linux package and is available from
+.UR https://\:www.kernel.org\:/pub\:/linux\:/utils\:/util-linux/
+Linux Kernel Archive
+.UE .
diff --git a/misc-utils/fincore.c b/misc-utils/fincore.c
new file mode 100644
index 0000000..09f64ed
--- /dev/null
+++ b/misc-utils/fincore.c
@@ -0,0 +1,412 @@
+/*
+ * fincore - count pages of file contents in core
+ *
+ * Copyright (C) 2017 Red Hat, Inc. All rights reserved.
+ * Written by Masatake YAMATO <yamato@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "c.h"
+#include "nls.h"
+#include "closestream.h"
+#include "xalloc.h"
+#include "strutils.h"
+
+#include "libsmartcols.h"
+
+/* For large files, mmap is called in iterative way.
+   Window is the unit of vma prepared in each mmap
+   calling.
+
+   Window size depends on page size.
+   e.g. 128MB on x86_64. ( = N_PAGES_IN_WINDOW * 4096 ). */
+#define N_PAGES_IN_WINDOW ((size_t)(32 * 1024))
+
+
+struct colinfo {
+	const char *name;
+	double whint;
+	int flags;
+	const char *help;
+};
+
+enum {
+	COL_PAGES,
+	COL_SIZE,
+	COL_FILE,
+	COL_RES
+};
+
+static struct colinfo infos[] = {
+	[COL_PAGES]  = { "PAGES",    1, SCOLS_FL_RIGHT, N_("file data resident in memory in pages")},
+	[COL_RES]    = { "RES",      5, SCOLS_FL_RIGHT, N_("file data resident in memory in bytes")},
+	[COL_SIZE]   = { "SIZE",     5, SCOLS_FL_RIGHT, N_("size of the file")},
+	[COL_FILE]   = { "FILE",     4, 0, N_("file name")},
+};
+
+static int columns[ARRAY_SIZE(infos) * 2] = {-1};
+static size_t ncolumns;
+
+struct fincore_control {
+	const size_t pagesize;
+
+	struct libscols_table *tb;		/* output */
+
+	unsigned int bytes : 1,
+		     noheadings : 1,
+		     raw : 1,
+		     json : 1;
+};
+
+
+static int column_name_to_id(const char *name, size_t namesz)
+{
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(infos); i++) {
+		const char *cn = infos[i].name;
+
+		if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
+			return i;
+	}
+	warnx(_("unknown column: %s"), name);
+	return -1;
+}
+
+static int get_column_id(int num)
+{
+	assert(num >= 0);
+	assert((size_t) num < ncolumns);
+	assert(columns[num] < (int) ARRAY_SIZE(infos));
+	return columns[num];
+}
+
+static const struct colinfo *get_column_info(int num)
+{
+	return &infos[ get_column_id(num) ];
+}
+
+static int add_output_data(struct fincore_control *ctl,
+			   const char *name,
+			   off_t file_size,
+			   off_t count_incore)
+{
+	size_t i;
+	char *tmp;
+	struct libscols_line *ln;
+
+	assert(ctl);
+	assert(ctl->tb);
+
+	ln = scols_table_new_line(ctl->tb, NULL);
+	if (!ln)
+		err(EXIT_FAILURE, _("failed to allocate output line"));
+
+	for (i = 0; i < ncolumns; i++) {
+		int rc = 0;
+
+		switch(get_column_id(i)) {
+		case COL_FILE:
+			rc = scols_line_set_data(ln, i, name);
+			break;
+		case COL_PAGES:
+			xasprintf(&tmp, "%jd",  (intmax_t) count_incore);
+			rc = scols_line_refer_data(ln, i, tmp);
+			break;
+		case COL_RES:
+		{
+			uintmax_t res = (uintmax_t) count_incore * ctl->pagesize;
+
+			if (ctl->bytes)
+				xasprintf(&tmp, "%ju", res);
+			else
+				tmp = size_to_human_string(SIZE_SUFFIX_1LETTER, res);
+			rc = scols_line_refer_data(ln, i, tmp);
+			break;
+		}
+		case COL_SIZE:
+			if (ctl->bytes)
+				xasprintf(&tmp, "%jd", (intmax_t) file_size);
+			else
+				tmp = size_to_human_string(SIZE_SUFFIX_1LETTER, file_size);
+			rc = scols_line_refer_data(ln, i, tmp);
+			break;
+		default:
+			return -EINVAL;
+		}
+
+		if (rc)
+			err(EXIT_FAILURE, _("failed to add output data"));
+	}
+
+	return 0;
+}
+
+static int do_mincore(struct fincore_control *ctl,
+		      void *window, const size_t len,
+		      const char *name,
+		      off_t *count_incore)
+{
+	static unsigned char vec[N_PAGES_IN_WINDOW];
+	int n = (len / ctl->pagesize) + ((len % ctl->pagesize)? 1: 0);
+
+	if (mincore (window, len, vec) < 0) {
+		warn(_("failed to do mincore: %s"), name);
+		return -errno;
+	}
+
+	while (n > 0)
+	{
+		if (vec[--n] & 0x1)
+		{
+			vec[n] = 0;
+			(*count_incore)++;
+		}
+	}
+
+	return 0;
+}
+
+static int fincore_fd (struct fincore_control *ctl,
+		       int fd,
+		       const char *name,
+		       off_t file_size,
+		       off_t *count_incore)
+{
+	size_t window_size = N_PAGES_IN_WINDOW * ctl->pagesize;
+	off_t file_offset, len;
+	int rc = 0;
+
+	for (file_offset = 0; file_offset < file_size; file_offset += len) {
+		void  *window = NULL;
+
+		len = file_size - file_offset;
+		if (len >= (off_t) window_size)
+			len = window_size;
+
+		window = mmap(window, len, PROT_NONE, MAP_PRIVATE, fd, file_offset);
+		if (window == MAP_FAILED) {
+			rc = -EINVAL;
+			warn(_("failed to do mmap: %s"), name);
+			break;
+		}
+
+		rc = do_mincore(ctl, window, len, name, count_incore);
+		if (rc)
+			break;
+
+		munmap (window, len);
+	}
+
+	return rc;
+}
+
+/*
+ * Returns: <0 on error, 0 success, 1 ignore.
+ */
+static int fincore_name(struct fincore_control *ctl,
+			const char *name,
+			struct stat *sb,
+			off_t *count_incore)
+{
+	int fd;
+	int rc = 0;
+
+	if ((fd = open (name, O_RDONLY)) < 0) {
+		warn(_("failed to open: %s"), name);
+		return -errno;
+	}
+
+	if (fstat (fd, sb) < 0) {
+		warn(_("failed to do fstat: %s"), name);
+		close (fd);
+		return -errno;
+	}
+
+	if (S_ISDIR(sb->st_mode))
+		rc = 1;			/* ignore */
+
+	else if (sb->st_size)
+		rc = fincore_fd(ctl, fd, name, sb->st_size, count_incore);
+
+	close (fd);
+	return rc;
+}
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+	size_t i;
+
+	fputs(USAGE_HEADER, out);
+	fprintf(out, _(" %s [options] file...\n"), program_invocation_short_name);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -J, --json            use JSON output format\n"), out);
+	fputs(_(" -b, --bytes           print sizes in bytes rather than in human readable format\n"), out);
+	fputs(_(" -n, --noheadings      don't print headings\n"), out);
+	fputs(_(" -o, --output <list>   output columns\n"), out);
+	fputs(_(" -r, --raw             use raw output format\n"), out);
+
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(23));
+
+	fprintf(out, USAGE_COLUMNS);
+
+	for (i = 0; i < ARRAY_SIZE(infos); i++)
+		fprintf(out, " %11s  %s\n", infos[i].name, _(infos[i].help));
+
+	printf(USAGE_MAN_TAIL("fincore(1)"));
+
+	exit(EXIT_SUCCESS);
+}
+
+int main(int argc, char ** argv)
+{
+	int c;
+	size_t i;
+	int rc = EXIT_SUCCESS;
+	char *outarg = NULL;
+
+	struct fincore_control ctl = {
+		.pagesize = getpagesize()
+	};
+
+	static const struct option longopts[] = {
+		{ "bytes",      no_argument, NULL, 'b' },
+		{ "noheadings", no_argument, NULL, 'n' },
+		{ "output",     required_argument, NULL, 'o' },
+		{ "version",    no_argument, NULL, 'V' },
+		{ "help",	no_argument, NULL, 'h' },
+		{ "json",       no_argument, NULL, 'J' },
+		{ "raw",        no_argument, NULL, 'r' },
+		{ NULL, 0, NULL, 0 },
+	};
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	while ((c = getopt_long (argc, argv, "bno:JrVh", longopts, NULL)) != -1) {
+		switch (c) {
+		case 'b':
+			ctl.bytes = 1;
+			break;
+		case 'n':
+			ctl.noheadings = 1;
+			break;
+		case 'o':
+			outarg = optarg;
+			break;
+		case 'J':
+			ctl.json = 1;
+			break;
+		case 'r':
+			ctl.raw = 1;
+			break;
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		case 'h':
+			usage();
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+
+	if (optind == argc) {
+		warnx(_("no file specified"));
+		errtryhelp(EXIT_FAILURE);
+	}
+
+	if (!ncolumns) {
+		columns[ncolumns++] = COL_RES;
+		columns[ncolumns++] = COL_PAGES;
+		columns[ncolumns++] = COL_SIZE;
+		columns[ncolumns++] = COL_FILE;
+	}
+
+	if (outarg && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns),
+					 &ncolumns, column_name_to_id) < 0)
+		return EXIT_FAILURE;
+
+	scols_init_debug(0);
+	ctl.tb = scols_new_table();
+	if (!ctl.tb)
+		err(EXIT_FAILURE, _("failed to allocate output table"));
+
+	scols_table_enable_noheadings(ctl.tb, ctl.noheadings);
+	scols_table_enable_raw(ctl.tb, ctl.raw);
+	scols_table_enable_json(ctl.tb, ctl.json);
+	if (ctl.json)
+		scols_table_set_name(ctl.tb, "fincore");
+
+	for (i = 0; i < ncolumns; i++) {
+		const struct colinfo *col = get_column_info(i);
+		struct libscols_column *cl;
+
+		cl = scols_table_new_column(ctl.tb, col->name, col->whint, col->flags);
+		if (!cl)
+			err(EXIT_FAILURE, _("failed to allocate output column"));
+
+		if (ctl.json) {
+			int id = get_column_id(i);
+
+			switch (id) {
+			case COL_FILE:
+				scols_column_set_json_type(cl, SCOLS_JSON_STRING);
+				break;
+			case COL_SIZE:
+			case COL_RES:
+				if (!ctl.bytes)
+					break;
+				/* fallthrough */
+			default:
+				scols_column_set_json_type(cl, SCOLS_JSON_NUMBER);
+				break;
+			}
+		}
+	}
+
+	for(; optind < argc; optind++) {
+		char *name = argv[optind];
+		struct stat sb;
+		off_t count_incore = 0;
+
+		switch (fincore_name(&ctl, name, &sb, &count_incore)) {
+		case 0:
+			add_output_data(&ctl, name, sb.st_size, count_incore);
+			break;
+		case 1:
+			break; /* ignore */
+		default:
+			rc = EXIT_FAILURE;
+			break;
+		}
+	}
+
+	scols_print_table(ctl.tb);
+	scols_unref_table(ctl.tb);
+
+	return rc;
+}
diff --git a/misc-utils/findfs.8 b/misc-utils/findfs.8
new file mode 100644
index 0000000..59466c1
--- /dev/null
+++ b/misc-utils/findfs.8
@@ -0,0 +1,79 @@
+.\" 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 "March 2014" "util-linux" "System Administration"
+.SH NAME
+findfs \- find a filesystem by label or UUID
+.SH SYNOPSIS
+.B findfs
+.BI NAME= value
+.SH DESCRIPTION
+.B findfs
+will search the block devices in the system looking for a filesystem or
+partition with specified tag. The currently supported tags are:
+.TP
+.B LABEL=<label>
+Specifies filesystem label.
+.TP
+.B UUID=<uuid>
+Specifies filesystem UUID.
+.TP
+.B PARTUUID=<uuid>
+Specifies partition UUID. This partition identifier is supported for example for
+GUID  Partition  Table (GPT) partition tables.
+.TP
+.B PARTLABEL=<label>
+Specifies partition label (name). The partition labels are supported for example for
+GUID Partition Table (GPT) or MAC partition tables.
+.PP
+If the filesystem or partition is found, the device name will be printed on
+stdout.
+
+The complete overview about filesystems and partitions you can get for example
+by
+.RS
+
+.B lsblk \-\-fs
+
+.B partx --show <disk>
+
+.B blkid
+
+.RE
+
+.SH EXIT STATUS
+.RS
+.PD 0
+.TP
+.B 0
+success
+.TP
+.B 1
+label or uuid cannot be found
+.TP
+.B 2
+usage error, wrong number of arguments or unknown option
+.PD
+.RE
+.SH ENVIRONMENT
+.IP LIBBLKID_DEBUG=all
+enables libblkid debug output.
+.SH AUTHORS
+.B findfs
+was originally written by
+.MT tytso@mit.edu
+Theodore Ts'o
+.ME
+and re-written for the util-linux package by
+.MT kzak@redhat.com
+Karel Zak
+.ME .
+.SH SEE ALSO
+.BR blkid (8),
+.BR lsblk (8),
+.BR partx (8)
+.SH AVAILABILITY
+The findfs command is part of the util-linux package and is available from
+.UR https://\:www.kernel.org\:/pub\:/linux\:/utils\:/util-linux/
+Linux Kernel Archive
+.UE .
diff --git a/misc-utils/findfs.c b/misc-utils/findfs.c
new file mode 100644
index 0000000..0997e1b
--- /dev/null
+++ b/misc-utils/findfs.c
@@ -0,0 +1,79 @@
+/*
+ * 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 <getopt.h>
+
+#include <blkid.h>
+
+#include "nls.h"
+#include "closestream.h"
+#include "c.h"
+
+/* Exit codes used by findfs. */
+#define FINDFS_SUCCESS		0	/* no errors */
+#define FINDFS_NOT_FOUND	1	/* label or uuid cannot be found */
+#define FINDFS_USAGE_ERROR	2	/* user did something unexpected */
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+	fputs(USAGE_HEADER, out);
+	fprintf(out, _(" %s [options] {LABEL,UUID,PARTUUID,PARTLABEL}=<value>\n"),
+		program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("Find a filesystem by label or UUID.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	printf(USAGE_HELP_OPTIONS(16));
+	printf(USAGE_MAN_TAIL("findfs(8)"));
+	exit(FINDFS_SUCCESS);
+}
+
+int main(int argc, char **argv)
+{
+	char	*dev;
+	int	c;
+	static const struct option longopts[] = {
+		{"version", no_argument, NULL, 'V'},
+		{"help", no_argument, NULL, 'h'},
+		{NULL, 0, NULL, 0}
+	};
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	if (argc != 2) {
+		/* we return '2' for backward compatibility
+		 * with version from e2fsprogs */
+		warnx(_("bad usage"));
+		errtryhelp(FINDFS_USAGE_ERROR);
+	}
+
+	while ((c = getopt_long(argc, argv, "Vh", longopts, NULL)) != -1)
+		switch (c) {
+		case 'V':
+			print_version(FINDFS_SUCCESS);
+		case 'h':
+			usage();
+		default:
+			errtryhelp(FINDFS_USAGE_ERROR);
+		}
+
+	dev = blkid_evaluate_tag(argv[1], NULL, NULL);
+	if (!dev)
+		errx(FINDFS_NOT_FOUND, _("unable to resolve '%s'"), argv[1]);
+
+	puts(dev);
+	return FINDFS_SUCCESS;
+}
+
diff --git a/misc-utils/findmnt-verify.c b/misc-utils/findmnt-verify.c
new file mode 100644
index 0000000..1d25542
--- /dev/null
+++ b/misc-utils/findmnt-verify.c
@@ -0,0 +1,527 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <libmount.h>
+#include <blkid.h>
+#include <sys/utsname.h>
+
+#include "nls.h"
+#include "c.h"
+#include "strutils.h"
+#include "xalloc.h"
+
+#include "findmnt.h"
+
+struct verify_context {
+	struct libmnt_fs	*fs;
+	struct libmnt_table	*tb;
+
+	char	**fs_ary;
+	size_t	fs_num;
+	size_t  fs_alloc;
+
+	int	nwarnings;
+	int	nerrors;
+
+	unsigned int	target_printed : 1,
+			no_fsck : 1;
+};
+
+static void verify_mesg(struct verify_context *vfy, char type, const char *fmt, va_list ap)
+{
+	if (!vfy->target_printed) {
+		fprintf(stdout, "%s\n", mnt_fs_get_target(vfy->fs));
+		vfy->target_printed = 1;
+	}
+
+	fprintf(stdout, "   [%c] ", type);
+	vfprintf(stdout, fmt, ap);
+	fputc('\n', stdout);
+}
+
+static int verify_warn(struct verify_context *vfy, const char *fmt, ...)
+{
+	va_list ap;
+	vfy->nwarnings++;
+	va_start(ap, fmt);
+	verify_mesg(vfy, 'W', fmt, ap);
+	va_end(ap);
+	return 0;
+}
+
+static int verify_err(struct verify_context *vfy, const char *fmt, ...)
+{
+	va_list ap;
+	vfy->nerrors++;
+	va_start(ap, fmt);
+	verify_mesg(vfy, 'E', fmt, ap);
+	va_end(ap);
+	return 0;
+}
+
+static int verify_ok(struct verify_context *vfy __attribute__((unused)),
+		      const char *fmt, ...)
+{
+	va_list ap;
+
+	if (!(flags & FL_VERBOSE))
+		return 0;
+
+	va_start(ap, fmt);
+	verify_mesg(vfy, ' ', fmt, ap);
+	va_end(ap);
+	return 0;
+}
+
+static int verify_order(struct verify_context *vfy)
+{
+	struct libmnt_iter *itr = NULL;
+	struct libmnt_fs *next;
+	const char *tgt;
+
+	tgt = mnt_fs_get_target(vfy->fs);
+	if (tgt && !(flags & FL_NOCACHE))
+		tgt  = mnt_resolve_target(tgt, cache);
+	else if (!tgt)
+		return 0;
+
+	itr = mnt_new_iter(MNT_ITER_FORWARD);
+	if (!itr) {
+		warn(_("failed to initialize libmount iterator"));
+		goto done;
+	}
+
+	/* set iterator position to 'fs' */
+	mnt_table_set_iter(vfy->tb, itr, vfy->fs);
+
+	if (mnt_table_next_fs(vfy->tb, itr, &next) != 0)
+		goto done;
+
+	/* scan all next filesystems */
+	while (mnt_table_next_fs(vfy->tb, itr, &next) == 0) {
+		const char *n_tgt;
+		size_t len;
+
+		n_tgt = mnt_fs_get_target(next);
+		if (n_tgt && !(flags & FL_NOCACHE))
+			n_tgt  = mnt_resolve_target(n_tgt, cache);
+		else if (!n_tgt)
+			continue;
+		len = strlen(n_tgt);
+
+		if (strncmp(n_tgt, tgt, len) == 0) {
+			if (*(tgt + len) == '\0')
+				verify_warn(vfy, _("target specified more than once"));
+			else if (*(tgt + len) == '/')
+				verify_err(vfy, _("wrong order: %s specified before %s"), tgt, n_tgt);
+		}
+	}
+done:
+	mnt_free_iter(itr);
+	return 0;
+}
+
+static int verify_target(struct verify_context *vfy)
+{
+	const char *tgt = mnt_fs_get_target(vfy->fs);
+	struct stat sb;
+
+	if (!tgt)
+		return verify_err(vfy, _("undefined target (fs_file)"));
+
+	if (!(flags & FL_NOCACHE)) {
+		const char *cn = mnt_resolve_target(tgt, cache);
+		if (!cn)
+			return -ENOMEM;
+		if (strcmp(cn, tgt) != 0)
+			verify_warn(vfy, _("non-canonical target path (real: %s)"), cn);
+		tgt = cn;
+	}
+	if (stat(tgt, &sb) != 0) {
+		if (mnt_fs_get_option(vfy->fs, "noauto", NULL, NULL) == 1)
+			verify_err(vfy, _("unreachable on boot required target: %m"));
+		else
+			verify_warn(vfy, _("unreachable target: %m"));
+
+	} else if (!S_ISDIR(sb.st_mode)
+		 && mnt_fs_get_option(vfy->fs, "bind", NULL, NULL) == 1) {
+		verify_err(vfy, _("target is not a directory"));
+	} else
+		verify_ok(vfy, _("target exists"));
+
+	return 0;
+}
+
+static char *verify_tag(struct verify_context *vfy, const char *name,
+		      const char *value)
+{
+	char *src = mnt_resolve_tag(name, value, cache);
+
+	if (!src) {
+		if (mnt_fs_get_option(vfy->fs, "noauto", NULL, NULL) == 1)
+			verify_err(vfy, _("unreachable on boot required source: %s=%s"), name, value);
+		else
+			verify_warn(vfy, _("unreachable: %s=%s"), name, value);
+	} else
+		verify_ok(vfy, _("%s=%s translated to %s"), name, value, src);
+
+	return src;
+}
+
+/* Note that mount source is very FS specific and we should not
+ * interpret unreachable source as error. The exception is only
+ * NAME=value, this has to be convertible to device name.
+ */
+static int verify_source(struct verify_context *vfy)
+{
+	const char *src = mnt_fs_get_srcpath(vfy->fs);
+	char *t = NULL, *v = NULL;
+	struct stat sb;
+	int isbind, rc = 0;
+
+	/* source is NAME=value tag */
+	if (!src) {
+		const char *tag = NULL, *val = NULL;
+
+		if (mnt_fs_get_tag(vfy->fs, &tag, &val) != 0)
+			return verify_err(vfy, _("undefined source (fs_spec)"));
+
+		src = verify_tag(vfy, tag, val);
+		if (!src)
+			goto done;
+
+	/* blkid is able to parse it, but libmount does not see it as a tag --
+	 * it means unsupported tag */
+	} else if (blkid_parse_tag_string(src, &t, &v) == 0 && stat(src, &sb) != 0) {
+		rc = verify_err(vfy, _("unsupported source tag: %s"), src);
+		goto done;
+	}
+	isbind = mnt_fs_get_option(vfy->fs, "bind", NULL, NULL) == 0;
+
+	/* source is path */
+	if (mnt_fs_is_pseudofs(vfy->fs) || mnt_fs_is_netfs(vfy->fs))
+		verify_ok(vfy, _("do not check %s source (pseudo/net)"), src);
+
+	else if (stat(src, &sb) != 0)
+		verify_warn(vfy, _("unreachable source: %s: %m"), src);
+
+	else if ((S_ISDIR(sb.st_mode) || S_ISREG(sb.st_mode)) && !isbind)
+		verify_warn(vfy, _("non-bind mount source %s is a directory or regular file"), src);
+
+	else if (!S_ISBLK(sb.st_mode) && !isbind)
+		verify_warn(vfy, _("source %s is not a block device"), src);
+	else
+		verify_ok(vfy, _("source %s exists"), src);
+done:
+	free(t);
+	free(v);
+	return rc;
+}
+
+static int verify_options(struct verify_context *vfy)
+{
+	const char *opts;
+
+	opts = mnt_fs_get_vfs_options(vfy->fs);
+	if (opts)
+		verify_ok(vfy, _("VFS options: %s"), opts);
+
+	opts = mnt_fs_get_fs_options(vfy->fs);
+	if (opts)
+		verify_ok(vfy, _("FS options: %s"), opts);
+
+	opts = mnt_fs_get_user_options(vfy->fs);
+	if (opts)
+		verify_ok(vfy, _("userspace options: %s"), opts);
+
+	return 0;
+}
+
+static int verify_swaparea(struct verify_context *vfy)
+{
+	char *arg;
+	size_t argsz = 0;
+
+	if (mnt_fs_get_option(vfy->fs, "discard", &arg, &argsz) == 0
+	    && arg
+	    && strncmp(arg, "once", argsz) != 0
+	    && strncmp(arg, "pages", argsz) != 0)
+		verify_err(vfy, _("unsupported swaparea discard policy: %s"), arg);
+
+	if (mnt_fs_get_option(vfy->fs, "pri", &arg, &argsz) == 0 && arg) {
+		char *p = arg;
+		if (*p == '-')
+			p++;
+		for (; p < arg + argsz; p++) {
+			if (!isdigit((unsigned char) *p)) {
+				verify_err(vfy, _("failed to parse swaparea priority option"));
+				break;
+			}
+		}
+	}
+
+	return 0;
+}
+
+static int is_supported_filesystem(struct verify_context *vfy, const char *name)
+{
+	size_t n;
+
+	if (!vfy->fs_num)
+		return 0;
+
+	for (n = 0; n < vfy->fs_num; n++ ) {
+		if (strcmp(vfy->fs_ary[n], name) == 0)
+			return 1;
+	}
+
+	return 0;
+}
+
+static int add_filesystem(struct verify_context *vfy, const char *name)
+{
+	#define MYCHUNK	16
+
+	if (is_supported_filesystem(vfy, name))
+		return 0;
+
+	if (vfy->fs_alloc == 0 || vfy->fs_num + 1 <= vfy->fs_alloc) {
+		vfy->fs_alloc = ((vfy->fs_alloc + 1 + MYCHUNK) / MYCHUNK) * MYCHUNK;
+		vfy->fs_ary = xrealloc(vfy->fs_ary, vfy->fs_alloc * sizeof(char *));
+	}
+
+	vfy->fs_ary[vfy->fs_num] = xstrdup(name);
+	vfy->fs_num++;
+
+	return 0;
+}
+
+static int read_proc_filesystems(struct verify_context *vfy)
+{
+	int rc = 0;
+	FILE *f;
+	char buf[80], *cp, *t;
+
+	f = fopen("/proc/filesystems", "r");
+	if (!f)
+		return -errno;
+
+	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;
+
+		rc = add_filesystem(vfy, cp);
+		if (rc)
+			break;
+	}
+	fclose(f);
+	return rc;
+}
+
+static int read_kernel_filesystems(struct verify_context *vfy)
+{
+	int rc = 0;
+#ifdef __linux__
+	struct utsname uts;
+	FILE *f;
+	char buf[1024];
+
+	if (uname(&uts))
+		return 0;
+	snprintf(buf, sizeof(buf), "/lib/modules/%s/modules.dep", uts.release);
+
+	f = fopen(buf, "r");
+	if (!f)
+		return 0;
+
+	while (!feof(f)) {
+		char *p, *name;
+
+		if (!fgets(buf, sizeof(buf), f))
+			break;
+
+		if (strncmp("kernel/fs/", buf, 10) != 0 ||
+		    strncmp("kernel/fs/nls/", buf, 14) == 0)
+			continue;
+
+		p = strchr(buf, ':');
+		if (!p)
+			continue;
+		*p = '\0';
+
+		name = strrchr(buf, '/');
+		if (!name)
+			continue;
+		name++;
+
+		p = strstr(name, ".ko");
+		if (!p)
+			continue;
+		*p = '\0';
+
+		rc = add_filesystem(vfy, name);
+		if (rc)
+			break;
+	}
+	fclose(f);
+#endif /* __linux__ */
+	return rc;
+}
+
+static int verify_fstype(struct verify_context *vfy)
+{
+	const char *src = mnt_resolve_spec(mnt_fs_get_source(vfy->fs), cache);
+	const char *type, *realtype;
+	int ambi = 0, isauto = 0, isswap = 0;
+
+	if (!src)
+		return 0;
+	if (mnt_fs_is_pseudofs(vfy->fs) || mnt_fs_is_netfs(vfy->fs))
+		return verify_ok(vfy, _("do not check %s FS type (pseudo/net)"), src);
+
+	type = mnt_fs_get_fstype(vfy->fs);
+
+	if (type) {
+		int none = strcmp(type, "none") == 0;
+
+		if (none
+		    && mnt_fs_get_option(vfy->fs, "bind", NULL, NULL) == 1
+		    && mnt_fs_get_option(vfy->fs, "move", NULL, NULL) == 1)
+			return verify_warn(vfy, _("\"none\" FS type is recommended for bind or move oprations only"));
+
+		if (strcmp(type, "auto") == 0)
+			isauto = 1;
+		else if (strcmp(type, "swap") == 0)
+			isswap = 1;
+		else if (strcmp(type, "xfs") == 0)
+			vfy->no_fsck = 1;
+
+		if (!isswap && !isauto && !none && !is_supported_filesystem(vfy, type))
+			verify_warn(vfy, _("%s seems unsupported by the current kernel"), type);
+	}
+	realtype = mnt_get_fstype(src, &ambi, cache);
+
+	if (!realtype) {
+		if (isauto)
+			return verify_err(vfy, _("cannot detect on-disk filesystem type"));
+		return verify_warn(vfy, _("cannot detect on-disk filesystem type"));
+	}
+
+	if (realtype) {
+		isswap = strcmp(realtype, "swap") == 0;
+		vfy->no_fsck = strcmp(realtype, "xfs") == 0;
+
+		if (type && !isauto && strcmp(type, realtype) != 0)
+			return verify_err(vfy, _("%s does not match with on-disk %s"), type, realtype);
+
+		if (!isswap && !is_supported_filesystem(vfy, realtype))
+			return verify_err(vfy, _("on-disk %s seems unsupported by the current kernel"), realtype);
+
+		verify_ok(vfy, _("FS type is %s"), realtype);
+	}
+
+	return 0;
+}
+
+static int verify_passno(struct verify_context *vfy)
+{
+	int passno = mnt_fs_get_passno(vfy->fs);
+	const char *tgt = mnt_fs_get_target(vfy->fs);
+
+	if (tgt && strcmp("/", tgt) == 0 && passno != 1 && !vfy->no_fsck)
+		return verify_warn(vfy, _("recommended root FS passno is 1 (current is %d)"), passno);
+
+	return 0;
+}
+
+static int verify_filesystem(struct verify_context *vfy)
+{
+	int rc = 0;
+
+	if (mnt_fs_is_swaparea(vfy->fs))
+		rc = verify_swaparea(vfy);
+	else {
+		rc = verify_target(vfy);
+		if (!rc)
+			rc = verify_options(vfy);
+	}
+
+	if (!rc)
+		rc = verify_source(vfy);
+	if (!rc)
+		rc = verify_fstype(vfy);
+	if (!rc)
+		rc = verify_passno(vfy);	/* depends on verify_fstype() */
+
+	return rc;
+}
+
+int verify_table(struct libmnt_table *tb)
+{
+	struct verify_context vfy = { .nerrors = 0 };
+	struct libmnt_iter *itr;
+	int rc = 0;		/* overall return code (alloc errors, etc.) */
+	int check_order = is_listall_mode();
+	static int has_read_fs = 0;
+
+	itr = mnt_new_iter(MNT_ITER_FORWARD);
+	if (!itr) {
+		warn(_("failed to initialize libmount iterator"));
+		goto done;
+	}
+
+	vfy.tb = tb;
+
+	if (has_read_fs == 0) {
+		read_proc_filesystems(&vfy);
+		read_kernel_filesystems(&vfy);
+		has_read_fs = 1;
+	}
+
+	while (rc == 0 && (vfy.fs = get_next_fs(tb, itr))) {
+		vfy.target_printed = 0;
+		vfy.no_fsck = 0;
+
+		if (check_order)
+			rc = verify_order(&vfy);
+		if (!rc)
+			rc = verify_filesystem(&vfy);
+
+		if (flags & FL_FIRSTONLY)
+			break;
+		flags |= FL_NOSWAPMATCH;
+	}
+
+done:
+	mnt_free_iter(itr);
+
+	/* summary */
+	if (vfy.nerrors || parse_nerrors || vfy.nwarnings) {
+		fputc('\n', stderr);
+		fprintf(stderr, P_("%d parse error", "%d parse errors", parse_nerrors), parse_nerrors);
+		fprintf(stderr, P_(", %d error",     ", %d errors", vfy.nerrors), vfy.nerrors);
+		fprintf(stderr, P_(", %d warning",   ", %d warnings", vfy.nwarnings), vfy.nwarnings);
+		fputc('\n', stderr);
+	} else
+		fprintf(stdout, _("Success, no errors or warnings detected\n"));
+
+	return rc != 0 ? rc : vfy.nerrors + parse_nerrors;
+}
diff --git a/misc-utils/findmnt.8 b/misc-utils/findmnt.8
new file mode 100644
index 0000000..e411c30
--- /dev/null
+++ b/misc-utils/findmnt.8
@@ -0,0 +1,308 @@
+.TH FINDMNT 8 "May 2018" "util-linux" "System Administration"
+.SH NAME
+findmnt \- find a filesystem
+.SH SYNOPSIS
+.B findmnt
+[options]
+.sp
+.B findmnt
+[options]
+.IR device | mountpoint
+.sp
+.B findmnt
+[options]
+.RB [ \-\-source ]
+.I device
+.RB [ \-\-target | \-\-mountpoint ]
+.I mountpoint
+.SH DESCRIPTION
+.B findmnt
+will list all mounted filesystems or search for a filesystem.  The
+.B \%findmnt
+command is able to search in
+.IR /etc/fstab ,
+.I /etc/mtab
+or
+.IR /proc/self/mountinfo .
+If
+.I device
+or
+.I mountpoint
+is not given, all filesystems are shown.
+.PP
+The device may be specified by device name, major:minor numbers,
+filesystem label or UUID, or partition label or UUID.  Note that
+.B \%findmnt
+follows
+.BR mount (8)
+behavior where a device name may be interpreted
+as a mountpoint (and vice versa) if the \fB\-\-target\fR, \fB\-\-mountpoint\fR or
+\fB\-\-source\fR options are not specified.
+.PP
+The command prints all mounted filesystems in the tree-like format by default.
+.SH OPTIONS
+.TP
+.BR \-A , " \-\-all"
+Disable all built-in filters and print all filesystems.
+.TP
+.BR \-a , " \-\-ascii"
+Use ascii characters for tree formatting.
+.TP
+.BR \-b , " \-\-bytes"
+Print the SIZE, USED and AVAIL columns in bytes rather than in a human-readable format.
+.TP
+.BR \-C , " \-\-nocanonicalize"
+Do not canonicalize paths at all.  This option affects the comparing of paths
+and the evaluation of tags (LABEL, UUID, etc.).
+.TP
+.BR \-c , " \-\-canonicalize"
+Canonicalize all printed paths.
+.TP
+.BR \-D , " \-\-df"
+Imitate the output of
+.BR df (1).
+This option is equivalent to
+.B \-o\ SOURCE,FSTYPE,SIZE,USED,AVAIL,USE%,TARGET
+but excludes all pseudo filesystems.
+Use \fB\-\-all\fP to print all filesystems.
+.TP
+.BR \-d , " \-\-direction \fIword\fP"
+The search direction, either
+.B forward
+or
+.BR backward .
+.TP
+.BR \-e , " \-\-evaluate"
+Convert all tags (LABEL, UUID, PARTUUID or PARTLABEL) to the corresponding device names.
+.TP
+.BR \-F , " \-\-tab\-file \fIpath\fP"
+Search in an alternative file.  If used with \fB\-\-fstab\fP, \fB\-\-mtab\fP
+or \fB\-\-kernel\fP, then it overrides the default paths.  If specified more
+than once, then tree-like output is disabled (see the \fB\-\-list\fP option).
+.TP
+.BR \-f , " \-\-first\-only"
+Print the first matching filesystem only.
+.TP
+.BR \-h , " \-\-help"
+Display help text and exit.
+.TP
+.BR \-i , " \-\-invert"
+Invert the sense of matching.
+.TP
+.BR \-J , " \-\-json"
+Use JSON output format.
+.TP
+.BR \-k , " \-\-kernel"
+Search in
+.IR /proc/self/mountinfo .
+The output is in the tree-like format.  This is the default.  The output
+contains only mount options maintained by kernel (see also \fB\-\-mtab)\fP.
+.TP
+.BR \-l , " \-\-list"
+Use the list output format.  This output format is automatically enabled if the
+output is restricted by the \fB\-t\fP, \fB\-O\fP, \fB\-S\fP or \fB\-T\fP
+option and the option \fB\-\-submounts\fP is not used or if more that one
+source file (the option \fB\-F\fP) is specified.
+.TP
+.BR \-M , " \-\-mountpoint \fIpath\fP"
+Explicitly define the mountpoint file or directory.  See also \fB\-\-target\fP.
+.TP
+.BR \-m , " \-\-mtab"
+Search in
+.IR /etc/mtab .
+The output is in the list format by default (see \fB\-\-tree\fP).  The output may include user
+space mount options.
+.TP
+.BR \-N , " \-\-task \fItid\fP"
+Use alternative namespace /proc/<tid>/mountinfo rather than the default
+/proc/self/mountinfo.  If the option is specified more than once, then
+tree-like output is disabled (see the \fB\-\-list\fP option).  See also the
+.BR unshare (1)
+command.
+.TP
+.BR \-n , " \-\-noheadings"
+Do not print a header line.
+.TP
+.BR \-O , " \-\-options \fIlist\fP"
+Limit the set of printed filesystems.  More than one option
+may be specified in a comma-separated list.  The
+.B \-t
+and
+.B \-O
+options are cumulative in effect.  It is different from
+.B \-t
+in that each option is matched exactly; a leading
+.I no
+at the beginning does not have global meaning.  The "no" can used for
+individual items in the list.  The "no" prefix interpretation can be disabled
+by "+" prefix.
+.TP
+.BR \-o , " \-\-output \fIlist\fP"
+Define output columns.  See the \fB\-\-help\fP output to get a list of the
+currently supported columns.  The
+.B TARGET
+column contains tree formatting if the
+.B \-\-list
+or
+.B \-\-raw
+options are not specified.
+
+The default list of columns may be extended if \fIlist\fP is
+specified in the format \fI+list\fP (e.g., \fBfindmnt \-o +PROPAGATION\fP).
+.TP
+.B \-\-output\-all
+Output almost all available columns.  The columns that require
+.B \-\-poll
+are not included.
+.TP
+.BR \-P , " \-\-pairs"
+Use key="value" output format.  All potentially unsafe characters are hex-escaped (\\x<code>).
+.TP
+.BR \-p , " \-\-poll\fR[\fI=list\fR]"
+Monitor changes in the /proc/self/mountinfo file.  Supported actions are: mount,
+umount, remount and move.  More than one action may be specified in a
+comma-separated list.  All actions are monitored by default.
+
+The time for which \fB\-\-poll\fR will block can be restricted with the \fB\-\-timeout\fP
+or \fB\-\-first\-only\fP options.
+
+The standard columns always use the new version of the information from the
+mountinfo file, except the umount action which is based on the original
+information cached by
+.BR findmnt (8).
+The poll mode allows using extra columns:
+.RS
+.TP
+.B ACTION
+mount, umount, move or remount action name; this column is enabled by default
+.TP
+.B OLD-TARGET
+available for umount and move actions
+.TP
+.B OLD-OPTIONS
+available for umount and remount actions
+.RE
+.TP
+.B \-\-pseudo
+Print only pseudo filesystems.
+.TP
+.BR \-R , " \-\-submounts"
+Print recursively all submounts for the selected filesystems.  The restrictions
+defined by options \fB\-t\fP, \fB\-O\fP, \fB\-S\fP, \fB\-T\fP and
+\fB\%\-\-direction\fP are not applied to submounts.  All submounts are always
+printed in tree-like order.  The option enables the tree-like output format by
+default.  This option has no effect for \fB\-\-mtab\fP or \fB\-\-fstab\fP.
+.TP
+.BR \-r , " \-\-raw"
+Use raw output format.  All potentially unsafe characters are hex-escaped (\\x<code>).
+.TP
+.B \-\-real
+Print only real filesystems.
+.TP
+.BR \-S , " \-\-source \fIspec\fP"
+Explicitly define the mount source.  Supported specifications are \fIdevice\fR,
+\fImaj\fB:\fImin\fR, \fBLABEL=\fIlabel\fR, \fBUUID=\fIuuid\fR,
+\fBPARTLABEL=\fIlabel\fR and \fBPARTUUID=\fIuuid\fR.
+.TP
+.BR \-s , " \-\-fstab"
+Search in
+.IR /etc/fstab .
+The output is in the list format (see \fB\-\-list\fR).
+.TP
+.BR \-T , " \-\-target \fIpath\fP"
+Define the mount target.  If \fIpath\fR
+is not a mountpoint file or directory, then
+.B findmnt
+checks the \fIpath\fR elements in reverse order to get the mountpoint (this feature is
+supported only when searching in kernel files and unsupported for \fB\-\-fstab\fP).  It's
+recommended to use the option \fB\-\-mountpoint\fR when checks of \fIpath\fR elements are
+unwanted and \fIpath\fR is a strictly specified mountpoint.
+.TP
+.BR \-t , " \-\-types \fIlist\fP"
+Limit the set of printed filesystems.  More than one type may be
+specified in a comma-separated list.  The list of filesystem types can be
+prefixed with
+.B no
+to specify the filesystem types on which no action should be taken.  For
+more details see
+.BR mount (8).
+.TP
+.B \-\-tree
+Enable tree-like output if possible.  The options is silently ignored for
+tables where is missing child-parent relation (e.g., fstab).
+.TP
+.BR \-U , " \-\-uniq"
+Ignore filesystems with duplicate mount targets, thus effectively skipping
+over-mounted mount points.
+.TP
+.BR \-u , " \-\-notruncate"
+Do not truncate text in columns.  The default is to not truncate the
+.BR TARGET ,
+.BR SOURCE ,
+.BR UUID ,
+.BR LABEL ,
+.BR PARTUUID ,
+.B PARTLABEL
+columns.  This option disables text truncation also in all other columns.
+.TP
+.BR \-v , " \-\-nofsroot"
+Do not print a [/dir] in the SOURCE column for bind mounts or btrfs subvolumes.
+.TP
+.BR \-w , " \-\-timeout \fImilliseconds\fP"
+Specify an upper limit on the time for which \fB\-\-poll\fR will block, in milliseconds.
+.TP
+.BR \-x , " \-\-verify"
+Check mount table content. The default is to verify
+.I /etc/fstab
+parsability and usability. It's possible to use this option also with \fB\-\-tab\-file\fP.
+It's possible to specify source (device) or target (mountpoint) to filter mount table. The option
+\fB\-\-verbose\fP forces findmnt to print more details.
+.TP
+.B \-\-verbose
+Force findmnt to print more information (\fB\-\-verify\fP only for now).
+.SH ENVIRONMENT
+.IP LIBMOUNT_FSTAB=<path>
+overrides the default location of the fstab file
+.IP LIBMOUNT_MTAB=<path>
+overrides the default location of the mtab file
+.IP LIBMOUNT_DEBUG=all
+enables libmount debug output
+.IP LIBSMARTCOLS_DEBUG=all
+enables libsmartcols debug output
+.IP LIBSMARTCOLS_DEBUG_PADDING=on
+use visible padding characters. Requires enabled LIBSMARTCOLS_DEBUG.
+.SH EXAMPLE
+.IP "\fBfindmnt \-\-fstab \-t nfs\fP"
+Prints all NFS filesystems defined in
+.IR /etc/fstab .
+.IP "\fBfindmnt \-\-fstab /mnt/foo\fP"
+Prints all
+.I /etc/fstab
+filesystems where the mountpoint directory is /mnt/foo.  It also prints bind mounts where /mnt/foo
+is a source.
+.IP "\fBfindmnt \-\-fstab \-\-target /mnt/foo\fP"
+Prints all
+.I /etc/fstab
+filesystems where the mountpoint directory is /mnt/foo.
+.IP "\fBfindmnt \-\-fstab \-\-evaluate\fP"
+Prints all
+.I /etc/fstab
+filesystems and converts LABEL= and UUID= tags to the real device names.
+.IP "\fBfindmnt \-n \-\-raw \-\-evaluate \-\-output=target LABEL=/boot\fP"
+Prints only the mountpoint where the filesystem with label "/boot" is mounted.
+.IP "\fBfindmnt \-\-poll \-\-mountpoint /mnt/foo\fP"
+Monitors mount, unmount, remount and move on /mnt/foo.
+.IP "\fBfindmnt \-\-poll=umount \-\-first-only \-\-mountpoint /mnt/foo\fP"
+Waits for /mnt/foo unmount.
+.IP "\fBfindmnt \-\-poll=remount \-t ext3 \-O ro\fP"
+Monitors remounts to read-only mode on all ext3 filesystems.
+.SH AUTHORS
+.nf
+Karel Zak <kzak@redhat.com>
+.fi
+.SH SEE ALSO
+.BR fstab (5),
+.BR mount (8)
+.SH AVAILABILITY
+The findmnt command is part of the util-linux package and is available from
+https://www.kernel.org/pub/linux/utils/util-linux/.
diff --git a/misc-utils/findmnt.c b/misc-utils/findmnt.c
new file mode 100644
index 0000000..43b4dc7
--- /dev/null
+++ b/misc-utils/findmnt.c
@@ -0,0 +1,1732 @@
+/*
+ * findmnt(8)
+ *
+ * Copyright (C) 2010-2015 Red Hat, Inc. All rights reserved.
+ * Written by Karel Zak <kzak@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <string.h>
+#include <termios.h>
+#ifdef HAVE_SYS_IOCTL_H
+# include <sys/ioctl.h>
+#endif
+#include <assert.h>
+#include <poll.h>
+#include <sys/statvfs.h>
+#include <sys/types.h>
+#ifdef HAVE_LIBUDEV
+# include <libudev.h>
+#endif
+#include <libmount.h>
+#include <libsmartcols.h>
+
+#include "pathnames.h"
+#include "nls.h"
+#include "closestream.h"
+#include "c.h"
+#include "strutils.h"
+#include "xalloc.h"
+#include "optutils.h"
+#include "mangle.h"
+
+#include "findmnt.h"
+
+/* column IDs */
+enum {
+	COL_SOURCE,
+	COL_TARGET,
+	COL_FSTYPE,
+	COL_OPTIONS,
+	COL_VFS_OPTIONS,
+	COL_FS_OPTIONS,
+	COL_LABEL,
+	COL_UUID,
+	COL_PARTLABEL,
+	COL_PARTUUID,
+	COL_MAJMIN,
+	COL_ACTION,
+	COL_OLD_TARGET,
+	COL_OLD_OPTIONS,
+	COL_SIZE,
+	COL_AVAIL,
+	COL_USED,
+	COL_USEPERC,
+	COL_FSROOT,
+	COL_TID,
+	COL_ID,
+	COL_OPT_FIELDS,
+	COL_PROPAGATION,
+	COL_FREQ,
+	COL_PASSNO
+};
+
+enum {
+	TABTYPE_FSTAB = 1,
+	TABTYPE_MTAB,
+	TABTYPE_KERNEL
+};
+
+/* column names */
+struct colinfo {
+	const char	*name;		/* header */
+	double		whint;		/* width hint (N < 1 is in percent of termwidth) */
+	int		flags;		/* libsmartcols flags */
+	const char      *help;		/* column description */
+	const char	*match;		/* pattern for match_func() */
+	void		*match_data;	/* match specific data */
+};
+
+/* columns descriptions (don't use const, this is writable) */
+static struct colinfo infos[] = {
+	[COL_SOURCE]       = { "SOURCE",       0.25, SCOLS_FL_NOEXTREMES, N_("source device") },
+	[COL_TARGET]       = { "TARGET",       0.30, SCOLS_FL_TREE| SCOLS_FL_NOEXTREMES, N_("mountpoint") },
+	[COL_FSTYPE]       = { "FSTYPE",       0.10, SCOLS_FL_TRUNC, N_("filesystem type") },
+	[COL_OPTIONS]      = { "OPTIONS",      0.10, SCOLS_FL_TRUNC, N_("all mount options") },
+	[COL_VFS_OPTIONS]  = { "VFS-OPTIONS",  0.20, SCOLS_FL_TRUNC, N_("VFS specific mount options") },
+	[COL_FS_OPTIONS]   = { "FS-OPTIONS",   0.10, SCOLS_FL_TRUNC, N_("FS specific mount options") },
+	[COL_LABEL]        = { "LABEL",        0.10, 0, N_("filesystem label") },
+	[COL_UUID]         = { "UUID",           36, 0, N_("filesystem UUID") },
+	[COL_PARTLABEL]    = { "PARTLABEL",    0.10, 0, N_("partition label") },
+	[COL_PARTUUID]     = { "PARTUUID",       36, 0, N_("partition UUID") },
+	[COL_MAJMIN]       = { "MAJ:MIN",         6, 0, N_("major:minor device number") },
+	[COL_ACTION]       = { "ACTION",         10, SCOLS_FL_STRICTWIDTH, N_("action detected by --poll") },
+	[COL_OLD_OPTIONS]  = { "OLD-OPTIONS",  0.10, SCOLS_FL_TRUNC, N_("old mount options saved by --poll") },
+	[COL_OLD_TARGET]   = { "OLD-TARGET",   0.30, 0, N_("old mountpoint saved by --poll") },
+	[COL_SIZE]         = { "SIZE",            5, SCOLS_FL_RIGHT, N_("filesystem size") },
+	[COL_AVAIL]        = { "AVAIL",           5, SCOLS_FL_RIGHT, N_("filesystem size available") },
+	[COL_USED]         = { "USED",            5, SCOLS_FL_RIGHT, N_("filesystem size used") },
+	[COL_USEPERC]      = { "USE%",            3, SCOLS_FL_RIGHT, N_("filesystem use percentage") },
+	[COL_FSROOT]       = { "FSROOT",       0.25, SCOLS_FL_NOEXTREMES, N_("filesystem root") },
+	[COL_TID]          = { "TID",             4, SCOLS_FL_RIGHT, N_("task ID") },
+	[COL_ID]           = { "ID",              2, SCOLS_FL_RIGHT, N_("mount ID") },
+	[COL_OPT_FIELDS]   = { "OPT-FIELDS",   0.10, SCOLS_FL_TRUNC, N_("optional mount fields") },
+	[COL_PROPAGATION]  = { "PROPAGATION",  0.10, 0, N_("VFS propagation flags") },
+	[COL_FREQ]         = { "FREQ",            1, SCOLS_FL_RIGHT, N_("dump(8) period in days [fstab only]") },
+	[COL_PASSNO]       = { "PASSNO",          1, SCOLS_FL_RIGHT, N_("pass number on parallel fsck(8) [fstab only]") }
+};
+
+/* columns[] array specifies all currently wanted output column. The columns
+ * are defined by infos[] array and you can specify (on command line) each
+ * column twice. That's enough, dynamically allocated array of the columns is
+ * unnecessary overkill and over-engineering in this case */
+static int columns[ARRAY_SIZE(infos) * 2];
+static size_t ncolumns;
+
+static inline size_t err_columns_index(size_t arysz, size_t idx)
+{
+	if (idx >= arysz)
+		errx(EXIT_FAILURE, _("too many columns specified, "
+				     "the limit is %zu columns"),
+				arysz - 1);
+	return idx;
+}
+
+#define add_column(ary, n, id)	\
+		((ary)[ err_columns_index(ARRAY_SIZE(ary), (n)) ] = (id))
+
+/* poll actions (parsed --poll=<list> */
+#define FINDMNT_NACTIONS	4		/* mount, umount, move, remount */
+static int actions[FINDMNT_NACTIONS];
+static int nactions;
+
+/* global (accessed from findmnt-verify.c too) */
+int flags;
+int parse_nerrors;
+struct libmnt_cache *cache;
+
+
+#ifdef HAVE_LIBUDEV
+static struct udev *udev;
+#endif
+
+static int match_func(struct libmnt_fs *fs, void *data __attribute__ ((__unused__)));
+
+
+static int get_column_id(int num)
+{
+	assert(num >= 0);
+	assert((size_t) num < ncolumns);
+	assert((size_t) columns[num] < ARRAY_SIZE(infos));
+	return columns[num];
+}
+
+static struct colinfo *get_column_info(int num)
+{
+	return &infos[ get_column_id(num) ];
+}
+
+static const char *column_id_to_name(int id)
+{
+	assert((size_t) id < ARRAY_SIZE(infos));
+	return infos[id].name;
+}
+
+static const char *get_column_name(int num)
+{
+	return get_column_info(num)->name;
+}
+
+static float get_column_whint(int num)
+{
+	return get_column_info(num)->whint;
+}
+
+static int get_column_flags(int num)
+{
+	return get_column_info(num)->flags;
+}
+
+static const char *get_match(int id)
+{
+	assert((size_t) id < ARRAY_SIZE(infos));
+	return infos[id].match;
+}
+
+static void *get_match_data(int id)
+{
+	assert((size_t) id < ARRAY_SIZE(infos));
+	return infos[id].match_data;
+}
+
+static void set_match(int id, const char *match)
+{
+	assert((size_t) id < ARRAY_SIZE(infos));
+	infos[id].match = match;
+}
+
+static void set_match_data(int id, void *data)
+{
+	assert((size_t) id < ARRAY_SIZE(infos));
+	infos[id].match_data = data;
+}
+
+/*
+ * source match means COL_SOURCE *or* COL_MAJMIN, depends on
+ * data format.
+ */
+static void set_source_match(const char *data)
+{
+	int maj, min;
+
+	if (sscanf(data, "%d:%d", &maj, &min) == 2) {
+		dev_t *devno = xmalloc(sizeof(dev_t));
+
+		*devno = makedev(maj, min);
+		set_match(COL_MAJMIN, data);
+		set_match_data(COL_MAJMIN, (void *) devno);
+		flags |= FL_NOSWAPMATCH;
+	} else
+		set_match(COL_SOURCE, data);
+}
+
+/*
+ * Extra functionality for --target <path>. The function mnt_table_find_mountpoint()
+ * also checks parents (path elements in reverse order) to get mountpoint.
+ *
+ * @tb has to be from kernel (so no fstab or so)!
+ */
+static void enable_extra_target_match(struct libmnt_table *tb)
+{
+	char *cn = NULL;
+	const char *tgt = NULL, *mnt = NULL;
+	struct libmnt_fs *fs;
+
+	/*
+	 * Check if match pattern is mountpoint, if not use the
+	 * real mountpoint.
+	 */
+	if (flags & FL_NOCACHE)
+		tgt = get_match(COL_TARGET);
+	else {
+		tgt = cn = mnt_resolve_path(get_match(COL_TARGET), cache);
+		if (!cn)
+			return;
+	}
+
+	fs = mnt_table_find_mountpoint(tb, tgt, MNT_ITER_BACKWARD);
+	if (fs)
+		mnt = mnt_fs_get_target(fs);
+	if (mnt && strcmp(mnt, tgt) != 0)
+		set_match(COL_TARGET, xstrdup(mnt));	/* replace the current setting */
+
+	if (!cache)
+		free(cn);
+}
+
+
+static int is_tabdiff_column(int id)
+{
+	assert((size_t) id < ARRAY_SIZE(infos));
+
+	switch(id) {
+	case COL_ACTION:
+	case COL_OLD_TARGET:
+	case COL_OLD_OPTIONS:
+		return 1;
+	default:
+		break;
+	}
+	return 0;
+}
+
+/*
+ * "findmnt" without any filter
+ */
+int is_listall_mode(void)
+{
+	if ((flags & FL_DF || flags & FL_REAL || flags & FL_PSEUDO) && !(flags & FL_ALL))
+		return 0;
+
+	return (!get_match(COL_SOURCE) &&
+		!get_match(COL_TARGET) &&
+		!get_match(COL_FSTYPE) &&
+		!get_match(COL_OPTIONS) &&
+		!get_match(COL_MAJMIN));
+}
+
+/*
+ * Returns 1 if the @act is in the --poll=<list>
+ */
+static int has_poll_action(int act)
+{
+	int i;
+
+	if (!nactions)
+		return 1;	/* all actions enabled */
+	for (i = 0; i < nactions; i++)
+		if (actions[i] == act)
+			return 1;
+	return 0;
+}
+
+static int poll_action_name_to_id(const char *name, size_t namesz)
+{
+	int id = -1;
+
+	if (strncasecmp(name, "move", namesz) == 0 && namesz == 4)
+		id = MNT_TABDIFF_MOVE;
+	else if (strncasecmp(name, "mount", namesz) == 0 && namesz == 5)
+		id = MNT_TABDIFF_MOUNT;
+	else if (strncasecmp(name, "umount", namesz) == 0 && namesz == 6)
+		id = MNT_TABDIFF_UMOUNT;
+	else if (strncasecmp(name, "remount", namesz) == 0 && namesz == 7)
+		id = MNT_TABDIFF_REMOUNT;
+	else
+		warnx(_("unknown action: %s"), name);
+
+	return id;
+}
+
+/*
+ * findmnt --first-only <devname|TAG=|mountpoint>
+ *
+ * ... it works like "mount <devname|TAG=|mountpoint>"
+ */
+static int is_mount_compatible_mode(void)
+{
+	if (!get_match(COL_SOURCE))
+	       return 0;		/* <devname|TAG=|mountpoint> is required */
+	if (get_match(COL_FSTYPE) || get_match(COL_OPTIONS))
+		return 0;		/* cannot be restricted by -t or -O */
+	if (!(flags & FL_FIRSTONLY))
+		return 0;		/* we have to return the first entry only */
+
+	return 1;			/* ok */
+}
+
+static void disable_columns_truncate(void)
+{
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(infos); i++)
+		infos[i].flags &= ~SCOLS_FL_TRUNC;
+}
+
+/*
+ * converts @name to column ID
+ */
+static int column_name_to_id(const char *name, size_t namesz)
+{
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(infos); i++) {
+		const char *cn = column_id_to_name(i);
+
+		if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
+			return i;
+	}
+	warnx(_("unknown column: %s"), name);
+	return -1;
+}
+
+
+#ifdef HAVE_LIBUDEV
+static char *get_tag_from_udev(const char *devname, int col)
+{
+	struct udev_device *dev;
+	const char *data = NULL;
+	char *res = NULL, *path;
+
+	if (!udev)
+		udev = udev_new();
+	if (!udev)
+		return NULL;
+
+	/* libudev don't like /dev/mapper/ symlinks */
+	path = realpath(devname, NULL);
+	if (path)
+		devname = path;
+
+	if (strncmp(devname, "/dev/", 5) == 0)
+		devname += 5;
+
+	dev = udev_device_new_from_subsystem_sysname(udev, "block", devname);
+	free(path);
+
+	if (!dev)
+		return NULL;
+
+	switch(col) {
+	case COL_LABEL:
+		data = udev_device_get_property_value(dev, "ID_FS_LABEL_ENC");
+		break;
+	case COL_UUID:
+		data = udev_device_get_property_value(dev, "ID_FS_UUID_ENC");
+		break;
+	case COL_PARTUUID:
+		data = udev_device_get_property_value(dev, "ID_PART_ENTRY_UUID");
+		break;
+	case COL_PARTLABEL:
+		data = udev_device_get_property_value(dev, "ID_PART_ENTRY_NAME");
+		break;
+	default:
+		break;
+	}
+
+	if (data) {
+		res = xstrdup(data);
+		unhexmangle_string(res);
+	}
+
+	udev_device_unref(dev);
+	return res;
+}
+#endif /* HAVE_LIBUDEV */
+
+/* Returns LABEL or UUID */
+static char *get_tag(struct libmnt_fs *fs, const char *tagname, int col
+#ifndef HAVE_LIBUDEV
+		__attribute__((__unused__))
+#endif
+		)
+{
+	const char *t, *v;
+	char *res = NULL;
+
+	if (!mnt_fs_get_tag(fs, &t, &v) && !strcmp(t, tagname))
+		res = xstrdup(v);
+	else {
+		const char *dev = mnt_fs_get_source(fs);
+
+		if (dev && !(flags & FL_NOCACHE))
+			dev = mnt_resolve_spec(dev, cache);
+#ifdef HAVE_LIBUDEV
+		if (dev)
+			res = get_tag_from_udev(dev, col);
+#endif
+		if (!res) {
+			res = mnt_cache_find_tag_value(cache, dev, tagname);
+			if (res && cache)
+				/* don't return pointer to cache */
+				res = xstrdup(res);
+		}
+	}
+
+	return res;
+}
+
+static char *get_vfs_attr(struct libmnt_fs *fs, int sizetype)
+{
+	struct statvfs buf;
+	uint64_t vfs_attr = 0;
+	char *sizestr;
+
+	if (statvfs(mnt_fs_get_target(fs), &buf) != 0)
+		return NULL;
+
+	switch(sizetype) {
+	case COL_SIZE:
+		vfs_attr = buf.f_frsize * buf.f_blocks;
+		break;
+	case COL_AVAIL:
+		vfs_attr = buf.f_frsize * buf.f_bavail;
+		break;
+	case COL_USED:
+		vfs_attr = buf.f_frsize * (buf.f_blocks - buf.f_bfree);
+		break;
+	case COL_USEPERC:
+		if (buf.f_blocks == 0)
+			return xstrdup("-");
+
+		xasprintf(&sizestr, "%.0f%%",
+				(double)(buf.f_blocks - buf.f_bfree) /
+				buf.f_blocks * 100);
+		return sizestr;
+	}
+
+	if (!vfs_attr)
+		sizestr = xstrdup("0");
+	else if (flags & FL_BYTES)
+		xasprintf(&sizestr, "%ju", vfs_attr);
+	else
+		sizestr = size_to_human_string(SIZE_SUFFIX_1LETTER, vfs_attr);
+
+	return sizestr;
+}
+
+/* reads FS data from libmount
+ */
+static char *get_data(struct libmnt_fs *fs, int num)
+{
+	char *str = NULL;
+	int col_id = get_column_id(num);
+
+	switch (col_id) {
+	case COL_SOURCE:
+	{
+		const char *root = mnt_fs_get_root(fs);
+		const char *spec = mnt_fs_get_srcpath(fs);
+		char *cn = NULL;
+
+		if (spec && (flags & FL_CANONICALIZE))
+			spec = cn = mnt_resolve_path(spec, cache);
+		if (!spec) {
+			spec = mnt_fs_get_source(fs);
+
+			if (spec && (flags & FL_EVALUATE))
+				spec = cn = mnt_resolve_spec(spec, cache);
+		}
+		if (root && spec && !(flags & FL_NOFSROOT) && strcmp(root, "/") != 0)
+			xasprintf(&str, "%s[%s]", spec, root);
+		else if (spec)
+			str = xstrdup(spec);
+		if (!cache)
+			free(cn);
+		break;
+	}
+	case COL_TARGET:
+		if (mnt_fs_get_target(fs))
+			str = xstrdup(mnt_fs_get_target(fs));
+		break;
+	case COL_FSTYPE:
+		if (mnt_fs_get_fstype(fs))
+			str = xstrdup(mnt_fs_get_fstype(fs));
+		break;
+	case COL_OPTIONS:
+		if (mnt_fs_get_options(fs))
+			str = xstrdup(mnt_fs_get_options(fs));
+		break;
+	case COL_VFS_OPTIONS:
+		if (mnt_fs_get_vfs_options(fs))
+			str = xstrdup(mnt_fs_get_vfs_options(fs));
+		break;
+	case COL_FS_OPTIONS:
+		if (mnt_fs_get_fs_options(fs))
+			str = xstrdup(mnt_fs_get_fs_options(fs));
+		break;
+	case COL_OPT_FIELDS:
+		if (mnt_fs_get_optional_fields(fs))
+			str = xstrdup(mnt_fs_get_optional_fields(fs));
+		break;
+	case COL_UUID:
+		str = get_tag(fs, "UUID", col_id);
+		break;
+	case COL_PARTUUID:
+		str = get_tag(fs, "PARTUUID", col_id);
+		break;
+	case COL_LABEL:
+		str = get_tag(fs, "LABEL", col_id);
+		break;
+	case COL_PARTLABEL:
+		str = get_tag(fs, "PARTLABEL", col_id);
+		break;
+
+	case COL_MAJMIN:
+	{
+		dev_t devno = mnt_fs_get_devno(fs);
+		if (!devno)
+			break;
+
+		if ((flags & FL_RAW) || (flags & FL_EXPORT) || (flags & FL_JSON))
+			xasprintf(&str, "%u:%u", major(devno), minor(devno));
+		else
+			xasprintf(&str, "%3u:%-3u", major(devno), minor(devno));
+		break;
+	}
+	case COL_SIZE:
+	case COL_AVAIL:
+	case COL_USED:
+	case COL_USEPERC:
+		str = get_vfs_attr(fs, col_id);
+		break;
+	case COL_FSROOT:
+		if (mnt_fs_get_root(fs))
+			str = xstrdup(mnt_fs_get_root(fs));
+		break;
+	case COL_TID:
+		if (mnt_fs_get_tid(fs))
+			xasprintf(&str, "%d", mnt_fs_get_tid(fs));
+		break;
+	case COL_ID:
+		if (mnt_fs_get_id(fs))
+			xasprintf(&str, "%d", mnt_fs_get_id(fs));
+		break;
+	case COL_PROPAGATION:
+		if (mnt_fs_is_kernel(fs)) {
+			unsigned long fl = 0;
+			char *n = NULL;
+
+			if (mnt_fs_get_propagation(fs, &fl) != 0)
+				break;
+
+			n = xstrdup((fl & MS_SHARED) ? "shared" : "private");
+
+			if (fl & MS_SLAVE) {
+				xasprintf(&str, "%s,slave", n);
+				free(n);
+				n = str;
+			}
+			if (fl & MS_UNBINDABLE) {
+				xasprintf(&str, "%s,unbindable", n);
+				free(n);
+				n = str;
+			}
+			str = n;
+		}
+		break;
+	case COL_FREQ:
+		if (!mnt_fs_is_kernel(fs))
+			xasprintf(&str, "%d", mnt_fs_get_freq(fs));
+		break;
+	case COL_PASSNO:
+		if (!mnt_fs_is_kernel(fs))
+			xasprintf(&str, "%d", mnt_fs_get_passno(fs));
+		break;
+	default:
+		break;
+	}
+	return str;
+}
+
+static char *get_tabdiff_data(struct libmnt_fs *old_fs,
+				    struct libmnt_fs *new_fs,
+				    int change,
+				    int num)
+{
+	char *str = NULL;
+
+	switch (get_column_id(num)) {
+	case COL_ACTION:
+		switch (change) {
+		case MNT_TABDIFF_MOUNT:
+			str = _("mount");
+			break;
+		case MNT_TABDIFF_UMOUNT:
+			str = _("umount");
+			break;
+		case MNT_TABDIFF_REMOUNT:
+			str = _("remount");
+			break;
+		case MNT_TABDIFF_MOVE:
+			str = _("move");
+			break;
+		default:
+			str = _("unknown");
+			break;
+		}
+		str = xstrdup(str);
+		break;
+	case COL_OLD_OPTIONS:
+		if (old_fs && (change == MNT_TABDIFF_REMOUNT ||
+			       change == MNT_TABDIFF_UMOUNT)
+		           && mnt_fs_get_options(old_fs))
+			str = xstrdup(mnt_fs_get_options(old_fs));
+		break;
+	case COL_OLD_TARGET:
+		if (old_fs && (change == MNT_TABDIFF_MOVE ||
+			       change == MNT_TABDIFF_UMOUNT)
+			   && mnt_fs_get_target(old_fs))
+			str = xstrdup(mnt_fs_get_target(old_fs));
+		break;
+	default:
+		if (new_fs)
+			str = get_data(new_fs, num);
+		else
+			str = get_data(old_fs, num);
+		break;
+	}
+	return str;
+}
+
+/* adds one line to the output @tab */
+static struct libscols_line *add_line(struct libscols_table *table, struct libmnt_fs *fs,
+					struct libscols_line *parent)
+{
+	size_t i;
+	struct libscols_line *line = scols_table_new_line(table, parent);
+
+	if (!line)
+		err(EXIT_FAILURE, _("failed to allocate output line"));
+
+	for (i = 0; i < ncolumns; i++) {
+		if (scols_line_refer_data(line, i, get_data(fs, i)))
+			err(EXIT_FAILURE, _("failed to add output data"));
+	}
+
+	scols_line_set_userdata(line, fs);
+	return line;
+}
+
+static struct libscols_line *add_tabdiff_line(struct libscols_table *table, struct libmnt_fs *new_fs,
+			struct libmnt_fs *old_fs, int change)
+{
+	size_t i;
+	struct libscols_line *line = scols_table_new_line(table, NULL);
+
+	if (!line)
+		err(EXIT_FAILURE, _("failed to allocate output line"));
+
+	for (i = 0; i < ncolumns; i++) {
+		if (scols_line_refer_data(line, i,
+				get_tabdiff_data(old_fs, new_fs, change, i)))
+			err(EXIT_FAILURE, _("failed to add output data"));
+	}
+
+	return line;
+}
+
+static int has_line(struct libscols_table *table, struct libmnt_fs *fs)
+{
+	struct libscols_line *ln;
+	struct libscols_iter *itr;
+	int rc = 0;
+
+	itr = scols_new_iter(SCOLS_ITER_FORWARD);
+	if (!itr)
+		return 0;
+
+	while (scols_table_next_line(table, itr, &ln) == 0) {
+		if ((struct libmnt_fs *) scols_line_get_userdata(ln) == fs) {
+			rc = 1;
+			break;
+		}
+	}
+
+	scols_free_iter(itr);
+	return rc;
+}
+
+/* reads filesystems from @tb (libmount) and fillin @table (output table) */
+static int create_treenode(struct libscols_table *table, struct libmnt_table *tb,
+			   struct libmnt_fs *fs, struct libscols_line *parent_line)
+{
+	struct libmnt_fs *chld = NULL;
+	struct libmnt_iter *itr = NULL;
+	struct libscols_line *line;
+	int rc = -1;
+
+	if (!fs) {
+		/* first call, get root FS */
+		if (mnt_table_get_root_fs(tb, &fs))
+			goto leave;
+		parent_line = NULL;
+
+	} else if ((flags & FL_SUBMOUNTS) && has_line(table, fs))
+		return 0;
+
+	itr = mnt_new_iter(MNT_ITER_FORWARD);
+	if (!itr)
+		goto leave;
+
+	if ((flags & FL_SUBMOUNTS) || match_func(fs, NULL)) {
+		line = add_line(table, fs, parent_line);
+		if (!line)
+			goto leave;
+	} else
+		line = parent_line;
+
+	/*
+	 * add all children to the output table
+	 */
+	while(mnt_table_next_child_fs(tb, itr, fs, &chld) == 0) {
+		if (create_treenode(table, tb, chld, line))
+			goto leave;
+	}
+	rc = 0;
+leave:
+	mnt_free_iter(itr);
+	return rc;
+}
+
+/* error callback */
+static int parser_errcb(struct libmnt_table *tb __attribute__ ((__unused__)),
+			const char *filename, int line)
+{
+	warnx(_("%s: parse error at line %d -- ignored"), filename, line);
+	++parse_nerrors;
+	return 1;
+}
+
+static char **append_tabfile(char **files, int *nfiles, char *filename)
+{
+	files = xrealloc(files, sizeof(char *) * (*nfiles + 1));
+	files[(*nfiles)++] = filename;
+	return files;
+}
+
+static char **append_pid_tabfile(char **files, int *nfiles, pid_t pid)
+{
+	char *path = NULL;
+
+	xasprintf(&path, "/proc/%d/mountinfo", (int) pid);
+	return append_tabfile(files, nfiles, path);
+}
+
+/* calls libmount fstab/mtab/mountinfo parser */
+static struct libmnt_table *parse_tabfiles(char **files,
+					   int nfiles,
+					   int tabtype)
+{
+	struct libmnt_table *tb;
+	int rc = 0;
+
+	tb = mnt_new_table();
+	if (!tb) {
+		warn(_("failed to initialize libmount table"));
+		return NULL;
+	}
+	mnt_table_set_parser_errcb(tb, parser_errcb);
+
+	do {
+		/* NULL means that libmount will use default paths */
+		const char *path = nfiles ? *files++ : NULL;
+
+		switch (tabtype) {
+		case TABTYPE_FSTAB:
+			rc = mnt_table_parse_fstab(tb, path);
+			break;
+		case TABTYPE_MTAB:
+			rc = mnt_table_parse_mtab(tb, path);
+			break;
+		case TABTYPE_KERNEL:
+			if (!path)
+				path = access(_PATH_PROC_MOUNTINFO, R_OK) == 0 ?
+					      _PATH_PROC_MOUNTINFO :
+					      _PATH_PROC_MOUNTS;
+
+			rc = mnt_table_parse_file(tb, path);
+			break;
+		}
+		if (rc) {
+			mnt_unref_table(tb);
+			warn(_("can't read %s"), path);
+			return NULL;
+		}
+	} while (--nfiles > 0);
+
+	return tb;
+}
+
+/*
+ * Parses mountinfo and calls mnt_cache_set_targets(cache, mtab). Only
+ * necessary if @tb in main() was read from a non-kernel source.
+ */
+static void cache_set_targets(struct libmnt_cache *tmp)
+{
+	struct libmnt_table *tb;
+	const char *path;
+
+	tb = mnt_new_table();
+	if (!tb)
+		return;
+
+	path = access(_PATH_PROC_MOUNTINFO, R_OK) == 0 ?
+		_PATH_PROC_MOUNTINFO :
+		_PATH_PROC_MOUNTS;
+
+	if (mnt_table_parse_file(tb, path) == 0)
+		mnt_cache_set_targets(tmp, tb);
+
+	mnt_unref_table(tb);
+}
+
+/* checks if @tb contains parent->child relations */
+static int tab_is_tree(struct libmnt_table *tb)
+{
+	struct libmnt_fs *fs = NULL;
+	struct libmnt_iter *itr;
+	int rc = 0;
+
+	itr = mnt_new_iter(MNT_ITER_BACKWARD);
+	if (!itr)
+		return 0;
+
+	rc = (mnt_table_next_fs(tb, itr, &fs) == 0 &&
+	      mnt_fs_is_kernel(fs) &&
+	      mnt_fs_get_root(fs));
+
+	mnt_free_iter(itr);
+	return rc;
+}
+
+/* checks if all fs in @tb are from kernel */
+static int tab_is_kernel(struct libmnt_table *tb)
+{
+	struct libmnt_fs *fs = NULL;
+	struct libmnt_iter *itr;
+
+	itr = mnt_new_iter(MNT_ITER_BACKWARD);
+	if (!itr)
+		return 0;
+
+	while (mnt_table_next_fs(tb, itr, &fs) == 0) {
+		if (!mnt_fs_is_kernel(fs)) {
+			mnt_free_iter(itr);
+			return 0;
+		}
+	}
+
+	mnt_free_iter(itr);
+	return 1;
+}
+
+/* filter function for libmount (mnt_table_find_next_fs()) */
+static int match_func(struct libmnt_fs *fs,
+		      void *data __attribute__ ((__unused__)))
+{
+	int rc = flags & FL_INVERT ? 1 : 0;
+	const char *m;
+	void *md;
+
+	m = get_match(COL_FSTYPE);
+	if (m && !mnt_fs_match_fstype(fs, m))
+		return rc;
+
+	m = get_match(COL_OPTIONS);
+	if (m && !mnt_fs_match_options(fs, m))
+		return rc;
+
+	md = get_match_data(COL_MAJMIN);
+	if (md && mnt_fs_get_devno(fs) != *((dev_t *) md))
+		return rc;
+
+	m = get_match(COL_TARGET);
+	if (m && !mnt_fs_match_target(fs, m, cache))
+		return rc;
+
+	m = get_match(COL_SOURCE);
+	if (m && !mnt_fs_match_source(fs, m, cache))
+		return rc;
+
+	if ((flags & FL_DF) && !(flags & FL_ALL)) {
+		const char *type = mnt_fs_get_fstype(fs);
+
+		if (type && strstr(type, "tmpfs"))	/* tmpfs is wanted */
+			return !rc;
+
+		if (mnt_fs_is_pseudofs(fs))
+			return rc;
+	}
+
+	if ((flags & FL_REAL) && mnt_fs_is_pseudofs(fs))
+	    return rc;
+
+	if ((flags & FL_PSEUDO) && !mnt_fs_is_pseudofs(fs))
+	    return rc;
+
+	return !rc;
+}
+
+/* iterate over filesystems in @tb */
+struct libmnt_fs *get_next_fs(struct libmnt_table *tb,
+				     struct libmnt_iter *itr)
+{
+	struct libmnt_fs *fs = NULL;
+
+	if (is_listall_mode()) {
+		/*
+		 * Print whole file
+		 */
+		if (mnt_table_next_fs(tb, itr, &fs) != 0)
+			return NULL;
+
+	} else if (is_mount_compatible_mode()) {
+		/*
+		 * Look up for FS in the same way how mount(8) searches in fstab
+		 *
+		 *   findmnt -f <spec>
+		 */
+		fs = mnt_table_find_source(tb, get_match(COL_SOURCE),
+					mnt_iter_get_direction(itr));
+
+		if (!fs && !(flags & FL_NOSWAPMATCH))
+			fs = mnt_table_find_target(tb, get_match(COL_SOURCE),
+					mnt_iter_get_direction(itr));
+	} else {
+		/*
+		 * Look up for all matching entries
+		 *
+		 *    findmnt [-l] <source> <target> [-O <options>] [-t <types>]
+		 *    findmnt [-l] <spec> [-O <options>] [-t <types>]
+		 */
+again:
+		if (mnt_table_find_next_fs(tb, itr, match_func,  NULL, &fs) != 0)
+			fs = NULL;
+
+		if (!fs &&
+		    !(flags & FL_NOSWAPMATCH) &&
+		    !get_match(COL_TARGET) && get_match(COL_SOURCE)) {
+
+			/* swap 'spec' and target. */
+			set_match(COL_TARGET, get_match(COL_SOURCE));
+			set_match(COL_SOURCE, NULL);
+			mnt_reset_iter(itr, -1);
+
+			goto again;
+		}
+	}
+
+	return fs;
+}
+
+/*
+ * Filter out unwanted lines for --list output or top level lines for
+ * --submounts tree output.
+ */
+static int add_matching_lines(struct libmnt_table *tb,
+			      struct libscols_table *table, int direction)
+{
+	struct libmnt_iter *itr;
+	struct libmnt_fs *fs;
+	int nlines = 0, rc = -1;
+
+	itr = mnt_new_iter(direction);
+	if (!itr) {
+		warn(_("failed to initialize libmount iterator"));
+		goto done;
+	}
+
+	while((fs = get_next_fs(tb, itr))) {
+		if ((flags & FL_TREE) || (flags & FL_SUBMOUNTS))
+			rc = create_treenode(table, tb, fs, NULL);
+		else
+			rc = !add_line(table, fs, NULL);
+		if (rc)
+			goto done;
+		nlines++;
+		if (flags & FL_FIRSTONLY)
+			break;
+		flags |= FL_NOSWAPMATCH;
+	}
+
+	if (nlines)
+		rc = 0;
+done:
+	mnt_free_iter(itr);
+	return rc;
+}
+
+static int poll_match(struct libmnt_fs *fs)
+{
+	int rc = match_func(fs, NULL);
+
+	if (rc == 0 && !(flags & FL_NOSWAPMATCH) &&
+	    get_match(COL_SOURCE) && !get_match(COL_TARGET)) {
+		/*
+		 * findmnt --poll /foo
+		 * The '/foo' maybe source as well as target.
+		 */
+		const char *str = get_match(COL_SOURCE);
+
+		set_match(COL_TARGET, str);	/* swap */
+		set_match(COL_SOURCE, NULL);
+
+		rc = match_func(fs, NULL);
+
+		set_match(COL_TARGET, NULL);	/* restore */
+		set_match(COL_SOURCE, str);
+
+	}
+	return rc;
+}
+
+static int poll_table(struct libmnt_table *tb, const char *tabfile,
+		  int timeout, struct libscols_table *table, int direction)
+{
+	FILE *f = NULL;
+	int rc = -1;
+	struct libmnt_iter *itr = NULL;
+	struct libmnt_table *tb_new;
+	struct libmnt_tabdiff *diff = NULL;
+	struct pollfd fds[1];
+
+	tb_new = mnt_new_table();
+	if (!tb_new) {
+		warn(_("failed to initialize libmount table"));
+		goto done;
+	}
+
+	itr = mnt_new_iter(direction);
+	if (!itr) {
+		warn(_("failed to initialize libmount iterator"));
+		goto done;
+	}
+
+	diff = mnt_new_tabdiff();
+	if (!diff) {
+		warn(_("failed to initialize libmount tabdiff"));
+		goto done;
+	}
+
+	/* cache is unnecessary to detect changes */
+	mnt_table_set_cache(tb, NULL);
+	mnt_table_set_cache(tb_new, NULL);
+
+	f = fopen(tabfile, "r");
+	if (!f) {
+		warn(_("cannot open %s"), tabfile);
+		goto done;
+	}
+
+	mnt_table_set_parser_errcb(tb_new, parser_errcb);
+
+	fds[0].fd = fileno(f);
+	fds[0].events = POLLPRI;
+
+	while (1) {
+		struct libmnt_table *tmp;
+		struct libmnt_fs *old, *new;
+		int change, count;
+
+		count = poll(fds, 1, timeout);
+		if (count == 0)
+			break;	/* timeout */
+		if (count < 0) {
+			warn(_("poll() failed"));
+			goto done;
+		}
+
+		rewind(f);
+		rc = mnt_table_parse_stream(tb_new, f, tabfile);
+		if (!rc)
+			rc = mnt_diff_tables(diff, tb, tb_new);
+		if (rc < 0)
+			goto done;
+
+		count = 0;
+		mnt_reset_iter(itr, direction);
+		while(mnt_tabdiff_next_change(
+				diff, itr, &old, &new, &change) == 0) {
+
+			if (!has_poll_action(change))
+				continue;
+			if (!poll_match(new ? new : old))
+				continue;
+			count++;
+			rc = !add_tabdiff_line(table, new, old, change);
+			if (rc)
+				goto done;
+			if (flags & FL_FIRSTONLY)
+				break;
+		}
+
+		if (count) {
+			rc = scols_table_print_range(table, NULL, NULL);
+			if (rc == 0)
+				fputc('\n', scols_table_get_stream(table));
+			fflush(stdout);
+			if (rc)
+				goto done;
+		}
+
+		/* swap tables */
+		tmp = tb;
+		tb = tb_new;
+		tb_new = tmp;
+
+		/* remove already printed lines to reduce memory usage */
+		scols_table_remove_lines(table);
+		mnt_reset_table(tb_new);
+
+		if (count && (flags & FL_FIRSTONLY))
+			break;
+	}
+
+	rc = 0;
+done:
+	mnt_unref_table(tb_new);
+	mnt_free_tabdiff(diff);
+	mnt_free_iter(itr);
+	if (f)
+		fclose(f);
+	return rc;
+}
+
+static int uniq_fs_target_cmp(
+		struct libmnt_table *tb __attribute__((__unused__)),
+		struct libmnt_fs *a,
+		struct libmnt_fs *b)
+{
+	return !mnt_fs_match_target(a, mnt_fs_get_target(b), cache);
+}
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+	size_t i;
+
+	fputs(USAGE_HEADER, out);
+	fprintf(out, _(
+	" %1$s [options]\n"
+	" %1$s [options] <device> | <mountpoint>\n"
+	" %1$s [options] <device> <mountpoint>\n"
+	" %1$s [options] [--source <device>] [--target <path> | --mountpoint <dir>]\n"),
+		program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("Find a (mounted) filesystem.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -s, --fstab            search in static table of filesystems\n"), out);
+	fputs(_(" -m, --mtab             search in table of mounted filesystems\n"
+		"                          (includes user space mount options)\n"), out);
+	fputs(_(" -k, --kernel           search in kernel table of mounted\n"
+		"                          filesystems (default)\n"), out);
+	fputc('\n', out);
+	fputs(_(" -p, --poll[=<list>]    monitor changes in table of mounted filesystems\n"), out);
+	fputs(_(" -w, --timeout <num>    upper limit in milliseconds that --poll will block\n"), out);
+	fputc('\n', out);
+
+	fputs(_(" -A, --all              disable all built-in filters, print all filesystems\n"), out);
+	fputs(_(" -a, --ascii            use ASCII chars for tree formatting\n"), out);
+	fputs(_(" -b, --bytes            print sizes in bytes rather than in human readable format\n"), out);
+	fputs(_(" -C, --nocanonicalize   don't canonicalize when comparing paths\n"), out);
+	fputs(_(" -c, --canonicalize     canonicalize printed paths\n"), out);
+	fputs(_(" -D, --df               imitate the output of df(1)\n"), out);
+	fputs(_(" -d, --direction <word> direction of search, 'forward' or 'backward'\n"), out);
+	fputs(_(" -e, --evaluate         convert tags (LABEL,UUID,PARTUUID,PARTLABEL) \n"
+	        "                          to device names\n"), out);
+	fputs(_(" -F, --tab-file <path>  alternative file for -s, -m or -k options\n"), out);
+	fputs(_(" -f, --first-only       print the first found filesystem only\n"), out);
+	fputs(_(" -i, --invert           invert the sense of matching\n"), out);
+	fputs(_(" -J, --json             use JSON output format\n"), out);
+	fputs(_(" -l, --list             use list format output\n"), out);
+	fputs(_(" -N, --task <tid>       use alternative namespace (/proc/<tid>/mountinfo file)\n"), out);
+	fputs(_(" -n, --noheadings       don't print column headings\n"), out);
+	fputs(_(" -O, --options <list>   limit the set of filesystems by mount options\n"), out);
+	fputs(_(" -o, --output <list>    the output columns to be shown\n"), out);
+	fputs(_("     --output-all       output all available columns\n"), out);
+	fputs(_(" -P, --pairs            use key=\"value\" output format\n"), out);
+	fputs(_("     --pseudo           print only pseudo-filesystems\n"), out);
+	fputs(_(" -R, --submounts        print all submounts for the matching filesystems\n"), out);
+	fputs(_(" -r, --raw              use raw output format\n"), out);
+	fputs(_("     --real             print only real filesystems\n"), out);
+	fputs(_(" -S, --source <string>  the device to mount (by name, maj:min, \n"
+	        "                          LABEL=, UUID=, PARTUUID=, PARTLABEL=)\n"), out);
+	fputs(_(" -T, --target <path>    the path to the filesystem to use\n"), out);
+	fputs(_("     --tree             enable tree format output is possible\n"), out);
+	fputs(_(" -M, --mountpoint <dir> the mountpoint directory\n"), out);
+	fputs(_(" -t, --types <list>     limit the set of filesystems by FS types\n"), out);
+	fputs(_(" -U, --uniq             ignore filesystems with duplicate target\n"), out);
+	fputs(_(" -u, --notruncate       don't truncate text in columns\n"), out);
+	fputs(_(" -v, --nofsroot         don't print [/dir] for bind or btrfs mounts\n"), out);
+
+	fputc('\n', out);
+	fputs(_(" -x, --verify           verify mount table content (default is fstab)\n"), out);
+	fputs(_("     --verbose          print more details\n"), out);
+
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(24));
+
+	fputs(USAGE_COLUMNS, out);
+	for (i = 0; i < ARRAY_SIZE(infos); i++)
+		fprintf(out, " %11s  %s\n", infos[i].name, _(infos[i].help));
+
+	printf(USAGE_MAN_TAIL("findmnt(8)"));
+
+	exit(EXIT_SUCCESS);
+}
+
+int main(int argc, char *argv[])
+{
+	struct libmnt_table *tb = NULL;
+	char **tabfiles = NULL;
+	int direction = MNT_ITER_FORWARD;
+	int verify = 0;
+	int c, rc = -1, timeout = -1;
+	int ntabfiles = 0, tabtype = 0;
+	char *outarg = NULL;
+	size_t i;
+	int force_tree = 0, istree = 0;
+
+	struct libscols_table *table = NULL;
+
+	enum {
+		FINDMNT_OPT_VERBOSE = CHAR_MAX + 1,
+		FINDMNT_OPT_TREE,
+		FINDMNT_OPT_OUTPUT_ALL,
+		FINDMNT_OPT_PSEUDO,
+		FINDMNT_OPT_REAL
+	};
+
+	static const struct option longopts[] = {
+		{ "all",	    no_argument,       NULL, 'A'		 },
+		{ "ascii",	    no_argument,       NULL, 'a'		 },
+		{ "bytes",	    no_argument,       NULL, 'b'		 },
+		{ "canonicalize",   no_argument,       NULL, 'c'		 },
+		{ "direction",	    required_argument, NULL, 'd'		 },
+		{ "df",		    no_argument,       NULL, 'D'		 },
+		{ "evaluate",	    no_argument,       NULL, 'e'		 },
+		{ "first-only",	    no_argument,       NULL, 'f'		 },
+		{ "fstab",	    no_argument,       NULL, 's'		 },
+		{ "help",	    no_argument,       NULL, 'h'		 },
+		{ "invert",	    no_argument,       NULL, 'i'		 },
+		{ "json",	    no_argument,       NULL, 'J'		 },
+		{ "kernel",	    no_argument,       NULL, 'k'		 },
+		{ "list",	    no_argument,       NULL, 'l'		 },
+		{ "mountpoint",	    required_argument, NULL, 'M'		 },
+		{ "mtab",	    no_argument,       NULL, 'm'		 },
+		{ "noheadings",	    no_argument,       NULL, 'n'		 },
+		{ "notruncate",	    no_argument,       NULL, 'u'		 },
+		{ "options",	    required_argument, NULL, 'O'		 },
+		{ "output",	    required_argument, NULL, 'o'		 },
+		{ "output-all",	    no_argument,       NULL, FINDMNT_OPT_OUTPUT_ALL },
+		{ "poll",	    optional_argument, NULL, 'p'		 },
+		{ "pairs",	    no_argument,       NULL, 'P'		 },
+		{ "raw",	    no_argument,       NULL, 'r'		 },
+		{ "types",	    required_argument, NULL, 't'		 },
+		{ "nocanonicalize", no_argument,       NULL, 'C'		 },
+		{ "nofsroot",	    no_argument,       NULL, 'v'		 },
+		{ "submounts",	    no_argument,       NULL, 'R'		 },
+		{ "source",	    required_argument, NULL, 'S'		 },
+		{ "tab-file",	    required_argument, NULL, 'F'		 },
+		{ "task",	    required_argument, NULL, 'N'		 },
+		{ "target",	    required_argument, NULL, 'T'		 },
+		{ "timeout",	    required_argument, NULL, 'w'		 },
+		{ "uniq",	    no_argument,       NULL, 'U'		 },
+		{ "verify",	    no_argument,       NULL, 'x'		 },
+		{ "version",	    no_argument,       NULL, 'V'		 },
+		{ "verbose",	    no_argument,       NULL, FINDMNT_OPT_VERBOSE },
+		{ "tree",	    no_argument,       NULL, FINDMNT_OPT_TREE	 },
+		{ "real",	    no_argument,       NULL, FINDMNT_OPT_REAL	 },
+		{ "pseudo",	    no_argument,       NULL, FINDMNT_OPT_PSEUDO	 },
+		{ NULL, 0, NULL, 0 }
+	};
+
+	static const ul_excl_t excl[] = {	/* rows and cols in ASCII order */
+		{ 'C', 'c'},			/* [no]canonicalize */
+		{ 'C', 'e' },			/* nocanonicalize, evaluate */
+		{ 'J', 'P', 'r','x' },		/* json,pairs,raw,verify */
+		{ 'M', 'T' },			/* mountpoint, target */
+		{ 'N','k','m','s' },		/* task,kernel,mtab,fstab */
+		{ 'P','l','r','x' },		/* pairs,list,raw,verify */
+		{ 'p','x' },			/* poll,verify */
+		{ 'm','p','s' },		/* mtab,poll,fstab */
+		{ FINDMNT_OPT_PSEUDO, FINDMNT_OPT_REAL },
+		{ 0 }
+	};
+	int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	/* default output format */
+	flags |= FL_TREE;
+
+	while ((c = getopt_long(argc, argv,
+				"AabCcDd:ehiJfF:o:O:p::PklmM:nN:rst:uvRS:T:Uw:Vx",
+				longopts, NULL)) != -1) {
+
+		err_exclusive_options(c, longopts, excl, excl_st);
+
+		switch(c) {
+		case 'A':
+			flags |= FL_ALL;
+			break;
+		case 'a':
+			flags |= FL_ASCII;
+			break;
+		case 'b':
+			flags |= FL_BYTES;
+			break;
+		case 'C':
+			flags |= FL_NOCACHE;
+			break;
+		case 'c':
+			flags |= FL_CANONICALIZE;
+			break;
+		case 'D':
+			flags &= ~FL_TREE;
+			flags |= FL_DF;
+			break;
+		case 'd':
+			if (!strcmp(optarg, "forward"))
+				direction = MNT_ITER_FORWARD;
+			else if (!strcmp(optarg, "backward"))
+				direction = MNT_ITER_BACKWARD;
+			else
+				errx(EXIT_FAILURE,
+					_("unknown direction '%s'"), optarg);
+			break;
+		case 'e':
+			flags |= FL_EVALUATE;
+			break;
+		case 'i':
+			flags |= FL_INVERT;
+			break;
+		case 'J':
+			flags |= FL_JSON;
+			break;
+		case 'f':
+			flags |= FL_FIRSTONLY;
+			break;
+		case 'F':
+			tabfiles = append_tabfile(tabfiles, &ntabfiles, optarg);
+			break;
+		case 'u':
+			disable_columns_truncate();
+			break;
+		case 'o':
+			outarg = optarg;
+			break;
+		case FINDMNT_OPT_OUTPUT_ALL:
+			for (ncolumns = 0; ncolumns < ARRAY_SIZE(infos); ncolumns++) {
+				if (is_tabdiff_column(ncolumns))
+					continue;
+				columns[ncolumns] = ncolumns;
+			}
+			break;
+		case 'O':
+			set_match(COL_OPTIONS, optarg);
+			break;
+		case 'p':
+			if (optarg) {
+				nactions = string_to_idarray(optarg,
+						actions, ARRAY_SIZE(actions),
+						poll_action_name_to_id);
+				if (nactions < 0)
+					exit(EXIT_FAILURE);
+			}
+			flags |= FL_POLL;
+			flags &= ~FL_TREE;
+			break;
+		case 'P':
+			flags |= FL_EXPORT;
+			flags &= ~FL_TREE;
+			break;
+		case 'm':		/* mtab */
+			tabtype = TABTYPE_MTAB;
+			flags &= ~FL_TREE;
+			break;
+		case 's':		/* fstab */
+			tabtype = TABTYPE_FSTAB;
+			flags &= ~FL_TREE;
+			break;
+		case 'k':		/* kernel (mountinfo) */
+			tabtype = TABTYPE_KERNEL;
+			break;
+		case 't':
+			set_match(COL_FSTYPE, optarg);
+			break;
+		case 'r':
+			flags &= ~FL_TREE;	/* disable the default */
+			flags |= FL_RAW;	/* enable raw */
+			break;
+		case 'l':
+			flags &= ~FL_TREE;	/* disable the default */
+			break;
+		case 'n':
+			flags |= FL_NOHEADINGS;
+			break;
+		case 'N':
+			tabtype = TABTYPE_KERNEL;
+			tabfiles = append_pid_tabfile(tabfiles, &ntabfiles,
+					strtou32_or_err(optarg,
+						_("invalid TID argument")));
+			break;
+		case 'v':
+			flags |= FL_NOFSROOT;
+			break;
+		case 'R':
+			flags |= FL_SUBMOUNTS;
+			break;
+		case 'S':
+			set_source_match(optarg);
+			flags |= FL_NOSWAPMATCH;
+			break;
+		case 'M':
+			flags |= FL_STRICTTARGET;
+			/* fallthrough */
+		case 'T':
+			set_match(COL_TARGET, optarg);
+			flags |= FL_NOSWAPMATCH;
+			break;
+		case 'U':
+			flags |= FL_UNIQ;
+			break;
+		case 'w':
+			timeout = strtos32_or_err(optarg, _("invalid timeout argument"));
+			break;
+		case 'x':
+			verify = 1;
+			break;
+		case FINDMNT_OPT_VERBOSE:
+			flags |= FL_VERBOSE;
+			break;
+		case FINDMNT_OPT_TREE:
+			force_tree = 1;
+			break;
+		case FINDMNT_OPT_PSEUDO:
+			flags |= FL_PSEUDO;
+			break;
+		case FINDMNT_OPT_REAL:
+			flags |= FL_REAL;
+			break;
+
+		case 'h':
+			usage();
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+
+	if (!ncolumns && (flags & FL_DF)) {
+		add_column(columns, ncolumns++, COL_SOURCE);
+		add_column(columns, ncolumns++, COL_FSTYPE);
+		add_column(columns, ncolumns++, COL_SIZE);
+		add_column(columns, ncolumns++, COL_USED);
+		add_column(columns, ncolumns++, COL_AVAIL);
+		add_column(columns, ncolumns++, COL_USEPERC);
+		add_column(columns, ncolumns++, COL_TARGET);
+	}
+
+	/* default columns */
+	if (!ncolumns) {
+		if (flags & FL_POLL)
+			add_column(columns, ncolumns++, COL_ACTION);
+
+		add_column(columns, ncolumns++, COL_TARGET);
+		add_column(columns, ncolumns++, COL_SOURCE);
+		add_column(columns, ncolumns++, COL_FSTYPE);
+		add_column(columns, ncolumns++, COL_OPTIONS);
+	}
+
+	if (outarg && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns),
+					 &ncolumns, column_name_to_id) < 0)
+		return EXIT_FAILURE;
+
+	if (!tabtype)
+		tabtype = verify ? TABTYPE_FSTAB : TABTYPE_KERNEL;
+
+	if ((flags & FL_POLL) && ntabfiles > 1)
+		errx(EXIT_FAILURE, _("--poll accepts only one file, but more specified by --tab-file"));
+
+	if (optind < argc && (get_match(COL_SOURCE) || get_match(COL_TARGET)))
+		errx(EXIT_FAILURE, _(
+			"options --target and --source can't be used together "
+			"with command line element that is not an option"));
+
+	if (optind < argc)
+		set_source_match(argv[optind++]);	/* dev/tag/mountpoint/maj:min */
+	if (optind < argc)
+		set_match(COL_TARGET, argv[optind++]);	/* mountpoint */
+
+	if ((flags & FL_SUBMOUNTS) && is_listall_mode())
+		/* don't care about submounts if list all mounts */
+		flags &= ~FL_SUBMOUNTS;
+
+	if (!(flags & FL_SUBMOUNTS) && ((flags & FL_FIRSTONLY)
+	    || get_match(COL_TARGET)
+	    || get_match(COL_SOURCE)
+	    || get_match(COL_MAJMIN)))
+		flags &= ~FL_TREE;
+
+	if (!(flags & FL_NOSWAPMATCH) &&
+	    !get_match(COL_TARGET) && get_match(COL_SOURCE)) {
+		/*
+		 * Check if we can swap source and target, it's
+		 * not possible if the source is LABEL=/UUID=
+		 */
+		const char *x = get_match(COL_SOURCE);
+
+		if (!strncmp(x, "LABEL=", 6) || !strncmp(x, "UUID=", 5) ||
+		    !strncmp(x, "PARTLABEL=", 10) || !strncmp(x, "PARTUUID=", 9))
+			flags |= FL_NOSWAPMATCH;
+	}
+
+	/*
+	 * initialize libmount
+	 */
+	mnt_init_debug(0);
+
+	tb = parse_tabfiles(tabfiles, ntabfiles, tabtype);
+	if (!tb)
+		goto leave;
+
+	if (tabtype == TABTYPE_MTAB && tab_is_kernel(tb))
+		tabtype = TABTYPE_KERNEL;
+
+	istree = tab_is_tree(tb);
+	if (istree && force_tree)
+		flags |= FL_TREE;
+
+	if ((flags & FL_TREE) && (ntabfiles > 1 || !istree))
+		flags &= ~FL_TREE;
+
+	if (!(flags & FL_NOCACHE)) {
+		cache = mnt_new_cache();
+		if (!cache) {
+			warn(_("failed to initialize libmount cache"));
+			goto leave;
+		}
+		mnt_table_set_cache(tb, cache);
+
+		if (tabtype != TABTYPE_KERNEL)
+			cache_set_targets(cache);
+	}
+
+	if (flags & FL_UNIQ)
+		mnt_table_uniq_fs(tb, MNT_UNIQ_KEEPTREE, uniq_fs_target_cmp);
+
+	if (verify) {
+		rc = verify_table(tb);
+		goto leave;
+	}
+
+	/*
+	 * initialize libsmartcols
+	 */
+	scols_init_debug(0);
+	table = scols_new_table();
+	if (!table) {
+		warn(_("failed to allocate output table"));
+		goto leave;
+	}
+	scols_table_enable_raw(table,        !!(flags & FL_RAW));
+	scols_table_enable_export(table,     !!(flags & FL_EXPORT));
+	scols_table_enable_json(table,       !!(flags & FL_JSON));
+	scols_table_enable_ascii(table,      !!(flags & FL_ASCII));
+	scols_table_enable_noheadings(table, !!(flags & FL_NOHEADINGS));
+
+	if (flags & FL_JSON)
+		scols_table_set_name(table, "filesystems");
+
+	for (i = 0; i < ncolumns; i++) {
+		struct libscols_column *cl;
+		int fl = get_column_flags(i);
+		int id = get_column_id(i);
+
+		if (!(flags & FL_TREE))
+			fl &= ~SCOLS_FL_TREE;
+
+		if (!(flags & FL_POLL) && is_tabdiff_column(id)) {
+			warnx(_("%s column is requested, but --poll "
+			       "is not enabled"), get_column_name(i));
+			goto leave;
+		}
+		cl = scols_table_new_column(table, get_column_name(i),
+					get_column_whint(i), fl);
+		if (!cl)	{
+			warn(_("failed to allocate output column"));
+			goto leave;
+		}
+
+		if (flags & FL_JSON) {
+			switch (id) {
+			case COL_SIZE:
+			case COL_AVAIL:
+			case COL_USED:
+				if (!(flags & FL_BYTES))
+					break;
+				/* fallthrough */
+			case COL_ID:
+			case COL_FREQ:
+			case COL_PASSNO:
+			case COL_TID:
+				scols_column_set_json_type(cl, SCOLS_JSON_NUMBER);
+				break;
+			default:
+				scols_column_set_json_type(cl, SCOLS_JSON_STRING);
+				break;
+			}
+		}
+	}
+
+	/*
+	 * Fill in data to the output table
+	 */
+	if (flags & FL_POLL) {
+		/* poll mode (accept the first tabfile only) */
+		rc = poll_table(tb, tabfiles ? *tabfiles : _PATH_PROC_MOUNTINFO, timeout, table, direction);
+
+	} else if ((flags & FL_TREE) && !(flags & FL_SUBMOUNTS)) {
+		/* whole tree */
+		rc = create_treenode(table, tb, NULL, NULL);
+	} else {
+		/* whole list of sub-tree */
+		rc = add_matching_lines(tb, table, direction);
+
+		if (rc != 0
+		    && tabtype == TABTYPE_KERNEL
+		    && (flags & FL_NOSWAPMATCH)
+		    && !(flags & FL_STRICTTARGET)
+		    && get_match(COL_TARGET)) {
+			/*
+			 * Found nothing, maybe the --target is regular file,
+			 * try it again with extra functionality for target
+			 * match
+			 */
+			enable_extra_target_match(tb);
+			rc = add_matching_lines(tb, table, direction);
+		}
+	}
+
+	/*
+	 * Print the output table for non-poll modes
+	 */
+	if (!rc && !(flags & FL_POLL))
+		scols_print_table(table);
+leave:
+	scols_unref_table(table);
+
+	mnt_unref_table(tb);
+	mnt_unref_cache(cache);
+
+	free(tabfiles);
+#ifdef HAVE_LIBUDEV
+	udev_unref(udev);
+#endif
+	return rc ? EXIT_FAILURE : EXIT_SUCCESS;
+}
diff --git a/misc-utils/findmnt.h b/misc-utils/findmnt.h
new file mode 100644
index 0000000..6388837
--- /dev/null
+++ b/misc-utils/findmnt.h
@@ -0,0 +1,41 @@
+#ifndef UTIL_LINUX_FINDMNT_H
+#define UTIL_LINUX_FINDMNT_H
+
+/* flags */
+enum {
+	FL_EVALUATE	= (1 << 1),
+	FL_CANONICALIZE = (1 << 2),
+	FL_FIRSTONLY	= (1 << 3),
+	FL_INVERT	= (1 << 4),
+	FL_NOSWAPMATCH	= (1 << 6),
+	FL_NOFSROOT	= (1 << 7),
+	FL_SUBMOUNTS	= (1 << 8),
+	FL_POLL		= (1 << 9),
+	FL_DF		= (1 << 10),
+	FL_ALL		= (1 << 11),
+	FL_UNIQ		= (1 << 12),
+	FL_BYTES	= (1 << 13),
+	FL_NOCACHE	= (1 << 14),
+	FL_STRICTTARGET = (1 << 15),
+	FL_VERBOSE	= (1 << 16),
+	FL_PSEUDO	= (1 << 17),
+	FL_REAL		= (1 << 18),
+
+	/* basic table settings */
+	FL_ASCII	= (1 << 20),
+	FL_RAW		= (1 << 21),
+	FL_NOHEADINGS	= (1 << 22),
+	FL_EXPORT	= (1 << 23),
+	FL_TREE		= (1 << 24),
+	FL_JSON		= (1 << 25),
+};
+
+extern struct libmnt_cache *cache;
+extern int flags;
+extern int parse_nerrors;
+
+extern int is_listall_mode(void);
+extern struct libmnt_fs *get_next_fs(struct libmnt_table *tb, struct libmnt_iter *itr);
+extern int verify_table(struct libmnt_table *tb);
+
+#endif /* UTIL_LINUX_FINDMNT_H */
diff --git a/misc-utils/getopt-parse.bash b/misc-utils/getopt-parse.bash
new file mode 100644
index 0000000..db8bf6b
--- /dev/null
+++ b/misc-utils/getopt-parse.bash
@@ -0,0 +1,75 @@
+#!/bin/bash
+
+# A small example script for using the getopt(1) program.
+# This script will only work with bash(1).
+# A similar script using the tcsh(1) language can be found
+# as getopt-parse.tcsh.
+
+# Example input and output (from the bash prompt):
+#
+# ./getopt-parse.bash -a par1 'another arg' --c-long 'wow!*\?' -cmore -b " very long "
+# Option a
+# Option c, no argument
+# Option c, argument 'more'
+# Option b, argument ' very long '
+# Remaining arguments:
+# --> 'par1'
+# --> 'another arg'
+# --> 'wow!*\?'
+
+# Note that we use "$@" to let each command-line parameter expand to a
+# separate word. The quotes around "$@" are essential!
+# We need TEMP as the 'eval set --' would nuke the return value of getopt.
+TEMP=$(getopt -o 'ab:c::' --long 'a-long,b-long:,c-long::' -n 'example.bash' -- "$@")
+
+if [ $? -ne 0 ]; then
+	echo 'Terminating...' >&2
+	exit 1
+fi
+
+# Note the quotes around "$TEMP": they are essential!
+eval set -- "$TEMP"
+unset TEMP
+
+while true; do
+	case "$1" in
+		'-a'|'--a-long')
+			echo 'Option a'
+			shift
+			continue
+		;;
+		'-b'|'--b-long')
+			echo "Option b, argument '$2'"
+			shift 2
+			continue
+		;;
+		'-c'|'--c-long')
+			# c has an optional argument. As we are in quoted mode,
+			# an empty parameter will be generated if its optional
+			# argument is not found.
+			case "$2" in
+				'')
+					echo 'Option c, no argument'
+				;;
+				*)
+					echo "Option c, argument '$2'"
+				;;
+			esac
+			shift 2
+			continue
+		;;
+		'--')
+			shift
+			break
+		;;
+		*)
+			echo 'Internal error!' >&2
+			exit 1
+		;;
+	esac
+done
+
+echo 'Remaining arguments:'
+for arg; do
+	echo "--> '$arg'"
+done
diff --git a/misc-utils/getopt-parse.tcsh b/misc-utils/getopt-parse.tcsh
new file mode 100644
index 0000000..032d7ac
--- /dev/null
+++ b/misc-utils/getopt-parse.tcsh
@@ -0,0 +1,77 @@
+#!/bin/tcsh
+
+# A small example script for using the getopt(1) program.
+# This script will only work with tcsh(1).
+# A similar script using the bash(1) language can be found
+# as getopt-parse.bash.
+
+# Example input and output (from the tcsh prompt):
+# ./parse.tcsh -a par1 'another arg' --c-long 'wow\!*\?' -cmore -b " very long "
+# Option a
+# Option c, no argument
+# Option c, argument `more'
+# Option b, argument ` very long '
+# Remaining arguments:
+# --> `par1'
+# --> `another arg'
+# --> `wow!*\?'
+
+# Note that we had to escape the exclamation mark in the wow-argument. This
+# is _not_ a problem with getopt, but with the tcsh command parsing. If you
+# would give the same line from the bash prompt (ie. call ./parse.tcsh),
+# you could remove the exclamation mark.
+
+# This is a bit tricky. We use a temp variable, to be able to check the
+# return value of getopt (eval nukes it). argv contains the command arguments
+# as a list. The ':q`  copies that list without doing any substitutions:
+# each element of argv becomes a separate argument for getopt. The braces
+# are needed because the result is also a list.
+set temp=(`getopt -s tcsh -o ab:c:: --long a-long,b-long:,c-long:: -- $argv:q`)
+if ($? != 0) then
+  echo "Terminating..." >/dev/stderr
+  exit 1
+endif
+
+# Now we do the eval part. As the result is a list, we need braces. But they
+# must be quoted, because they must be evaluated when the eval is called.
+# The 'q` stops doing any silly substitutions.
+eval set argv=\($temp:q\)
+
+while (1)
+	switch($1:q)
+	case -a:
+	case --a-long:
+		echo "Option a" ; shift
+		breaksw;
+	case -b:
+	case --b-long:
+		echo "Option b, argument "\`$2:q\' ; shift ; shift
+		breaksw
+	case -c:
+	case --c-long:
+		# c has an optional argument. As we are in quoted mode,
+		# an empty parameter will be generated if its optional
+		# argument is not found.
+
+		if ($2:q == "") then
+			echo "Option c, no argument"
+		else
+			echo "Option c, argument "\`$2:q\'
+		endif
+		shift; shift
+		breaksw
+	case --:
+		shift
+		break
+	default:
+		echo "Internal error!" ; exit 1
+	endsw
+end
+
+echo "Remaining arguments:"
+# foreach el ($argv:q) created problems for some tcsh-versions (at least
+# 6.02). So we use another shift-loop here:
+while ($#argv > 0)
+	echo '--> '\`$1:q\'
+	shift
+end
diff --git a/misc-utils/getopt.1 b/misc-utils/getopt.1
new file mode 100644
index 0000000..356e16a
--- /dev/null
+++ b/misc-utils/getopt.1
@@ -0,0 +1,460 @@
+.TH GETOPT "1" "December 2014" "util-linux" "User Commands"
+.SH NAME
+getopt \- parse command options (enhanced)
+.SH SYNOPSIS
+.B getopt
+.I optstring parameters
+.br
+.B getopt
+[options]
+.RB [ \-\- ]
+.I optstring parameters
+.br
+.B getopt
+[options]
+.BR \-o | \-\-options
+.I optstring
+[options]
+.RB [ \-\- ]
+.I parameters
+.SH DESCRIPTION
+.B getopt
+is used to break up
+.RI ( parse )
+options in command lines for easy parsing by shell procedures, and to
+check for valid options.  It uses the
+.SM GNU
+.BR getopt (3)
+routines to do this.
+.PP
+The parameters
+.B getopt
+is called with can be divided into two parts: options which modify
+the way
+.B getopt
+will do the parsing
+.RI "(the " options
+and the
+.I optstring
+in the
+.BR SYNOPSIS ),
+and the parameters which are to be parsed
+.RI ( parameters
+in the
+.BR SYNOPSIS ).
+The second part will start at the first non\-option parameter that is
+not an option argument, or after the first occurrence of
+.RB ' \-\- '.
+If no
+.RB ' \-o '
+or
+.RB ' \-\-options '
+option is found in the first part, the first parameter of the second
+part is used as the short options string.
+.PP
+If the environment variable
+.B GETOPT_COMPATIBLE
+is set, or if the first
+.I parameter
+is not an option (does not start with a
+.RB ' \- ',
+the first format in the
+.BR SYNOPSIS ),
+.B getopt
+will generate output that is compatible with that of other versions of
+.BR getopt (1).
+It will still do parameter shuffling and recognize optional arguments
+(see section
+.B COMPATIBILITY
+for more information).
+.PP
+Traditional implementations of
+.BR getopt (1)
+are unable to cope with whitespace and other (shell-specific)
+special characters in arguments and non\-option parameters.  To solve
+this problem, this implementation can generate quoted output which
+must once again be interpreted by the shell (usually by using the
+.B eval
+command).  This has the effect of preserving those characters, but
+you must call
+.B getopt
+in a way that is no longer compatible with other versions (the second
+or third format in the
+.BR SYNOPSIS ).
+To determine whether this enhanced version of
+.BR getopt (1)
+is installed, a special test option
+.RB ( \-T )
+can be used.
+.SH OPTIONS
+.TP
+.BR \-a , " \-\-alternative"
+Allow long options to start with a single
+.RB ' \- '.
+.TP
+.BR \-h , " \-\-help"
+Display help text and exit.  No other output is generated.
+.TP
+.BR \-l , " \-\-longoptions \fIlongopts\fP"
+The long (multi\-character) options to be recognized.  More than one
+option name may be specified at once, by separating the names with
+commas.  This option may be given more than once, the
+.I longopts
+are cumulative.  Each long option name in
+.I longopts
+may be followed by one colon to indicate it has a required argument,
+and by two colons to indicate it has an optional argument.
+.TP
+.BR \-n , " \-\-name \fIprogname\fP"
+The name that will be used by the
+.BR getopt (3)
+routines when it reports errors.  Note that errors of
+.BR getopt (1)
+are still reported as coming from getopt.
+.TP
+.BR \-o , " \-\-options \fIshortopts\fP"
+The short (one\-character) options to be recognized.  If this option
+is not found, the first parameter of
+.B getopt
+that does not start with a
+.RB ' \- '
+(and is not an option argument) is used as the short options string.
+Each short option character in
+.I shortopts
+may be followed by one colon to indicate it has a required argument,
+and by two colons to indicate it has an optional argument.  The first
+character of shortopts may be
+.RB ' + '
+or
+.RB ' \- '
+to influence the way options are parsed and output is generated (see
+section
+.B SCANNING MODES
+for details).
+.TP
+.BR \-q , " \-\-quiet"
+Disable error reporting by getopt(3).
+.TP
+.BR  \-Q , " \-\-quiet\-output"
+Do not generate normal output.  Errors are still reported by
+.BR getopt (3),
+unless you also use
+.BR \-q .
+.TP
+.BR \-s , " \-\-shell \fIshell\fP"
+Set quoting conventions to those of
+.IR shell .
+If the \fB\-s\fR option is not given, the
+.SM BASH
+conventions are used.  Valid arguments are currently
+.RB ' sh '
+.RB ' bash ',
+.RB ' csh ',
+and
+.RB ' tcsh '.
+.TP
+.BR \-T , " \-\-test"
+Test if your
+.BR getopt (1)
+is this enhanced version or an old version.  This generates no
+output, and sets the error status to 4.  Other implementations of
+.BR getopt (1),
+and this version if the environment variable
+.B GETOPT_COMPATIBLE
+is set, will return
+.RB ' \-\- '
+and error status 0.
+.TP
+.BR \-u , " \-\-unquoted"
+Do not quote the output.  Note that whitespace and special
+(shell-dependent) characters can cause havoc in this mode (like they
+do with other
+.BR getopt (1)
+implementations).
+.TP
+.BR \-V , " \-\-version"
+Display version information and exit.  No other output is generated.
+.SH PARSING
+This section specifies the format of the second part of the
+parameters of
+.B getopt
+(the
+.I parameters
+in the
+.BR SYNOPSIS ).
+The next section
+.RB ( OUTPUT )
+describes the output that is generated.  These parameters were
+typically the parameters a shell function was called with.  Care must
+be taken that each parameter the shell function was called with
+corresponds to exactly one parameter in the parameter list of
+.B getopt
+(see the
+.BR EXAMPLES ).
+All parsing is done by the GNU
+.BR getopt (3)
+routines.
+.PP
+The parameters are parsed from left to right.  Each parameter is
+classified as a short option, a long option, an argument to an
+option, or a non\-option parameter.
+.PP
+A simple short option is a
+.RB ' \- '
+followed by a short option character.  If the option has a required
+argument, it may be written directly after the option character or as
+the next parameter (i.e., separated by whitespace on the command
+line).  If the option has an optional argument, it must be written
+directly after the option character if present.
+.PP
+It is possible to specify several short options after one
+.RB ' \- ',
+as long as all (except possibly the last) do not have required or
+optional arguments.
+.PP
+A long option normally begins with
+.RB ' \-\- '
+followed by the long option name.  If the option has a required
+argument, it may be written directly after the long option name,
+separated by
+.RB ' = ',
+or as the next argument (i.e., separated by whitespace on the command
+line).  If the option has an optional argument, it must be written
+directly after the long option name, separated by
+.RB ' = ',
+if present (if you add the
+.RB ' = '
+but nothing behind it, it is interpreted as if no argument was
+present; this is a slight bug, see the
+.BR BUGS ).
+Long options may be abbreviated, as long as the abbreviation is not
+ambiguous.
+.PP
+Each parameter not starting with a
+.RB ' \- ',
+and not a required argument of a previous option, is a non\-option
+parameter.  Each parameter after a
+.RB ' \-\- '
+parameter is always interpreted as a non\-option parameter.  If the
+environment variable
+.B POSIXLY_CORRECT
+is set, or if the short option string started with a
+.RB ' + ',
+all remaining parameters are interpreted as non\-option parameters as
+soon as the first non\-option parameter is found.
+.SH OUTPUT
+Output is generated for each element described in the previous
+section.  Output is done in the same order as the elements are
+specified in the input, except for non\-option parameters.  Output
+can be done in
+.I compatible
+.RI ( unquoted )
+mode, or in such way that whitespace and other special characters
+within arguments and non\-option parameters are preserved (see
+.BR QUOTING ).
+When the output is processed in the shell script, it will seem to be
+composed of distinct elements that can be processed one by one (by
+using the shift command in most shell languages).  This is imperfect
+in unquoted mode, as elements can be split at unexpected places if
+they contain whitespace or special characters.
+.PP
+If there are problems parsing the parameters, for example because a
+required argument is not found or an option is not recognized, an
+error will be reported on stderr, there will be no output for the
+offending element, and a non\-zero error status is returned.
+.PP
+For a short option, a single
+.RB ' \- '
+and the option character are generated as one parameter.  If the
+option has an argument, the next parameter will be the argument.  If
+the option takes an optional argument, but none was found, the next
+parameter will be generated but be empty in quoting mode, but no
+second parameter will be generated in unquoted (compatible) mode.
+Note that many other
+.BR getopt (1)
+implementations do not support optional arguments.
+.PP
+If several short options were specified after a single
+.RB ' \- ',
+each will be present in the output as a separate parameter.
+.PP
+For a long option,
+.RB ' \-\- '
+and the full option name are generated as one parameter.  This is
+done regardless whether the option was abbreviated or specified with
+a single
+.RB ' \- '
+in the input.  Arguments are handled as with short options.
+.PP
+Normally, no non\-option parameters output is generated until all
+options and their arguments have been generated.  Then
+.RB ' \-\- '
+is generated as a single parameter, and after it the non\-option
+parameters in the order they were found, each as a separate
+parameter.  Only if the first character of the short options string
+was a
+.RB ' \- ',
+non\-option parameter output is generated at the place they are found
+in the input (this is not supported if the first format of the
+.B SYNOPSIS
+is used; in that case all preceding occurrences of
+.RB ' \- '
+and
+.RB ' + '
+are ignored).
+.SH QUOTING
+In compatible mode, whitespace or 'special' characters in arguments
+or non\-option parameters are not handled correctly.  As the output
+is fed to the shell script, the script does not know how it is
+supposed to break the output into separate parameters.  To circumvent
+this problem, this implementation offers quoting.  The idea is that
+output is generated with quotes around each parameter.  When this
+output is once again fed to the shell (usually by a shell
+.B eval
+command), it is split correctly into separate parameters.
+.PP
+Quoting is not enabled if the environment variable
+.B GETOPT_COMPATIBLE
+is set, if the first form of the
+.B SYNOPSIS
+is used, or if the option
+.RB ' \-u '
+is found.
+.PP
+Different shells use different quoting conventions.  You can use the
+.RB ' \-s '
+option to select the shell you are using.  The following shells are
+currently supported:
+.RB ' sh ',
+.RB ' bash ',
+.RB ' csh '
+and
+.RB ' tcsh '.
+Actually, only two 'flavors' are distinguished: sh\-like quoting
+conventions and csh\-like quoting conventions.  Chances are that if
+you use another shell script language, one of these flavors can still
+be used.
+.SH "SCANNING MODES"
+The first character of the short options string may be a
+.RB ' \- '
+or a
+.RB ' + '
+to indicate a special scanning mode.  If the first calling form in
+the
+.B SYNOPSIS
+is used they are ignored; the environment variable
+.B POSIXLY_CORRECT
+is still examined, though.
+.PP
+If the first character is
+.RB ' + ',
+or if the environment variable
+.B POSIXLY_CORRECT
+is set, parsing stops as soon as the first non\-option parameter
+(i.e., a parameter that does not start with a
+.RB ' \- ')
+is found that is not an option argument.  The remaining parameters
+are all interpreted as non\-option parameters.
+.PP
+If the first character is a
+.RB ' \- ',
+non\-option parameters are outputted at the place where they are
+found; in normal operation, they are all collected at the end of
+output after a
+.RB ' \-\- '
+parameter has been generated.  Note that this
+.RB ' \-\- '
+parameter is still generated, but it will always be the last
+parameter in this mode.
+.SH COMPATIBILITY
+This version of
+.BR getopt (1)
+is written to be as compatible as possible to other versions.
+Usually you can just replace them with this version without any
+modifications, and with some advantages.
+.PP
+If the first character of the first parameter of getopt is not a
+.RB ' \- ',
+.B getopt
+goes into compatibility mode.  It will interpret its first
+parameter as the string of short options, and all other arguments
+will be parsed.  It will still do parameter shuffling (i.e., all
+non\-option parameters are output at the end), unless the
+environment variable
+.B POSIXLY_CORRECT
+is set.
+.PP
+The environment variable
+.B GETOPT_COMPATIBLE
+forces
+.B getopt
+into compatibility mode.  Setting both this environment variable and
+.B POSIXLY_CORRECT
+offers 100% compatibility for 'difficult' programs.  Usually, though,
+neither is needed.
+.PP
+In compatibility mode, leading
+.RB ' \- '
+and
+.RB ' + '
+characters in the short options string are ignored.
+.SH RETURN CODES
+.B getopt
+returns error code
+.B 0
+for successful parsing,
+.B 1
+if
+.BR getopt (3)
+returns errors,
+.B 2
+if it does not understand its own parameters,
+.B 3
+if an internal error occurs like out\-of\-memory, and
+.B 4
+if it is called with
+.BR \-T .
+.SH EXAMPLES
+Example scripts for (ba)sh and (t)csh are provided with the
+.BR getopt (1)
+distribution, and are installed in
+.I /usr/share/doc/util-linux/getopt/
+directory.
+.SH ENVIRONMENT
+.IP POSIXLY_CORRECT
+This environment variable is examined by the
+.BR getopt (3)
+routines.  If it is set, parsing stops as soon as a parameter is
+found that is not an option or an option argument.  All remaining
+parameters are also interpreted as non\-option parameters, regardless
+whether they start with a
+.RB ' \- '.
+.IP GETOPT_COMPATIBLE
+Forces
+.B getopt
+to use the first calling format as specified in the
+.BR SYNOPSIS .
+.SH BUGS
+.BR getopt (3)
+can parse long options with optional arguments that are given an
+empty optional argument (but cannot do this for short options).
+This
+.BR getopt (1)
+treats optional arguments that are empty as if they were not present.
+.PP
+The syntax if you do not want any short option variables at all is
+not very intuitive (you have to set them explicitly to the empty
+string).
+.SH AUTHOR
+.MT frodo@frodo.looijaard.name
+Frodo Looijaard
+.ME
+.SH "SEE ALSO"
+.BR bash (1),
+.BR tcsh (1),
+.BR getopt (3)
+.SH AVAILABILITY
+The getopt command is part of the util-linux package and is available from
+.UR https://\:www.kernel.org\:/pub\:/linux\:/utils\:/util-linux/
+Linux Kernel Archive
+.UE .
diff --git a/misc-utils/getopt.1.in b/misc-utils/getopt.1.in
new file mode 100644
index 0000000..1e913ea
--- /dev/null
+++ b/misc-utils/getopt.1.in
@@ -0,0 +1,460 @@
+.TH GETOPT "1" "December 2014" "util-linux" "User Commands"
+.SH NAME
+getopt \- parse command options (enhanced)
+.SH SYNOPSIS
+.B getopt
+.I optstring parameters
+.br
+.B getopt
+[options]
+.RB [ \-\- ]
+.I optstring parameters
+.br
+.B getopt
+[options]
+.BR \-o | \-\-options
+.I optstring
+[options]
+.RB [ \-\- ]
+.I parameters
+.SH DESCRIPTION
+.B getopt
+is used to break up
+.RI ( parse )
+options in command lines for easy parsing by shell procedures, and to
+check for valid options.  It uses the
+.SM GNU
+.BR getopt (3)
+routines to do this.
+.PP
+The parameters
+.B getopt
+is called with can be divided into two parts: options which modify
+the way
+.B getopt
+will do the parsing
+.RI "(the " options
+and the
+.I optstring
+in the
+.BR SYNOPSIS ),
+and the parameters which are to be parsed
+.RI ( parameters
+in the
+.BR SYNOPSIS ).
+The second part will start at the first non\-option parameter that is
+not an option argument, or after the first occurrence of
+.RB ' \-\- '.
+If no
+.RB ' \-o '
+or
+.RB ' \-\-options '
+option is found in the first part, the first parameter of the second
+part is used as the short options string.
+.PP
+If the environment variable
+.B GETOPT_COMPATIBLE
+is set, or if the first
+.I parameter
+is not an option (does not start with a
+.RB ' \- ',
+the first format in the
+.BR SYNOPSIS ),
+.B getopt
+will generate output that is compatible with that of other versions of
+.BR getopt (1).
+It will still do parameter shuffling and recognize optional arguments
+(see section
+.B COMPATIBILITY
+for more information).
+.PP
+Traditional implementations of
+.BR getopt (1)
+are unable to cope with whitespace and other (shell-specific)
+special characters in arguments and non\-option parameters.  To solve
+this problem, this implementation can generate quoted output which
+must once again be interpreted by the shell (usually by using the
+.B eval
+command).  This has the effect of preserving those characters, but
+you must call
+.B getopt
+in a way that is no longer compatible with other versions (the second
+or third format in the
+.BR SYNOPSIS ).
+To determine whether this enhanced version of
+.BR getopt (1)
+is installed, a special test option
+.RB ( \-T )
+can be used.
+.SH OPTIONS
+.TP
+.BR \-a , " \-\-alternative"
+Allow long options to start with a single
+.RB ' \- '.
+.TP
+.BR \-h , " \-\-help"
+Display help text and exit.  No other output is generated.
+.TP
+.BR \-l , " \-\-longoptions \fIlongopts\fP"
+The long (multi\-character) options to be recognized.  More than one
+option name may be specified at once, by separating the names with
+commas.  This option may be given more than once, the
+.I longopts
+are cumulative.  Each long option name in
+.I longopts
+may be followed by one colon to indicate it has a required argument,
+and by two colons to indicate it has an optional argument.
+.TP
+.BR \-n , " \-\-name \fIprogname\fP"
+The name that will be used by the
+.BR getopt (3)
+routines when it reports errors.  Note that errors of
+.BR getopt (1)
+are still reported as coming from getopt.
+.TP
+.BR \-o , " \-\-options \fIshortopts\fP"
+The short (one\-character) options to be recognized.  If this option
+is not found, the first parameter of
+.B getopt
+that does not start with a
+.RB ' \- '
+(and is not an option argument) is used as the short options string.
+Each short option character in
+.I shortopts
+may be followed by one colon to indicate it has a required argument,
+and by two colons to indicate it has an optional argument.  The first
+character of shortopts may be
+.RB ' + '
+or
+.RB ' \- '
+to influence the way options are parsed and output is generated (see
+section
+.B SCANNING MODES
+for details).
+.TP
+.BR \-q , " \-\-quiet"
+Disable error reporting by getopt(3).
+.TP
+.BR  \-Q , " \-\-quiet\-output"
+Do not generate normal output.  Errors are still reported by
+.BR getopt (3),
+unless you also use
+.BR \-q .
+.TP
+.BR \-s , " \-\-shell \fIshell\fP"
+Set quoting conventions to those of
+.IR shell .
+If the \fB\-s\fR option is not given, the
+.SM BASH
+conventions are used.  Valid arguments are currently
+.RB ' sh '
+.RB ' bash ',
+.RB ' csh ',
+and
+.RB ' tcsh '.
+.TP
+.BR \-T , " \-\-test"
+Test if your
+.BR getopt (1)
+is this enhanced version or an old version.  This generates no
+output, and sets the error status to 4.  Other implementations of
+.BR getopt (1),
+and this version if the environment variable
+.B GETOPT_COMPATIBLE
+is set, will return
+.RB ' \-\- '
+and error status 0.
+.TP
+.BR \-u , " \-\-unquoted"
+Do not quote the output.  Note that whitespace and special
+(shell-dependent) characters can cause havoc in this mode (like they
+do with other
+.BR getopt (1)
+implementations).
+.TP
+.BR \-V , " \-\-version"
+Display version information and exit.  No other output is generated.
+.SH PARSING
+This section specifies the format of the second part of the
+parameters of
+.B getopt
+(the
+.I parameters
+in the
+.BR SYNOPSIS ).
+The next section
+.RB ( OUTPUT )
+describes the output that is generated.  These parameters were
+typically the parameters a shell function was called with.  Care must
+be taken that each parameter the shell function was called with
+corresponds to exactly one parameter in the parameter list of
+.B getopt
+(see the
+.BR EXAMPLES ).
+All parsing is done by the GNU
+.BR getopt (3)
+routines.
+.PP
+The parameters are parsed from left to right.  Each parameter is
+classified as a short option, a long option, an argument to an
+option, or a non\-option parameter.
+.PP
+A simple short option is a
+.RB ' \- '
+followed by a short option character.  If the option has a required
+argument, it may be written directly after the option character or as
+the next parameter (i.e., separated by whitespace on the command
+line).  If the option has an optional argument, it must be written
+directly after the option character if present.
+.PP
+It is possible to specify several short options after one
+.RB ' \- ',
+as long as all (except possibly the last) do not have required or
+optional arguments.
+.PP
+A long option normally begins with
+.RB ' \-\- '
+followed by the long option name.  If the option has a required
+argument, it may be written directly after the long option name,
+separated by
+.RB ' = ',
+or as the next argument (i.e., separated by whitespace on the command
+line).  If the option has an optional argument, it must be written
+directly after the long option name, separated by
+.RB ' = ',
+if present (if you add the
+.RB ' = '
+but nothing behind it, it is interpreted as if no argument was
+present; this is a slight bug, see the
+.BR BUGS ).
+Long options may be abbreviated, as long as the abbreviation is not
+ambiguous.
+.PP
+Each parameter not starting with a
+.RB ' \- ',
+and not a required argument of a previous option, is a non\-option
+parameter.  Each parameter after a
+.RB ' \-\- '
+parameter is always interpreted as a non\-option parameter.  If the
+environment variable
+.B POSIXLY_CORRECT
+is set, or if the short option string started with a
+.RB ' + ',
+all remaining parameters are interpreted as non\-option parameters as
+soon as the first non\-option parameter is found.
+.SH OUTPUT
+Output is generated for each element described in the previous
+section.  Output is done in the same order as the elements are
+specified in the input, except for non\-option parameters.  Output
+can be done in
+.I compatible
+.RI ( unquoted )
+mode, or in such way that whitespace and other special characters
+within arguments and non\-option parameters are preserved (see
+.BR QUOTING ).
+When the output is processed in the shell script, it will seem to be
+composed of distinct elements that can be processed one by one (by
+using the shift command in most shell languages).  This is imperfect
+in unquoted mode, as elements can be split at unexpected places if
+they contain whitespace or special characters.
+.PP
+If there are problems parsing the parameters, for example because a
+required argument is not found or an option is not recognized, an
+error will be reported on stderr, there will be no output for the
+offending element, and a non\-zero error status is returned.
+.PP
+For a short option, a single
+.RB ' \- '
+and the option character are generated as one parameter.  If the
+option has an argument, the next parameter will be the argument.  If
+the option takes an optional argument, but none was found, the next
+parameter will be generated but be empty in quoting mode, but no
+second parameter will be generated in unquoted (compatible) mode.
+Note that many other
+.BR getopt (1)
+implementations do not support optional arguments.
+.PP
+If several short options were specified after a single
+.RB ' \- ',
+each will be present in the output as a separate parameter.
+.PP
+For a long option,
+.RB ' \-\- '
+and the full option name are generated as one parameter.  This is
+done regardless whether the option was abbreviated or specified with
+a single
+.RB ' \- '
+in the input.  Arguments are handled as with short options.
+.PP
+Normally, no non\-option parameters output is generated until all
+options and their arguments have been generated.  Then
+.RB ' \-\- '
+is generated as a single parameter, and after it the non\-option
+parameters in the order they were found, each as a separate
+parameter.  Only if the first character of the short options string
+was a
+.RB ' \- ',
+non\-option parameter output is generated at the place they are found
+in the input (this is not supported if the first format of the
+.B SYNOPSIS
+is used; in that case all preceding occurrences of
+.RB ' \- '
+and
+.RB ' + '
+are ignored).
+.SH QUOTING
+In compatible mode, whitespace or 'special' characters in arguments
+or non\-option parameters are not handled correctly.  As the output
+is fed to the shell script, the script does not know how it is
+supposed to break the output into separate parameters.  To circumvent
+this problem, this implementation offers quoting.  The idea is that
+output is generated with quotes around each parameter.  When this
+output is once again fed to the shell (usually by a shell
+.B eval
+command), it is split correctly into separate parameters.
+.PP
+Quoting is not enabled if the environment variable
+.B GETOPT_COMPATIBLE
+is set, if the first form of the
+.B SYNOPSIS
+is used, or if the option
+.RB ' \-u '
+is found.
+.PP
+Different shells use different quoting conventions.  You can use the
+.RB ' \-s '
+option to select the shell you are using.  The following shells are
+currently supported:
+.RB ' sh ',
+.RB ' bash ',
+.RB ' csh '
+and
+.RB ' tcsh '.
+Actually, only two 'flavors' are distinguished: sh\-like quoting
+conventions and csh\-like quoting conventions.  Chances are that if
+you use another shell script language, one of these flavors can still
+be used.
+.SH "SCANNING MODES"
+The first character of the short options string may be a
+.RB ' \- '
+or a
+.RB ' + '
+to indicate a special scanning mode.  If the first calling form in
+the
+.B SYNOPSIS
+is used they are ignored; the environment variable
+.B POSIXLY_CORRECT
+is still examined, though.
+.PP
+If the first character is
+.RB ' + ',
+or if the environment variable
+.B POSIXLY_CORRECT
+is set, parsing stops as soon as the first non\-option parameter
+(i.e., a parameter that does not start with a
+.RB ' \- ')
+is found that is not an option argument.  The remaining parameters
+are all interpreted as non\-option parameters.
+.PP
+If the first character is a
+.RB ' \- ',
+non\-option parameters are outputted at the place where they are
+found; in normal operation, they are all collected at the end of
+output after a
+.RB ' \-\- '
+parameter has been generated.  Note that this
+.RB ' \-\- '
+parameter is still generated, but it will always be the last
+parameter in this mode.
+.SH COMPATIBILITY
+This version of
+.BR getopt (1)
+is written to be as compatible as possible to other versions.
+Usually you can just replace them with this version without any
+modifications, and with some advantages.
+.PP
+If the first character of the first parameter of getopt is not a
+.RB ' \- ',
+.B getopt
+goes into compatibility mode.  It will interpret its first
+parameter as the string of short options, and all other arguments
+will be parsed.  It will still do parameter shuffling (i.e., all
+non\-option parameters are output at the end), unless the
+environment variable
+.B POSIXLY_CORRECT
+is set.
+.PP
+The environment variable
+.B GETOPT_COMPATIBLE
+forces
+.B getopt
+into compatibility mode.  Setting both this environment variable and
+.B POSIXLY_CORRECT
+offers 100% compatibility for 'difficult' programs.  Usually, though,
+neither is needed.
+.PP
+In compatibility mode, leading
+.RB ' \- '
+and
+.RB ' + '
+characters in the short options string are ignored.
+.SH RETURN CODES
+.B getopt
+returns error code
+.B 0
+for successful parsing,
+.B 1
+if
+.BR getopt (3)
+returns errors,
+.B 2
+if it does not understand its own parameters,
+.B 3
+if an internal error occurs like out\-of\-memory, and
+.B 4
+if it is called with
+.BR \-T .
+.SH EXAMPLES
+Example scripts for (ba)sh and (t)csh are provided with the
+.BR getopt (1)
+distribution, and are installed in
+.I @docdir@/getopt/
+directory.
+.SH ENVIRONMENT
+.IP POSIXLY_CORRECT
+This environment variable is examined by the
+.BR getopt (3)
+routines.  If it is set, parsing stops as soon as a parameter is
+found that is not an option or an option argument.  All remaining
+parameters are also interpreted as non\-option parameters, regardless
+whether they start with a
+.RB ' \- '.
+.IP GETOPT_COMPATIBLE
+Forces
+.B getopt
+to use the first calling format as specified in the
+.BR SYNOPSIS .
+.SH BUGS
+.BR getopt (3)
+can parse long options with optional arguments that are given an
+empty optional argument (but cannot do this for short options).
+This
+.BR getopt (1)
+treats optional arguments that are empty as if they were not present.
+.PP
+The syntax if you do not want any short option variables at all is
+not very intuitive (you have to set them explicitly to the empty
+string).
+.SH AUTHOR
+.MT frodo@frodo.looijaard.name
+Frodo Looijaard
+.ME
+.SH "SEE ALSO"
+.BR bash (1),
+.BR tcsh (1),
+.BR getopt (3)
+.SH AVAILABILITY
+The getopt command is part of the util-linux package and is available from
+.UR https://\:www.kernel.org\:/pub\:/linux\:/utils\:/util-linux/
+Linux Kernel Archive
+.UE .
diff --git a/misc-utils/getopt.c b/misc-utils/getopt.c
new file mode 100644
index 0000000..01a2df6
--- /dev/null
+++ b/misc-utils/getopt.c
@@ -0,0 +1,472 @@
+/*
+ *  getopt.c - Enhanced implementation of BSD getopt(1)
+ *  Copyright (c) 1997-2014 Frodo Looijaard <frodo@frodo.looijaard.name>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/*
+ * Version 1.0-b4: Tue Sep 23 1997. First public release.
+ * Version 1.0: Wed Nov 19 1997.
+ *   Bumped up the version number to 1.0
+ *   Fixed minor typo (CSH instead of TCSH)
+ * Version 1.0.1: Tue Jun 3 1998
+ *   Fixed sizeof instead of strlen bug
+ *   Bumped up the version number to 1.0.1
+ * Version 1.0.2: Thu Jun 11 1998 (not present)
+ *   Fixed gcc-2.8.1 warnings
+ *   Fixed --version/-V option (not present)
+ * Version 1.0.5: Tue Jun 22 1999
+ *   Make -u option work (not present)
+ * Version 1.0.6: Tue Jun 27 2000
+ *   No important changes
+ * Version 1.1.0: Tue Jun 30 2000
+ *   Added NLS support (partly written by Arkadiusz Miśkiewicz
+ *     <misiek@pld.org.pl>)
+ * Version 1.1.4: Mon Nov 7 2005
+ *   Fixed a few type's in the manpage
+ * Version 1.1.5: Sun Aug 12 2012
+ *  Sync with util-linux-2.21, fixed build problems, many new translations
+ * Version 1.1.6: Mon Nov 24 2014
+ *  Sync with util-linux git 20141120, detect ambiguous long options, fix
+ *  backslash problem in tcsh
+ */
+
+/* Exit codes:
+ *   0) No errors, successful operation.
+ *   1) getopt(3) returned an error.
+ *   2) A problem with parameter parsing for getopt(1).
+ *   3) Internal error, out of memory
+ *   4) Returned for -T
+ */
+#define GETOPT_EXIT_CODE	1
+#define PARAMETER_EXIT_CODE	2
+#define XALLOC_EXIT_CODE	3
+#define CLOSE_EXIT_CODE		XALLOC_EXIT_CODE
+#define TEST_EXIT_CODE		4
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <getopt.h>
+#ifdef HAVE_SYS_PARAM_H
+# include <sys/param.h> /* BSD */
+#endif
+
+#include "closestream.h"
+#include "nls.h"
+#include "xalloc.h"
+
+/* NON_OPT is the code that is returned getopt(3) when a non-option is
+ * found in 'char optstring[]="-abc...";', e.g., it begins by '-' */
+#define NON_OPT 1
+/* LONG_OPT is the code that is returned when a long option is found. */
+#define LONG_OPT 0
+
+/* The shells recognized. */
+typedef enum { BASH, TCSH } shell_t;
+
+struct getopt_control {
+	shell_t shell;			/* the shell we generate output for */
+	char *optstr;			/* getopt(3) optstring */
+	char *name;
+	struct option *long_options;	/* long options */
+	int long_options_length;	/* length of options array */
+	int long_options_nr;		/* number of used elements in array */
+	unsigned int
+		compatible:1,		/* compatibility mode for 'difficult' programs */
+		quiet_errors:1,		/* print errors */
+		quiet_output:1,		/* print output */
+		quote:1;		/* quote output */
+};
+
+enum { REALLOC_INCREMENT = 8 };
+
+/* Allow changing which getopt is in use with function pointer. */
+static int (*getopt_long_fp) (int argc, char *const *argv, const char *optstr,
+			      const struct option * longopts, int *longindex);
+
+/*
+ * This function 'normalizes' a single argument: it puts single quotes
+ * around it and escapes other special characters. If quote is false, it
+ * just returns its argument.
+ *
+ * Bash only needs special treatment for single quotes; tcsh also recognizes
+ * exclamation marks within single quotes, and nukes whitespace. This
+ * function returns a pointer to a buffer that is overwritten by each call.
+ */
+static void print_normalized(const struct getopt_control *ctl, const char *arg)
+{
+	char *buf;
+	const char *argptr = arg;
+	char *bufptr;
+
+	if (!ctl->quote) {
+		printf(" %s", arg);
+		return;
+	}
+
+	/*
+	 * Each character in arg may take up to four characters in the
+	 * result: For a quote we need a closing quote, a backslash, a quote
+	 * and an opening quote! We need also the global opening and closing
+	 * quote, and one extra character for '\0'.
+	 */
+	buf = xmalloc(strlen(arg) * 4 + 3);
+	bufptr = buf;
+
+	for (*bufptr++ = '\''; *argptr; argptr++) {
+		if (ctl->shell == TCSH) {
+			switch (*argptr) {
+			case '\\':
+				/* Backslash: replace it with: '\\' */
+				*bufptr++ = '\\';
+				*bufptr++ = '\\';
+				continue;
+			case '!':
+				/* Exclamation mark: replace it with: \! */
+				*bufptr++ = '\'';
+				*bufptr++ = '\\';
+				*bufptr++ = '!';
+				*bufptr++ = '\'';
+				continue;
+			case '\n':
+				/* Newline: replace it with: \n */
+				*bufptr++ = '\\';
+				*bufptr++ = 'n';
+				continue;
+			}
+			if (isspace(*argptr)) {
+				/* Non-newline whitespace: replace it with \<ws> */
+				*bufptr++ = '\'';
+				*bufptr++ = '\\';
+				*bufptr++ = *argptr;
+				*bufptr++ = '\'';
+				continue;
+			}
+		}
+		if (*argptr == '\'') {
+			/* Quote: replace it with: '\'' */
+			*bufptr++ = '\'';
+			*bufptr++ = '\\';
+			*bufptr++ = '\'';
+			*bufptr++ = '\'';
+		} else
+			/* Just copy */
+			*bufptr++ = *argptr;
+	}
+
+	*bufptr++ = '\'';
+	*bufptr++ = '\0';
+	printf(" %s", buf);
+	free(buf);
+}
+
+/*
+ * Generate the output. argv[0] is the program name (used for reporting errors).
+ * argv[1..] contains the options to be parsed. argc must be the number of
+ * elements in argv (ie. 1 if there are no options, only the program name),
+ * optstr must contain the short options, and longopts the long options.
+ * Other settings are found in global variables.
+ */
+static int generate_output(struct getopt_control *ctl, char *argv[], int argc)
+{
+	int exit_code = EXIT_SUCCESS;	/* Assume everything will be OK */
+	int opt;
+	int longindex;
+	const char *charptr;
+
+	if (ctl->quiet_errors)
+		/* No error reporting from getopt(3) */
+		opterr = 0;
+	/* Reset getopt(3) */
+	optind = 0;
+
+	while ((opt =
+		(getopt_long_fp
+		 (argc, argv, ctl->optstr,
+		  (const struct option *)ctl->long_options, &longindex)))
+	       != EOF) {
+		if (opt == '?' || opt == ':')
+			exit_code = GETOPT_EXIT_CODE;
+		else if (!ctl->quiet_output) {
+			switch (opt) {
+			case LONG_OPT:
+				printf(" --%s", ctl->long_options[longindex].name);
+				if (ctl->long_options[longindex].has_arg)
+					print_normalized(ctl, optarg ? optarg : "");
+				break;
+			case NON_OPT:
+				print_normalized(ctl, optarg ? optarg : "");
+				break;
+			default:
+				printf(" -%c", opt);
+				charptr = strchr(ctl->optstr, opt);
+				if (charptr != NULL && *++charptr == ':')
+					print_normalized(ctl, optarg ? optarg : "");
+			}
+		}
+	}
+	if (!ctl->quiet_output) {
+		printf(" --");
+		while (optind < argc)
+			print_normalized(ctl, argv[optind++]);
+		printf("\n");
+	}
+	for (longindex = 0; longindex < ctl->long_options_nr; longindex++)
+		free((char *)ctl->long_options[longindex].name);
+	free(ctl->long_options);
+	free(ctl->optstr);
+	free(ctl->name);
+	return exit_code;
+}
+
+/*
+ * Report an error when parsing getopt's own arguments. If message is NULL,
+ * we already sent a message, we just exit with a helpful hint.
+ */
+static void __attribute__ ((__noreturn__)) parse_error(const char *message)
+{
+	if (message)
+		warnx("%s", message);
+	errtryhelp(PARAMETER_EXIT_CODE);
+}
+
+
+/* Register a long option. The contents of name is copied. */
+static void add_longopt(struct getopt_control *ctl, const char *name, int has_arg)
+{
+	static int flag;
+	int nr = ctl->long_options_nr;
+
+	if (ctl->long_options_nr == ctl->long_options_length) {
+		ctl->long_options_length += REALLOC_INCREMENT;
+		ctl->long_options = xrealloc(ctl->long_options,
+					     sizeof(struct option) *
+					     ctl->long_options_length);
+	}
+	if (name) {
+		/* Not for init! */
+		ctl->long_options[nr].has_arg = has_arg;
+		ctl->long_options[nr].flag = &flag;
+		ctl->long_options[nr].val = ctl->long_options_nr;
+		ctl->long_options[nr].name = xstrdup(name);
+	} else {
+		/* lets use add_longopt(ct, NULL, 0) to terminate the array */
+		ctl->long_options[nr].name = NULL;
+		ctl->long_options[nr].has_arg = 0;
+		ctl->long_options[nr].flag = NULL;
+		ctl->long_options[nr].val = 0;
+	}
+}
+
+
+/*
+ * Register several long options. options is a string of long options,
+ * separated by commas or whitespace. This nukes options!
+ */
+static void add_long_options(struct getopt_control *ctl, char *options)
+{
+	int arg_opt;
+	char *tokptr = strtok(options, ", \t\n");
+
+	while (tokptr) {
+		size_t len = strlen(tokptr);
+
+		arg_opt = no_argument;
+		if (len > 0) {
+			if (tokptr[len - 1] == ':') {
+				if (tokptr[len - 2] == ':') {
+					tokptr[len - 2] = '\0';
+					arg_opt = optional_argument;
+				} else {
+					tokptr[len - 1] = '\0';
+					arg_opt = required_argument;
+				}
+				if (!*tokptr)
+					parse_error(_
+						    ("empty long option after "
+						     "-l or --long argument"));
+			}
+			add_longopt(ctl, tokptr, arg_opt);
+			ctl->long_options_nr++;
+		}
+		tokptr = strtok(NULL, ", \t\n");
+	}
+	add_longopt(ctl, NULL, 0);	/* ensure long_options[] is not full */
+}
+
+static shell_t shell_type(const char *new_shell)
+{
+	if (!strcmp(new_shell, "bash"))
+		return BASH;
+	if (!strcmp(new_shell, "sh"))
+		return BASH;
+	if (!strcmp(new_shell, "tcsh"))
+		return TCSH;
+	if (!strcmp(new_shell, "csh"))
+		return TCSH;
+	parse_error(_("unknown shell after -s or --shell argument"));
+}
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	fputs(USAGE_HEADER, stdout);
+	printf(_(
+		" %1$s <optstring> <parameters>\n"
+		" %1$s [options] [--] <optstring> <parameters>\n"
+		" %1$s [options] -o|--options <optstring> [options] [--] <parameters>\n"),
+		program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, stdout);
+	fputs(_("Parse command options.\n"), stdout);
+
+	fputs(USAGE_OPTIONS, stdout);
+	fputs(_(" -a, --alternative             allow long options starting with single -\n"), stdout);
+	fputs(_(" -l, --longoptions <longopts>  the long options to be recognized\n"), stdout);
+	fputs(_(" -n, --name <progname>         the name under which errors are reported\n"), stdout);
+	fputs(_(" -o, --options <optstring>     the short options to be recognized\n"), stdout);
+	fputs(_(" -q, --quiet                   disable error reporting by getopt(3)\n"), stdout);
+	fputs(_(" -Q, --quiet-output            no normal output\n"), stdout);
+	fputs(_(" -s, --shell <shell>           set quoting conventions to those of <shell>\n"), stdout);
+	fputs(_(" -T, --test                    test for getopt(1) version\n"), stdout);
+	fputs(_(" -u, --unquoted                do not quote the output\n"), stdout);
+	fputs(USAGE_SEPARATOR, stdout);
+	printf(USAGE_HELP_OPTIONS(31));
+	printf(USAGE_MAN_TAIL("getopt(1)"));
+	exit(EXIT_SUCCESS);
+}
+
+int main(int argc, char *argv[])
+{
+	struct getopt_control ctl = {
+		.shell = BASH,
+		.quote = 1
+	};
+	int opt;
+
+	/* Stop scanning as soon as a non-option argument is found! */
+	static const char *shortopts = "+ao:l:n:qQs:TuhV";
+	static const struct option longopts[] = {
+		{"options", required_argument, NULL, 'o'},
+		{"longoptions", required_argument, NULL, 'l'},
+		{"quiet", no_argument, NULL, 'q'},
+		{"quiet-output", no_argument, NULL, 'Q'},
+		{"shell", required_argument, NULL, 's'},
+		{"test", no_argument, NULL, 'T'},
+		{"unquoted", no_argument, NULL, 'u'},
+		{"help", no_argument, NULL, 'h'},
+		{"alternative", no_argument, NULL, 'a'},
+		{"name", required_argument, NULL, 'n'},
+		{"version", no_argument, NULL, 'V'},
+		{NULL, 0, NULL, 0}
+	};
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	if (getenv("GETOPT_COMPATIBLE"))
+		ctl.compatible = 1;
+
+	if (argc == 1) {
+		if (ctl.compatible) {
+			/*
+			 * For some reason, the original getopt gave no
+			 * error when there were no arguments.
+			 */
+			printf(" --\n");
+			return EXIT_SUCCESS;
+		}
+		parse_error(_("missing optstring argument"));
+	}
+
+	add_longopt(&ctl, NULL, 0);	/* init */
+	getopt_long_fp = getopt_long;
+
+	if (argv[1][0] != '-' || ctl.compatible) {
+		ctl.quote = 0;
+		ctl.optstr = xmalloc(strlen(argv[1]) + 1);
+		strcpy(ctl.optstr, argv[1] + strspn(argv[1], "-+"));
+		argv[1] = argv[0];
+		return generate_output(&ctl, argv + 1, argc - 1);
+	}
+
+	while ((opt =
+		getopt_long(argc, argv, shortopts, longopts, NULL)) != EOF)
+		switch (opt) {
+		case 'a':
+			getopt_long_fp = getopt_long_only;
+			break;
+		case 'o':
+			free(ctl.optstr);
+			ctl.optstr = xstrdup(optarg);
+			break;
+		case 'l':
+			add_long_options(&ctl, optarg);
+			break;
+		case 'n':
+			free(ctl.name);
+			ctl.name = xstrdup(optarg);
+			break;
+		case 'q':
+			ctl.quiet_errors = 1;
+			break;
+		case 'Q':
+			ctl.quiet_output = 1;
+			break;
+		case 's':
+			ctl.shell = shell_type(optarg);
+			break;
+		case 'T':
+			free(ctl.long_options);
+			return TEST_EXIT_CODE;
+		case 'u':
+			ctl.quote = 0;
+			break;
+
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		case '?':
+		case ':':
+			parse_error(NULL);
+		case 'h':
+			usage();
+		default:
+			parse_error(_("internal error, contact the author."));
+		}
+
+	if (!ctl.optstr) {
+		if (optind >= argc)
+			parse_error(_("missing optstring argument"));
+		else {
+			ctl.optstr = xstrdup(argv[optind]);
+			optind++;
+		}
+	}
+
+	if (ctl.name) {
+		argv[optind - 1] = ctl.name;
+#if defined (HAVE_SETPROGNAME) && !defined (__linux__)
+		setprogname(ctl.name);
+#endif
+	} else
+		argv[optind - 1] = argv[0];
+
+	return generate_output(&ctl, argv + optind - 1, argc - optind + 1);
+}
diff --git a/misc-utils/hardlink.1 b/misc-utils/hardlink.1
new file mode 100644
index 0000000..de26d34
--- /dev/null
+++ b/misc-utils/hardlink.1
@@ -0,0 +1,69 @@
+.TH "hardlink" "1"
+.SH NAME
+hardlink \- Consolidate duplicate files via hardlinks
+.SH SYNOPSIS
+.B hardlink
+[options]
+.RI [ directory ...]
+.SH DESCRIPTION
+This manual page documents \fBhardlink\fR, a
+program which consolidates duplicate files in one or more directories
+using hardlinks.
+.PP
+\fBhardlink\fR traverses one
+or more directories searching for duplicate files.  When it finds duplicate
+files, it uses one of them as the master.  It then removes all other
+duplicates and places a hardlink for each one pointing to the master file.
+This allows for conservation of disk space where multiple directories
+on a single filesystem contain many duplicate files.
+.PP
+Since hard links can only span a single filesystem, \fBhardlink\fR
+is only useful when all directories specified are on the same filesystem.
+.SH OPTIONS
+.TP
+.BR \-c , " \-\-content"
+Compare only the contents of the files being considered for consolidation.
+Disregards permission, ownership and other differences.
+.TP
+.BR \-f , " \-\-force"
+Force hardlinking across file systems.
+.TP
+.BR \-n , " \-\-dry\-run"
+Do not perform the consolidation; only print what would be changed.
+.TP
+.BR \-v , " \-\-verbose"
+Print summary after hardlinking. The option may be specified more than once. In
+this case (e.g., \fB\-vv\fR) it prints every hardlinked file and bytes saved.
+.TP
+.BR \-x , " \-\-exclude " \fIregex\fR
+Exclude files and directories matching pattern from hardlinking.
+.sp
+The optional pattern for excluding files and directories must be a PCRE2
+compatible regular expression. Only the basename of the file or directory
+is checked, not its path. Excluded directories' contents will not be examined.
+.TP
+.BR \-h , " \-\-help"
+Display help text and exit.
+.TP
+.BR \-V , " \-\-version"
+Display version information and exit.
+.SH BUGS
+\fBhardlink\fR assumes that its target directory trees do not change from under
+it.  If a directory tree does change, this may result in \fBhardlink\fR
+accessing files and/or directories outside of the intended directory tree.
+Thus, you must avoid running \fBhardlink\fR on potentially changing directory
+trees, and especially on directory trees under control of another user.
+.PP
+Historically \fBhardlink\fR silently excluded any names beginning with
+".in.", as well as any names beginning with "." followed by exactly 6
+other characters. That prior behavior can be achieved by specifying
+.br
+\-x '^(\\.in\\.|\\.[^.]{6}$)'
+.SH AUTHORS
+\fBhardlink\fR was written by Jakub Jelinek <jakub@redhat.com> and later modified by
+Ruediger Meier <ruediger.meier@ga-group.nl> and Karel Zak <kzak@redhat.com> for util-linux.
+.PP
+Man page written by Brian Long and later updated by Jindrich Novy <jnovy@redhat.com>
+.SH AVAILABILITY
+The hardlink command is part of the util-linux package and is available from
+https://www.kernel.org/pub/linux/utils/util-linux/.
diff --git a/misc-utils/hardlink.c b/misc-utils/hardlink.c
new file mode 100644
index 0000000..2711b2a
--- /dev/null
+++ b/misc-utils/hardlink.c
@@ -0,0 +1,531 @@
+/*
+ * hardlink - consolidate duplicate files via hardlinks
+ *
+ * Copyright (C) 2018 Red Hat, Inc. All rights reserved.
+ * Written by Jakub Jelinek <jakub@redhat.com>
+ *
+ * Copyright (C) 2019 Karel Zak <kzak@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include <sys/types.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <errno.h>
+#ifdef HAVE_PCRE
+# define PCRE2_CODE_UNIT_WIDTH 8
+# include <pcre2.h>
+#endif
+
+#include "c.h"
+#include "xalloc.h"
+#include "nls.h"
+#include "closestream.h"
+
+#define NHASH   (1<<17)  /* Must be a power of 2! */
+#define NBUF    64
+
+struct hardlink_file;
+
+struct hardlink_hash {
+	struct hardlink_hash *next;
+	struct hardlink_file *chain;
+	off_t size;
+	time_t mtime;
+};
+
+struct hardlink_dir {
+	struct hardlink_dir *next;
+	char name[];
+};
+
+struct hardlink_file {
+	struct hardlink_file *next;
+	ino_t ino;
+	dev_t dev;
+	unsigned int cksum;
+	char name[];
+};
+
+struct hardlink_dynstr {
+	char *buf;
+	size_t alloc;
+};
+
+struct hardlink_ctl {
+	struct hardlink_dir *dirs;
+	struct hardlink_hash *hps[NHASH];
+	char iobuf1[BUFSIZ];
+	char iobuf2[BUFSIZ];
+	/* summary counters */
+	unsigned long long ndirs;
+	unsigned long long nobjects;
+	unsigned long long nregfiles;
+	unsigned long long ncomp;
+	unsigned long long nlinks;
+	unsigned long long nsaved;
+	/* current device */
+	dev_t dev;
+	/* flags */
+	unsigned int verbose;
+	unsigned int
+		no_link:1,
+		content_only:1,
+		force:1;
+};
+/* ctl is in global scope due use in atexit() */
+struct hardlink_ctl global_ctl;
+
+__attribute__ ((always_inline))
+static inline unsigned int hash(off_t size, time_t mtime)
+{
+	return (size ^ mtime) & (NHASH - 1);
+}
+
+__attribute__ ((always_inline))
+static inline int stcmp(struct stat *st1, struct stat *st2, int content_scope)
+{
+	if (content_scope)
+		return st1->st_size != st2->st_size;
+
+	return st1->st_mode != st2->st_mode
+		|| st1->st_uid != st2->st_uid
+		|| st1->st_gid != st2->st_gid
+		|| st1->st_size != st2->st_size
+		|| st1->st_mtime != st2->st_mtime;
+}
+
+static void print_summary(void)
+{
+	struct hardlink_ctl const *const ctl = &global_ctl;
+
+	if (!ctl->verbose)
+		return;
+
+	if (ctl->verbose > 1 && ctl->nlinks)
+		fputc('\n', stdout);
+
+	printf(_("Directories:   %9lld\n"), ctl->ndirs);
+	printf(_("Objects:       %9lld\n"), ctl->nobjects);
+	printf(_("Regular files: %9lld\n"), ctl->nregfiles);
+	printf(_("Comparisons:   %9lld\n"), ctl->ncomp);
+	printf(  "%s%9lld\n", (ctl->no_link ?
+	       _("Would link:    ") :
+	       _("Linked:        ")), ctl->nlinks);
+	printf(  "%s %9lld\n", (ctl->no_link ?
+	       _("Would save:   ") :
+	       _("Saved:        ")), ctl->nsaved);
+}
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	fputs(USAGE_HEADER, stdout);
+	printf(_(" %s [options] directory...\n"), program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, stdout);
+	puts(_("Consolidate duplicate files using hardlinks."));
+
+	fputs(USAGE_OPTIONS, stdout);
+	puts(_(" -c, --content          compare only contents, ignore permission, etc."));
+	puts(_(" -n, --dry-run          don't actually link anything"));
+	puts(_(" -v, --verbose          print summary after hardlinking"));
+	puts(_(" -vv                    print every hardlinked file and summary"));
+	puts(_(" -f, --force            force hardlinking across filesystems"));
+	puts(_(" -x, --exclude <regex>  exclude files matching pattern"));
+
+	fputs(USAGE_SEPARATOR, stdout);
+	printf(USAGE_HELP_OPTIONS(16)); /* char offset to align option descriptions */
+	printf(USAGE_MAN_TAIL("hardlink(1)"));
+	exit(EXIT_SUCCESS);
+}
+
+__attribute__ ((always_inline))
+static inline size_t add2(size_t a, size_t b)
+{
+	size_t sum = a + b;
+
+	if (sum < a)
+		errx(EXIT_FAILURE, _("integer overflow"));
+	return sum;
+}
+
+__attribute__ ((always_inline))
+static inline size_t add3(size_t a, size_t b, size_t c)
+{
+	return add2(add2(a, b), c);
+}
+
+static void growstr(struct hardlink_dynstr *str, size_t newlen)
+{
+	if (newlen < str->alloc)
+		return;
+	str->buf = xrealloc(str->buf, str->alloc = add2(newlen, 1));
+}
+
+static void process_path(struct hardlink_ctl *ctl, const char *name)
+{
+	struct stat st, st2, st3;
+	const size_t namelen = strlen(name);
+
+	ctl->nobjects++;
+	if (lstat(name, &st))
+		return;
+
+	if (st.st_dev != ctl->dev && !ctl->force) {
+		if (ctl->dev)
+			errx(EXIT_FAILURE,
+			     _("%s is on different filesystem than the rest "
+			       "(use -f option to override)."), name);
+		ctl->dev = st.st_dev;
+	}
+	if (S_ISDIR(st.st_mode)) {
+		struct hardlink_dir *dp = xmalloc(add3(sizeof(*dp), namelen, 1));
+		memcpy(dp->name, name, namelen + 1);
+		dp->next = ctl->dirs;
+		ctl->dirs = dp;
+
+	} else if (S_ISREG(st.st_mode)) {
+		int fd, i;
+		struct hardlink_file *fp, *fp2;
+		struct hardlink_hash *hp;
+		const char *n1, *n2;
+		unsigned int buf[NBUF];
+		int cksumsize = sizeof(buf);
+		unsigned int cksum;
+		time_t mtime = ctl->content_only ? 0 : st.st_mtime;
+		unsigned int hsh = hash(st.st_size, mtime);
+		off_t fsize;
+
+		ctl->nregfiles++;
+		if (ctl->verbose > 1)
+			printf("%s\n", name);
+
+		fd = open(name, O_RDONLY);
+		if (fd < 0)
+			return;
+
+		if ((size_t)st.st_size < sizeof(buf)) {
+			cksumsize = st.st_size;
+			memset(((char *)buf) + cksumsize, 0,
+			       (sizeof(buf) - cksumsize) % sizeof(buf[0]));
+		}
+		if (read(fd, buf, cksumsize) != cksumsize) {
+			close(fd);
+			return;
+		}
+		cksumsize = (cksumsize + sizeof(buf[0]) - 1) / sizeof(buf[0]);
+		for (i = 0, cksum = 0; i < cksumsize; i++) {
+			if (cksum + buf[i] < cksum)
+				cksum += buf[i] + 1;
+			else
+				cksum += buf[i];
+		}
+		for (hp = ctl->hps[hsh]; hp; hp = hp->next) {
+			if (hp->size == st.st_size && hp->mtime == mtime)
+				break;
+		}
+		if (!hp) {
+			hp = xmalloc(sizeof(*hp));
+			hp->size = st.st_size;
+			hp->mtime = mtime;
+			hp->chain = NULL;
+			hp->next = ctl->hps[hsh];
+			ctl->hps[hsh] = hp;
+		}
+		for (fp = hp->chain; fp; fp = fp->next) {
+			if (fp->cksum == cksum)
+				break;
+		}
+		for (fp2 = fp; fp2 && fp2->cksum == cksum; fp2 = fp2->next) {
+			if (fp2->ino == st.st_ino && fp2->dev == st.st_dev) {
+				close(fd);
+				return;
+			}
+		}
+		for (fp2 = fp; fp2 && fp2->cksum == cksum; fp2 = fp2->next) {
+
+			if (!lstat(fp2->name, &st2) && S_ISREG(st2.st_mode) &&
+			    !stcmp(&st, &st2, ctl->content_only) &&
+			    st2.st_ino != st.st_ino &&
+			    st2.st_dev == st.st_dev) {
+
+				int fd2 = open(fp2->name, O_RDONLY);
+				if (fd2 < 0)
+					continue;
+
+				if (fstat(fd2, &st2) || !S_ISREG(st2.st_mode)
+				    || st2.st_size == 0) {
+					close(fd2);
+					continue;
+				}
+				ctl->ncomp++;
+				lseek(fd, 0, SEEK_SET);
+
+				for (fsize = st.st_size; fsize > 0;
+				     fsize -= (off_t)sizeof(ctl->iobuf1)) {
+					ssize_t xsz;
+					ssize_t rsize = fsize > (ssize_t) sizeof(ctl->iobuf1) ?
+							(ssize_t) sizeof(ctl->iobuf1) : fsize;
+
+					if ((xsz = read(fd, ctl->iobuf1, rsize)) != rsize)
+						warn(_("cannot read %s"), name);
+					else if ((xsz = read(fd2, ctl->iobuf2, rsize)) != rsize)
+						warn(_("cannot read %s"), fp2->name);
+
+					if (xsz != rsize) {
+						close(fd);
+						close(fd2);
+						return;
+					}
+					if (memcmp(ctl->iobuf1, ctl->iobuf2, rsize) != 0)
+						break;
+				}
+				close(fd2);
+				if (fsize > 0)
+					continue;
+				if (lstat(name, &st3)) {
+					warn(_("cannot stat %s"), name);
+					close(fd);
+					return;
+				}
+				st3.st_atime = st.st_atime;
+				if (stcmp(&st, &st3, 0)) {
+					warnx(_("file %s changed underneath us"), name);
+					close(fd);
+					return;
+				}
+				n1 = fp2->name;
+				n2 = name;
+
+				if (!ctl->no_link) {
+					const char *suffix =
+					    ".$$$___cleanit___$$$";
+					const size_t suffixlen = strlen(suffix);
+					size_t n2len = strlen(n2);
+					struct hardlink_dynstr nam2 = { NULL, 0 };
+
+					growstr(&nam2, add2(n2len, suffixlen));
+					memcpy(nam2.buf, n2, n2len);
+					memcpy(&nam2.buf[n2len], suffix,
+					       suffixlen + 1);
+					/* First create a temporary link to n1 under a new name */
+					if (link(n1, nam2.buf)) {
+						warn(_("failed to hardlink %s to %s (create temporary link as %s failed)"),
+							n1, n2, nam2.buf);
+						free(nam2.buf);
+						continue;
+					}
+					/* Then rename into place over the existing n2 */
+					if (rename(nam2.buf, n2)) {
+						warn(_("failed to hardlink %s to %s (rename temporary link to %s failed)"),
+							n1, n2, n2);
+						/* Something went wrong, try to remove the now redundant temporary link */
+						if (unlink(nam2.buf))
+							warn(_("failed to remove temporary link %s"), nam2.buf);
+						free(nam2.buf);
+						continue;
+					}
+					free(nam2.buf);
+				}
+				ctl->nlinks++;
+				if (st3.st_nlink > 1) {
+					/* We actually did not save anything this time, since the link second argument
+					   had some other links as well.  */
+					if (ctl->verbose > 1)
+						printf(_(" %s %s to %s\n"),
+							(ctl->no_link ? _("Would link") : _("Linked")),
+							n1, n2);
+				} else {
+					ctl->nsaved += ((st.st_size + 4095) / 4096) * 4096;
+					if (ctl->verbose > 1)
+						printf(_(" %s %s to %s, %s %jd\n"),
+							(ctl->no_link ? _("Would link") : _("Linked")),
+							n1, n2,
+							(ctl->no_link ? _("would save") : _("saved")),
+							(intmax_t)st.st_size);
+				}
+				close(fd);
+				return;
+			}
+		}
+		fp2 = xmalloc(add3(sizeof(*fp2), namelen, 1));
+		close(fd);
+		fp2->ino = st.st_ino;
+		fp2->dev = st.st_dev;
+		fp2->cksum = cksum;
+		memcpy(fp2->name, name, namelen + 1);
+
+		if (fp) {
+			fp2->next = fp->next;
+			fp->next = fp2;
+		} else {
+			fp2->next = hp->chain;
+			hp->chain = fp2;
+		}
+		return;
+	}
+}
+
+int main(int argc, char **argv)
+{
+	int ch;
+	int i;
+#ifdef HAVE_PCRE
+	int errornumber;
+	PCRE2_SIZE erroroffset;
+	pcre2_code *re = NULL;
+	PCRE2_SPTR exclude_pattern = NULL;
+	pcre2_match_data *match_data = NULL;
+#endif
+	struct hardlink_dynstr nam1 = { NULL, 0 };
+	struct hardlink_ctl *ctl = &global_ctl;
+
+	static const struct option longopts[] = {
+		{ "content",    no_argument, NULL, 'c' },
+		{ "dry-run",    no_argument, NULL, 'n' },
+		{ "exclude",    required_argument, NULL, 'x' },
+		{ "force",      no_argument, NULL, 'f' },
+		{ "help",       no_argument, NULL, 'h' },
+		{ "verbose",    no_argument, NULL, 'v' },
+		{ "version",    no_argument, NULL, 'V' },
+		{ NULL, 0, NULL, 0 },
+	};
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	while ((ch = getopt_long(argc, argv, "cnvfx:Vh", longopts, NULL)) != -1) {
+		switch (ch) {
+		case 'n':
+			ctl->no_link = 1;
+			break;
+		case 'v':
+			ctl->verbose++;
+			break;
+		case 'c':
+			ctl->content_only = 1;
+			break;
+		case 'f':
+			ctl->force = 1;
+			break;
+		case 'x':
+#ifdef HAVE_PCRE
+			exclude_pattern = (PCRE2_SPTR) optarg;
+#else
+			errx(EXIT_FAILURE,
+			     _("option --exclude not supported (built without pcre2)"));
+#endif
+			break;
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		case 'h':
+			usage();
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+
+	if (optind == argc) {
+		warnx(_("no directory specified"));
+		errtryhelp(EXIT_FAILURE);
+	}
+
+#ifdef HAVE_PCRE
+	if (exclude_pattern) {
+		re = pcre2_compile(exclude_pattern, /* the pattern */
+				   PCRE2_ZERO_TERMINATED, /* indicates pattern is zero-terminate */
+				   0, /* default options */
+				   &errornumber, &erroroffset, NULL); /* use default compile context */
+		if (!re) {
+			PCRE2_UCHAR buffer[256];
+			pcre2_get_error_message(errornumber, buffer,
+						sizeof(buffer));
+			errx(EXIT_FAILURE, _("pattern error at offset %d: %s"),
+				(int)erroroffset, buffer);
+		}
+		match_data = pcre2_match_data_create_from_pattern(re, NULL);
+	}
+#endif
+	atexit(print_summary);
+
+	for (i = optind; i < argc; i++)
+		process_path(ctl, argv[i]);
+
+	while (ctl->dirs) {
+		DIR *dh;
+		struct dirent *di;
+		struct hardlink_dir *dp = ctl->dirs;
+		size_t nam1baselen = strlen(dp->name);
+
+		ctl->dirs = dp->next;
+		growstr(&nam1, add2(nam1baselen, 1));
+		memcpy(nam1.buf, dp->name, nam1baselen);
+		free(dp);
+		nam1.buf[nam1baselen++] = '/';
+		nam1.buf[nam1baselen] = 0;
+		dh = opendir(nam1.buf);
+
+		if (dh == NULL)
+			continue;
+		ctl->ndirs++;
+
+		while ((di = readdir(dh)) != NULL) {
+			if (!di->d_name[0])
+				continue;
+			if (di->d_name[0] == '.') {
+				if (!di->d_name[1] || !strcmp(di->d_name, ".."))
+					continue;
+			}
+#ifdef HAVE_PCRE
+			if (re && pcre2_match(re, /* compiled regex */
+					      (PCRE2_SPTR) di->d_name, strlen(di->d_name), 0, /* start at offset 0 */
+					      0, /* default options */
+					      match_data, /* block for storing the result */
+					      NULL) /* use default match context */
+			    >=0) {
+				if (ctl->verbose) {
+					nam1.buf[nam1baselen] = 0;
+					printf(_("Skipping %s%s\n"), nam1.buf, di->d_name);
+				}
+				continue;
+			}
+#endif
+			{
+				size_t subdirlen;
+				growstr(&nam1,
+					add2(nam1baselen, subdirlen =
+					     strlen(di->d_name)));
+				memcpy(&nam1.buf[nam1baselen], di->d_name,
+				       add2(subdirlen, 1));
+			}
+			process_path(ctl, nam1.buf);
+		}
+		closedir(dh);
+	}
+#ifdef HAVE_PCRE
+	pcre2_code_free(re);
+	pcre2_match_data_free(match_data);
+#endif
+	return 0;
+}
diff --git a/misc-utils/kill.1 b/misc-utils/kill.1
new file mode 100644
index 0000000..5e0ebaf
--- /dev/null
+++ b/misc-utils/kill.1
@@ -0,0 +1,240 @@
+.\" Copyright 1994 Salvatore Valente (svalente@mit.edu)
+.\" Copyright 1992 Rickard E. Faith (faith@cs.unc.edu)
+.\" May be distributed under the GNU General Public License
+.TH KILL 1 "November 2019" "util-linux" "User Commands"
+.SH NAME
+kill \- terminate a process
+.SH SYNOPSIS
+.B kill
+.RB [ \- \fIsignal\fR| \-s
+.IR signal | \fB\-p\fP ]
+.RB [ \-q
+.IR value ]
+.RB [ \-a ]
+\fR[\fB\-\-timeout \fImilliseconds signal\fR]
+.RB [ \-\- ]
+.IR pid | name ...
+.br
+.B kill \-l
+.RI [ number ]
+.RB "| " \-L
+.SH DESCRIPTION
+The command
+.B kill
+sends the specified \fIsignal\fR to the specified processes or process groups.
+.PP
+If no signal is specified, the TERM signal is sent.
+The default action for this signal is to terminate the process.
+This signal should be used in preference to the
+KILL signal (number 9), since a process may install a handler for the
+TERM signal in order to perform clean-up steps before terminating in
+an orderly fashion.
+If a process does not terminate after a TERM signal has been sent,
+then the KILL signal may be used; be aware that the latter signal
+cannot be caught, and so does not give the target process the opportunity
+to perform any clean-up before terminating.
+.PP
+Most modern shells have a builtin
+.B kill
+command, with a usage rather similar to
+that of the command described here.  The
+.BR \-\-all ,
+.BR \-\-pid ", and"
+.B \-\-queue
+options, and the possibility to specify processes by command name, are local extensions.
+.PP
+If \fIsignal\fR is 0, then no actual signal is sent, but error checking is still performed.
+
+.SH ARGUMENTS
+The list of processes to be signaled can be a mixture of names and PIDs.
+.TP
+.I pid
+Each
+.I pid
+can be expressed in one of the following ways:
+.RS
+.TP
+.I n
+where
+.I n
+is larger than 0.  The process with PID
+.I n
+is signaled.
+.TP
+.B 0
+All processes in the current process group are signaled.
+.TP
+.B \-1
+All processes with a PID larger than 1 are signaled.
+.TP
+.BI \- n
+where
+.I n
+is larger than 1.  All processes in process group
+.I n
+are signaled.  When an argument of the form '\-n' is given, and it is meant to
+denote a process group, either a signal must be specified first, or the
+argument must be preceded by a '\-\-' option, otherwise it will be taken as the
+signal to send.
+.RE
+.TP
+.I name
+All processes invoked using this \fIname\fR will be signaled.
+
+.SH OPTIONS
+.TP
+\fB\-s\fR, \fB\-\-signal\fR \fIsignal\fR
+The signal to send.  It may be given as a name or a number.
+.TP
+\fB\-l\fR, \fB\-\-list\fR [\fInumber\fR]
+Print a list of signal names, or convert the given signal number to a name.
+The signals can be found in
+.IR /usr/\:include/\:linux/\:signal.h .
+.TP
+\fB\-L\fR, \fB\-\-table\fR
+Similar to \fB\-l\fR, but it will print signal names and their corresponding
+numbers.
+.TP
+\fB\-a\fR, \fB\-\-all\fR
+Do not restrict the command-name-to-PID conversion to processes with the same
+UID as the present process.
+.TP
+\fB\-p\fR, \fB\-\-pid\fR
+Only print the process ID (PID) of the named processes, do not send any
+signals.
+.TP
+\fB\-\-verbose\fR
+Print PID(s) that will be signaled with
+.B kill
+along with the signal.
+.TP
+\fB\-q\fR, \fB\-\-queue\fR \fIvalue\fR
+Send the signal using
+.BR sigqueue (3)
+rather than
+.BR kill (2).
+The
+.I value
+argument is an integer that is sent along with the signal.  If the
+receiving process has installed a handler for this signal using the
+.B SA_SIGINFO
+flag to
+.BR sigaction (2),
+then it can obtain this data via the
+.I si_sigval
+field of the
+.I siginfo_t
+structure.
+.TP
+\fB\-\-timeout\fR \fImilliseconds signal\fR
+Send a signal defined in the usual way to a process,
+followed by an additional signal after a specified delay.
+The
+.B \-\-timeout
+option causes
+.B kill
+to wait for a period defined in
+.I milliseconds
+before sending a follow-up
+.I signal
+to the process.
+This feature is implemented using the Linux kernel
+PID file descriptor feature in order to guarantee that the follow-up signal
+is sent to the same process or not sent if the process no longer exists.
+.IP
+Note that the operating system may re-use PIDs and implementing an
+equivalent feature in a shell using
+.B kill
+and
+.B sleep
+would be subject to races whereby the follow-up signal might be sent
+to a different process that used a recycled PID.
+.IP
+The
+.B \-\-timeout
+option can be specified multiple times: the signals are sent
+sequentially with the specified timeouts.  The
+.B \-\-timeout
+option can be combined with the
+.B \-\-queue
+option.
+.IP
+As an example, the following command sends
+the signals QUIT, TERM and KILL in sequence and waits for 1000
+milliseconds between sending the signals:
+.IP
+.in +4n
+.EX
+kill \-\-verbose \-\-timeout 1000 TERM \-\-timeout 1000 KILL \e
+        \-\-signal QUIT 12345
+.EE
+.in
+.SH EXIT STATUS
+.B kill
+has the following exit status values:
+.PP
+.RS
+.PD 0
+.TP
+.B 0
+success
+.TP
+.B 1
+failure
+.TP
+.B 64
+partial success (when more than one process specified)
+.PD
+.RE
+.SH NOTES
+Although it is possible to specify the TID (thread ID, see
+.BR gettid (2))
+of one of the threads in a multithreaded process as the argument of
+.BR kill ,
+the signal is nevertheless directed to the process
+(i.e., the entire thread group).
+In other words, it is not possible to send a signal to an
+explicitly selected thread in a multithreaded process.
+The signal will be delivered to an arbitrarily selected thread
+in the target process that is not blocking the signal.
+For more details, see
+.BR signal (7)
+and the description of
+.B CLONE_THREAD
+in
+.BR clone (2).
+.P
+Various shells provide a builtin
+.B kill
+command that is
+preferred in relation to the
+.BR kill (1)
+executable described by this manual.
+The easiest way to ensure one is executing the command described in this page
+is to use the full path when calling the command, for example:
+.B "/bin/kill \-\-version"
+.SH AUTHORS
+.MT svalente@mit.edu
+Salvatore Valente
+.ME
+.br
+.MT kzak@redhat.com
+Karel Zak
+.ME
+.br
+.PP
+The original version was taken from BSD 4.4.
+
+.SH SEE ALSO
+.BR bash (1),
+.BR tcsh (1),
+.BR sigaction (2),
+.BR kill (2),
+.BR sigqueue (3),
+.BR signal (7)
+
+.SH AVAILABILITY
+The kill command is part of the util-linux package and is available from
+.UR https://\:www.kernel.org\:/pub\:/linux\:/utils\:/util-linux/
+Linux Kernel Archive
+.UE .
diff --git a/misc-utils/kill.c b/misc-utils/kill.c
new file mode 100644
index 0000000..9cfb03c
--- /dev/null
+++ b/misc-utils/kill.c
@@ -0,0 +1,513 @@
+/*
+ * Copyright (c) 1988, 1993, 1994
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+/*
+ *  oct 5 1994 -- almost entirely re-written to allow for process names.
+ *  modifications (c) salvatore valente <svalente@mit.edu>
+ *  may be used / modified / distributed under the same terms as the original.
+ *
+ *  1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
+ *  - added Native Language Support
+ *
+ *  1999-11-13 aeb Accept signal numbers 128+s.
+ *
+ * Copyright (C) 2014 Sami Kerola <kerolasa@iki.fi>
+ * Copyright (C) 2014 Karel Zak <kzak@redhat.com>
+ */
+
+#include <ctype.h>		/* for isdigit() */
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "c.h"
+#include "closestream.h"
+#include "nls.h"
+#include "pidfd-utils.h"
+#include "procutils.h"
+#include "signames.h"
+#include "strutils.h"
+#include "ttyutils.h"
+#include "xalloc.h"
+
+/* partial success, otherwise we return regular EXIT_{SUCCESS,FAILURE} */
+#define KILL_EXIT_SOMEOK	64
+
+enum {
+	KILL_FIELD_WIDTH = 11,
+	KILL_OUTPUT_WIDTH = 72
+};
+
+#ifdef UL_HAVE_PIDFD
+# include <poll.h>
+# include "list.h"
+struct timeouts {
+	int period;
+	int sig;
+	struct list_head follow_ups;
+};
+#endif
+
+struct kill_control {
+	char *arg;
+	pid_t pid;
+	int numsig;
+#ifdef HAVE_SIGQUEUE
+	union sigval sigdata;
+#endif
+#ifdef UL_HAVE_PIDFD
+	struct list_head follow_ups;
+#endif
+	unsigned int
+		check_all:1,
+		do_kill:1,
+		do_pid:1,
+		use_sigval:1,
+#ifdef UL_HAVE_PIDFD
+		timeout:1,
+#endif
+		verbose:1;
+};
+
+static void print_signal_name(int signum)
+{
+	const char *name = signum_to_signame(signum);
+
+	if (name) {
+		printf("%s\n", name);
+		return;
+	}
+#ifdef SIGRTMIN
+	if (SIGRTMIN <= signum && signum <= SIGRTMAX) {
+		printf("RT%d\n", signum - SIGRTMIN);
+		return;
+	}
+#endif
+	printf("%d\n", signum);
+}
+
+static void pretty_print_signal(FILE *fp, size_t term_width, size_t *lpos,
+				int signum, const char *name)
+{
+	if (term_width < (*lpos + KILL_FIELD_WIDTH)) {
+		fputc('\n', fp);
+		*lpos = 0;
+	}
+	*lpos += KILL_FIELD_WIDTH;
+	fprintf(fp, "%2d %-8s", signum, name);
+}
+
+static void print_all_signals(FILE *fp, int pretty)
+{
+	size_t n, lth, lpos = 0, width;
+	const char *signame = NULL;
+	int signum = 0;
+
+	if (!pretty) {
+		for (n = 0; get_signame_by_idx(n, &signame, NULL) == 0; n++) {
+			lth = 1 + strlen(signame);
+			if (KILL_OUTPUT_WIDTH < lpos + lth) {
+				fputc('\n', fp);
+				lpos = 0;
+			} else if (lpos)
+				fputc(' ', fp);
+			lpos += lth;
+			fputs(signame, fp);
+		}
+#ifdef SIGRTMIN
+		fputs(" RT<N> RTMIN+<N> RTMAX-<N>", fp);
+#endif
+		fputc('\n', fp);
+		return;
+	}
+
+	/* pretty print */
+	width = get_terminal_width(KILL_OUTPUT_WIDTH + 1) - 1;
+	for (n = 0; get_signame_by_idx(n, &signame, &signum) == 0; n++)
+		pretty_print_signal(fp, width, &lpos, signum, signame);
+#ifdef SIGRTMIN
+	pretty_print_signal(fp, width, &lpos, SIGRTMIN, "RTMIN");
+	pretty_print_signal(fp, width, &lpos, SIGRTMAX, "RTMAX");
+#endif
+	fputc('\n', fp);
+}
+
+static void err_nosig(char *name)
+{
+	warnx(_("unknown signal %s; valid signals:"), name);
+	print_all_signals(stderr, 1);
+	exit(EXIT_FAILURE);
+}
+
+static int arg_to_signum(char *arg, int maskbit)
+{
+	int numsig;
+	char *ep;
+
+	if (isdigit(*arg)) {
+		numsig = strtol(arg, &ep, 10);
+		if (NSIG <= numsig && maskbit && (numsig & 128) != 0)
+			numsig -= 128;
+		if (*ep != 0 || numsig < 0 || NSIG <= numsig)
+			return -1;
+		return numsig;
+	}
+	return signame_to_signum(arg);
+}
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+	fputs(USAGE_HEADER, out);
+	fprintf(out, _(" %s [options] <pid>|<name>...\n"), program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("Forcibly terminate a process.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -a, --all              do not restrict the name-to-pid conversion to processes\n"
+		"                          with the same uid as the present process\n"), out);
+	fputs(_(" -s, --signal <signal>  send this <signal> instead of SIGTERM\n"), out);
+#ifdef HAVE_SIGQUEUE
+	fputs(_(" -q, --queue <value>    use sigqueue(2), not kill(2), and pass <value> as data\n"), out);
+#endif
+#ifdef UL_HAVE_PIDFD
+	fputs(_("     --timeout <milliseconds> <follow-up signal>\n"
+		"                        wait up to timeout and send follow-up signal\n"), out);
+#endif
+	fputs(_(" -p, --pid              print pids without signaling them\n"), out);
+	fputs(_(" -l, --list[=<signal>]  list signal names, or convert a signal number to a name\n"), out);
+	fputs(_(" -L, --table            list signal names and numbers\n"), out);
+	fputs(_("     --verbose          print pids that will be signaled\n"), out);
+
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(24));
+	printf(USAGE_MAN_TAIL("kill(1)"));
+
+	exit(EXIT_SUCCESS);
+}
+
+static void __attribute__((__noreturn__)) print_kill_version(void)
+{
+	static const char *features[] = {
+#ifdef HAVE_SIGQUEUE
+		"sigqueue",
+#endif
+#ifdef UL_HAVE_PIDFD
+		"pidfd",
+#endif
+	};
+
+	printf(_("%s from %s"), program_invocation_short_name, PACKAGE_STRING);
+
+	if (ARRAY_SIZE(features)) {
+		size_t i;
+		fputs(_(" (with: "), stdout);
+		for (i = 0; i < ARRAY_SIZE(features); i++) {
+			fputs(features[i], stdout);
+			if (i + 1 < ARRAY_SIZE(features))
+				fputs(", ", stdout);
+		}
+		fputs(")\n", stdout);
+	}
+	exit(EXIT_SUCCESS);
+}
+
+static char **parse_arguments(int argc, char **argv, struct kill_control *ctl)
+{
+	char *arg;
+
+	/* Loop through the arguments.  Actually, -a is the only option
+	 * can be used with other options.  The 'kill' is basically a
+	 * one-option-at-most program. */
+	for (argc--, argv++; 0 < argc; argc--, argv++) {
+		arg = *argv;
+		if (*arg != '-')
+			break;
+		if (!strcmp(arg, "--")) {
+			argc--, argv++;
+			break;
+		}
+		if (!strcmp(arg, "-v") || !strcmp(arg, "-V") ||
+		    !strcmp(arg, "--version"))
+			print_kill_version();
+		if (!strcmp(arg, "-h") || !strcmp(arg, "--help"))
+			usage();
+		if (!strcmp(arg, "--verbose")) {
+			ctl->verbose = 1;
+			continue;
+		}
+		if (!strcmp(arg, "-a") || !strcmp(arg, "--all")) {
+			ctl->check_all = 1;
+			continue;
+		}
+		if (!strcmp(arg, "-l") || !strcmp(arg, "--list")) {
+			if (argc < 2) {
+				print_all_signals(stdout, 0);
+				exit(EXIT_SUCCESS);
+			}
+			if (2 < argc)
+				errx(EXIT_FAILURE, _("too many arguments"));
+			/* argc == 2, accept "kill -l $?" */
+			arg = argv[1];
+			if ((ctl->numsig = arg_to_signum(arg, 1)) < 0)
+				errx(EXIT_FAILURE, _("unknown signal: %s"),
+				     arg);
+			print_signal_name(ctl->numsig);
+			exit(EXIT_SUCCESS);
+		}
+		/* for compatibility with procps kill(1) */
+		if (!strncmp(arg, "--list=", 7) || !strncmp(arg, "-l=", 3)) {
+			char *p = strchr(arg, '=') + 1;
+			if ((ctl->numsig = arg_to_signum(p, 1)) < 0)
+				errx(EXIT_FAILURE, _("unknown signal: %s"), p);
+			print_signal_name(ctl->numsig);
+			exit(EXIT_SUCCESS);
+		}
+		if (!strcmp(arg, "-L") || !strcmp(arg, "--table")) {
+			print_all_signals(stdout, 1);
+			exit(EXIT_SUCCESS);
+		}
+		if (!strcmp(arg, "-p") || !strcmp(arg, "--pid")) {
+			ctl->do_pid = 1;
+			if (ctl->do_kill)
+				errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--signal");
+#ifdef HAVE_SIGQUEUE
+			if (ctl->use_sigval)
+				errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--queue");
+#endif
+			continue;
+		}
+		if (!strcmp(arg, "-s") || !strcmp(arg, "--signal")) {
+			if (argc < 2)
+				errx(EXIT_FAILURE, _("not enough arguments"));
+			ctl->do_kill = 1;
+			if (ctl->do_pid)
+				errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--signal");
+			argc--, argv++;
+			arg = *argv;
+			if ((ctl->numsig = arg_to_signum(arg, 0)) < 0)
+				err_nosig(arg);
+			continue;
+		}
+#ifdef HAVE_SIGQUEUE
+		if (!strcmp(arg, "-q") || !strcmp(arg, "--queue")) {
+			if (argc < 2)
+				errx(EXIT_FAILURE, _("option '%s' requires an argument"), arg);
+			if (ctl->do_pid)
+				errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--queue");
+			argc--, argv++;
+			arg = *argv;
+			ctl->sigdata.sival_int = strtos32_or_err(arg, _("argument error"));
+			ctl->use_sigval = 1;
+			continue;
+		}
+#endif
+#ifdef UL_HAVE_PIDFD
+		if (!strcmp(arg, "--timeout")) {
+			struct timeouts *next;
+
+			ctl->timeout = 1;
+			if (argc < 2)
+				errx(EXIT_FAILURE, _("option '%s' requires an argument"), arg);
+			argc--, argv++;
+			arg = *argv;
+			next = xcalloc(1, sizeof(*next));
+			next->period = strtos32_or_err(arg, _("argument error"));
+			INIT_LIST_HEAD(&next->follow_ups);
+			argc--, argv++;
+			arg = *argv;
+			if ((next->sig = arg_to_signum(arg, 0)) < 0)
+				err_nosig(arg);
+			list_add_tail(&next->follow_ups, &ctl->follow_ups);
+			continue;
+		}
+#endif
+		/* 'arg' begins with a dash but is not a known option.
+		 * So it's probably something like -HUP, or -1/-n try to
+		 * deal with it.
+		 *
+		 * -n could be either signal n or pid -n (a process group
+		 * number).  In case of doubt, POSIX tells us to assume a
+		 * signal.  But if a signal has already been parsed, then
+		 * assume it is a process group, so stop parsing options. */
+		if (ctl->do_kill)
+			break;
+		arg++;
+		if ((ctl->numsig = arg_to_signum(arg, 0)) < 0)
+			errx(EXIT_FAILURE, _("invalid signal name or number: %s"), arg);
+		ctl->do_kill = 1;
+		if (ctl->do_pid)
+			errx(EXIT_FAILURE, _("%s and %s are mutually exclusive"), "--pid", "--signal");
+	}
+	if (!*argv)
+		errx(EXIT_FAILURE, _("not enough arguments"));
+	return argv;
+}
+
+#ifdef UL_HAVE_PIDFD
+static int kill_with_timeout(const struct kill_control *ctl)
+{
+	int pfd, n;
+	struct pollfd p = { 0 };
+	siginfo_t info = { 0 };
+	struct list_head *entry;
+
+	info.si_code = SI_QUEUE;
+	info.si_signo = ctl->numsig;
+	info.si_uid = getuid();
+	info.si_pid = getpid();
+	info.si_value.sival_int =
+	    ctl->use_sigval != 0 ? ctl->use_sigval : ctl->numsig;
+
+	if ((pfd = pidfd_open(ctl->pid, 0)) < 0)
+		err(EXIT_FAILURE, _("pidfd_open() failed: %d"), ctl->pid);
+	p.fd = pfd;
+	p.events = POLLIN;
+
+	if (pidfd_send_signal(pfd, ctl->numsig, &info, 0) < 0)
+		err(EXIT_FAILURE, _("pidfd_send_signal() failed"));
+	list_for_each(entry, &ctl->follow_ups) {
+		struct timeouts *timeout;
+
+		timeout = list_entry(entry, struct timeouts, follow_ups);
+		n = poll(&p, 1, timeout->period);
+		if (n < 0)
+			err(EXIT_FAILURE, _("poll() failed"));
+		if (n == 0) {
+			info.si_signo = timeout->sig;
+			if (ctl->verbose)
+				printf(_("timeout, sending signal %d to pid %d\n"),
+					 timeout->sig, ctl->pid);
+			if (pidfd_send_signal(pfd, timeout->sig, &info, 0) < 0)
+				err(EXIT_FAILURE, _("pidfd_send_signal() failed"));
+		}
+	}
+	return 0;
+}
+#endif
+
+static int kill_verbose(const struct kill_control *ctl)
+{
+	int rc = 0;
+
+	if (ctl->verbose)
+		printf(_("sending signal %d to pid %d\n"), ctl->numsig, ctl->pid);
+	if (ctl->do_pid) {
+		printf("%ld\n", (long) ctl->pid);
+		return 0;
+	}
+#ifdef UL_HAVE_PIDFD
+	if (ctl->timeout) {
+		rc = kill_with_timeout(ctl);
+	} else
+#endif
+#ifdef HAVE_SIGQUEUE
+	if (ctl->use_sigval)
+		rc = sigqueue(ctl->pid, ctl->numsig, ctl->sigdata);
+	else
+#endif
+		rc = kill(ctl->pid, ctl->numsig);
+
+	if (rc < 0)
+		warn(_("sending signal to %s failed"), ctl->arg);
+	return rc;
+}
+
+int main(int argc, char **argv)
+{
+	struct kill_control ctl = { .numsig = SIGTERM };
+	int nerrs = 0, ct = 0;
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+#ifdef UL_HAVE_PIDFD
+	INIT_LIST_HEAD(&ctl.follow_ups);
+#endif
+	argv = parse_arguments(argc, argv, &ctl);
+
+	/* The rest of the arguments should be process ids and names. */
+	for ( ; (ctl.arg = *argv) != NULL; argv++) {
+		char *ep = NULL;
+
+		errno = 0;
+		ctl.pid = strtol(ctl.arg, &ep, 10);
+		if (errno == 0 && ep && *ep == '\0' && ctl.arg < ep) {
+			if (kill_verbose(&ctl) != 0)
+				nerrs++;
+			ct++;
+		} else {
+			struct proc_processes *ps = proc_open_processes();
+			int found = 0;
+
+			if (!ps)
+				continue;
+			if (!ctl.check_all)
+				proc_processes_filter_by_uid(ps, getuid());
+
+			proc_processes_filter_by_name(ps, ctl.arg);
+			while (proc_next_pid(ps, &ctl.pid) == 0) {
+				if (kill_verbose(&ctl) != 0)
+					nerrs++;
+				ct++;
+				found = 1;
+			}
+			proc_close_processes(ps);
+
+			if (!found) {
+				nerrs++, ct++;
+				warnx(_("cannot find process \"%s\""), ctl.arg);
+			}
+		}
+	}
+
+#ifdef UL_HAVE_PIDFD
+	while (!list_empty(&ctl.follow_ups)) {
+		struct timeouts *x = list_entry(ctl.follow_ups.next,
+				                  struct timeouts, follow_ups);
+		list_del(&x->follow_ups);
+		free(x);
+	}
+#endif
+	if (ct && nerrs == 0)
+		return EXIT_SUCCESS;	/* full success */
+	if (ct == nerrs)
+		return EXIT_FAILURE;	/* all failed */
+
+	return KILL_EXIT_SOMEOK;	/* partial success */
+}
+
diff --git a/misc-utils/logger.1 b/misc-utils/logger.1
new file mode 100644
index 0000000..448311d
--- /dev/null
+++ b/misc-utils/logger.1
@@ -0,0 +1,383 @@
+.\" Copyright (c) 1983, 1990, 1993
+.\"	The Regents of the University of California.  All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. All advertising materials mentioning features or use of this software
+.\"    must display the following acknowledgement:
+.\"	This product includes software developed by the University of
+.\"	California, Berkeley and its contributors.
+.\" 4. Neither the name of the University nor the names of its contributors
+.\"    may be used to endorse or promote products derived from this software
+.\"    without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\"	@(#)logger.1	8.1 (Berkeley) 6/6/93
+.\"
+.TH LOGGER "1" "November 2015" "util-linux" "User Commands"
+.SH NAME
+logger \- enter messages into the system log
+.SH SYNOPSIS
+.B logger
+[options]
+.RI [ message ]
+.SH DESCRIPTION
+.B logger
+makes entries in the system log.
+.sp
+When the optional \fImessage\fR argument is present, it is written
+to the log.  If it is not present, and the \fB\-f\fR option is not
+given either, then standard input is logged.
+.SH OPTIONS
+.TP
+.BR \-d , " \-\-udp"
+Use datagrams (UDP) only.  By default the connection is tried to the
+syslog port defined in /etc/services, which is often 514 .
+.sp
+See also \fB\-\-server\fR and \fB\-\-socket\fR to specify where to connect.
+.TP
+.BR \-e , " \-\-skip-empty"
+Ignore empty lines when processing files.  An empty line
+is defined to be a line without any characters.  Thus a line consisting
+only of whitespace is NOT considered empty.
+Note that when the \fB\-\-prio\-prefix\fR option is specified, the priority
+is not part of the line.  Thus an empty line in this mode is a line that does
+not have any characters after the priority prefix (e.g., \fB<13>\fR).
+.TP
+.BR \-f , " \-\-file " \fIfile
+Log the contents of the specified \fIfile\fR.
+This option cannot be combined with a command-line message.
+.TP
+.B \-i
+Log the PID of the logger process with each line.
+.TP
+.BR "\-\-id" [ =\fIid ]
+Log the PID of the logger process with each line.  When the optional
+argument \fIid\fR is specified, then it is used instead of the logger
+command's PID.  The use of \fB\-\-id=$$\fR
+(PPID) is recommended in scripts that send several messages.
+
+Note that the system logging infrastructure (for example \fBsystemd\fR when
+listening on /dev/log) may follow local socket credentials to overwrite the
+PID specified in the message.
+.BR logger (1)
+is able to set those socket credentials to the given \fIid\fR, but only if you
+have root permissions and a process with the specified PID exists, otherwise
+the socket credentials are not modified and the problem is silently ignored.
+.TP
+.BR \-\-journald [ =\fIfile ]
+Write a systemd journal entry.  The entry is read from the given \fIfile\fR,
+when specified, otherwise from standard input.
+Each line must begin with a field that is accepted by journald; see
+.BR systemd.journal-fields (7)
+for details.  The use of a MESSAGE_ID field is generally a good idea, as it
+makes finding entries easy.  Examples:
+.IP
+.nf
+\fB    logger \-\-journald <<end
+\fB    MESSAGE_ID=67feb6ffbaf24c5cbec13c008dd72309
+\fB    MESSAGE=The dogs bark, but the caravan goes on.
+\fB    DOGS=bark
+\fB    CARAVAN=goes on
+\fB    end
+.IP
+\fB    logger \-\-journald=entry.txt
+.fi
+.IP
+Notice that
+.B \-\-journald
+will ignore values of other options, such as priority.  If priority is
+needed it must be within input, and use PRIORITY field.  The simple
+execution of
+.B journalctl
+will display MESSAGE field.  Use
+.B journalctl \-\-output json-pretty
+to see rest of the fields.
+.sp
+To include newlines in MESSAGE, specify MESSAGE several times.  This is
+handled as a special case, other fields will be stored as an array in
+the journal if they appear multiple times.
+.TP
+.BI \-\-msgid " msgid"
+Sets the RFC5424 MSGID field.  Note that the space character is not permitted
+inside of \fImsgid\fR.  This option is only used if \fB\-\-rfc5424\fR is
+specified as well; otherwise, it is silently ignored.
+.TP
+.BR \-n , " \-\-server " \fIserver
+Write to the specified remote syslog \fIserver\fR
+instead of to the system log socket.  Unless
+\fB\-\-udp\fR or \fB\-\-tcp\fR
+is specified, \fBlogger\fR will first try to use UDP,
+but if this fails a TCP connection is attempted.
+.TP
+.B \-\-no\-act
+Causes everything to be done except for writing the log message to the system
+log, and removing the connection or the journal.  This option can be used
+together with \fB\-\-stderr\fR for testing purposes.
+.TP
+.B \-\-octet\-count
+Use the RFC 6587 octet counting framing method for sending messages.
+When this option is not used, the default is no framing on UDP, and
+RFC6587 non-transparent framing (also known as octet stuffing) on TCP.
+.TP
+.BR \-P , " \-\-port " \fIport
+Use the specified \fIport\fR.  When this option is not specified, the
+port defaults to syslog for udp and to syslog-conn for tcp connections.
+.TP
+.BR \-p , " \-\-priority " \fIpriority
+Enter the message into the log with the specified \fIpriority\fR.
+The priority may be specified numerically or as a
+.IR facility . level
+pair.
+For example, \fB\-p local3.info\fR
+logs the message as informational in the local3 facility.
+The default is \fBuser.notice\fR.
+.TP
+.B \-\-prio\-prefix
+Look for a syslog prefix on every line read from standard input.
+This prefix is a decimal number within angle brackets that encodes both
+the facility and the level.  The number is constructed by multiplying the
+facility by 8 and then adding the level.  For example, \fBlocal0.info\fR,
+meaning facility=16 and level=6, becomes \fB<134>\fR.
+.sp
+If the prefix contains no facility, the facility defaults to what is
+specified by the \fB\-p\fR option.  Similarly, if no prefix is provided,
+the line is logged using the \fIpriority\fR given with \fB\-p\fR.
+.sp
+This option doesn't affect a command-line message.
+.TP
+.B \-\-rfc3164
+Use the RFC 3164 BSD syslog protocol to submit messages to a remote server.
+.TP
+.BR \-\-rfc5424 [ =\fIwithout ]
+Use the RFC 5424 syslog protocol to submit messages to a remote server.
+The optional \fIwithout\fR argument can be a comma-separated list of
+the following values: \fBnotq\fR, \fBnotime\fR, \fBnohost\fR.
+
+The \fBnotq\fR value suppresses the time-quality structured data
+from the submitted message.  The time-quality information shows whether
+the local clock was synchronized plus the maximum number of microseconds
+the timestamp might be off.  The time quality is also automatically
+suppressed when \fB\-\-sd\-id timeQuality\fR is specified.
+
+The \fBnotime\fR value (which implies \fBnotq\fR)
+suppresses the complete sender timestamp that is in
+ISO-8601 format, including microseconds and timezone.
+
+The \fBnohost\fR value suppresses
+.BR gethostname (2)
+information from the message header.
+.IP
+The RFC 5424 protocol has been the default for
+.B logger
+since version 2.26.
+.TP
+.BR \-s , " \-\-stderr"
+Output the message to standard error as well as to the system log.
+.TP
+.BR "\-\-sd\-id \fIname" [ @\fIdigits ]
+Specifies a structured data element ID for an RFC 5424 message header.  The
+option has to be used before \fB\-\-sd\-param\fR to introduce a new element.
+The number of structured data elements is unlimited.  The ID (\fIname\fR plus
+possibly \fB@\fIdigits\fR) is case-sensitive and uniquely identifies the type
+and purpose of the element.  The same ID must not exist more than once in
+a message.  The \fB@\fIdigits\fR part is required for user-defined
+non-standardized IDs.
+
+\fBlogger\fR currently generates the \fBtimeQuality\fR standardized element
+only.  RFC 5424 also describes the elements \fBorigin\fR (with parameters
+ip, enterpriseId, software and swVersion) and \fBmeta\fR (with parameters
+sequenceId, sysUpTime and language).
+These element IDs may be specified without the \fB@\fIdigits\fR suffix.
+
+.TP
+.BR "\-\-sd\-param " \fIname ="\fIvalue\fB"
+Specifies a structured data element parameter, a name and value pair.
+The option has to be used after \fB\-\-sd\-id\fR and may be specified more
+than once for the same element.  Note that the quotation marks around
+\fIvalue\fR are required and must be escaped on the command line.
+.IP
+.nf
+\fB    logger \-\-rfc5424 \-\-sd-id zoo@123               \\
+\fB                     \-\-sd-param tiger=\\"hungry\\"   \\
+\fB                     \-\-sd-param zebra=\\"running\\"  \\
+\fB                     \-\-sd-id manager@123           \\
+\fB                     \-\-sd-param onMeeting=\\"yes\\"  \\
+\fB                     "this is message"
+.fi
+.IP
+produces:
+.IP
+.\".nf
+.\" this long line gets cut of in the output of "troff", and wraps
+.\" in "nroff"
+\fB  <13>1 2015-10-01T14:07:59.168662+02:00 ws kzak - - [timeQuality tzKnown="1" isSynced="1" syncAccuracy="218616"][zoo@123 tiger="hungry" zebra="running"][manager@123 onMeeting="yes"] this is message
+.\".fi
+.TP
+.BR \-S , " \-\-size " \fIsize
+Sets the maximum permitted message size to \fIsize\fR.  The default
+is 1KiB characters, which is the limit traditionally used and specified
+in RFC 3164.  With RFC 5424, this limit has become flexible.  A good assumption
+is that RFC 5424 receivers can at least process 4KiB messages.
+
+Most receivers accept messages larger than 1KiB over any type of syslog
+protocol.  As such, the \fB\-\-size\fR option affects logger in
+all cases (not only when \fB\-\-rfc5424\fR was used).
+
+Note: the message-size limit limits the overall message size, including
+the syslog header.  Header sizes vary depending on the selected options and
+the hostname length.  As a rule of thumb, headers are usually not longer than
+50 to 80 characters.  When selecting a maximum message size, it is important
+to ensure that the receiver supports the max size as well, otherwise messages
+may become truncated.  Again, as a rule of thumb two to four KiB message size
+should generally be OK, whereas anything larger should be verified to work.
+
+.TP
+.BR \-\-socket\-errors [ =\fImode ]
+Print errors about Unix socket connections.  The \fImode\fR can be a value of
+\fBoff\fR, \fBon\fR, or \fBauto\fR.  When the mode is auto logger will detect
+if the init process is systemd, and if so assumption is made /dev/log can be
+used early at boot.  Other init systems lack of /dev/log will not cause errors
+that is identical with messaging using
+.BR openlog (3)
+system call.  The
+.BR logger (1)
+before version 2.26 used openlog, and hence was unable to detected loss of
+messages sent to Unix sockets.
+.IP
+The default mode is \fBauto\fR.  When errors are not enabled lost messages are
+not communicated and will result to successful exit status of
+.BR logger (1)
+invocation.
+.TP
+.BR \-T , " \-\-tcp"
+Use stream (TCP) only.  By default the connection is tried to the
+.I syslog-conn
+port defined in /etc/services, which is often
+.IR 601 .
+.sp
+See also \fB\-\-server\fR and \fB\-\-socket\fR to specify where to connect.
+.TP
+.BR \-t , " \-\-tag " \fItag
+Mark every line to be logged with the specified
+.IR tag .
+The default tag is the name of the user logged in on the terminal (or a user
+name based on effective user ID).
+.TP
+.BR \-u , " \-\-socket " \fIsocket
+Write to the specified
+.I socket
+instead of to the system log socket.
+.TP
+.B \-\-
+End the argument list.  This allows the \fImessage\fR
+to start with a hyphen (\-).
+.TP
+.BR \-V , " \-\-version"
+Display version information and exit.
+.TP
+.BR \-h , " \-\-help"
+Display help text and exit.
+.SH EXIT STATUS
+The
+.B logger
+utility exits 0 on success, and >0 if an error occurs.
+.SH FACILITIES AND LEVELS
+Valid facility names are:
+.IP
+.nr WI \n(.lu-\n(.iu-\w'\fBauthpriv\fR'u-3n
+.TS
+tab(:);
+l lw(\n(WIu).
+\fBauth
+\fBauthpriv\fR:for security information of a sensitive nature
+\fBcron
+\fBdaemon
+\fBftp
+\fBkern\fR:T{
+cannot be generated from userspace process, automatically converted to \fBuser
+T}
+\fBlpr
+\fBmail
+\fBnews
+\fBsyslog
+\fBuser
+\fBuucp
+\fBlocal0
+  to:
+\fBlocal7
+\fBsecurity\fR:deprecated synonym for \fBauth
+.TE
+.PP
+Valid level names are:
+.IP
+.TS
+tab(:);
+l l.
+\fBemerg
+\fBalert
+\fBcrit
+\fBerr
+\fBwarning
+\fBnotice
+\fBinfo
+\fBdebug
+\fBpanic\fR:deprecated synonym for \fBemerg
+\fBerror\fR:deprecated synonym for \fBerr
+\fBwarn\fR:deprecated synonym for \fBwarning
+.TE
+.PP
+For the priority order and intended purposes of these facilities and levels, see
+.BR syslog (3).
+.SH CONFORMING TO
+The
+.B logger
+command is expected to be IEEE Std 1003.2 ("POSIX.2") compatible.
+.SH EXAMPLES
+.B logger System rebooted
+.br
+.B logger \-p local0.notice \-t HOSTIDM \-f /dev/idmc
+.br
+.B logger \-n loghost.example.com System rebooted
+.SH AUTHORS
+The
+.B logger
+command
+was originally written by University of California in 1983-1993 and later
+rewritten by
+.MT kzak@redhat.com
+Karel Zak
+.ME ,
+.MT rgerhards@adiscon.com
+Rainer Gerhards
+.ME
+and
+.MT kerolasa@iki.fi
+Sami Kerola
+.ME .
+.SH SEE ALSO
+.BR journalctl (1),
+.BR syslog (3),
+.BR systemd.journal-fields (7)
+.SH AVAILABILITY
+The logger command is part of the util-linux package and is available from
+.UR https://\:www.kernel.org\:/pub\:/linux\:/utils\:/util-linux/
+Linux Kernel Archive
+.UE .
diff --git a/misc-utils/logger.c b/misc-utils/logger.c
new file mode 100644
index 0000000..d51cd59
--- /dev/null
+++ b/misc-utils/logger.c
@@ -0,0 +1,1316 @@
+/*
+ * Copyright (c) 1983, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
+ * - added Native Language Support
+ * Sun Mar 21 1999 - Arnaldo Carvalho de Melo <acme@conectiva.com.br>
+ * - fixed strerr(errno) in gettext calls
+ */
+
+#include <errno.h>
+#include <limits.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <getopt.h>
+#include <pwd.h>
+#include <signal.h>
+#include <sys/uio.h>
+
+#include "all-io.h"
+#include "c.h"
+#include "closestream.h"
+#include "nls.h"
+#include "pathnames.h"
+#include "strutils.h"
+#include "xalloc.h"
+#include "strv.h"
+#include "list.h"
+
+#define	SYSLOG_NAMES
+#include <syslog.h>
+
+#ifdef HAVE_LIBSYSTEMD
+# define SD_JOURNAL_SUPPRESS_LOCATION
+# include <systemd/sd-daemon.h>
+# include <systemd/sd-journal.h>
+#endif
+
+#ifdef HAVE_SYS_TIMEX_H
+# include <sys/timex.h>
+#endif
+
+enum {
+	TYPE_UDP = (1 << 1),
+	TYPE_TCP = (1 << 2),
+	ALL_TYPES = TYPE_UDP | TYPE_TCP
+};
+
+enum {
+	AF_UNIX_ERRORS_OFF = 0,
+	AF_UNIX_ERRORS_ON,
+	AF_UNIX_ERRORS_AUTO
+};
+
+enum {
+	OPT_PRIO_PREFIX = CHAR_MAX + 1,
+	OPT_JOURNALD,
+	OPT_RFC3164,
+	OPT_RFC5424,
+	OPT_SOCKET_ERRORS,
+	OPT_MSGID,
+	OPT_NOACT,
+	OPT_ID,
+	OPT_STRUCTURED_DATA_ID,
+	OPT_STRUCTURED_DATA_PARAM,
+	OPT_OCTET_COUNT
+};
+
+/* rfc5424 structured data */
+struct structured_data {
+	char *id;		/* SD-ID */
+	char **params;		/* array with SD-PARAMs */
+
+	struct list_head	sds;
+};
+
+struct logger_ctl {
+	int fd;
+	int pri;
+	pid_t pid;			/* zero when unwanted */
+	char *hdr;			/* the syslog header (based on protocol) */
+	char const *tag;
+	char *msgid;
+	char *unix_socket;		/* -u <path> or default to _PATH_DEVLOG */
+	char *server;
+	char *port;
+	int socket_type;
+	size_t max_message_size;
+	struct list_head user_sds;	/* user defined rfc5424 structured data */
+	struct list_head reserved_sds;	/* standard rfc5424 structured data */
+
+	void (*syslogfp)(struct logger_ctl *ctl);
+
+	unsigned int
+			unix_socket_errors:1,	/* whether to report or not errors */
+			noact:1,		/* do not write to sockets */
+			prio_prefix:1,		/* read priority from input */
+			stderr_printout:1,	/* output message to stderr */
+			rfc5424_time:1,		/* include time stamp */
+			rfc5424_tq:1,		/* include time quality markup */
+			rfc5424_host:1,		/* include hostname */
+			skip_empty_lines:1,	/* do not send empty lines when processing files */
+			octet_count:1;		/* use RFC6587 octet counting */
+};
+
+#define is_connected(_ctl)	((_ctl)->fd >= 0)
+static void logger_reopen(struct logger_ctl *ctl);
+
+/*
+ * For tests we want to be able to control datetime outputs
+ */
+#ifdef TEST_LOGGER
+static inline int logger_gettimeofday(struct timeval *tv, struct timezone *tz)
+{
+	char *str = getenv("LOGGER_TEST_TIMEOFDAY");
+	uintmax_t sec, usec;
+
+	if (str && sscanf(str, "%ju.%ju", &sec, &usec) == 2) {
+		tv->tv_sec = sec;
+		tv->tv_usec = usec;
+		return tv->tv_sec >= 0 && tv->tv_usec >= 0 ? 0 : -EINVAL;
+	}
+
+	return gettimeofday(tv, tz);
+}
+
+static inline char *logger_xgethostname(void)
+{
+	char *str = getenv("LOGGER_TEST_HOSTNAME");
+	return str ? xstrdup(str) : xgethostname();
+}
+
+static inline pid_t logger_getpid(void)
+{
+	char *str = getenv("LOGGER_TEST_GETPID");
+	unsigned int pid;
+
+	if (str && sscanf(str, "%u", &pid) == 1)
+		return pid;
+	return getpid();
+}
+
+
+#undef HAVE_NTP_GETTIME		/* force to default non-NTP */
+
+#else /* !TEST_LOGGER */
+# define logger_gettimeofday(x, y)	gettimeofday(x, y)
+# define logger_xgethostname		xgethostname
+# define logger_getpid			getpid
+#endif
+
+
+static int decode(const char *name, const CODE *codetab)
+{
+	register const CODE *c;
+
+	if (name == NULL || *name == '\0')
+		return -1;
+	if (isdigit(*name)) {
+		int num;
+		char *end = NULL;
+
+		errno = 0;
+		num = strtol(name, &end, 10);
+		if (errno || name == end || (end && *end))
+			return -1;
+		for (c = codetab; c->c_name; c++)
+			if (num == c->c_val)
+				return num;
+		return -1;
+	}
+	for (c = codetab; c->c_name; c++)
+		if (!strcasecmp(name, c->c_name))
+			return (c->c_val);
+
+	return -1;
+}
+
+static int pencode(char *s)
+{
+	int facility, level;
+	char *separator;
+
+	assert(s);
+
+	separator = strchr(s, '.');
+	if (separator) {
+		*separator = '\0';
+		facility = decode(s, facilitynames);
+		if (facility < 0)
+			errx(EXIT_FAILURE, _("unknown facility name: %s"), s);
+		s = ++separator;
+	} else
+		facility = LOG_USER;
+	level = decode(s, prioritynames);
+	if (level < 0)
+		errx(EXIT_FAILURE, _("unknown priority name: %s"), s);
+	if (facility == LOG_KERN)
+		facility = LOG_USER;	/* kern is forbidden */
+	return ((level & LOG_PRIMASK) | (facility & LOG_FACMASK));
+}
+
+static int unix_socket(struct logger_ctl *ctl, const char *path, int *socket_type)
+{
+	int fd = -1, i, type = -1;
+	static struct sockaddr_un s_addr;	/* AF_UNIX address of local logger */
+
+	if (strlen(path) >= sizeof(s_addr.sun_path))
+		errx(EXIT_FAILURE, _("openlog %s: pathname too long"), path);
+
+	s_addr.sun_family = AF_UNIX;
+	strcpy(s_addr.sun_path, path);
+
+	for (i = 2; i; i--) {
+		int st = -1;
+
+		if (i == 2 && *socket_type & TYPE_UDP) {
+			st = SOCK_DGRAM;
+			type = TYPE_UDP;
+		}
+		if (i == 1 && *socket_type & TYPE_TCP) {
+			st = SOCK_STREAM;
+			type = TYPE_TCP;
+		}
+		if (st == -1 || (fd = socket(AF_UNIX, st, 0)) == -1)
+			continue;
+		if (connect(fd, (struct sockaddr *)&s_addr, sizeof(s_addr)) == -1) {
+			close(fd);
+			continue;
+		}
+		break;
+	}
+
+	if (i == 0) {
+		if (ctl->unix_socket_errors)
+			err(EXIT_FAILURE, _("socket %s"), path);
+
+		/* write_output() will try to reconnect */
+		return -1;
+	}
+
+	/* replace ALL_TYPES with the real TYPE_* */
+	if (type > 0 && type != *socket_type)
+		*socket_type = type;
+	return fd;
+}
+
+static int inet_socket(const char *servername, const char *port, int *socket_type)
+{
+	int fd, errcode, i, type = -1;
+	struct addrinfo hints, *res;
+	const char *p = port;
+
+	for (i = 2; i; i--) {
+		memset(&hints, 0, sizeof(hints));
+		if (i == 2 && *socket_type & TYPE_UDP) {
+			hints.ai_socktype = SOCK_DGRAM;
+			type = TYPE_UDP;
+			if (port == NULL)
+				p = "syslog";
+		}
+		if (i == 1 && *socket_type & TYPE_TCP) {
+			hints.ai_socktype = SOCK_STREAM;
+			type = TYPE_TCP;
+			if (port == NULL)
+				p = "syslog-conn";
+		}
+		if (hints.ai_socktype == 0)
+			continue;
+		hints.ai_family = AF_UNSPEC;
+		errcode = getaddrinfo(servername, p, &hints, &res);
+		if (errcode != 0)
+			errx(EXIT_FAILURE, _("failed to resolve name %s port %s: %s"),
+			     servername, p, gai_strerror(errcode));
+		if ((fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol)) == -1) {
+			freeaddrinfo(res);
+			continue;
+		}
+		if (connect(fd, res->ai_addr, res->ai_addrlen) == -1) {
+			freeaddrinfo(res);
+			close(fd);
+			continue;
+		}
+
+		freeaddrinfo(res);
+		break;
+	}
+
+	if (i == 0)
+		errx(EXIT_FAILURE, _("failed to connect to %s port %s"), servername, p);
+
+	/* replace ALL_TYPES with the real TYPE_* */
+	if (type > 0 && type != *socket_type)
+		*socket_type = type;
+	return fd;
+}
+
+#ifdef HAVE_LIBSYSTEMD
+static int journald_entry(struct logger_ctl *ctl, FILE *fp)
+{
+	struct iovec *iovec;
+	char *buf = NULL;
+	ssize_t sz;
+	int n, lines = 0, vectors = 8, ret = 0, msgline = -1;
+	size_t dummy = 0;
+
+	iovec = xmalloc(vectors * sizeof(struct iovec));
+	while (1) {
+		buf = NULL;
+		sz = getline(&buf, &dummy, fp);
+		if (sz == -1 ||
+		   (sz = rtrim_whitespace((unsigned char *) buf)) == 0) {
+			free(buf);
+			break;
+		}
+
+		if (strncmp(buf, "MESSAGE=", 8) == 0) {
+			if (msgline == -1)
+				msgline = lines;	/* remember the first message */
+			else {
+				char *p = xrealloc(iovec[msgline].iov_base,
+						   iovec[msgline].iov_len + sz - 8 + 2);
+
+				iovec[msgline].iov_base = p;
+				p += iovec[msgline].iov_len;
+				*p++ = '\n';
+				memcpy(p, buf + 8, sz - 8);
+				free(buf);
+
+				iovec[msgline].iov_len += sz - 8 + 1;
+				continue;
+			}
+		}
+
+		if (lines == vectors) {
+			vectors *= 2;
+			if (IOV_MAX < vectors)
+				errx(EXIT_FAILURE, _("maximum input lines (%d) exceeded"), IOV_MAX);
+			iovec = xrealloc(iovec, vectors * sizeof(struct iovec));
+		}
+		iovec[lines].iov_base = buf;
+		iovec[lines].iov_len = sz;
+		++lines;
+	}
+
+	if (!ctl->noact)
+		ret = sd_journal_sendv(iovec, lines);
+	if (ctl->stderr_printout) {
+		for (n = 0; n < lines; n++)
+			fprintf(stderr, "%s\n", (char *) iovec[n].iov_base);
+	}
+	for (n = 0; n < lines; n++)
+		free(iovec[n].iov_base);
+	free(iovec);
+	return ret;
+}
+#endif
+
+static char const *xgetlogin(void)
+{
+	char const *cp;
+	struct passwd *pw;
+
+	if (!(cp = getlogin()) || !*cp)
+		cp = (pw = getpwuid(geteuid()))? pw->pw_name : "<someone>";
+	return cp;
+}
+
+/* this creates a timestamp based on current time according to the
+ * fine rules of RFC3164, most importantly it ensures in a portable
+ * way that the month day is correctly written (with a SP instead
+ * of a leading 0). The function uses a static buffer which is
+ * overwritten on the next call (just like ctime() does).
+ */
+static char const *rfc3164_current_time(void)
+{
+	static char time[32];
+	struct timeval tv;
+	struct tm tm;
+	static char const * const monthnames[] = {
+		"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",
+		"Sep", "Oct", "Nov", "Dec"
+	};
+
+	logger_gettimeofday(&tv, NULL);
+	localtime_r(&tv.tv_sec, &tm);
+	snprintf(time, sizeof(time),"%s %2d %2.2d:%2.2d:%2.2d",
+		monthnames[tm.tm_mon], tm.tm_mday,
+		tm.tm_hour, tm.tm_min, tm.tm_sec);
+	return time;
+}
+
+#define next_iovec(ary, idx) __extension__ ({		\
+		assert(ARRAY_SIZE(ary) > (size_t)idx);	\
+		assert(idx >= 0);			\
+		&ary[idx++];				\
+})
+
+#define iovec_add_string(ary, idx, str, len)		\
+	do {						\
+		struct iovec *v = next_iovec(ary, idx);	\
+		v->iov_base = (void *) str;		\
+		v->iov_len = len ? len : strlen(str);	\
+	} while (0)
+
+#define iovec_memcmp(ary, idx, str, len)		\
+		memcmp((ary)[(idx) - 1].iov_base, str, len)
+
+/* writes generated buffer to desired destination. For TCP syslog,
+ * we use RFC6587 octet-stuffing (unless octet-counting is selected).
+ * This is not great, but doing full blown RFC5425 (TLS) looks like
+ * it is too much for the logger utility. If octet-counting is
+ * selected, we use that.
+ */
+static void write_output(struct logger_ctl *ctl, const char *const msg)
+{
+	struct iovec iov[4];
+	int iovlen = 0;
+	char *octet = NULL;
+
+	/* initial connect failed? */
+	if (!ctl->noact && !is_connected(ctl))
+		logger_reopen(ctl);
+
+	/* 1) octen count */
+	if (ctl->octet_count) {
+		size_t len = xasprintf(&octet, "%zu ", strlen(ctl->hdr) + strlen(msg));
+		iovec_add_string(iov, iovlen, octet, len);
+	}
+
+	/* 2) header */
+	iovec_add_string(iov, iovlen, ctl->hdr, 0);
+
+	/* 3) message */
+	iovec_add_string(iov, iovlen, msg, 0);
+
+	if (!ctl->noact && is_connected(ctl)) {
+		struct msghdr message = { 0 };
+#ifdef SCM_CREDENTIALS
+		struct cmsghdr *cmhp;
+		struct ucred *cred;
+		union {
+			struct cmsghdr cmh;
+			char   control[CMSG_SPACE(sizeof(struct ucred))];
+		} cbuf;
+#endif
+
+		/* 4) add extra \n to make sure message is terminated */
+		if ((ctl->socket_type == TYPE_TCP) && !ctl->octet_count)
+			iovec_add_string(iov, iovlen, "\n", 1);
+
+		message.msg_iov = iov;
+		message.msg_iovlen = iovlen;
+
+#ifdef SCM_CREDENTIALS
+		/* syslog/journald may follow local socket credentials rather
+		 * than in the message PID. If we use --id as root than we can
+		 * force kernel to accept another valid PID than the real logger(1)
+		 * PID.
+		 */
+		if (ctl->pid && !ctl->server && ctl->pid != getpid()
+		    && geteuid() == 0 && kill(ctl->pid, 0) == 0) {
+
+			message.msg_control = cbuf.control;
+			message.msg_controllen = CMSG_SPACE(sizeof(struct ucred));
+
+			cmhp = CMSG_FIRSTHDR(&message);
+			cmhp->cmsg_len = CMSG_LEN(sizeof(struct ucred));
+			cmhp->cmsg_level = SOL_SOCKET;
+			cmhp->cmsg_type = SCM_CREDENTIALS;
+			cred = (struct ucred *) CMSG_DATA(cmhp);
+
+			cred->pid = ctl->pid;
+		}
+#endif
+		/* Note that logger(1) maybe executed for long time (as pipe
+		 * reader) and connection endpoint (syslogd) may be restarted.
+		 *
+		 * The libc syslog() function reconnects on failed send().
+		 * Let's do the same to be robust.    [kzak -- Oct 2017]
+		 *
+		 * MSG_NOSIGNAL is POSIX.1-2008 compatible, but it for example
+		 * not supported by apple-darwin15.6.0.
+		 */
+#ifndef MSG_NOSIGNAL
+# define MSG_NOSIGNAL 0
+#endif
+		if (sendmsg(ctl->fd, &message, MSG_NOSIGNAL) < 0) {
+			logger_reopen(ctl);
+			if (sendmsg(ctl->fd, &message, MSG_NOSIGNAL) < 0)
+				warn(_("send message failed"));
+		}
+	}
+
+	if (ctl->stderr_printout) {
+		/* make sure it's terminated for stderr */
+		if (iovec_memcmp(iov, iovlen, "\n", 1) != 0)
+			iovec_add_string(iov, iovlen, "\n", 1);
+
+		ignore_result( writev(STDERR_FILENO, iov, iovlen) );
+	}
+
+	free(octet);
+}
+
+#define NILVALUE "-"
+static void syslog_rfc3164_header(struct logger_ctl *const ctl)
+{
+	char pid[30], *hostname;
+
+	*pid = '\0';
+	if (ctl->pid)
+		snprintf(pid, sizeof(pid), "[%d]", ctl->pid);
+
+	if ((hostname = logger_xgethostname())) {
+		char *dot = strchr(hostname, '.');
+		if (dot)
+			*dot = '\0';
+	} else
+		hostname = xstrdup(NILVALUE);
+
+	xasprintf(&ctl->hdr, "<%d>%.15s %s %.200s%s: ",
+		 ctl->pri, rfc3164_current_time(), hostname, ctl->tag, pid);
+
+	free(hostname);
+}
+
+static inline struct list_head *get_user_structured_data(struct logger_ctl *ctl)
+{
+	return &ctl->user_sds;
+}
+
+static inline struct list_head *get_reserved_structured_data(struct logger_ctl *ctl)
+{
+	return &ctl->reserved_sds;
+}
+
+static int has_structured_data_id(struct list_head *ls, const char *id)
+{
+	struct list_head *p;
+
+	if (!ls || list_empty(ls))
+		return 0;
+
+	list_for_each(p, ls) {
+		struct structured_data *sd = list_entry(p, struct structured_data, sds);
+		if (sd->id && strcmp(sd->id, id) == 0)
+			return 1;
+	}
+
+	return 0;
+}
+
+static void add_structured_data_id(struct list_head *ls, const char *id)
+{
+	struct structured_data *sd;
+
+	assert(id);
+
+	if (has_structured_data_id(ls, id))
+		errx(EXIT_FAILURE, _("structured data ID '%s' is not unique"), id);
+
+	sd = xcalloc(1, sizeof(*sd));
+	INIT_LIST_HEAD(&sd->sds);
+	sd->id = xstrdup(id);
+
+	list_add_tail(&sd->sds, ls);
+}
+
+static void add_structured_data_param(struct list_head *ls, const char *param)
+{
+	struct structured_data *sd;
+
+	if (list_empty(ls))
+		errx(EXIT_FAILURE, _("--sd-id was not specified for --sd-param %s"), param);
+
+	assert(param);
+
+	sd = list_last_entry(ls, struct structured_data, sds);
+
+	if (strv_extend(&sd->params,  param))
+		err_oom();
+}
+
+static void add_structured_data_paramf(struct list_head *ls, const char *fmt, ...)
+{
+	struct structured_data *sd;
+	va_list ap;
+	int x;
+
+	assert(!list_empty(ls));
+	assert(fmt);
+
+	sd = list_last_entry(ls, struct structured_data, sds);
+	va_start(ap, fmt);
+	x = strv_extendv(&sd->params, fmt, ap);
+	va_end(ap);
+
+	if (x)
+		err_oom();
+}
+
+static char *strdup_structured_data(struct structured_data *sd)
+{
+	char *res, *tmp;
+
+	if (strv_isempty(sd->params))
+		return NULL;
+
+	xasprintf(&res, "[%s %s]", sd->id,
+			(tmp = strv_join(sd->params, " ")));
+	free(tmp);
+	return res;
+}
+
+static char *strdup_structured_data_list(struct list_head *ls)
+{
+	struct list_head *p;
+	char *res = NULL;
+
+	list_for_each(p, ls) {
+		struct structured_data *sd = list_entry(p, struct structured_data, sds);
+		char *one = strdup_structured_data(sd);
+		char *tmp = res;
+
+		if (!one)
+			continue;
+		res = strappend(tmp, one);
+		free(tmp);
+		free(one);
+	}
+
+	return res;
+}
+
+static char *get_structured_data_string(struct logger_ctl *ctl)
+{
+	char *sys = NULL, *usr = NULL, *res;
+
+	if (!list_empty(&ctl->reserved_sds))
+		sys = strdup_structured_data_list(&ctl->reserved_sds);
+	if (!list_empty(&ctl->user_sds))
+		usr = strdup_structured_data_list(&ctl->user_sds);
+
+	if (sys && usr) {
+		res = strappend(sys, usr);
+		free(sys);
+		free(usr);
+	} else
+		res = sys ? sys : usr;
+
+	return res;
+}
+
+static int valid_structured_data_param(const char *str)
+{
+	char *eq  = strchr(str, '='),
+	     *qm1 = strchr(str, '"'),
+	     *qm2 = qm1 ? strchr(qm1 + 1, '"') : NULL;
+
+	if (!eq || !qm1 || !qm2)		/* something is missing */
+		return 0;
+
+	/* foo="bar" */
+	return eq > str && eq < qm1 && eq + 1 == qm1 && qm1 < qm2 && *(qm2 + 1) == '\0';
+}
+
+/* SD-ID format:
+ *	name@<private enterprise number>, e.g., "ourSDID@32473"
+ */
+static int valid_structured_data_id(const char *str)
+{
+	char *at = strchr(str, '@');
+	const char *p;
+
+	/* standardized IDs without @<digits> */
+	if (!at && (strcmp(str, "timeQuality") == 0 ||
+		    strcmp(str, "origin") == 0 ||
+		    strcmp(str, "meta") == 0))
+		return 1;
+
+	if (!at || at == str || !*(at + 1))
+		return 0;
+
+	/* <digits> or <digits>.<digits>[...] */
+	for (p = at + 1; p && *p; p++) {
+		const char *end;
+
+		if (isdigit_strend(p, &end))
+			break;	/* only digits in the string */
+
+		if (end == NULL || end == p ||
+		    *end != '.' || *(end + 1) == '\0')
+			return 0;
+		p = end;
+	}
+
+	/* check for forbidden chars in the <name> */
+	for (p = str; p < at; p++) {
+		if (*p == '[' || *p == '=' || *p == '"' || *p == '@')
+			return 0;
+		if (isblank((unsigned char) *p) || iscntrl((unsigned char) *p))
+			return 0;
+	}
+	return 1;
+}
+
+
+/* Some field mappings may be controversial, thus I give the reason
+ * why this specific mapping was used:
+ * APP-NAME <-- tag
+ *    Some may argue that "logger" is a better fit, but we think
+ *    this is better inline of what other implementations do. In
+ *    rsyslog, for example, the TAG value is populated from APP-NAME.
+ * PROCID <-- pid
+ *    This is a relatively straightforward interpretation from
+ *    RFC5424, sect. 6.2.6.
+ * MSGID <-- msgid (from --msgid)
+ *    One may argue that the string "logger" would be better suited
+ *    here so that a receiver can identify the sender process.
+ *    However, this does not sound like a good match to RFC5424,
+ *    sect. 6.2.7.
+ * Note that appendix A.1 of RFC5424 does not provide clear guidance
+ * of how these fields should be used. This is the case because the
+ * IETF working group couldn't arrive at a clear agreement when we
+ * specified RFC5424. The rest of the field mappings should be
+ * pretty clear from RFC5424. -- Rainer Gerhards, 2015-03-10
+ */
+static void syslog_rfc5424_header(struct logger_ctl *const ctl)
+{
+	char *time;
+	char *hostname;
+	char const *app_name = ctl->tag;
+	char *procid;
+	char *const msgid = xstrdup(ctl->msgid ? ctl->msgid : NILVALUE);
+	char *structured = NULL;
+	struct list_head *sd;
+
+	if (ctl->rfc5424_time) {
+		struct timeval tv;
+		struct tm tm;
+
+		logger_gettimeofday(&tv, NULL);
+		if (localtime_r(&tv.tv_sec, &tm) != NULL) {
+			char fmt[64];
+			const size_t i = strftime(fmt, sizeof(fmt),
+						  "%Y-%m-%dT%H:%M:%S.%%06u%z ", &tm);
+			/* patch TZ info to comply with RFC3339 (we left SP at end) */
+			fmt[i - 1] = fmt[i - 2];
+			fmt[i - 2] = fmt[i - 3];
+			fmt[i - 3] = ':';
+			xasprintf(&time, fmt, tv.tv_usec);
+		} else
+			err(EXIT_FAILURE, _("localtime() failed"));
+	} else
+		time = xstrdup(NILVALUE);
+
+	if (ctl->rfc5424_host) {
+		if (!(hostname = logger_xgethostname()))
+			hostname = xstrdup(NILVALUE);
+		/* Arbitrary looking 'if (var < strlen()) checks originate from
+		 * RFC 5424 - 6 Syslog Message Format definition.  */
+		if (255 < strlen(hostname))
+			errx(EXIT_FAILURE, _("hostname '%s' is too long"),
+			     hostname);
+	} else
+		hostname = xstrdup(NILVALUE);
+
+	if (48 < strlen(ctl->tag))
+		errx(EXIT_FAILURE, _("tag '%s' is too long"), ctl->tag);
+
+	if (ctl->pid)
+		xasprintf(&procid, "%d", ctl->pid);
+	else
+		procid = xstrdup(NILVALUE);
+
+	sd = get_reserved_structured_data(ctl);
+
+	/* time quality structured data (maybe overwritten by --sd-id timeQuality) */
+	if (ctl->rfc5424_tq && !has_structured_data_id(sd, "timeQuality")) {
+
+		add_structured_data_id(sd, "timeQuality");
+		add_structured_data_param(sd, "tzKnown=\"1\"");
+
+#ifdef HAVE_NTP_GETTIME
+		struct ntptimeval ntptv;
+
+		if (ntp_gettime(&ntptv) == TIME_OK) {
+			add_structured_data_param(sd, "isSynced=\"1\"");
+			add_structured_data_paramf(sd, "syncAccuracy=\"%ld\"", ntptv.maxerror);
+		} else
+#endif
+			add_structured_data_paramf(sd, "isSynced=\"0\"");
+	}
+
+	/* convert all structured data to string */
+	structured = get_structured_data_string(ctl);
+	if (!structured)
+		structured = xstrdup(NILVALUE);
+
+	xasprintf(&ctl->hdr, "<%d>1 %s %s %s %s %s %s ",
+		ctl->pri,
+		time,
+		hostname,
+		app_name,
+		procid,
+		msgid,
+		structured);
+
+	free(time);
+	free(hostname);
+	/* app_name points to ctl->tag, do NOT free! */
+	free(procid);
+	free(msgid);
+	free(structured);
+}
+
+static void parse_rfc5424_flags(struct logger_ctl *ctl, char *s)
+{
+	char *in, *tok;
+
+	in = s;
+	while ((tok = strtok(in, ","))) {
+		in = NULL;
+		if (!strcmp(tok, "notime")) {
+			ctl->rfc5424_time = 0;
+			ctl->rfc5424_tq = 0;
+		} else if (!strcmp(tok, "notq"))
+			ctl->rfc5424_tq = 0;
+		else if (!strcmp(tok, "nohost"))
+			ctl->rfc5424_host = 0;
+		else
+			warnx(_("ignoring unknown option argument: %s"), tok);
+	}
+}
+
+static int parse_unix_socket_errors_flags(char *s)
+{
+	if (!strcmp(s, "off"))
+		return AF_UNIX_ERRORS_OFF;
+	if (!strcmp(s, "on"))
+		return AF_UNIX_ERRORS_ON;
+	if (!strcmp(s, "auto"))
+		return AF_UNIX_ERRORS_AUTO;
+	warnx(_("invalid argument: %s: using automatic errors"), s);
+	return AF_UNIX_ERRORS_AUTO;
+}
+
+static void syslog_local_header(struct logger_ctl *const ctl)
+{
+	char pid[32];
+
+	if (ctl->pid)
+		snprintf(pid, sizeof(pid), "[%d]", ctl->pid);
+	else
+		pid[0] = '\0';
+
+	xasprintf(&ctl->hdr, "<%d>%s %s%s: ", ctl->pri, rfc3164_current_time(),
+		ctl->tag, pid);
+}
+
+static void generate_syslog_header(struct logger_ctl *const ctl)
+{
+	free(ctl->hdr);
+	ctl->hdr = NULL;
+	ctl->syslogfp(ctl);
+}
+
+/* just open, nothing else */
+static void __logger_open(struct logger_ctl *ctl)
+{
+	if (ctl->server) {
+		ctl->fd = inet_socket(ctl->server, ctl->port, &ctl->socket_type);
+	} else {
+		if (!ctl->unix_socket)
+			ctl->unix_socket = _PATH_DEVLOG;
+
+		ctl->fd = unix_socket(ctl, ctl->unix_socket, &ctl->socket_type);
+	}
+}
+
+/* open and initialize relevant @ctl tuff */
+static void logger_open(struct logger_ctl *ctl)
+{
+	__logger_open(ctl);
+
+	if (!ctl->syslogfp)
+		ctl->syslogfp = ctl->server ? syslog_rfc5424_header :
+					      syslog_local_header;
+	if (!ctl->tag)
+		ctl->tag = xgetlogin();
+
+	generate_syslog_header(ctl);
+}
+
+/* re-open; usually after failed connection */
+static void logger_reopen(struct logger_ctl *ctl)
+{
+	if (ctl->fd != -1)
+		close(ctl->fd);
+	ctl->fd = -1;
+
+	__logger_open(ctl);
+}
+
+static void logger_command_line(struct logger_ctl *ctl, char **argv)
+{
+	/* note: we never re-generate the syslog header here, even if we
+	 * generate multiple messages. If so, we think it is the right thing
+	 * to do to report them with the same timestamp, as the user actually
+	 * intended to send a single message.
+	 */
+	char *const buf = xmalloc(ctl->max_message_size + 1);
+	char *p = buf;
+	const char *endp = buf + ctl->max_message_size - 1;
+	size_t len;
+
+	while (*argv) {
+		len = strlen(*argv);
+		if (endp < p + len && p != buf) {
+			write_output(ctl, buf);
+			p = buf;
+		}
+		if (ctl->max_message_size < len) {
+			(*argv)[ctl->max_message_size] = '\0'; /* truncate */
+			write_output(ctl, *argv++);
+			continue;
+		}
+		if (p != buf)
+			*p++ = ' ';
+		memmove(p, *argv++, len);
+		*(p += len) = '\0';
+	}
+	if (p != buf)
+		write_output(ctl, buf);
+	free(buf);
+}
+
+static void logger_stdin(struct logger_ctl *ctl)
+{
+	/* note: we re-generate the syslog header for each log message to
+	 * update header timestamps and to reflect possible priority changes.
+	 * The initial header is generated by logger_open().
+	 */
+	int has_header = 1;
+	int default_priority = ctl->pri;
+	int last_pri = default_priority;
+	size_t max_usrmsg_size = ctl->max_message_size - strlen(ctl->hdr);
+	char *const buf = xmalloc(max_usrmsg_size + 2 + 2);
+	int pri;
+	int c;
+	size_t i;
+
+	c = getchar();
+	while (c != EOF) {
+		i = 0;
+		if (ctl->prio_prefix && c == '<') {
+			pri = 0;
+			buf[i++] = c;
+			while (isdigit(c = getchar()) && pri <= 191) {
+				buf[i++] = c;
+				pri = pri * 10 + c - '0';
+			}
+			if (c != EOF && c != '\n')
+				buf[i++] = c;
+			if (c == '>' && 0 <= pri && pri <= 191) {
+				/* valid RFC PRI values */
+				i = 0;
+				if (pri < 8)	/* kern facility is forbidden */
+					pri |= 8;
+				ctl->pri = pri;
+			} else
+				ctl->pri = default_priority;
+
+			if (ctl->pri != last_pri) {
+				has_header = 0;
+				max_usrmsg_size =
+				    ctl->max_message_size - strlen(ctl->hdr);
+				last_pri = ctl->pri;
+			}
+			if (c != EOF && c != '\n')
+				c = getchar();
+		}
+
+		while (c != EOF && c != '\n' && i < max_usrmsg_size) {
+			buf[i++] = c;
+			c = getchar();
+		}
+		buf[i] = '\0';
+
+		if (i > 0 || !ctl->skip_empty_lines) {
+			if (!has_header)
+				generate_syslog_header(ctl);
+			write_output(ctl, buf);
+			has_header = 0;
+		}
+
+		if (c == '\n')	/* discard line terminator */
+			c = getchar();
+	}
+
+	free(buf);
+}
+
+static void logger_close(const struct logger_ctl *ctl)
+{
+	if (ctl->fd != -1 && close(ctl->fd) != 0)
+		err(EXIT_FAILURE, _("close failed"));
+	free(ctl->hdr);
+}
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+	fputs(USAGE_HEADER, out);
+	fprintf(out, _(" %s [options] [<message>]\n"), program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("Enter messages into the system log.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -i                       log the logger command's PID\n"), out);
+	fputs(_("     --id[=<id>]          log the given <id>, or otherwise the PID\n"), out);
+	fputs(_(" -f, --file <file>        log the contents of this file\n"), out);
+	fputs(_(" -e, --skip-empty         do not log empty lines when processing files\n"), out);
+	fputs(_("     --no-act             do everything except the write the log\n"), out);
+	fputs(_(" -p, --priority <prio>    mark given message with this priority\n"), out);
+	fputs(_("     --octet-count        use rfc6587 octet counting\n"), out);
+	fputs(_("     --prio-prefix        look for a prefix on every line read from stdin\n"), out);
+	fputs(_(" -s, --stderr             output message to standard error as well\n"), out);
+	fputs(_(" -S, --size <size>        maximum size for a single message\n"), out);
+	fputs(_(" -t, --tag <tag>          mark every line with this tag\n"), out);
+	fputs(_(" -n, --server <name>      write to this remote syslog server\n"), out);
+	fputs(_(" -P, --port <port>        use this port for UDP or TCP connection\n"), out);
+	fputs(_(" -T, --tcp                use TCP only\n"), out);
+	fputs(_(" -d, --udp                use UDP only\n"), out);
+	fputs(_("     --rfc3164            use the obsolete BSD syslog protocol\n"), out);
+	fputs(_("     --rfc5424[=<snip>]   use the syslog protocol (the default for remote);\n"
+		"                            <snip> can be notime, or notq, and/or nohost\n"), out);
+	fputs(_("     --sd-id <id>         rfc5424 structured data ID\n"), out);
+	fputs(_("     --sd-param <data>    rfc5424 structured data name=value\n"), out);
+	fputs(_("     --msgid <msgid>      set rfc5424 message id field\n"), out);
+	fputs(_(" -u, --socket <socket>    write to this Unix socket\n"), out);
+	fputs(_("     --socket-errors[=<on|off|auto>]\n"
+		"                          print connection errors when using Unix sockets\n"), out);
+#ifdef HAVE_LIBSYSTEMD
+	fputs(_("     --journald[=<file>]  write journald entry\n"), out);
+#endif
+
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(26));
+	printf(USAGE_MAN_TAIL("logger(1)"));
+
+	exit(EXIT_SUCCESS);
+}
+
+/*
+ * logger -- read and log utility
+ *
+ *	Reads from an input and arranges to write the result on the system
+ *	log.
+ */
+int main(int argc, char **argv)
+{
+	struct logger_ctl ctl = {
+		.fd = -1,
+		.pid = 0,
+		.pri = LOG_USER | LOG_NOTICE,
+		.prio_prefix = 0,
+		.tag = NULL,
+		.unix_socket = NULL,
+		.unix_socket_errors = 0,
+		.server = NULL,
+		.port = NULL,
+		.hdr = NULL,
+		.msgid = NULL,
+		.socket_type = ALL_TYPES,
+		.max_message_size = 1024,
+		.rfc5424_time = 1,
+		.rfc5424_tq = 1,
+		.rfc5424_host = 1,
+		.skip_empty_lines = 0
+	};
+	int ch;
+	int stdout_reopened = 0;
+	int unix_socket_errors_mode = AF_UNIX_ERRORS_AUTO;
+#ifdef HAVE_LIBSYSTEMD
+	FILE *jfd = NULL;
+#endif
+	static const struct option longopts[] = {
+		{ "id",		   optional_argument, 0, OPT_ID		   },
+		{ "stderr",	   no_argument,	      0, 's'		   },
+		{ "file",	   required_argument, 0, 'f'		   },
+		{ "no-act",        no_argument,       0, OPT_NOACT,	   },
+		{ "priority",	   required_argument, 0, 'p'		   },
+		{ "tag",	   required_argument, 0, 't'		   },
+		{ "socket",	   required_argument, 0, 'u'		   },
+		{ "socket-errors", required_argument, 0, OPT_SOCKET_ERRORS },
+		{ "udp",	   no_argument,	      0, 'd'		   },
+		{ "tcp",	   no_argument,	      0, 'T'		   },
+		{ "server",	   required_argument, 0, 'n'		   },
+		{ "port",	   required_argument, 0, 'P'		   },
+		{ "version",	   no_argument,	      0, 'V'		   },
+		{ "help",	   no_argument,	      0, 'h'		   },
+		{ "octet-count",   no_argument,	      0, OPT_OCTET_COUNT   },
+		{ "prio-prefix",   no_argument,	      0, OPT_PRIO_PREFIX   },
+		{ "rfc3164",	   no_argument,	      0, OPT_RFC3164	   },
+		{ "rfc5424",	   optional_argument, 0, OPT_RFC5424	   },
+		{ "size",	   required_argument, 0, 'S'		   },
+		{ "msgid",	   required_argument, 0, OPT_MSGID	   },
+		{ "skip-empty",	   no_argument,	      0, 'e'		   },
+		{ "sd-id",         required_argument, 0, OPT_STRUCTURED_DATA_ID          },
+		{ "sd-param",      required_argument, 0, OPT_STRUCTURED_DATA_PARAM       },
+#ifdef HAVE_LIBSYSTEMD
+		{ "journald",	   optional_argument, 0, OPT_JOURNALD	   },
+#endif
+		{ NULL,		   0,		      0, 0		   }
+	};
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	INIT_LIST_HEAD(&ctl.user_sds);
+	INIT_LIST_HEAD(&ctl.reserved_sds);
+
+	while ((ch = getopt_long(argc, argv, "ef:ip:S:st:u:dTn:P:Vh",
+					    longopts, NULL)) != -1) {
+		switch (ch) {
+		case 'f':		/* file to log */
+			if (freopen(optarg, "r", stdin) == NULL)
+				err(EXIT_FAILURE, _("file %s"), optarg);
+			stdout_reopened = 1;
+			break;
+		case 'e':
+			ctl.skip_empty_lines = 1;
+			break;
+		case 'i':		/* log process id also */
+			ctl.pid = logger_getpid();
+			break;
+		case OPT_ID:
+			if (optarg) {
+				const char *p = optarg;
+
+				if (*p == '=')
+					p++;
+				ctl.pid = strtoul_or_err(optarg, _("failed to parse id"));
+			} else
+				ctl.pid = logger_getpid();
+			break;
+		case 'p':		/* priority */
+			ctl.pri = pencode(optarg);
+			break;
+		case 's':		/* log to standard error */
+			ctl.stderr_printout = 1;
+			break;
+		case 't':		/* tag */
+			ctl.tag = optarg;
+			break;
+		case 'u':		/* unix socket */
+			ctl.unix_socket = optarg;
+			break;
+		case 'S':		/* max message size */
+			ctl.max_message_size = strtosize_or_err(optarg,
+				_("failed to parse message size"));
+			break;
+		case 'd':
+			ctl.socket_type = TYPE_UDP;
+			break;
+		case 'T':
+			ctl.socket_type = TYPE_TCP;
+			break;
+		case 'n':
+			ctl.server = optarg;
+			break;
+		case 'P':
+			ctl.port = optarg;
+			break;
+		case OPT_OCTET_COUNT:
+			ctl.octet_count = 1;
+			break;
+		case OPT_PRIO_PREFIX:
+			ctl.prio_prefix = 1;
+			break;
+		case OPT_RFC3164:
+			ctl.syslogfp = syslog_rfc3164_header;
+			break;
+		case OPT_RFC5424:
+			ctl.syslogfp = syslog_rfc5424_header;
+			if (optarg)
+				parse_rfc5424_flags(&ctl, optarg);
+			break;
+		case OPT_MSGID:
+			if (strchr(optarg, ' '))
+				errx(EXIT_FAILURE, _("--msgid cannot contain space"));
+			ctl.msgid = optarg;
+			break;
+#ifdef HAVE_LIBSYSTEMD
+		case OPT_JOURNALD:
+			if (optarg) {
+				jfd = fopen(optarg, "r");
+				if (!jfd)
+					err(EXIT_FAILURE, _("cannot open %s"),
+					    optarg);
+			} else
+				jfd = stdin;
+			break;
+#endif
+		case OPT_SOCKET_ERRORS:
+			unix_socket_errors_mode = parse_unix_socket_errors_flags(optarg);
+			break;
+		case OPT_NOACT:
+			ctl.noact = 1;
+			break;
+		case OPT_STRUCTURED_DATA_ID:
+			if (!valid_structured_data_id(optarg))
+				errx(EXIT_FAILURE, _("invalid structured data ID: '%s'"), optarg);
+			add_structured_data_id(get_user_structured_data(&ctl), optarg);
+			break;
+		case OPT_STRUCTURED_DATA_PARAM:
+			if (!valid_structured_data_param(optarg))
+				errx(EXIT_FAILURE, _("invalid structured data parameter: '%s'"), optarg);
+			add_structured_data_param(get_user_structured_data(&ctl), optarg);
+			break;
+
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		case 'h':
+			usage();
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+	argc -= optind;
+	argv += optind;
+	if (stdout_reopened && argc)
+		warnx(_("--file <file> and <message> are mutually exclusive, message is ignored"));
+#ifdef HAVE_LIBSYSTEMD
+	if (jfd) {
+		int ret = journald_entry(&ctl, jfd);
+		if (stdin != jfd)
+			fclose(jfd);
+		if (ret)
+			errx(EXIT_FAILURE, _("journald entry could not be written"));
+		return EXIT_SUCCESS;
+	}
+#endif
+
+	/* user overwrites built-in SD-ELEMENT */
+	if (has_structured_data_id(get_user_structured_data(&ctl), "timeQuality"))
+		ctl.rfc5424_tq = 0;
+
+	switch (unix_socket_errors_mode) {
+	case AF_UNIX_ERRORS_OFF:
+		ctl.unix_socket_errors = 0;
+		break;
+	case AF_UNIX_ERRORS_ON:
+		ctl.unix_socket_errors = 1;
+		break;
+	case AF_UNIX_ERRORS_AUTO:
+		ctl.unix_socket_errors = ctl.noact || ctl.stderr_printout;
+#ifdef HAVE_LIBSYSTEMD
+		ctl.unix_socket_errors |= !!sd_booted();
+#endif
+		break;
+	default:
+		abort();
+	}
+	logger_open(&ctl);
+	if (0 < argc)
+		logger_command_line(&ctl, argv);
+	else
+		/* Note. --file <arg> reopens stdin making the below
+		 * function to be used for file inputs. */
+		logger_stdin(&ctl);
+	logger_close(&ctl);
+	return EXIT_SUCCESS;
+}
diff --git a/misc-utils/look.1 b/misc-utils/look.1
new file mode 100644
index 0000000..2de4f8d
--- /dev/null
+++ b/misc-utils/look.1
@@ -0,0 +1,123 @@
+.\" Copyright (c) 1990, 1993
+.\"	The Regents of the University of California.  All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. All advertising materials mentioning features or use of this software
+.\"    must display the following acknowledgement:
+.\"	This product includes software developed by the University of
+.\"	California, Berkeley and its contributors.
+.\" 4. Neither the name of the University nor the names of its contributors
+.\"    may be used to endorse or promote products derived from this software
+.\"    without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\"     @(#)look.1	8.1 (Berkeley) 6/14/93
+.\"
+.TH LOOK 1 "June 2011" "util-linux" "User Commands"
+.SH NAME
+look \- display lines beginning with a given string
+.SH SYNOPSIS
+.B look
+[options]
+.IR "string " [ file ]
+.SH DESCRIPTION
+The
+.B look
+utility displays any lines in
+.I file
+which contain
+.IR string .
+As
+.B look
+performs a binary search, the lines in
+.I file
+must be sorted (where
+.BR sort (1)
+was given the same options
+.BR "\-d " and/or " \-f " that
+.B look
+is invoked with).
+.PP
+If
+.I file
+is not specified, the file
+.I /usr/share/dict/words
+is used, only alphanumeric characters are compared and the case of
+alphabetic characters is ignored.
+.SH OPTIONS
+.TP
+.BR \-a , " \-\-alternative"
+Use the alternative dictionary file.
+.TP
+.BR \-d , " \-\-alphanum"
+Use normal dictionary character set and order, i.e., only blanks and
+alphanumeric characters are compared.  This is on by default if no file is
+specified.
+
+Note that blanks have been added to dictionary character set for
+compatibility with \fBsort \-d\fR command since version 2.28.
+.TP
+.BR \-f , " \-\-ignore\-case"
+Ignore the case of alphabetic characters.  This is on by default if no file is
+specified.
+.TP
+.BR \-t , " \-\-terminate " \fIcharacter\fR
+Specify a string termination character, i.e., only the characters
+in \fIstring\fR up to and including the first occurrence of \fIcharacter\fR
+are compared.
+.TP
+.BR \-V , " \-\-version"
+Display version information and exit.
+.TP
+.BR \-h , " \-\-help"
+Display help text and exit.
+.PP
+The
+.B look
+utility exits 0 if one or more lines were found and displayed, 1 if
+no lines were found, and >1 if an error occurred.
+.SH ENVIRONMENT
+.TP
+.B WORDLIST
+Path to a dictionary file.  The environment variable has greater priority
+than the dictionary path defined in FILES segment.
+.SH FILES
+.IP "\fB/usr/share/dict/words\fR" 4
+the dictionary
+.IP "\fB/usr/share/dict/web2\fR" 4
+the alternative dictionary
+.SH HISTORY
+The
+.B look
+utility appeared in Version 7 AT&T Unix.
+.SH EXAMPLES
+.RS
+.nf
+sort \-d /etc/passwd \-o /tmp/look.dict
+look \-t: root:foobar /tmp/look.dict
+.fi
+.RE
+.SH SEE ALSO
+.BR grep (1),
+.BR sort (1)
+.SH AVAILABILITY
+The look command is part of the util-linux package and is available from
+https://www.kernel.org/pub/linux/utils/util-linux/.
diff --git a/misc-utils/look.c b/misc-utils/look.c
new file mode 100644
index 0000000..d3f0622
--- /dev/null
+++ b/misc-utils/look.c
@@ -0,0 +1,375 @@
+/*-
+ * Copyright (c) 1991, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * David Hitz of Auspex Systems, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+ /* 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
+  * - added Native Language Support
+  */
+
+/*
+ * look -- find lines in a sorted list.
+ *
+ * The man page said that TABs and SPACEs participate in -d comparisons.
+ * In fact, they were ignored.  This implements historic practice, not
+ * the manual page.
+ */
+
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <ctype.h>
+#include <getopt.h>
+
+#include "nls.h"
+#include "xalloc.h"
+#include "pathnames.h"
+#include "closestream.h"
+
+#define	EQUAL		0
+#define	GREATER		1
+#define	LESS		(-1)
+
+static int dflag, fflag;
+/* uglified the source a bit with globals, so that we only need
+   to allocate comparbuf once */
+static int stringlen;
+static char *string;
+static char *comparbuf;
+
+static char *binary_search (char *, char *);
+static int compare (char *, char *);
+static char *linear_search (char *, char *);
+static int look (char *, char *);
+static void print_from (char *, char *);
+static void __attribute__((__noreturn__)) usage(void);
+
+int
+main(int argc, char *argv[])
+{
+	struct stat sb;
+	int ch, fd, termchar;
+	char *back, *file, *front, *p;
+
+	static const struct option longopts[] = {
+		{"alternative", no_argument, NULL, 'a'},
+		{"alphanum", no_argument, NULL, 'd'},
+		{"ignore-case", no_argument, NULL, 'f'},
+		{"terminate", required_argument, NULL, 't'},
+		{"version", no_argument, NULL, 'V'},
+		{"help", no_argument, NULL, 'h'},
+		{NULL, 0, NULL, 0}
+	};
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	setlocale(LC_ALL, "");
+
+	if ((file = getenv("WORDLIST")) && !access(file, R_OK))
+		/* use the WORDLIST */;
+	else
+		file = _PATH_WORDS;
+
+	termchar = '\0';
+	string = NULL;		/* just for gcc */
+
+	while ((ch = getopt_long(argc, argv, "adft:Vh", longopts, NULL)) != -1)
+		switch(ch) {
+		case 'a':
+			file = _PATH_WORDS_ALT;
+			break;
+		case 'd':
+			dflag = 1;
+			break;
+		case 'f':
+			fflag = 1;
+			break;
+		case 't':
+			termchar = *optarg;
+			break;
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		case 'h':
+			usage();
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	argc -= optind;
+	argv += optind;
+
+	switch (argc) {
+	case 2:				/* Don't set -df for user. */
+		string = *argv++;
+		file = *argv;
+		break;
+	case 1:				/* But set -df by default. */
+		dflag = fflag = 1;
+		string = *argv;
+		break;
+	default:
+		warnx(_("bad usage"));
+		errtryhelp(EXIT_FAILURE);
+	}
+
+	if (termchar != '\0' && (p = strchr(string, termchar)) != NULL)
+		*++p = '\0';
+
+	if ((fd = open(file, O_RDONLY, 0)) < 0 || fstat(fd, &sb))
+		err(EXIT_FAILURE, "%s", file);
+	front = mmap(NULL, (size_t) sb.st_size, PROT_READ,
+		     MAP_SHARED, fd, (off_t) 0);
+	if
+#ifdef MAP_FAILED
+		(front == MAP_FAILED)
+#else
+		((void *)(front) <= (void *)0)
+#endif
+			err(EXIT_FAILURE, "%s", file);
+	back = front + sb.st_size;
+	return look(front, back);
+}
+
+static int
+look(char *front, char *back)
+{
+	int ch;
+	char *readp, *writep;
+
+	/* Reformat string to avoid doing it multiple times later. */
+	if (dflag) {
+		for (readp = writep = string; (ch = *readp++) != 0;) {
+			if (isalnum(ch) || isblank(ch))
+				*(writep++) = ch;
+		}
+		*writep = '\0';
+		stringlen = writep - string;
+	} else
+		stringlen = strlen(string);
+
+	comparbuf = xmalloc(stringlen+1);
+
+	front = binary_search(front, back);
+	front = linear_search(front, back);
+
+	if (front)
+		print_from(front, back);
+
+	free(comparbuf);
+
+	return (front ? 0 : 1);
+}
+
+
+/*
+ * Binary search for "string" in memory between "front" and "back".
+ *
+ * This routine is expected to return a pointer to the start of a line at
+ * *or before* the first word matching "string".  Relaxing the constraint
+ * this way simplifies the algorithm.
+ *
+ * Invariants:
+ * 	front points to the beginning of a line at or before the first
+ *	matching string.
+ *
+ * 	back points to the beginning of a line at or after the first
+ *	matching line.
+ *
+ * Advancing the Invariants:
+ *
+ * 	p = first newline after halfway point from front to back.
+ *
+ * 	If the string at "p" is not greater than the string to match,
+ *	p is the new front.  Otherwise it is the new back.
+ *
+ * Termination:
+ *
+ * 	The definition of the routine allows it return at any point,
+ *	since front is always at or before the line to print.
+ *
+ * 	In fact, it returns when the chosen "p" equals "back".  This
+ *	implies that there exists a string is least half as long as
+ *	(back - front), which in turn implies that a linear search will
+ *	be no more expensive than the cost of simply printing a string or two.
+ *
+ * 	Trying to continue with binary search at this point would be
+ *	more trouble than it's worth.
+ */
+#define	SKIP_PAST_NEWLINE(p, back) \
+	while (p < back && *p++ != '\n')
+
+static char *
+binary_search(char *front, char *back)
+{
+	char *p;
+
+	p = front + (back - front) / 2;
+	SKIP_PAST_NEWLINE(p, back);
+
+	/*
+	 * If the file changes underneath us, make sure we don't
+	 * infinitely loop.
+	 */
+	while (p < back && back > front) {
+		if (compare(p, back) == GREATER)
+			front = p;
+		else
+			back = p;
+		p = front + (back - front) / 2;
+		SKIP_PAST_NEWLINE(p, back);
+	}
+	return (front);
+}
+
+/*
+ * Find the first line that starts with string, linearly searching from front
+ * to back.
+ *
+ * Return NULL for no such line.
+ *
+ * This routine assumes:
+ *
+ * 	o front points at the first character in a line.
+ *	o front is before or at the first line to be printed.
+ */
+static char *
+linear_search(char *front, char *back)
+{
+	while (front < back) {
+		switch (compare(front, back)) {
+		case EQUAL:		/* Found it. */
+			return (front);
+		case LESS:		/* No such string. */
+			return (NULL);
+		case GREATER:		/* Keep going. */
+			break;
+		}
+		SKIP_PAST_NEWLINE(front, back);
+	}
+	return (NULL);
+}
+
+/*
+ * Print as many lines as match string, starting at front.
+ */
+static void
+print_from(char *front, char *back)
+{
+	int eol;
+
+	while (front < back && compare(front, back) == EQUAL) {
+		if (compare(front, back) == EQUAL) {
+			eol = 0;
+			while (front < back && !eol) {
+				if (putchar(*front) == EOF)
+					err(EXIT_FAILURE, "stdout");
+				if (*front++ == '\n')
+					eol = 1;
+			}
+		} else
+			SKIP_PAST_NEWLINE(front, back);
+	}
+}
+
+/*
+ * Return LESS, GREATER, or EQUAL depending on how  string  compares with
+ * string2 (s1 ??? s2).
+ *
+ * 	o Matches up to len(s1) are EQUAL.
+ *	o Matches up to len(s2) are GREATER.
+ *
+ * Compare understands about the -f and -d flags, and treats comparisons
+ * appropriately.
+ *
+ * The string "string" is null terminated.  The string "s2" is '\n' terminated
+ * (or "s2end" terminated).
+ *
+ * We use strcasecmp etc, since it knows how to ignore case also
+ * in other locales.
+ */
+static int
+compare(char *s2, char *s2end) {
+	int i;
+	char *p;
+
+	/* copy, ignoring things that should be ignored */
+	p = comparbuf;
+	i = stringlen;
+	while(s2 < s2end && *s2 != '\n' && i) {
+		if (!dflag || isalnum(*s2) || isblank(*s2))
+		{
+			*p++ = *s2;
+			i--;
+		}
+		s2++;
+	}
+	*p = 0;
+
+	/* and compare */
+	if (fflag)
+		i = strncasecmp(comparbuf, string, stringlen);
+	else
+		i = strncmp(comparbuf, string, stringlen);
+
+	return ((i > 0) ? LESS : (i < 0) ? GREATER : EQUAL);
+}
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+	fputs(USAGE_HEADER, out);
+	fprintf(out, _(" %s [options] <string> [<file>...]\n"), program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("Display lines beginning with a specified string.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -a, --alternative        use the alternative dictionary\n"), out);
+	fputs(_(" -d, --alphanum           compare only blanks and alphanumeric characters\n"), out);
+	fputs(_(" -f, --ignore-case        ignore case differences when comparing\n"), out);
+	fputs(_(" -t, --terminate <char>   define the string-termination character\n"), out);
+
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(26));
+	printf(USAGE_MAN_TAIL("look(1)"));
+
+	exit(EXIT_SUCCESS);
+}
diff --git a/misc-utils/lsblk-devtree.c b/misc-utils/lsblk-devtree.c
new file mode 100644
index 0000000..4d15f70
--- /dev/null
+++ b/misc-utils/lsblk-devtree.c
@@ -0,0 +1,472 @@
+/*
+ * These functions implement tree of block devices. The devtree struct contains
+ * two basic lists:
+ *
+ * 1) devtree->devices -- This is simple list without any hierarchy. We use
+ * reference counting here.
+ *
+ * 2) devtree->roots -- The root nodes of the trees. The code does not use
+ * reference counting here due to complexity and it's unnecessary.
+ *
+ * Note that the same device maybe have more parents and more children. The
+ * device is allocated only once and shared within the tree. The dependence
+ * (devdep struct) contains reference to child as well as to parent and the
+ * dependence is reference by ls_childs from parent device and by ls_parents
+ * from child. (Yes, "childs" is used for children ;-)
+ *
+ * Copyright (C) 2018 Karel Zak <kzak@redhat.com>
+ */
+#include "lsblk.h"
+#include "sysfs.h"
+
+
+void lsblk_reset_iter(struct lsblk_iter *itr, int direction)
+{
+	if (direction == -1)
+		direction = itr->direction;
+
+	memset(itr, 0, sizeof(*itr));
+	itr->direction = direction;
+}
+
+struct lsblk_device *lsblk_new_device()
+{
+	struct lsblk_device *dev;
+
+	dev = calloc(1, sizeof(*dev));
+	if (!dev)
+		return NULL;
+
+	dev->refcount = 1;
+	dev->removable = -1;
+	dev->discard_granularity = (uint64_t) -1;
+
+	INIT_LIST_HEAD(&dev->childs);
+	INIT_LIST_HEAD(&dev->parents);
+	INIT_LIST_HEAD(&dev->ls_roots);
+	INIT_LIST_HEAD(&dev->ls_devices);
+
+	DBG(DEV, ul_debugobj(dev, "alloc"));
+	return dev;
+}
+
+void lsblk_ref_device(struct lsblk_device *dev)
+{
+	if (dev)
+		dev->refcount++;
+}
+
+/* removes dependence from child as well as from parent */
+static int remove_dependence(struct lsblk_devdep *dep)
+{
+	if (!dep)
+		return -EINVAL;
+
+	DBG(DEP, ul_debugobj(dep, "   dealloc"));
+
+	list_del_init(&dep->ls_childs);
+	list_del_init(&dep->ls_parents);
+
+	free(dep);
+	return 0;
+}
+
+static int device_remove_dependences(struct lsblk_device *dev)
+{
+	if (!dev)
+		return -EINVAL;
+
+	if (!list_empty(&dev->childs))
+		DBG(DEV, ul_debugobj(dev, "  %s: remove all children deps", dev->name));
+	while (!list_empty(&dev->childs)) {
+		struct lsblk_devdep *dp = list_entry(dev->childs.next,
+					struct lsblk_devdep, ls_childs);
+		remove_dependence(dp);
+	}
+
+	if (!list_empty(&dev->parents))
+		DBG(DEV, ul_debugobj(dev, "  %s: remove all parents deps", dev->name));
+	while (!list_empty(&dev->parents)) {
+		struct lsblk_devdep *dp = list_entry(dev->parents.next,
+					struct lsblk_devdep, ls_parents);
+		remove_dependence(dp);
+	}
+
+	return 0;
+}
+
+void lsblk_unref_device(struct lsblk_device *dev)
+{
+	if (!dev)
+		return;
+
+	if (--dev->refcount <= 0) {
+		DBG(DEV, ul_debugobj(dev, " freeing [%s] <<", dev->name));
+
+		device_remove_dependences(dev);
+		lsblk_device_free_properties(dev->properties);
+
+		lsblk_unref_device(dev->wholedisk);
+
+		free(dev->dm_name);
+		free(dev->filename);
+		free(dev->mountpoint);
+		free(dev->dedupkey);
+
+		ul_unref_path(dev->sysfs);
+
+		DBG(DEV, ul_debugobj(dev, " >> dealloc [%s]", dev->name));
+		free(dev->name);
+		free(dev);
+	}
+}
+
+int lsblk_device_has_child(struct lsblk_device *dev, struct lsblk_device *child)
+{
+	struct lsblk_device *x = NULL;
+	struct lsblk_iter itr;
+
+	lsblk_reset_iter(&itr, LSBLK_ITER_FORWARD);
+
+	while (lsblk_device_next_child(dev, &itr, &x) == 0) {
+		if (x == child)
+			return 1;
+	}
+
+	return 0;
+}
+
+int lsblk_device_new_dependence(struct lsblk_device *parent, struct lsblk_device *child)
+{
+	struct lsblk_devdep *dp;
+
+	if (!parent || !child)
+		return -EINVAL;
+
+	if (lsblk_device_has_child(parent, child))
+		return 1;
+
+	dp = calloc(1, sizeof(*dp));
+	if (!dp)
+		return -ENOMEM;
+
+	INIT_LIST_HEAD(&dp->ls_childs);
+	INIT_LIST_HEAD(&dp->ls_parents);
+
+	dp->child = child;
+	list_add_tail(&dp->ls_childs, &parent->childs);
+
+	dp->parent = parent;
+	list_add_tail(&dp->ls_parents, &child->parents);
+
+        DBG(DEV, ul_debugobj(parent, "add dependence 0x%p [%s->%s]", dp, parent->name, child->name));
+
+	return 0;
+}
+
+static int device_next_child(struct lsblk_device *dev,
+			  struct lsblk_iter *itr,
+			  struct lsblk_devdep **dp)
+{
+	int rc = 1;
+
+	if (!dev || !itr || !dp)
+		return -EINVAL;
+	*dp = NULL;
+
+	if (!itr->head)
+		LSBLK_ITER_INIT(itr, &dev->childs);
+	if (itr->p != itr->head) {
+		LSBLK_ITER_ITERATE(itr, *dp, struct lsblk_devdep, ls_childs);
+		rc = 0;
+	}
+
+	return rc;
+}
+
+int lsblk_device_next_child(struct lsblk_device *dev,
+			  struct lsblk_iter *itr,
+			  struct lsblk_device **child)
+{
+	struct lsblk_devdep *dp = NULL;
+	int rc = device_next_child(dev, itr, &dp);
+
+	if (!child)
+		return -EINVAL;
+
+	*child = rc == 0 ? dp->child : NULL;
+	return rc;
+}
+
+int lsblk_device_is_last_parent(struct lsblk_device *dev, struct lsblk_device *parent)
+{
+	struct lsblk_devdep *dp = list_last_entry(
+					&dev->parents,
+					struct lsblk_devdep, ls_parents);
+	if (!dp)
+		return 0;
+	return dp->parent == parent;
+}
+
+int lsblk_device_next_parent(
+			struct lsblk_device *dev,
+			struct lsblk_iter *itr,
+			struct lsblk_device **parent)
+{
+	int rc = 1;
+
+	if (!dev || !itr || !parent)
+		return -EINVAL;
+	*parent = NULL;
+
+	if (!itr->head)
+		LSBLK_ITER_INIT(itr, &dev->parents);
+	if (itr->p != itr->head) {
+		struct lsblk_devdep *dp = NULL;
+		LSBLK_ITER_ITERATE(itr, dp, struct lsblk_devdep, ls_parents);
+		if (dp)
+			*parent = dp->parent;
+		rc = 0;
+	}
+
+	return rc;
+}
+
+struct lsblk_devtree *lsblk_new_devtree()
+{
+	struct lsblk_devtree *tr;
+
+	tr = calloc(1, sizeof(*tr));
+	if (!tr)
+		return NULL;
+
+	tr->refcount = 1;
+
+	INIT_LIST_HEAD(&tr->roots);
+	INIT_LIST_HEAD(&tr->devices);
+
+	DBG(TREE, ul_debugobj(tr, "alloc"));
+	return tr;
+}
+
+void lsblk_ref_devtree(struct lsblk_devtree *tr)
+{
+	if (tr)
+		tr->refcount++;
+}
+
+void lsblk_unref_devtree(struct lsblk_devtree *tr)
+{
+	if (!tr)
+		return;
+
+	if (--tr->refcount <= 0) {
+		DBG(TREE, ul_debugobj(tr, "dealloc"));
+
+		while (!list_empty(&tr->devices)) {
+			struct lsblk_device *dev = list_entry(tr->devices.next,
+						struct lsblk_device, ls_devices);
+			lsblk_devtree_remove_device(tr, dev);
+		}
+		free(tr);
+	}
+}
+
+int lsblk_devtree_add_root(struct lsblk_devtree *tr, struct lsblk_device *dev)
+{
+	if (!lsblk_devtree_has_device(tr, dev))
+		lsblk_devtree_add_device(tr, dev);
+
+	/* We don't increment reference counter for tr->roots list. The primary
+	 * reference is tr->devices */
+
+        DBG(TREE, ul_debugobj(tr, "add root device 0x%p [%s]", dev, dev->name));
+        list_add_tail(&dev->ls_roots, &tr->roots);
+	return 0;
+}
+
+int lsblk_devtree_next_root(struct lsblk_devtree *tr,
+			    struct lsblk_iter *itr,
+			    struct lsblk_device **dev)
+{
+	int rc = 1;
+
+	if (!tr || !itr || !dev)
+		return -EINVAL;
+	*dev = NULL;
+	if (!itr->head)
+		LSBLK_ITER_INIT(itr, &tr->roots);
+	if (itr->p != itr->head) {
+		LSBLK_ITER_ITERATE(itr, *dev, struct lsblk_device, ls_roots);
+		rc = 0;
+	}
+	return rc;
+}
+
+int lsblk_devtree_add_device(struct lsblk_devtree *tr, struct lsblk_device *dev)
+{
+	lsblk_ref_device(dev);
+
+        DBG(TREE, ul_debugobj(tr, "add device 0x%p [%s]", dev, dev->name));
+        list_add_tail(&dev->ls_devices, &tr->devices);
+	return 0;
+}
+
+int lsblk_devtree_next_device(struct lsblk_devtree *tr,
+			    struct lsblk_iter *itr,
+			    struct lsblk_device **dev)
+{
+	int rc = 1;
+
+	if (!tr || !itr || !dev)
+		return -EINVAL;
+	*dev = NULL;
+	if (!itr->head)
+		LSBLK_ITER_INIT(itr, &tr->devices);
+	if (itr->p != itr->head) {
+		LSBLK_ITER_ITERATE(itr, *dev, struct lsblk_device, ls_devices);
+		rc = 0;
+	}
+	return rc;
+}
+
+int lsblk_devtree_has_device(struct lsblk_devtree *tr, struct lsblk_device *dev)
+{
+	struct lsblk_device *x = NULL;
+	struct lsblk_iter itr;
+
+	lsblk_reset_iter(&itr, LSBLK_ITER_FORWARD);
+
+	while (lsblk_devtree_next_device(tr, &itr, &x) == 0) {
+		if (x == dev)
+			return 1;
+	}
+
+	return 0;
+}
+
+struct lsblk_device *lsblk_devtree_get_device(struct lsblk_devtree *tr, const char *name)
+{
+	struct lsblk_device *dev = NULL;
+	struct lsblk_iter itr;
+
+	lsblk_reset_iter(&itr, LSBLK_ITER_FORWARD);
+
+	while (lsblk_devtree_next_device(tr, &itr, &dev) == 0) {
+		if (strcmp(name, dev->name) == 0)
+			return dev;
+	}
+
+	return NULL;
+}
+
+int lsblk_devtree_remove_device(struct lsblk_devtree *tr, struct lsblk_device *dev)
+{
+        DBG(TREE, ul_debugobj(tr, "remove device 0x%p [%s]", dev, dev->name));
+
+	if (!lsblk_devtree_has_device(tr, dev))
+		return 1;
+
+	list_del_init(&dev->ls_roots);
+	list_del_init(&dev->ls_devices);
+	lsblk_unref_device(dev);
+
+	return 0;
+}
+
+static int device_dedupkey_is_equal(
+			struct lsblk_device *dev,
+			struct lsblk_device *pattern)
+{
+	assert(pattern->dedupkey);
+
+	if (!dev->dedupkey || dev == pattern)
+		return 0;
+	if (strcmp(dev->dedupkey, pattern->dedupkey) == 0) {
+		if (!device_is_partition(dev) ||
+		    !dev->wholedisk->dedupkey ||
+		     strcmp(dev->dedupkey, dev->wholedisk->dedupkey) != 0) {
+			DBG(DEV, ul_debugobj(dev, "%s: match deduplication pattern", dev->name));
+			return 1;
+		}
+	}
+	return 0;
+}
+
+static void device_dedup_dependencies(
+			struct lsblk_device *dev,
+			struct lsblk_device *pattern)
+{
+	struct lsblk_iter itr;
+	struct lsblk_devdep *dp;
+
+	lsblk_reset_iter(&itr, LSBLK_ITER_FORWARD);
+
+	while (device_next_child(dev, &itr, &dp) == 0) {
+		struct lsblk_device *child = dp->child;
+
+		if (device_dedupkey_is_equal(child, pattern)) {
+			DBG(DEV, ul_debugobj(dev, "remove duplicate dependence: 0x%p [%s]",
+						dp->child, dp->child->name));
+			remove_dependence(dp);
+		} else
+			device_dedup_dependencies(child, pattern);
+	}
+}
+
+static void devtree_dedup(struct lsblk_devtree *tr, struct lsblk_device *pattern)
+{
+	struct lsblk_iter itr;
+	struct lsblk_device *dev = NULL;
+
+	lsblk_reset_iter(&itr, LSBLK_ITER_FORWARD);
+
+	DBG(TREE, ul_debugobj(tr, "de-duplicate by key: %s", pattern->dedupkey));
+
+	while (lsblk_devtree_next_root(tr, &itr, &dev) == 0) {
+		if (device_dedupkey_is_equal(dev, pattern)) {
+			DBG(TREE, ul_debugobj(tr, "remove duplicate device: 0x%p [%s]",
+						dev, dev->name));
+			/* Note that root list does not use ref-counting; the
+			 * primary reference is ls_devices */
+			list_del_init(&dev->ls_roots);
+		} else
+			device_dedup_dependencies(dev, pattern);
+	}
+}
+
+static int cmp_devices_devno(struct list_head *a, struct list_head *b,
+			  __attribute__((__unused__)) void *data)
+{
+	struct lsblk_device *ax = list_entry(a, struct lsblk_device, ls_devices),
+			    *bx = list_entry(b, struct lsblk_device, ls_devices);
+
+	return cmp_numbers(makedev(ax->maj, ax->min),
+			   makedev(bx->maj, bx->min));
+}
+
+/* Note that dev->dedupkey has to be already set */
+int lsblk_devtree_deduplicate_devices(struct lsblk_devtree *tr)
+{
+	struct lsblk_device *pattern = NULL;
+	struct lsblk_iter itr;
+	char *last = NULL;
+
+	list_sort(&tr->devices, cmp_devices_devno, NULL);
+	lsblk_reset_iter(&itr, LSBLK_ITER_FORWARD);
+
+	while (lsblk_devtree_next_device(tr, &itr, &pattern) == 0) {
+		if (!pattern->dedupkey)
+			continue;
+		if (device_is_partition(pattern) &&
+		    pattern->wholedisk->dedupkey &&
+		    strcmp(pattern->dedupkey, pattern->wholedisk->dedupkey) == 0)
+			continue;
+		if (last && strcmp(pattern->dedupkey, last) == 0)
+			continue;
+
+		devtree_dedup(tr, pattern);
+		last = pattern->dedupkey;
+	}
+	return 0;
+}
diff --git a/misc-utils/lsblk-mnt.c b/misc-utils/lsblk-mnt.c
new file mode 100644
index 0000000..c034e34
--- /dev/null
+++ b/misc-utils/lsblk-mnt.c
@@ -0,0 +1,127 @@
+#include "c.h"
+#include "pathnames.h"
+#include "xalloc.h"
+#include "nls.h"
+
+#include <libmount.h>
+
+#include "lsblk.h"
+
+static struct libmnt_table *mtab, *swaps;
+static struct libmnt_cache *mntcache;
+
+static int table_parser_errcb(struct libmnt_table *tb __attribute__((__unused__)),
+			const char *filename, int line)
+{
+	if (filename)
+		warnx(_("%s: parse error at line %d -- ignored"), filename, line);
+	return 1;
+}
+
+static int is_active_swap(const char *filename)
+{
+	if (!swaps) {
+		swaps = mnt_new_table();
+		if (!swaps)
+			return 0;
+		if (!mntcache)
+			mntcache = mnt_new_cache();
+
+		mnt_table_set_parser_errcb(swaps, table_parser_errcb);
+		mnt_table_set_cache(swaps, mntcache);
+
+		if (!lsblk->sysroot)
+			mnt_table_parse_swaps(swaps, NULL);
+		else {
+			char buf[PATH_MAX];
+			snprintf(buf, sizeof(buf), "%s" _PATH_PROC_SWAPS, lsblk->sysroot);
+			mnt_table_parse_swaps(swaps, buf);
+		}
+	}
+
+	return mnt_table_find_srcpath(swaps, filename, MNT_ITER_BACKWARD) != NULL;
+}
+
+char *lsblk_device_get_mountpoint(struct lsblk_device *dev)
+{
+	struct libmnt_fs *fs;
+	const char *fsroot;
+
+	assert(dev);
+	assert(dev->filename);
+
+	if (dev->is_mounted || dev->is_swap)
+		return dev->mountpoint;
+
+	if (!mtab) {
+		mtab = mnt_new_table();
+		if (!mtab)
+			return NULL;
+		if (!mntcache)
+			mntcache = mnt_new_cache();
+
+		mnt_table_set_parser_errcb(mtab, table_parser_errcb);
+		mnt_table_set_cache(mtab, mntcache);
+
+		if (!lsblk->sysroot)
+			mnt_table_parse_mtab(mtab, NULL);
+		else {
+			char buf[PATH_MAX];
+			snprintf(buf, sizeof(buf), "%s" _PATH_PROC_MOUNTINFO, lsblk->sysroot);
+			mnt_table_parse_mtab(mtab, buf);
+		}
+	}
+
+	/* Note that maj:min in /proc/self/mountinfo does not have to match with
+	 * devno as returned by stat(), so we have to try devname too
+	 */
+	fs = mnt_table_find_devno(mtab, makedev(dev->maj, dev->min), MNT_ITER_BACKWARD);
+	if (!fs)
+		fs = mnt_table_find_srcpath(mtab, dev->filename, MNT_ITER_BACKWARD);
+	if (!fs) {
+		if (is_active_swap(dev->filename)) {
+			dev->mountpoint = xstrdup("[SWAP]");
+			dev->is_swap = 1;
+		} else
+			dev->mountpoint = NULL;
+
+		return dev->mountpoint;
+	}
+
+	/* found */
+	fsroot = mnt_fs_get_root(fs);
+	if (fsroot && strcmp(fsroot, "/") != 0) {
+		/* hmm.. we found bind mount or btrfs subvolume, let's try to
+		 * get real FS root mountpoint */
+		struct libmnt_fs *rfs;
+		struct libmnt_iter *itr = mnt_new_iter(MNT_ITER_BACKWARD);
+
+		mnt_table_set_iter(mtab, itr, fs);
+		while (mnt_table_next_fs(mtab, itr, &rfs) == 0) {
+			fsroot = mnt_fs_get_root(rfs);
+			if ((!fsroot || strcmp(fsroot, "/") == 0)
+			    && mnt_fs_match_source(rfs, dev->filename, mntcache)) {
+				fs = rfs;
+				break;
+			}
+		}
+		mnt_free_iter(itr);
+	}
+
+	DBG(DEV, ul_debugobj(dev, "mountpoint: %s", mnt_fs_get_target(fs)));
+	dev->mountpoint = xstrdup(mnt_fs_get_target(fs));
+	dev->is_mounted = 1;
+	return dev->mountpoint;
+}
+
+void lsblk_mnt_init(void)
+{
+	mnt_init_debug(0);
+}
+
+void lsblk_mnt_deinit(void)
+{
+	mnt_unref_table(mtab);
+	mnt_unref_table(swaps);
+	mnt_unref_cache(mntcache);
+}
diff --git a/misc-utils/lsblk-properties.c b/misc-utils/lsblk-properties.c
new file mode 100644
index 0000000..1940171
--- /dev/null
+++ b/misc-utils/lsblk-properties.c
@@ -0,0 +1,381 @@
+
+#include <blkid.h>
+
+#ifdef HAVE_LIBUDEV
+# include <libudev.h>
+#endif
+
+#include "c.h"
+#include "xalloc.h"
+#include "mangle.h"
+#include "path.h"
+#include "nls.h"
+
+#include "lsblk.h"
+
+#ifdef HAVE_LIBUDEV
+static struct udev *udev;
+#endif
+
+void lsblk_device_free_properties(struct lsblk_devprop *p)
+{
+	if (!p)
+		return;
+
+	free(p->fstype);
+	free(p->fsversion);
+	free(p->uuid);
+	free(p->ptuuid);
+	free(p->pttype);
+	free(p->label);
+	free(p->parttype);
+	free(p->partuuid);
+	free(p->partlabel);
+	free(p->wwn);
+	free(p->serial);
+	free(p->model);
+	free(p->partflags);
+
+	free(p->mode);
+	free(p->owner);
+	free(p->group);
+
+	free(p);
+}
+
+#ifndef HAVE_LIBUDEV
+static struct lsblk_devprop *get_properties_by_udev(struct lsblk_device *dev
+				__attribute__((__unused__)))
+{
+	return NULL;
+}
+#else
+static struct lsblk_devprop *get_properties_by_udev(struct lsblk_device *ld)
+{
+	struct udev_device *dev;
+
+	if (ld->udev_requested)
+		return ld->properties;
+
+	if (!udev)
+		udev = udev_new();	/* global handler */
+	if (!udev)
+		goto done;
+
+	dev = udev_device_new_from_subsystem_sysname(udev, "block", ld->name);
+	if (dev) {
+		const char *data;
+		struct lsblk_devprop *prop;
+
+		if (ld->properties)
+			lsblk_device_free_properties(ld->properties);
+		prop = ld->properties = xcalloc(1, sizeof(*ld->properties));
+
+		if ((data = udev_device_get_property_value(dev, "ID_FS_LABEL_ENC"))) {
+			prop->label = xstrdup(data);
+			unhexmangle_string(prop->label);
+		}
+		if ((data = udev_device_get_property_value(dev, "ID_FS_UUID_ENC"))) {
+			prop->uuid = xstrdup(data);
+			unhexmangle_string(prop->uuid);
+		}
+		if ((data = udev_device_get_property_value(dev, "ID_PART_TABLE_UUID")))
+			prop->ptuuid = xstrdup(data);
+		if ((data = udev_device_get_property_value(dev, "ID_PART_TABLE_TYPE")))
+			prop->pttype = xstrdup(data);
+		if ((data = udev_device_get_property_value(dev, "ID_PART_ENTRY_NAME"))) {
+			prop->partlabel = xstrdup(data);
+			unhexmangle_string(prop->partlabel);
+		}
+		if ((data = udev_device_get_property_value(dev, "ID_FS_TYPE")))
+			prop->fstype = xstrdup(data);
+		if ((data = udev_device_get_property_value(dev, "ID_FS_VERSION")))
+			prop->fsversion = xstrdup(data);
+		if ((data = udev_device_get_property_value(dev, "ID_PART_ENTRY_TYPE")))
+			prop->parttype = xstrdup(data);
+		if ((data = udev_device_get_property_value(dev, "ID_PART_ENTRY_UUID")))
+			prop->partuuid = xstrdup(data);
+		if ((data = udev_device_get_property_value(dev, "ID_PART_ENTRY_FLAGS")))
+			prop->partflags = xstrdup(data);
+
+		data = udev_device_get_property_value(dev, "ID_WWN_WITH_EXTENSION");
+		if (!data)
+			data = udev_device_get_property_value(dev, "ID_WWN");
+		if (data)
+			prop->wwn = xstrdup(data);
+
+		data = udev_device_get_property_value(dev, "ID_SCSI_SERIAL");
+		if(!data)
+			data = udev_device_get_property_value(dev, "ID_SERIAL_SHORT");
+		if(!data)
+			data = udev_device_get_property_value(dev, "ID_SERIAL");
+		if (data)
+			prop->serial = xstrdup(data);
+
+		if ((data = udev_device_get_property_value(dev, "ID_MODEL")))
+			prop->model = xstrdup(data);
+
+		udev_device_unref(dev);
+		DBG(DEV, ul_debugobj(ld, "%s: found udev properties", ld->name));
+	}
+
+done:
+	ld->udev_requested = 1;
+
+	DBG(DEV, ul_debugobj(ld, " from udev"));
+	return ld->properties;
+}
+#endif /* HAVE_LIBUDEV */
+
+
+static int lookup(char *buf, char *pattern, char **value)
+{
+	char *p, *v;
+	int len;
+
+	/* do not re-fill value */
+	if (!buf || *value)
+		return 0;
+
+	len = strlen(pattern);
+	if (strncmp(buf, pattern, len) != 0)
+		return 0;
+
+	p = buf + len;
+	if (*p != '=')
+		return 0;
+	p++;
+	if (!*p || *p == '\n')
+		return 0;
+	v = p;
+	for (; *p && *p != '\n'; p++) ;
+	if (*p == '\n')
+		*p = '\0';
+
+	*value = xstrdup(v);
+	return 1;
+}
+
+/* read device properties from fake text file (used on --sysroot) */
+static struct lsblk_devprop *get_properties_by_file(struct lsblk_device *ld)
+{
+	struct lsblk_devprop *prop;
+	struct path_cxt *pc;
+	FILE *fp = NULL;
+	struct stat sb;
+	char buf[BUFSIZ];
+
+	assert(lsblk->sysroot);
+
+	if (ld->file_requested)
+		return ld->properties;
+
+	if (ld->properties || ld->filename) {
+		lsblk_device_free_properties(ld->properties);
+		ld->properties = NULL;
+	}
+
+	pc = ul_new_path("/");
+	if (!pc)
+		return NULL;
+	if (ul_path_set_prefix(pc, lsblk->sysroot) != 0)
+		goto done;
+	if (ul_path_stat(pc, &sb, ld->filename) != 0 || !S_ISREG(sb.st_mode))
+		goto done;
+
+	fp = ul_path_fopen(pc, "r", ld->filename);
+	if (!fp)
+		goto done;
+
+	prop = ld->properties;
+	if (!prop)
+		prop = ld->properties = xcalloc(1, sizeof(*ld->properties));
+
+	while (fgets(buf, sizeof(buf), fp) != NULL) {
+		/* udev based */
+		if (lookup(buf, "ID_FS_LABEL_ENC", &prop->label))
+			unhexmangle_string(prop->label);
+		else if (lookup(buf, "ID_FS_UUID_ENC", &prop->uuid))
+			unhexmangle_string(prop->uuid);
+		else if (lookup(buf, "ID_PART_ENTRY_NAME", &prop->partlabel))
+			unhexmangle_string(prop->partlabel);
+		else if (lookup(buf, "ID_PART_TABLE_UUID", &prop->ptuuid)) ;
+		else if (lookup(buf, "ID_PART_TABLE_TYPE", &prop->pttype)) ;
+		else if (lookup(buf, "ID_FS_TYPE", &prop->fstype)) ;
+		else if (lookup(buf, "ID_FS_VERSION", &prop->fsversion)) ;
+		else if (lookup(buf, "ID_PART_ENTRY_TYPE", &prop->parttype)) ;
+		else if (lookup(buf, "ID_PART_ENTRY_UUID", &prop->partuuid)) ;
+		else if (lookup(buf, "ID_PART_ENTRY_FLAGS", &prop->partflags)) ;
+		else if (lookup(buf, "ID_MODEL", &prop->model)) ;
+		else if (lookup(buf, "ID_WWN_WITH_EXTENSION", &prop->wwn)) ;
+		else if (lookup(buf, "ID_WWN", &prop->wwn)) ;
+		else if (lookup(buf, "SCSI_IDENT_SERIAL", &prop->serial)) ;	/* serial from sg3_utils */
+		else if (lookup(buf, "ID_SCSI_SERIAL", &prop->serial)) ;
+		else if (lookup(buf, "ID_SERIAL_SHORT", &prop->serial)) ;
+		else if (lookup(buf, "ID_SERIAL", &prop->serial)) ;
+
+		/* lsblk specific */
+		else if (lookup(buf, "MODE", &prop->mode)) ;
+		else if (lookup(buf, "OWNER", &prop->owner)) ;
+		else if (lookup(buf, "GROUP", &prop->group)) ;
+
+		else
+			continue;
+	}
+done:
+	if (fp)
+		fclose(fp);
+	ul_unref_path(pc);
+	ld->file_requested = 1;
+
+	DBG(DEV, ul_debugobj(ld, " from fake-file"));
+	return ld->properties;
+}
+
+
+static struct lsblk_devprop *get_properties_by_blkid(struct lsblk_device *dev)
+{
+	blkid_probe pr = NULL;
+
+	if (dev->blkid_requested)
+		return dev->properties;
+
+	if (!dev->size)
+		goto done;
+	if (getuid() != 0)
+		goto done;;				/* no permissions to read from the device */
+
+	pr = blkid_new_probe_from_filename(dev->filename);
+	if (!pr)
+		goto done;
+
+	blkid_probe_enable_superblocks(pr, 1);
+	blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_LABEL |
+					      BLKID_SUBLKS_UUID |
+					      BLKID_SUBLKS_TYPE);
+	blkid_probe_enable_partitions(pr, 1);
+	blkid_probe_set_partitions_flags(pr, BLKID_PARTS_ENTRY_DETAILS);
+
+	if (!blkid_do_safeprobe(pr)) {
+		const char *data = NULL;
+		struct lsblk_devprop *prop;
+
+		if (dev->properties)
+			lsblk_device_free_properties(dev->properties);
+		prop = dev->properties = xcalloc(1, sizeof(*dev->properties));
+
+		if (!blkid_probe_lookup_value(pr, "TYPE", &data, NULL))
+			prop->fstype = xstrdup(data);
+		if (!blkid_probe_lookup_value(pr, "UUID", &data, NULL))
+			prop->uuid = xstrdup(data);
+		if (!blkid_probe_lookup_value(pr, "PTUUID", &data, NULL))
+			prop->ptuuid = xstrdup(data);
+		if (!blkid_probe_lookup_value(pr, "PTTYPE", &data, NULL))
+			prop->pttype = xstrdup(data);
+		if (!blkid_probe_lookup_value(pr, "LABEL", &data, NULL))
+			prop->label = xstrdup(data);
+		if (!blkid_probe_lookup_value(pr, "VERSION", &data, NULL))
+			prop->fsversion = xstrdup(data);
+		if (!blkid_probe_lookup_value(pr, "PART_ENTRY_TYPE", &data, NULL))
+			prop->parttype = xstrdup(data);
+		if (!blkid_probe_lookup_value(pr, "PART_ENTRY_UUID", &data, NULL))
+			prop->partuuid = xstrdup(data);
+		if (!blkid_probe_lookup_value(pr, "PART_ENTRY_NAME", &data, NULL))
+			prop->partlabel = xstrdup(data);
+		if (!blkid_probe_lookup_value(pr, "PART_ENTRY_FLAGS", &data, NULL))
+			prop->partflags = xstrdup(data);
+
+		DBG(DEV, ul_debugobj(dev, "%s: found blkid properties", dev->name));
+	}
+
+done:
+	blkid_free_probe(pr);
+
+	DBG(DEV, ul_debugobj(dev, " from blkid"));
+	dev->blkid_requested = 1;
+	return dev->properties;
+}
+
+struct lsblk_devprop *lsblk_device_get_properties(struct lsblk_device *dev)
+{
+	struct lsblk_devprop *p = NULL;
+
+	DBG(DEV, ul_debugobj(dev, "%s: properties requested", dev->filename));
+	if (lsblk->sysroot)
+		return get_properties_by_file(dev);
+
+	p = get_properties_by_udev(dev);
+	if (!p)
+		p = get_properties_by_blkid(dev);
+	return p;
+}
+
+void lsblk_properties_deinit(void)
+{
+#ifdef HAVE_LIBUDEV
+	udev_unref(udev);
+#endif
+}
+
+
+
+/*
+ * Partition types
+ */
+struct lsblk_parttype {
+	unsigned int	code;		/* type as number or zero */
+	char		*name;		/* description */
+	char		*typestr;	/* type as string or NULL */
+};
+
+static const struct lsblk_parttype mbr_types[] =
+{
+	#include "pt-mbr-partnames.h"
+};
+
+#define DEF_GUID(_u, _n) \
+	{ \
+		.typestr = (_u), \
+		.name = (_n),    \
+	}
+static const struct lsblk_parttype gpt_types[] =
+{
+	#include "pt-gpt-partnames.h"
+};
+
+const char *lsblk_parttype_code_to_string(const char *code, const char *pttype)
+{
+	size_t i;
+
+	if (!code || !pttype)
+		return NULL;
+
+	if (strcmp(pttype, "dos") == 0 || strcmp(pttype, "mbr") == 0) {
+		char *end = NULL;
+		unsigned int xcode;
+
+		errno = 0;
+		xcode = strtol(code, &end, 16);
+
+		if (errno || *end != '\0')
+			return NULL;
+
+		for (i = 0; i < ARRAY_SIZE(mbr_types); i++) {
+			const struct lsblk_parttype *t = &mbr_types[i];
+
+			if (t->name && t->code == xcode)
+				return t->name;
+		}
+
+	} else if (strcmp(pttype, "gpt") == 0) {
+		for (i = 0; i < ARRAY_SIZE(gpt_types); i++) {
+			const struct lsblk_parttype *t = &gpt_types[i];
+
+			if (t->name && t->typestr &&
+			    strcasecmp(code, t->typestr) == 0)
+				return t->name;
+		}
+	}
+
+	return NULL;
+}
diff --git a/misc-utils/lsblk.8 b/misc-utils/lsblk.8
new file mode 100644
index 0000000..3da4e2e
--- /dev/null
+++ b/misc-utils/lsblk.8
@@ -0,0 +1,215 @@
+.TH LSBLK 8 "February 2013" "util-linux" "System Administration"
+.SH NAME
+lsblk \- list block devices
+.SH SYNOPSIS
+.B lsblk
+[options]
+.RI [ device ...]
+.SH DESCRIPTION
+.B lsblk
+lists information about all available or the specified block devices.  The
+.B lsblk
+command reads the
+.B sysfs
+filesystem and
+.B udev db
+to gather information. If the udev db is not available or lsblk is compiled without udev support than it
+tries to read LABELs, UUIDs and filesystem types from the block device. In this case root permissions
+are necessary.
+.PP
+The command prints all block devices (except RAM disks) in a tree-like format
+by default.  Use
+.B "lsblk \-\-help"
+to get a list of all available columns.
+.PP
+The default output, as well as the default output from options like
+.B \-\-fs
+and
+.BR \-\-topology ,
+is subject to change.  So whenever possible, you should avoid using default
+outputs in your scripts.  Always explicitly define expected columns by using
+.B \-\-output
+.I columns-list
+and
+.B \-\-list
+in environments where a stable output is required.
+.PP
+Note that
+.B lsblk
+might be executed in time when
+.B udev
+does not have all information about recently added or modified devices yet. In this
+case it is recommended to use
+.B "udevadm settle"
+before lsblk to synchronize with udev.
+.SH OPTIONS
+.TP
+.BR \-a , " \-\-all"
+Also list empty devices and RAM disk devices.
+.TP
+.BR \-b , " \-\-bytes"
+Print the SIZE column in bytes rather than in a human-readable format.
+.TP
+.BR \-D , " \-\-discard"
+Print information about the discarding capabilities (TRIM, UNMAP) for each device.
+.TP
+.BR \-d , " \-\-nodeps"
+Do not print holder devices or slaves.  For example, \fBlsblk \-\-nodeps /dev/sda\fR prints
+information about the sda device only.
+.TP
+.BR \-E , " \-\-dedup " \fIcolumn\fP
+Use \fIcolumn\fP as a de-duplication key to de-duplicate output tree. If the
+key is not available for the device, or the device is a partition and parental
+whole-disk device provides the same key than the device is always printed.
+
+The usual use case is to de-duplicate output on system multi-path devices, for
+example by \fB\-E WWN\fR.
+.TP
+.BR \-e , " \-\-exclude " \fIlist\fP
+Exclude the devices specified by the comma-separated \fIlist\fR of major device numbers.
+Note that RAM disks (major=1) are excluded by default if \fB\-\-all\fR is not specified.
+The filter is applied to the top-level devices only. This may be confusing for
+\fB\-\-list\fR output format where hierarchy of the devices is not obvious.
+.TP
+.BR \-f , " \-\-fs"
+Output info about filesystems.  This option is equivalent to
+.BR \-o\ NAME,FSTYPE,LABEL,UUID,FSAVAIL,FSUSE%,MOUNTPOINT .
+The authoritative information about filesystems and raids is provided by the
+.BR blkid (8)
+command.
+.TP
+.BR \-h , " \-\-help"
+Display help text and exit.
+.TP
+.BR \-I , " \-\-include " \fIlist\fP
+Include devices specified by the comma-separated \fIlist\fR of major device numbers.
+The filter is applied to the top-level devices only. This may be confusing for
+\fB\-\-list\fR output format where hierarchy of the devices is not obvious.
+.TP
+.BR \-i , " \-\-ascii"
+Use ASCII characters for tree formatting.
+.TP
+.BR \-J , " \-\-json"
+Use JSON output format.  It's strongly recommended to use \fB\-\-output\fR and
+also \fB\-\-tree\fR if necessary.
+.TP
+.BR \-l , " \-\-list"
+Produce output in the form of a list. The output does not provide information
+about relationships between devices and since version 2.34 every device is
+printed only once if \fB\-\-pairs\fR or \fB\-\-raw\fR not specified (the
+parsable outputs are maintained in backwardly compatible way).
+.TP
+.BR \-M , " \-\-merge"
+Group parents of sub-trees to provide more readable output for RAIDs and
+Multi-path devices. The tree-like output is required.
+.TP
+.BR \-m , " \-\-perms"
+Output info about device owner, group and mode.  This option is equivalent to
+.BR \-o\ NAME,SIZE,OWNER,GROUP,MODE .
+.TP
+.BR \-n , " \-\-noheadings"
+Do not print a header line.
+.TP
+.BR \-o , " \-\-output " \fIlist\fP
+Specify which output columns to print.  Use
+.B \-\-help
+to get a list of all supported columns.  The columns may affect tree-like output.
+The default is to use tree for the column 'NAME' (see also \fB\-\-tree\fR).
+
+The default list of columns may be extended if \fIlist\fP is
+specified in the format \fI+list\fP (e.g., \fBlsblk \-o +UUID\fP).
+.TP
+.BR \-O , " \-\-output\-all"
+Output all available columns.
+.TP
+.BR \-P , " \-\-pairs"
+Produce output in the form of key="value" pairs.  The output lines are still ordered by
+dependencies.  All potentially unsafe characters are hex-escaped (\\x<code>).
+.TP
+.BR \-p , " \-\-paths"
+Print full device paths.
+.TP
+.BR \-r , " \-\-raw"
+Produce output in raw format.  The output lines are still ordered by
+dependencies.  All potentially unsafe characters are hex-escaped
+(\\x<code>) in the NAME, KNAME, LABEL, PARTLABEL and MOUNTPOINT columns.
+.TP
+.BR \-S , " \-\-scsi"
+Output info about SCSI devices only.  All partitions, slaves and holder devices are ignored.
+.TP
+.BR \-s , " \-\-inverse"
+Print dependencies in inverse order. If the \fB\-\-list\fR output is requested then
+the lines are still ordered by dependencies.
+.TP
+.BR \-T , " \-\-tree" [ =\fIcolumn ]
+Force tree-like output format.  If \fIcolumn\fP is specified, then a tree is printed in the column.
+The default is NAME column.
+.TP
+.BR \-t , " \-\-topology"
+Output info about block-device topology.
+This option is equivalent to
+.BR \-o\ NAME,ALIGNMENT,MIN-IO,OPT-IO,PHY-SEC,LOG-SEC,ROTA,SCHED,RQ-SIZE,RA,WSAME .
+.TP
+.BR \-V , " \-\-version"
+Display version information and exit.
+.TP
+.BR \-x , " \-\-sort " \fIcolumn\fP
+Sort output lines by \fIcolumn\fP. This option enables \fB\-\-list\fR output format by default.
+It is possible to use the option \fI\-\-tree\fP to force tree-like output and
+than the tree branches are sorted by the \fIcolumn\fP.
+.TP
+.BR \-z , " \-\-zoned"
+Print the zone model for each device.
+.TP
+.BR " \-\-sysroot " \fIdirectory\fP
+Gather data for a Linux instance other than the instance from which the lsblk
+command is issued.  The specified directory is the system root of the Linux
+instance to be inspected.  The real device nodes in the target directory can
+be replaced by text files with udev attributes.
+
+.SH EXIT STATUS
+.IP 0
+success
+.IP 1
+failure
+.IP 32
+none of specified devices found
+.IP 64
+some specified devices found, some not found
+
+.SH ENVIRONMENT
+.IP LSBLK_DEBUG=all
+enables lsblk debug output.
+.IP LIBBLKID_DEBUG=all
+enables libblkid debug output.
+.IP LIBMOUNT_DEBUG=all
+enables libmount debug output.
+.IP LIBSMARTCOLS_DEBUG=all
+enables libsmartcols debug output.
+.IP LIBSMARTCOLS_DEBUG_PADDING=on
+use visible padding characters. Requires enabled LIBSMARTCOLS_DEBUG.
+.SH NOTES
+For partitions, some information (e.g., queue attributes) is inherited from the
+parent device.
+.PP
+The
+.B lsblk
+command needs to be able to look up each block device by major:minor numbers,
+which is done by using
+.IR /sys/dev/block .
+This sysfs block directory appeared in kernel 2.6.27 (October 2008).
+In case of problems with a new enough kernel, check that CONFIG_SYSFS
+was enabled at the time of the kernel build.
+
+.SH AUTHORS
+.nf
+Milan Broz <mbroz@redhat.com>
+Karel Zak <kzak@redhat.com>
+.fi
+.SH SEE ALSO
+.BR ls (1),
+.BR blkid (8),
+.BR findmnt (8)
+.SH AVAILABILITY
+The lsblk command is part of the util-linux package and is available from
+https://www.kernel.org/pub/linux/utils/util-linux/.
diff --git a/misc-utils/lsblk.c b/misc-utils/lsblk.c
new file mode 100644
index 0000000..49c15ab
--- /dev/null
+++ b/misc-utils/lsblk.c
@@ -0,0 +1,2202 @@
+/*
+ * lsblk(8) - list block devices
+ *
+ * Copyright (C) 2010-2018 Red Hat, Inc. All rights reserved.
+ * Written by Milan Broz <mbroz@redhat.com>
+ *            Karel Zak <kzak@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include <stdio.h>
+#include <errno.h>
+#include <getopt.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <stdarg.h>
+#include <locale.h>
+#include <pwd.h>
+#include <grp.h>
+#include <ctype.h>
+#include <assert.h>
+
+#include <blkid.h>
+
+#include "c.h"
+#include "pathnames.h"
+#include "blkdev.h"
+#include "canonicalize.h"
+#include "nls.h"
+#include "xalloc.h"
+#include "strutils.h"
+#include "sysfs.h"
+#include "closestream.h"
+#include "optutils.h"
+#include "fileutils.h"
+
+#include "lsblk.h"
+
+UL_DEBUG_DEFINE_MASK(lsblk);
+UL_DEBUG_DEFINE_MASKNAMES(lsblk) = UL_DEBUG_EMPTY_MASKNAMES;
+
+#define LSBLK_EXIT_SOMEOK 64
+#define LSBLK_EXIT_ALLFAILED 32
+
+static int column_id_to_number(int id);
+
+/* column IDs */
+enum {
+	COL_NAME = 0,
+	COL_KNAME,
+	COL_PATH,
+	COL_MAJMIN,
+	COL_FSAVAIL,
+	COL_FSSIZE,
+	COL_FSTYPE,
+	COL_FSUSED,
+	COL_FSUSEPERC,
+	COL_FSVERSION,
+	COL_TARGET,
+	COL_LABEL,
+	COL_UUID,
+	COL_PTUUID,
+	COL_PTTYPE,
+	COL_PARTTYPE,
+	COL_PARTTYPENAME,
+	COL_PARTLABEL,
+	COL_PARTUUID,
+	COL_PARTFLAGS,
+	COL_RA,
+	COL_RO,
+	COL_RM,
+	COL_HOTPLUG,
+	COL_MODEL,
+	COL_SERIAL,
+	COL_SIZE,
+	COL_STATE,
+	COL_OWNER,
+	COL_GROUP,
+	COL_MODE,
+	COL_ALIOFF,
+	COL_MINIO,
+	COL_OPTIO,
+	COL_PHYSEC,
+	COL_LOGSEC,
+	COL_ROTA,
+	COL_SCHED,
+	COL_RQ_SIZE,
+	COL_TYPE,
+	COL_DALIGN,
+	COL_DGRAN,
+	COL_DMAX,
+	COL_DZERO,
+	COL_WSAME,
+	COL_WWN,
+	COL_RAND,
+	COL_PKNAME,
+	COL_HCTL,
+	COL_TRANSPORT,
+	COL_SUBSYS,
+	COL_REV,
+	COL_VENDOR,
+	COL_ZONED,
+	COL_DAX
+};
+
+/* basic table settings */
+enum {
+	LSBLK_ASCII =		(1 << 0),
+	LSBLK_RAW =		(1 << 1),
+	LSBLK_NOHEADINGS =	(1 << 2),
+	LSBLK_EXPORT =		(1 << 3),
+	LSBLK_TREE =		(1 << 4),
+	LSBLK_JSON =		(1 << 5),
+};
+
+/* Types used for qsort() and JSON */
+enum {
+	COLTYPE_STR	= 0,	/* default */
+	COLTYPE_NUM	= 1,	/* always u64 number */
+	COLTYPE_SORTNUM = 2,	/* string on output, u64 for qsort() */
+	COLTYPE_SIZE	= 3,	/* srring by default, number when --bytes */
+	COLTYPE_BOOL	= 4	/* 0 or 1 */
+};
+
+/* column names */
+struct colinfo {
+	const char	*name;		/* header */
+	double		whint;		/* width hint (N < 1 is in percent of termwidth) */
+	int		flags;		/* SCOLS_FL_* */
+	const char      *help;
+	int		type;		/* COLTYPE_* */
+};
+
+/* columns descriptions */
+static struct colinfo infos[] = {
+	[COL_NAME]   = { "NAME",    0.25, SCOLS_FL_NOEXTREMES, N_("device name") },
+	[COL_KNAME]  = { "KNAME",   0.3, 0, N_("internal kernel device name") },
+	[COL_PKNAME] = { "PKNAME",  0.3, 0, N_("internal parent kernel device name") },
+	[COL_PATH]   = { "PATH",    0.3,  0, N_("path to the device node") },
+	[COL_MAJMIN] = { "MAJ:MIN", 6, 0, N_("major:minor device number"), COLTYPE_SORTNUM },
+
+	[COL_FSAVAIL]   = { "FSAVAIL", 5, SCOLS_FL_RIGHT, N_("filesystem size available") },
+	[COL_FSSIZE]    = { "FSSIZE", 5, SCOLS_FL_RIGHT, N_("filesystem size") },
+	[COL_FSTYPE]    = { "FSTYPE", 0.1, SCOLS_FL_TRUNC, N_("filesystem type") },
+	[COL_FSUSED]    = { "FSUSED", 5, SCOLS_FL_RIGHT, N_("filesystem size used") },
+	[COL_FSUSEPERC] = { "FSUSE%", 3, SCOLS_FL_RIGHT, N_("filesystem use percentage") },
+	[COL_FSVERSION] = { "FSVER", 0.1, SCOLS_FL_TRUNC, N_("filesystem version") },
+
+	[COL_TARGET] = { "MOUNTPOINT", 0.10, SCOLS_FL_TRUNC, N_("where the device is mounted") },
+	[COL_LABEL]  = { "LABEL",   0.1, 0, N_("filesystem LABEL") },
+	[COL_UUID]   = { "UUID",    36,  0, N_("filesystem UUID") },
+
+	[COL_PTUUID] = { "PTUUID",  36,  0, N_("partition table identifier (usually UUID)") },
+	[COL_PTTYPE] = { "PTTYPE",  0.1, 0, N_("partition table type") },
+
+	[COL_PARTTYPE]  = { "PARTTYPE",  36,  0, N_("partition type code or UUID") },
+	[COL_PARTTYPENAME]  = { "PARTTYPENAME",  0.1,  0, N_("partition type name") },
+	[COL_PARTLABEL] = { "PARTLABEL", 0.1, 0, N_("partition LABEL") },
+	[COL_PARTUUID]  = { "PARTUUID",  36,  0, N_("partition UUID") },
+	[COL_PARTFLAGS] = { "PARTFLAGS",  36,  0, N_("partition flags") },
+
+	[COL_RA]     = { "RA",      3, SCOLS_FL_RIGHT, N_("read-ahead of the device"), COLTYPE_NUM },
+	[COL_RO]     = { "RO",      1, SCOLS_FL_RIGHT, N_("read-only device"), COLTYPE_BOOL },
+	[COL_RM]     = { "RM",      1, SCOLS_FL_RIGHT, N_("removable device"), COLTYPE_BOOL },
+	[COL_HOTPLUG]= { "HOTPLUG", 1, SCOLS_FL_RIGHT, N_("removable or hotplug device (usb, pcmcia, ...)"), COLTYPE_BOOL },
+	[COL_ROTA]   = { "ROTA",    1, SCOLS_FL_RIGHT, N_("rotational device"), COLTYPE_BOOL },
+	[COL_RAND]   = { "RAND",    1, SCOLS_FL_RIGHT, N_("adds randomness"), COLTYPE_BOOL },
+	[COL_MODEL]  = { "MODEL",   0.1, SCOLS_FL_TRUNC, N_("device identifier") },
+	[COL_SERIAL] = { "SERIAL",  0.1, SCOLS_FL_TRUNC, N_("disk serial number") },
+	[COL_SIZE]   = { "SIZE",    5, SCOLS_FL_RIGHT, N_("size of the device"), COLTYPE_SIZE },
+	[COL_STATE]  = { "STATE",   7, SCOLS_FL_TRUNC, N_("state of the device") },
+	[COL_OWNER]  = { "OWNER",   0.1, SCOLS_FL_TRUNC, N_("user name"), },
+	[COL_GROUP]  = { "GROUP",   0.1, SCOLS_FL_TRUNC, N_("group name") },
+	[COL_MODE]   = { "MODE",    10,   0, N_("device node permissions") },
+	[COL_ALIOFF] = { "ALIGNMENT", 6, SCOLS_FL_RIGHT, N_("alignment offset"), COLTYPE_NUM },
+	[COL_MINIO]  = { "MIN-IO",  6, SCOLS_FL_RIGHT, N_("minimum I/O size"), COLTYPE_NUM },
+	[COL_OPTIO]  = { "OPT-IO",  6, SCOLS_FL_RIGHT, N_("optimal I/O size"), COLTYPE_NUM },
+	[COL_PHYSEC] = { "PHY-SEC", 7, SCOLS_FL_RIGHT, N_("physical sector size"), COLTYPE_NUM },
+	[COL_LOGSEC] = { "LOG-SEC", 7, SCOLS_FL_RIGHT, N_("logical sector size"), COLTYPE_NUM },
+	[COL_SCHED]  = { "SCHED",   0.1, 0, N_("I/O scheduler name") },
+	[COL_RQ_SIZE]= { "RQ-SIZE", 5, SCOLS_FL_RIGHT, N_("request queue size"), COLTYPE_NUM },
+	[COL_TYPE]   = { "TYPE",    4, 0, N_("device type") },
+	[COL_DALIGN] = { "DISC-ALN", 6, SCOLS_FL_RIGHT, N_("discard alignment offset"), COLTYPE_NUM },
+	[COL_DGRAN]  = { "DISC-GRAN", 6, SCOLS_FL_RIGHT, N_("discard granularity"), COLTYPE_SIZE },
+	[COL_DMAX]   = { "DISC-MAX", 6, SCOLS_FL_RIGHT, N_("discard max bytes"), COLTYPE_SIZE },
+	[COL_DZERO]  = { "DISC-ZERO", 1, SCOLS_FL_RIGHT, N_("discard zeroes data"), COLTYPE_BOOL },
+	[COL_WSAME]  = { "WSAME",   6, SCOLS_FL_RIGHT, N_("write same max bytes"), COLTYPE_SIZE },
+	[COL_WWN]    = { "WWN",     18, 0, N_("unique storage identifier") },
+	[COL_HCTL]   = { "HCTL", 10, 0, N_("Host:Channel:Target:Lun for SCSI") },
+	[COL_TRANSPORT] = { "TRAN", 6, 0, N_("device transport type") },
+	[COL_SUBSYS] = { "SUBSYSTEMS", 0.1, SCOLS_FL_NOEXTREMES, N_("de-duplicated chain of subsystems") },
+	[COL_REV]    = { "REV",   4, SCOLS_FL_RIGHT, N_("device revision") },
+	[COL_VENDOR] = { "VENDOR", 0.1, SCOLS_FL_TRUNC, N_("device vendor") },
+	[COL_ZONED]  = { "ZONED", 0.3, 0, N_("zone model") },
+	[COL_DAX]    = { "DAX", 1, SCOLS_FL_RIGHT, N_("dax-capable device"), COLTYPE_BOOL },
+};
+
+struct lsblk *lsblk;	/* global handler */
+
+/*
+ * columns[] array specifies all currently wanted output column. The columns
+ * are defined by infos[] array and you can specify (on command line) each
+ * column twice. That's enough, dynamically allocated array of the columns is
+ * unnecessary overkill and over-engineering in this case
+ */
+static int columns[ARRAY_SIZE(infos) * 2];
+static size_t ncolumns;
+
+static inline void add_column(int id)
+{
+	if (ncolumns >= ARRAY_SIZE(columns))
+		errx(EXIT_FAILURE, _("too many columns specified, "
+				     "the limit is %zu columns"),
+				ARRAY_SIZE(columns) - 1);
+	columns[ ncolumns++ ] =  id;
+}
+
+static inline void add_uniq_column(int id)
+{
+	if (column_id_to_number(id) < 0)
+		add_column(id);
+}
+
+static void lsblk_init_debug(void)
+{
+	__UL_INIT_DEBUG_FROM_ENV(lsblk, LSBLK_DEBUG_, 0, LSBLK_DEBUG);
+}
+
+/*
+ * exclude/include devices filter based on major device numbers
+ */
+static int excludes[256];
+static size_t nexcludes;
+
+static int includes[256];
+static size_t nincludes;
+
+static int is_maj_excluded(int maj)
+{
+	size_t i;
+
+	assert(ARRAY_SIZE(excludes) > nexcludes);
+
+	if (!nexcludes)
+		return 0;	/* filter not enabled, device not excluded */
+
+	for (i = 0; i < nexcludes; i++) {
+		if (excludes[i] == maj) {
+			DBG(FILTER, ul_debug("exclude: maj=%d", maj));
+			return 1;
+		}
+	}
+	return 0;
+}
+
+static int is_maj_included(int maj)
+{
+	size_t i;
+
+	assert(ARRAY_SIZE(includes) > nincludes);
+
+	if (!nincludes)
+		return 1;	/* filter not enabled, device is included */
+
+	for (i = 0; i < nincludes; i++) {
+		if (includes[i] == maj) {
+			DBG(FILTER, ul_debug("include: maj=%d", maj));
+			return 1;
+		}
+	}
+	return 0;
+}
+
+/* Converts column sequential number to column ID (COL_*) */
+static int get_column_id(int num)
+{
+	assert(num >= 0);
+	assert((size_t) num < ncolumns);
+	assert(columns[num] < (int) ARRAY_SIZE(infos));
+	return columns[num];
+}
+
+/* Returns column description for the column sequential number */
+static struct colinfo *get_column_info(int num)
+{
+	return &infos[ get_column_id(num) ];
+}
+
+/* Converts column name (as defined in the infos[] to the column ID */
+static int column_name_to_id(const char *name, size_t namesz)
+{
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(infos); i++) {
+		const char *cn = infos[i].name;
+
+		if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
+			return i;
+	}
+	warnx(_("unknown column: %s"), name);
+	return -1;
+}
+
+/* Converts column ID (COL_*) to column sequential number */
+static int column_id_to_number(int id)
+{
+	size_t i;
+
+	for (i = 0; i < ncolumns; i++)
+		if (columns[i] == id)
+			return i;
+	return -1;
+}
+
+/* Checks for DM prefix in the device name */
+static int is_dm(const char *name)
+{
+	return strncmp(name, "dm-", 3) ? 0 : 1;
+}
+
+/* Returns full pat to the device node (TODO: what about sysfs_blkdev_get_path()) */
+static char *get_device_path(struct lsblk_device *dev)
+{
+	char path[PATH_MAX];
+
+	assert(dev);
+	assert(dev->name);
+
+	if (is_dm(dev->name))
+		return __canonicalize_dm_name(lsblk->sysroot, dev->name);
+
+	snprintf(path, sizeof(path), "/dev/%s", dev->name);
+	sysfs_devname_sys_to_dev(path);
+	return xstrdup(path);
+}
+
+static int is_readonly_device(struct lsblk_device *dev)
+{
+	int fd, ro = 0;
+
+	if (ul_path_scanf(dev->sysfs, "ro", "%d", &ro) == 1)
+		return ro;
+
+	/* fallback if "ro" attribute does not exist */
+	fd = open(dev->filename, O_RDONLY);
+	if (fd != -1) {
+		if (ioctl(fd, BLKROGET, &ro) != 0)
+			ro = 0;
+		close(fd);
+	}
+	return ro;
+}
+
+static char *get_scheduler(struct lsblk_device *dev)
+{
+	char buf[128];
+	char *p, *res = NULL;
+
+	if (ul_path_read_buffer(dev->sysfs, buf, sizeof(buf), "queue/scheduler") == 0)
+		return NULL;
+	p = strchr(buf, '[');
+	if (p) {
+		res = p + 1;
+		p = strchr(res, ']');
+		if (p) {
+			*p = '\0';
+			res = xstrdup(res);
+		} else
+			res = NULL;
+	}
+	return res;
+}
+
+static char *get_type(struct lsblk_device *dev)
+{
+	char *res = NULL, *p;
+
+	if (device_is_partition(dev))
+		return xstrdup("part");
+
+	if (is_dm(dev->name)) {
+		char *dm_uuid = NULL;
+
+		/* The DM_UUID prefix should be set to subsystem owning
+		 * the device - LVM, CRYPT, DMRAID, MPATH, PART */
+		if (ul_path_read_string(dev->sysfs, &dm_uuid, "dm/uuid") > 0
+		    && dm_uuid) {
+			char *tmp = dm_uuid;
+			char *dm_uuid_prefix = strsep(&tmp, "-");
+
+			if (dm_uuid_prefix) {
+				/* kpartx hack to remove partition number */
+				if (strncasecmp(dm_uuid_prefix, "part", 4) == 0)
+					dm_uuid_prefix[4] = '\0';
+
+				res = xstrdup(dm_uuid_prefix);
+			}
+		}
+
+		free(dm_uuid);
+		if (!res)
+			/* No UUID or no prefix - just mark it as DM device */
+			res = xstrdup("dm");
+
+	} else if (!strncmp(dev->name, "loop", 4)) {
+		res = xstrdup("loop");
+
+	} else if (!strncmp(dev->name, "md", 2)) {
+		char *md_level = NULL;
+
+		ul_path_read_string(dev->sysfs, &md_level, "md/level");
+		res = md_level ? md_level : xstrdup("md");
+
+	} else {
+		const char *type = NULL;
+		int x = 0;
+
+		if (ul_path_read_s32(dev->sysfs, &x, "device/type") == 0)
+			type = blkdev_scsi_type_to_name(x);
+		if (!type)
+			type = "disk";
+		res = xstrdup(type);
+	}
+
+	for (p = res; p && *p; p++)
+		*p = tolower((unsigned char) *p);
+	return res;
+}
+
+/* Thanks to lsscsi code for idea of detection logic used here */
+static char *get_transport(struct lsblk_device *dev)
+{
+	struct path_cxt *sysfs = dev->sysfs;
+	char *attr = NULL;
+	const char *trans = NULL;
+
+
+	/* SCSI - Serial Peripheral Interface */
+	if (sysfs_blkdev_scsi_host_is(sysfs, "spi"))
+		trans = "spi";
+
+	/* FC/FCoE - Fibre Channel / Fibre Channel over Ethernet */
+	else if (sysfs_blkdev_scsi_host_is(sysfs, "fc")) {
+		attr = sysfs_blkdev_scsi_host_strdup_attribute(sysfs, "fc", "symbolic_name");
+		if (!attr)
+			return NULL;
+		trans = strstr(attr, " over ") ? "fcoe" : "fc";
+		free(attr);
+	}
+
+	/* SAS - Serial Attached SCSI */
+	else if (sysfs_blkdev_scsi_host_is(sysfs, "sas") ||
+		 sysfs_blkdev_scsi_has_attribute(sysfs, "sas_device"))
+		trans = "sas";
+
+
+	/* SBP - Serial Bus Protocol (FireWire) */
+	else if (sysfs_blkdev_scsi_has_attribute(sysfs, "ieee1394_id"))
+		trans = "sbp";
+
+	/* iSCSI */
+	else if (sysfs_blkdev_scsi_host_is(sysfs, "iscsi"))
+		trans ="iscsi";
+
+	/* USB - Universal Serial Bus */
+	else if (sysfs_blkdev_scsi_path_contains(sysfs, "usb"))
+		trans = "usb";
+
+	/* ATA, SATA */
+	else if (sysfs_blkdev_scsi_host_is(sysfs, "scsi")) {
+		attr = sysfs_blkdev_scsi_host_strdup_attribute(sysfs, "scsi", "proc_name");
+		if (!attr)
+			return NULL;
+		if (!strncmp(attr, "ahci", 4) || !strncmp(attr, "sata", 4))
+			trans = "sata";
+		else if (strstr(attr, "ata"))
+			trans = "ata";
+		free(attr);
+
+	} else if (strncmp(dev->name, "nvme", 4) == 0)
+		trans = "nvme";
+
+	return trans ? xstrdup(trans) : NULL;
+}
+
+static char *get_subsystems(struct lsblk_device *dev)
+{
+	char path[PATH_MAX];
+	char *sub, *chain, *res = NULL;
+	size_t len = 0, last = 0;
+
+	chain = sysfs_blkdev_get_devchain(dev->sysfs, path, sizeof(path));
+	if (!chain)
+		return NULL;
+
+	while (sysfs_blkdev_next_subsystem(dev->sysfs, chain, &sub) == 0) {
+		size_t sz;
+
+		/* don't create "block:scsi:scsi", but "block:scsi" */
+		if (len && strcmp(res + last, sub) == 0) {
+			free(sub);
+			continue;
+		}
+
+		sz = strlen(sub);
+		res = xrealloc(res, len + sz + 2);
+		if (len)
+			res[len++] = ':';
+
+		memcpy(res + len, sub, sz + 1);
+		last = len;
+		len += sz;
+		free(sub);
+	}
+
+	return res;
+}
+
+
+#define is_parsable(_l)	(scols_table_is_raw((_l)->table) || \
+			 scols_table_is_export((_l)->table) || \
+			 scols_table_is_json((_l)->table))
+
+static char *mk_name(const char *name)
+{
+	char *p;
+	if (!name)
+		return NULL;
+	if (lsblk->paths)
+		xasprintf(&p, "/dev/%s", name);
+	else
+		p = xstrdup(name);
+	if (p)
+		sysfs_devname_sys_to_dev(p);
+	return p;
+}
+
+static char *mk_dm_name(const char *name)
+{
+	char *p;
+	if (!name)
+		return NULL;
+	if (lsblk->paths)
+		xasprintf(&p, "/dev/mapper/%s", name);
+	else
+		p = xstrdup(name);
+	return p;
+}
+
+/* stores data to scols cell userdata (invisible and independent on output)
+ * to make the original values accessible for sort functions
+ */
+static void set_sortdata_u64(struct libscols_line *ln, int col, uint64_t x)
+{
+	struct libscols_cell *ce = scols_line_get_cell(ln, col);
+	uint64_t *data;
+
+	if (!ce)
+		return;
+	data = xmalloc(sizeof(uint64_t));
+	*data = x;
+	scols_cell_set_userdata(ce, data);
+}
+
+/* do not modify *data on any error */
+static void str2u64(const char *str, uint64_t *data)
+{
+	uintmax_t num;
+	char *end = NULL;
+
+	errno = 0;
+	if (str == NULL || *str == '\0')
+		return;
+	num = strtoumax(str, &end, 10);
+
+	if (errno || str == end || (end && *end))
+		return;
+	*data = num;
+}
+
+static void unref_sortdata(struct libscols_table *tb)
+{
+	struct libscols_iter *itr;
+	struct libscols_line *ln;
+
+	if (!tb || !lsblk->sort_col)
+		return;
+	itr = scols_new_iter(SCOLS_ITER_FORWARD);
+	if (!itr)
+		return;
+	while (scols_table_next_line(tb, itr, &ln) == 0) {
+		struct libscols_cell *ce = scols_line_get_column_cell(ln,
+								lsblk->sort_col);
+		void *data = scols_cell_get_userdata(ce);
+		free(data);
+	}
+
+	scols_free_iter(itr);
+}
+
+static char *get_vfs_attribute(struct lsblk_device *dev, int id)
+{
+	char *sizestr;
+	uint64_t vfs_attr = 0;
+	char *mnt;
+
+	if (!dev->fsstat.f_blocks) {
+		mnt = lsblk_device_get_mountpoint(dev);
+		if (!mnt || dev->is_swap)
+			return NULL;
+		if (statvfs(mnt, &dev->fsstat) != 0)
+			return NULL;
+	}
+
+	switch(id) {
+	case COL_FSSIZE:
+		vfs_attr = dev->fsstat.f_frsize * dev->fsstat.f_blocks;
+		break;
+	case COL_FSAVAIL:
+		vfs_attr = dev->fsstat.f_frsize * dev->fsstat.f_bavail;
+		break;
+	case COL_FSUSED:
+		vfs_attr = dev->fsstat.f_frsize * (dev->fsstat.f_blocks - dev->fsstat.f_bfree);
+		break;
+	case COL_FSUSEPERC:
+		if (dev->fsstat.f_blocks == 0)
+			return xstrdup("-");
+
+		xasprintf(&sizestr, "%.0f%%",
+				(double)(dev->fsstat.f_blocks - dev->fsstat.f_bfree) /
+				dev->fsstat.f_blocks * 100);
+		return sizestr;
+	}
+
+	if (!vfs_attr)
+		sizestr = xstrdup("0");
+	else if (lsblk->bytes)
+		xasprintf(&sizestr, "%ju", vfs_attr);
+	else
+		sizestr = size_to_human_string(SIZE_SUFFIX_1LETTER, vfs_attr);
+
+	return sizestr;
+}
+
+static struct stat *device_get_stat(struct lsblk_device *dev)
+{
+	if (!dev->st.st_rdev
+	    && stat(dev->filename, &dev->st) != 0)
+		return NULL;
+
+	return &dev->st;
+}
+
+static int is_removable_device(struct lsblk_device *dev, struct lsblk_device *parent)
+{
+	struct path_cxt *pc;
+
+	if (dev->removable != -1)
+		goto done;
+	if (ul_path_scanf(dev->sysfs, "removable", "%d", &dev->removable) == 1)
+		goto done;
+
+	if (parent) {
+		pc = sysfs_blkdev_get_parent(dev->sysfs);
+		if (!pc)
+			goto done;
+
+		/* dev is partition and parent is whole-disk  */
+		if (pc == parent->sysfs)
+			dev->removable = is_removable_device(parent, NULL);
+
+		/* parent is something else, use sysfs parent */
+		else if (ul_path_scanf(pc, "removable", "%d", &dev->removable) != 1)
+			dev->removable = 0;
+	}
+done:
+	if (dev->removable == -1)
+		dev->removable = 0;
+	return dev->removable;
+}
+
+static uint64_t device_get_discard_granularity(struct lsblk_device *dev)
+{
+	if (dev->discard_granularity == (uint64_t) -1
+	    && ul_path_read_u64(dev->sysfs, &dev->discard_granularity,
+			        "queue/discard_granularity") != 0)
+		dev->discard_granularity = 0;
+
+	return dev->discard_granularity;
+}
+
+/*
+ * Generates data (string) for column specified by column ID for specified device. If sortdata
+ * is not NULL then returns number usable to sort the column if the data are available for the
+ * column.
+ */
+static char *device_get_data(
+		struct lsblk_device *dev,		/* device */
+		struct lsblk_device *parent,		/* device parent as defined in the tree */
+		int id,					/* column ID (COL_*) */
+		uint64_t *sortdata)			/* returns sort data as number */
+{
+	struct lsblk_devprop *prop = NULL;
+	char *str = NULL;
+
+	switch(id) {
+	case COL_NAME:
+		str = dev->dm_name ? mk_dm_name(dev->dm_name) :	mk_name(dev->name);
+		break;
+	case COL_KNAME:
+		str = mk_name(dev->name);
+		break;
+	case COL_PKNAME:
+		if (parent)
+			str = mk_name(parent->name);
+		break;
+	case COL_PATH:
+		if (dev->filename)
+			str = xstrdup(dev->filename);
+		break;
+	case COL_OWNER:
+		if (lsblk->sysroot)
+			prop = lsblk_device_get_properties(dev);
+		if (prop && prop->owner) {
+			str = xstrdup(prop->owner);
+		} else {
+			struct stat *st = device_get_stat(dev);
+			struct passwd *pw = st ? getpwuid(st->st_uid) : NULL;
+			if (pw)
+				str = xstrdup(pw->pw_name);
+		}
+		break;
+	case COL_GROUP:
+		if (lsblk->sysroot)
+			prop = lsblk_device_get_properties(dev);
+		if (prop && prop->group) {
+			str = xstrdup(prop->group);
+		} else {
+			struct stat *st = device_get_stat(dev);
+			struct group *gr = st ? getgrgid(st->st_gid) : NULL;
+			if (gr)
+				str = xstrdup(gr->gr_name);
+		}
+		break;
+	case COL_MODE:
+		if (lsblk->sysroot)
+			prop = lsblk_device_get_properties(dev);
+		if (prop && prop->mode) {
+			str = xstrdup(prop->mode);
+		} else {
+			struct stat *st = device_get_stat(dev);
+			char md[11] = { '\0' };
+
+			if (st)
+				str = xstrdup(xstrmode(st->st_mode, md));
+		}
+		break;
+	case COL_MAJMIN:
+		if (is_parsable(lsblk))
+			xasprintf(&str, "%u:%u", dev->maj, dev->min);
+		else
+			xasprintf(&str, "%3u:%-3u", dev->maj, dev->min);
+		if (sortdata)
+			*sortdata = makedev(dev->maj, dev->min);
+		break;
+	case COL_FSTYPE:
+		prop = lsblk_device_get_properties(dev);
+		if (prop && prop->fstype)
+			str = xstrdup(prop->fstype);
+		break;
+	case COL_FSSIZE:
+	case COL_FSAVAIL:
+	case COL_FSUSED:
+	case COL_FSUSEPERC:
+		str = get_vfs_attribute(dev, id);
+		break;
+	case COL_FSVERSION:
+		prop = lsblk_device_get_properties(dev);
+		if (prop && prop->fsversion)
+			str = xstrdup(prop->fsversion);
+		break;
+	case COL_TARGET:
+	{
+		char *s = lsblk_device_get_mountpoint(dev);
+		if (s)
+			str = xstrdup(s);
+		else
+			str = NULL;
+		break;
+	}
+	case COL_LABEL:
+		prop = lsblk_device_get_properties(dev);
+		if (prop && prop->label)
+			str = xstrdup(prop->label);
+		break;
+	case COL_UUID:
+		prop = lsblk_device_get_properties(dev);
+		if (prop && prop->uuid)
+			str = xstrdup(prop->uuid);
+		break;
+	case COL_PTUUID:
+		prop = lsblk_device_get_properties(dev);
+		if (prop && prop->ptuuid)
+			str = xstrdup(prop->ptuuid);
+		break;
+	case COL_PTTYPE:
+		prop = lsblk_device_get_properties(dev);
+		if (prop && prop->pttype)
+			str = xstrdup(prop->pttype);
+		break;
+	case COL_PARTTYPE:
+		prop = lsblk_device_get_properties(dev);
+		if (prop && prop->parttype)
+			str = xstrdup(prop->parttype);
+		break;
+	case COL_PARTTYPENAME:
+		prop = lsblk_device_get_properties(dev);
+		if (prop && prop->parttype && prop->pttype) {
+			const char *x = lsblk_parttype_code_to_string(
+						prop->parttype, prop->pttype);
+			if (x)
+				str = xstrdup(x);
+		}
+		break;
+	case COL_PARTLABEL:
+		prop = lsblk_device_get_properties(dev);
+		if (prop && prop->partlabel)
+			str = xstrdup(prop->partlabel);
+		break;
+	case COL_PARTUUID:
+		prop = lsblk_device_get_properties(dev);
+		if (prop && prop->partuuid)
+			str = xstrdup(prop->partuuid);
+		break;
+	case COL_PARTFLAGS:
+		prop = lsblk_device_get_properties(dev);
+		if (prop && prop->partflags)
+			str = xstrdup(prop->partflags);
+		break;
+	case COL_WWN:
+		prop = lsblk_device_get_properties(dev);
+		if (prop && prop->wwn)
+			str = xstrdup(prop->wwn);
+		break;
+	case COL_RA:
+		ul_path_read_string(dev->sysfs, &str, "queue/read_ahead_kb");
+		if (sortdata)
+			str2u64(str, sortdata);
+		break;
+	case COL_RO:
+		str = xstrdup(is_readonly_device(dev) ? "1" : "0");
+		break;
+	case COL_RM:
+		str = xstrdup(is_removable_device(dev, parent) ? "1" : "0");
+		break;
+	case COL_HOTPLUG:
+		str = sysfs_blkdev_is_hotpluggable(dev->sysfs) ? xstrdup("1") : xstrdup("0");
+		break;
+	case COL_ROTA:
+		ul_path_read_string(dev->sysfs, &str, "queue/rotational");
+		break;
+	case COL_RAND:
+		ul_path_read_string(dev->sysfs, &str, "queue/add_random");
+		break;
+	case COL_MODEL:
+		if (!device_is_partition(dev) && dev->nslaves == 0) {
+			prop = lsblk_device_get_properties(dev);
+			if (prop && prop->model)
+				str = xstrdup(prop->model);
+			else
+				ul_path_read_string(dev->sysfs, &str, "device/model");
+		}
+		break;
+	case COL_SERIAL:
+		if (!device_is_partition(dev) && dev->nslaves == 0) {
+			prop = lsblk_device_get_properties(dev);
+			if (prop && prop->serial)
+				str = xstrdup(prop->serial);
+			else
+				ul_path_read_string(dev->sysfs, &str, "device/serial");
+		}
+		break;
+	case COL_REV:
+		if (!device_is_partition(dev) && dev->nslaves == 0)
+			ul_path_read_string(dev->sysfs, &str, "device/rev");
+		break;
+	case COL_VENDOR:
+		if (!device_is_partition(dev) && dev->nslaves == 0)
+			ul_path_read_string(dev->sysfs, &str, "device/vendor");
+		break;
+	case COL_SIZE:
+		if (lsblk->bytes)
+			xasprintf(&str, "%ju", dev->size);
+		else
+			str = size_to_human_string(SIZE_SUFFIX_1LETTER, dev->size);
+		if (sortdata)
+			*sortdata = dev->size;
+		break;
+	case COL_STATE:
+		if (!device_is_partition(dev) && !dev->dm_name)
+			ul_path_read_string(dev->sysfs, &str, "device/state");
+		else if (dev->dm_name) {
+			int x = 0;
+			if (ul_path_read_s32(dev->sysfs, &x, "dm/suspended") == 0)
+				str = xstrdup(x ? "suspended" : "running");
+		}
+		break;
+	case COL_ALIOFF:
+		ul_path_read_string(dev->sysfs, &str, "alignment_offset");
+		if (sortdata)
+			str2u64(str, sortdata);
+		break;
+	case COL_MINIO:
+		ul_path_read_string(dev->sysfs, &str, "queue/minimum_io_size");
+		if (sortdata)
+			str2u64(str, sortdata);
+		break;
+	case COL_OPTIO:
+		ul_path_read_string(dev->sysfs, &str, "queue/optimal_io_size");
+		if (sortdata)
+			str2u64(str, sortdata);
+		break;
+	case COL_PHYSEC:
+		ul_path_read_string(dev->sysfs, &str, "queue/physical_block_size");
+		if (sortdata)
+			str2u64(str, sortdata);
+		break;
+	case COL_LOGSEC:
+		ul_path_read_string(dev->sysfs, &str, "queue/logical_block_size");
+		if (sortdata)
+			str2u64(str, sortdata);
+		break;
+	case COL_SCHED:
+		str = get_scheduler(dev);
+		break;
+	case COL_RQ_SIZE:
+		ul_path_read_string(dev->sysfs, &str, "queue/nr_requests");
+		if (sortdata)
+			str2u64(str, sortdata);
+		break;
+	case COL_TYPE:
+		str = get_type(dev);
+		break;
+	case COL_HCTL:
+	{
+		int h, c, t, l;
+		if (sysfs_blkdev_scsi_get_hctl(dev->sysfs, &h, &c, &t, &l) == 0)
+			xasprintf(&str, "%d:%d:%d:%d", h, c, t, l);
+		break;
+	}
+	case COL_TRANSPORT:
+		str = get_transport(dev);
+		break;
+	case COL_SUBSYS:
+		str = get_subsystems(dev);
+		break;
+	case COL_DALIGN:
+		if (device_get_discard_granularity(dev) > 0)
+			ul_path_read_string(dev->sysfs, &str, "discard_alignment");
+		if (!str)
+			str = xstrdup("0");
+		if (sortdata)
+			str2u64(str, sortdata);
+		break;
+	case COL_DGRAN:
+		if (lsblk->bytes) {
+			ul_path_read_string(dev->sysfs, &str, "queue/discard_granularity");
+			if (sortdata)
+				str2u64(str, sortdata);
+		} else {
+			uint64_t x = device_get_discard_granularity(dev);
+			str = size_to_human_string(SIZE_SUFFIX_1LETTER, x);
+			if (sortdata)
+				*sortdata = x;
+		}
+		break;
+	case COL_DMAX:
+		if (lsblk->bytes) {
+			ul_path_read_string(dev->sysfs, &str, "queue/discard_max_bytes");
+			if (sortdata)
+				str2u64(str, sortdata);
+		} else {
+			uint64_t x;
+			if (ul_path_read_u64(dev->sysfs, &x, "queue/discard_max_bytes") == 0) {
+				str = size_to_human_string(SIZE_SUFFIX_1LETTER, x);
+				if (sortdata)
+					*sortdata = x;
+			}
+		}
+		break;
+	case COL_DZERO:
+		if (device_get_discard_granularity(dev) > 0)
+			ul_path_read_string(dev->sysfs, &str, "queue/discard_zeroes_data");
+		if (!str)
+			str = xstrdup("0");
+		break;
+	case COL_WSAME:
+		if (lsblk->bytes) {
+			ul_path_read_string(dev->sysfs, &str, "queue/write_same_max_bytes");
+			if (sortdata)
+				str2u64(str, sortdata);
+		} else {
+			uint64_t x;
+
+			if (ul_path_read_u64(dev->sysfs, &x, "queue/write_same_max_bytes") == 0) {
+				str = size_to_human_string(SIZE_SUFFIX_1LETTER, x);
+				if (sortdata)
+					*sortdata = x;
+			}
+		}
+		if (!str)
+			str = xstrdup("0");
+		break;
+	case COL_ZONED:
+		ul_path_read_string(dev->sysfs, &str, "queue/zoned");
+		break;
+	case COL_DAX:
+		ul_path_read_string(dev->sysfs, &str, "queue/dax");
+		break;
+	};
+
+	return str;
+}
+
+/*
+ * Adds data for all wanted columns about the device to the smartcols table
+ */
+static void device_to_scols(
+			struct lsblk_device *dev,
+			struct lsblk_device *parent,
+			struct libscols_table *tab,
+			struct libscols_line *parent_line)
+{
+	size_t i;
+	struct libscols_line *ln;
+	struct lsblk_iter itr;
+	struct lsblk_device *child = NULL;
+	int link_group = 0;
+
+
+	DBG(DEV, ul_debugobj(dev, "add '%s' to scols", dev->name));
+	ON_DBG(DEV, if (ul_path_isopen_dirfd(dev->sysfs)) ul_debugobj(dev, " %s ---> is open!", dev->name));
+
+	if (!parent && dev->wholedisk)
+		parent = dev->wholedisk;
+
+	/* Do not print device more than once on --list if tree order is not requested */
+	if (!(lsblk->flags & LSBLK_TREE) && !lsblk->force_tree_order && dev->is_printed)
+		return;
+
+	if (lsblk->merge && list_count_entries(&dev->parents) > 1) {
+		if (!lsblk_device_is_last_parent(dev, parent))
+			return;
+		link_group = 1;
+	}
+
+	ln = scols_table_new_line(tab, link_group ? NULL : parent_line);
+	if (!ln)
+		err(EXIT_FAILURE, _("failed to allocate output line"));
+
+	dev->is_printed = 1;
+
+	if (link_group) {
+		struct lsblk_device *p;
+		struct libscols_line *gr = parent_line;
+
+		/* Merge all my parents to the one group */
+		DBG(DEV, ul_debugobj(dev, " grouping parents [--merge]"));
+		lsblk_reset_iter(&itr, LSBLK_ITER_FORWARD);
+		while (lsblk_device_next_parent(dev, &itr, &p) == 0) {
+			if (!p->scols_line) {
+				DBG(DEV, ul_debugobj(dev, " *** ignore '%s' no scols line yet", p->name));
+				continue;
+			}
+			DBG(DEV, ul_debugobj(dev, " group '%s'", p->name));
+			scols_table_group_lines(tab, p->scols_line, gr, 0);
+		}
+
+		/* Link the group -- this makes group->child connection */
+		DBG(DEV, ul_debugobj(dev, " linking the group [--merge]"));
+		scols_line_link_group(ln, gr, 0);
+	}
+
+	/* read column specific data and set it to smartcols table line */
+	for (i = 0; i < ncolumns; i++) {
+		char *data;
+		int id = get_column_id(i);
+
+		if (lsblk->sort_id != id)
+			data = device_get_data(dev, parent, id, NULL);
+		else {
+			uint64_t sortdata = (uint64_t) -1;
+
+			data = device_get_data(dev, parent, id, &sortdata);
+			if (data && sortdata != (uint64_t) -1)
+				set_sortdata_u64(ln, i, sortdata);
+		}
+		DBG(DEV, ul_debugobj(dev, " refer data[%zu]=\"%s\"", i, data));
+		if (data && scols_line_refer_data(ln, i, data))
+			err(EXIT_FAILURE, _("failed to add output data"));
+	}
+
+	dev->scols_line = ln;
+
+	if (dev->npartitions == 0)
+		/* For partitions we often read from parental whole-disk sysfs,
+		 * otherwise we can close */
+		ul_path_close_dirfd(dev->sysfs);
+
+	lsblk_reset_iter(&itr, LSBLK_ITER_FORWARD);
+	while (lsblk_device_next_child(dev, &itr, &child) == 0) {
+		DBG(DEV, ul_debugobj(dev, "%s -> continue to child", dev->name));
+		device_to_scols(child, dev, tab, ln);
+		DBG(DEV, ul_debugobj(dev, "%s <- child done", dev->name));
+	}
+
+	/* Let's be careful with number of open files */
+	ul_path_close_dirfd(dev->sysfs);
+}
+
+/*
+ * Walks on tree and adds one line for each device to the smartcols table
+ */
+static void devtree_to_scols(struct lsblk_devtree *tr, struct libscols_table *tab)
+{
+	struct lsblk_iter itr;
+	struct lsblk_device *dev = NULL;
+
+	lsblk_reset_iter(&itr, LSBLK_ITER_FORWARD);
+
+	while (lsblk_devtree_next_root(tr, &itr, &dev) == 0)
+		device_to_scols(dev, NULL, tab, NULL);
+}
+
+/*
+ * Reads very basic information about the device from sysfs into the device struct
+ */
+static int initialize_device(struct lsblk_device *dev,
+		    struct lsblk_device *wholedisk,
+		    const char *name)
+{
+	dev_t devno;
+
+	DBG(DEV, ul_debugobj(dev, "initialize %s [wholedisk=%p %s]",
+			name, wholedisk, wholedisk ? wholedisk->name : ""));
+
+	if (sysfs_devname_is_hidden(lsblk->sysroot, name)) {
+		DBG(DEV, ul_debugobj(dev, "%s: hidden, ignore", name));
+		return -1;
+	}
+
+	dev->name = xstrdup(name);
+
+	if (wholedisk) {
+		dev->wholedisk = wholedisk;
+		lsblk_ref_device(wholedisk);
+	}
+
+	dev->filename = get_device_path(dev);
+	if (!dev->filename) {
+		DBG(DEV, ul_debugobj(dev, "%s: failed to get device path", dev->name));
+		return -1;
+	}
+	DBG(DEV, ul_debugobj(dev, "%s: filename=%s", dev->name, dev->filename));
+
+	devno = __sysfs_devname_to_devno(lsblk->sysroot, dev->name, wholedisk ? wholedisk->name : NULL);
+	if (!devno) {
+		DBG(DEV, ul_debugobj(dev, "%s: unknown device name", dev->name));
+		return -1;
+	}
+
+	dev->sysfs = ul_new_sysfs_path(devno, wholedisk ? wholedisk->sysfs : NULL, lsblk->sysroot);
+	if (!dev->sysfs) {
+		DBG(DEV, ul_debugobj(dev, "%s: failed to initialize sysfs handler", dev->name));
+		return -1;
+	}
+
+	dev->maj = major(devno);
+	dev->min = minor(devno);
+	dev->size = 0;
+
+	if (ul_path_read_u64(dev->sysfs, &dev->size, "size") == 0)	/* in sectors */
+		dev->size <<= 9;					/* in bytes */
+
+	/* Ignore devices of zero size */
+	if (!lsblk->all_devices && dev->size == 0) {
+		DBG(DEV, ul_debugobj(dev, "zero size device -- ignore"));
+		return -1;
+	}
+	if (is_dm(dev->name)) {
+		ul_path_read_string(dev->sysfs, &dev->dm_name, "dm/name");
+		if (!dev->dm_name) {
+			DBG(DEV, ul_debugobj(dev, "%s: failed to get dm name", dev->name));
+			return -1;
+		}
+	}
+
+	dev->npartitions = sysfs_blkdev_count_partitions(dev->sysfs, dev->name);
+	dev->nholders = ul_path_count_dirents(dev->sysfs, "holders");
+	dev->nslaves = ul_path_count_dirents(dev->sysfs, "slaves");
+
+	DBG(DEV, ul_debugobj(dev, "%s: npartitions=%d, nholders=%d, nslaves=%d",
+			dev->name, dev->npartitions, dev->nholders, dev->nslaves));
+
+	/* ignore non-SCSI devices */
+	if (lsblk->scsi && sysfs_blkdev_scsi_get_hctl(dev->sysfs, NULL, NULL, NULL, NULL)) {
+		DBG(DEV, ul_debugobj(dev, "non-scsi device -- ignore"));
+		return -1;
+	}
+
+	DBG(DEV, ul_debugobj(dev, "%s: context successfully initialized", dev->name));
+	return 0;
+}
+
+static struct lsblk_device *devtree_get_device_or_new(struct lsblk_devtree *tr,
+					       struct lsblk_device *disk,
+					       const char *name)
+{
+	struct lsblk_device *dev = lsblk_devtree_get_device(tr, name);
+
+	if (!dev) {
+		dev = lsblk_new_device();
+		if (!dev)
+			err(EXIT_FAILURE, _("failed to allocate device"));
+
+		if (initialize_device(dev, disk, name) != 0) {
+			lsblk_unref_device(dev);
+			return NULL;
+		}
+		lsblk_devtree_add_device(tr, dev);
+		lsblk_unref_device(dev);		/* keep it referenced by devtree only */
+	} else
+		DBG(DEV, ul_debugobj(dev, "%s: already processed", name));
+
+	return dev;
+}
+
+static int process_dependencies(
+			struct lsblk_devtree *tr,
+			struct lsblk_device *dev,
+			int do_partitions);
+
+/*
+ * Read devices from whole-disk device into tree
+ */
+static int process_partitions(struct lsblk_devtree *tr, struct lsblk_device *disk)
+{
+	DIR *dir;
+	struct dirent *d;
+
+	assert(disk);
+
+	/*
+	 * Do not process further if there are no partitions for
+	 * this device or the device itself is a partition.
+	 */
+	if (!disk->npartitions || device_is_partition(disk))
+		return -EINVAL;
+
+	DBG(DEV, ul_debugobj(disk, "%s: probe whole-disk for partitions", disk->name));
+
+	dir = ul_path_opendir(disk->sysfs, NULL);
+	if (!dir)
+		err(EXIT_FAILURE, _("failed to open device directory in sysfs"));
+
+	while ((d = xreaddir(dir))) {
+		struct lsblk_device *part;
+
+		if (!(sysfs_blkdev_is_partition_dirent(dir, d, disk->name)))
+			continue;
+
+		DBG(DEV, ul_debugobj(disk, "  checking %s", d->d_name));
+
+		part = devtree_get_device_or_new(tr, disk, d->d_name);
+		if (!part)
+			continue;
+
+		if (lsblk_device_new_dependence(disk, part) == 0)
+			process_dependencies(tr, part, 0);
+
+		ul_path_close_dirfd(part->sysfs);
+	}
+
+	/* For partitions we need parental (whole-disk) sysfs directory pretty
+	 * often, so close it now when all is done */
+	ul_path_close_dirfd(disk->sysfs);
+
+	DBG(DEV, ul_debugobj(disk, "probe whole-disk for partitions -- done"));
+	closedir(dir);
+	return 0;
+}
+
+static char *get_wholedisk_from_partition_dirent(DIR *dir, struct dirent *d, char *buf, size_t bufsz)
+{
+	char *p;
+	int len;
+
+	if ((len = readlinkat(dirfd(dir), d->d_name, buf, bufsz - 1)) < 0)
+		return 0;
+
+	buf[len] = '\0';
+
+	/* The path ends with ".../<device>/<partition>" */
+	p = strrchr(buf, '/');
+	if (!p)
+		return NULL;
+	*p = '\0';
+
+	p = strrchr(buf, '/');
+	if (!p)
+		return NULL;
+	p++;
+
+	return p;
+}
+
+/*
+ * Reads slaves/holders and partitions for specified device into device tree
+ */
+static int process_dependencies(
+			struct lsblk_devtree *tr,
+			struct lsblk_device *dev,
+			int do_partitions)
+{
+	DIR *dir;
+	struct dirent *d;
+	const char *depname;
+
+	assert(dev);
+
+	if (lsblk->nodeps)
+		return 0;
+
+	/* read all or specified partition */
+	if (do_partitions && dev->npartitions)
+		process_partitions(tr, dev);
+
+	DBG(DEV, ul_debugobj(dev, "%s: reading dependencies", dev->name));
+
+	if (!(lsblk->inverse ? dev->nslaves : dev->nholders)) {
+		DBG(DEV, ul_debugobj(dev, " ignore (no slaves/holders)"));
+		return 0;
+	}
+
+	depname = lsblk->inverse ? "slaves" : "holders";
+	dir = ul_path_opendir(dev->sysfs, depname);
+	if (!dir) {
+		DBG(DEV, ul_debugobj(dev, " ignore (no slaves/holders directory)"));
+		return 0;
+	}
+	ul_path_close_dirfd(dev->sysfs);
+
+	DBG(DEV, ul_debugobj(dev, " %s: checking for '%s' dependence", dev->name, depname));
+
+	while ((d = xreaddir(dir))) {
+		struct lsblk_device *dep = NULL;
+		struct lsblk_device *disk = NULL;
+
+		/* Is the dependency a partition? */
+		if (sysfs_blkdev_is_partition_dirent(dir, d, NULL)) {
+
+			char buf[PATH_MAX];
+			char *diskname;
+
+			DBG(DEV, ul_debugobj(dev, " %s: dependence is partition", d->d_name));
+
+			diskname = get_wholedisk_from_partition_dirent(dir, d, buf, sizeof(buf));
+			if (diskname)
+				disk = devtree_get_device_or_new(tr, NULL, diskname);
+			if (!disk) {
+				DBG(DEV, ul_debugobj(dev, "  ignore no wholedisk ???"));
+				goto next;
+			}
+
+			dep = devtree_get_device_or_new(tr, disk, d->d_name);
+			if (!dep)
+				goto next;
+
+			if (lsblk_device_new_dependence(dev, dep) == 0)
+				process_dependencies(tr, dep, 1);
+
+			if (lsblk->inverse
+			    && lsblk_device_new_dependence(dep, disk) == 0)
+				process_dependencies(tr, disk, 0);
+		}
+		/* The dependency is a whole device. */
+		else {
+			DBG(DEV, ul_debugobj(dev, " %s: %s: dependence is whole-disk",
+								dev->name, d->d_name));
+
+			dep = devtree_get_device_or_new(tr, NULL, d->d_name);
+			if (!dep)
+				goto next;
+
+			if (lsblk_device_new_dependence(dev, dep) == 0)
+				/* For inverse tree we don't want to show partitions
+				 * if the dependence is on whole-disk */
+				process_dependencies(tr, dep, lsblk->inverse ? 0 : 1);
+		}
+next:
+		if (dep && dep->sysfs)
+			ul_path_close_dirfd(dep->sysfs);
+		if (disk && disk->sysfs)
+			ul_path_close_dirfd(disk->sysfs);
+	}
+	closedir(dir);
+
+	DBG(DEV, ul_debugobj(dev, "%s: checking for '%s' -- done", dev->name, depname));
+	return 0;
+}
+
+/*
+ * Defines the device as root node in the device tree and walks on all dependencies of the device.
+ */
+static int __process_one_device(struct lsblk_devtree *tr, char *devname, dev_t devno)
+{
+	struct lsblk_device *dev = NULL;
+	struct lsblk_device *disk = NULL;
+	char buf[PATH_MAX + 1], *name = NULL, *diskname = NULL;
+	int real_part = 0, rc = -EINVAL;
+
+	if (devno == 0 && devname) {
+		struct stat st;
+
+		DBG(DEV, ul_debug("%s: reading alone device", devname));
+
+		if (stat(devname, &st) || !S_ISBLK(st.st_mode)) {
+			warnx(_("%s: not a block device"), devname);
+			goto leave;
+		}
+		devno = st.st_rdev;
+	} else if (devno) {
+		DBG(DEV, ul_debug("%d:%d: reading alone device", major(devno), minor(devno)));
+	} else {
+		assert(devno || devname);
+		return -EINVAL;
+	}
+
+	/* TODO: sysfs_devno_to_devname() internally initializes path_cxt, it
+	 * would be better to use ul_new_sysfs_path() + sysfs_blkdev_get_name()
+	 * and reuse path_cxt for initialize_device()
+	 */
+	name = sysfs_devno_to_devname(devno, buf, sizeof(buf));
+	if (!name) {
+		if (devname)
+			warn(_("%s: failed to get sysfs name"), devname);
+		goto leave;
+	}
+	name = xstrdup(name);
+
+	if (!strncmp(name, "dm-", 3)) {
+		/* dm mapping is never a real partition! */
+		real_part = 0;
+	} else {
+		dev_t diskno = 0;
+
+		if (blkid_devno_to_wholedisk(devno, buf, sizeof(buf), &diskno)) {
+			warn(_("%s: failed to get whole-disk device number"), name);
+			goto leave;
+		}
+		diskname = buf;
+		real_part = devno != diskno;
+	}
+
+	if (!real_part) {
+		/*
+		 * Device is not a partition.
+		 */
+		DBG(DEV, ul_debug(" non-partition"));
+
+		dev = devtree_get_device_or_new(tr, NULL, name);
+		if (!dev)
+			goto leave;
+
+		lsblk_devtree_add_root(tr, dev);
+		process_dependencies(tr, dev, !lsblk->inverse);
+	} else {
+		/*
+		 * Partition, read sysfs name of the disk device
+		 */
+		DBG(DEV, ul_debug(" partition"));
+
+		disk = devtree_get_device_or_new(tr, NULL, diskname);
+		if (!disk)
+			goto leave;
+
+		dev = devtree_get_device_or_new(tr, disk, name);
+		if (!dev)
+			goto leave;
+
+		lsblk_devtree_add_root(tr, dev);
+		process_dependencies(tr, dev, 1);
+
+		if (lsblk->inverse
+		    && lsblk_device_new_dependence(dev, disk) == 0)
+			process_dependencies(tr, disk, 0);
+		else
+			ul_path_close_dirfd(disk->sysfs);
+	}
+
+	rc = 0;
+leave:
+	if (dev && dev->sysfs)
+		ul_path_close_dirfd(dev->sysfs);
+	if (disk && disk->sysfs)
+		ul_path_close_dirfd(disk->sysfs);
+	free(name);
+	return rc;
+}
+
+static int process_one_device(struct lsblk_devtree *tr, char *devname)
+{
+	assert(devname);
+	return __process_one_device(tr, devname, 0);
+}
+
+/*
+ * The /sys/block contains only root devices, and no partitions. It seems more
+ * simple to scan /sys/dev/block where are all devices without exceptions to get
+ * top-level devices for the reverse tree.
+ */
+static int process_all_devices_inverse(struct lsblk_devtree *tr)
+{
+	DIR *dir;
+	struct dirent *d;
+	struct path_cxt *pc = ul_new_path(_PATH_SYS_DEVBLOCK);
+
+	assert(lsblk->inverse);
+
+	if (!pc)
+		err(EXIT_FAILURE, _("failed to allocate /sys handler"));
+
+	ul_path_set_prefix(pc, lsblk->sysroot);
+	dir = ul_path_opendir(pc, NULL);
+	if (!dir)
+		goto done;
+
+	DBG(DEV, ul_debug("iterate on " _PATH_SYS_DEVBLOCK));
+
+	while ((d = xreaddir(dir))) {
+		dev_t devno;
+		int maj, min;
+
+		DBG(DEV, ul_debug(" %s dentry", d->d_name));
+
+		if (sscanf(d->d_name, "%d:%d", &maj, &min) != 2)
+			continue;
+		devno = makedev(maj, min);
+
+		if (is_maj_excluded(maj) || !is_maj_included(maj))
+			continue;
+		if (ul_path_countf_dirents(pc, "%s/holders", d->d_name) != 0)
+			continue;
+		if (sysfs_devno_count_partitions(devno) != 0)
+			continue;
+		__process_one_device(tr, NULL, devno);
+	}
+
+	closedir(dir);
+done:
+	ul_unref_path(pc);
+	DBG(DEV, ul_debug("iterate on " _PATH_SYS_DEVBLOCK " -- done"));
+	return 0;
+}
+
+/*
+ * Reads root nodes (devices) from /sys/block into devices tree
+ */
+static int process_all_devices(struct lsblk_devtree *tr)
+{
+	DIR *dir;
+	struct dirent *d;
+	struct path_cxt *pc;
+
+	assert(lsblk->inverse == 0);
+
+	pc = ul_new_path(_PATH_SYS_BLOCK);
+	if (!pc)
+		err(EXIT_FAILURE, _("failed to allocate /sys handler"));
+
+	ul_path_set_prefix(pc, lsblk->sysroot);
+	dir = ul_path_opendir(pc, NULL);
+	if (!dir)
+		goto done;
+
+	DBG(DEV, ul_debug("iterate on " _PATH_SYS_BLOCK));
+
+	while ((d = xreaddir(dir))) {
+		struct lsblk_device *dev = NULL;
+
+		DBG(DEV, ul_debug(" %s dentry", d->d_name));
+		dev = devtree_get_device_or_new(tr, NULL, d->d_name);
+		if (!dev)
+			goto next;
+
+		/* remove unwanted devices */
+		if (is_maj_excluded(dev->maj) || !is_maj_included(dev->maj)) {
+			DBG(DEV, ul_debug(" %s: ignore (by filter)", d->d_name));
+			lsblk_devtree_remove_device(tr, dev);
+			dev = NULL;
+			goto next;
+		}
+
+		if (dev->nslaves) {
+			DBG(DEV, ul_debug(" %s: ignore (in-middle)", d->d_name));
+			goto next;
+		}
+
+		lsblk_devtree_add_root(tr, dev);
+		process_dependencies(tr, dev, 1);
+next:
+		/* Let's be careful with number of open files */
+		if (dev && dev->sysfs)
+			ul_path_close_dirfd(dev->sysfs);
+	}
+
+	closedir(dir);
+done:
+	ul_unref_path(pc);
+	DBG(DEV, ul_debug("iterate on " _PATH_SYS_BLOCK " -- done"));
+	return 0;
+}
+
+/*
+ * Parses major numbers as specified on lsblk command line
+ */
+static void parse_excludes(const char *str0)
+{
+	const char *str = str0;
+
+	while (str && *str) {
+		char *end = NULL;
+		unsigned long n;
+
+		errno = 0;
+		n = strtoul(str, &end, 10);
+
+		if (end == str || (end && *end && *end != ','))
+			errx(EXIT_FAILURE, _("failed to parse list '%s'"), str0);
+		if (errno != 0 && (n == ULONG_MAX || n == 0))
+			err(EXIT_FAILURE, _("failed to parse list '%s'"), str0);
+		excludes[nexcludes++] = n;
+
+		if (nexcludes == ARRAY_SIZE(excludes))
+			/* TRANSLATORS: The standard value for %d is 256. */
+			errx(EXIT_FAILURE, _("the list of excluded devices is "
+					"too large (limit is %d devices)"),
+					(int)ARRAY_SIZE(excludes));
+
+		str = end && *end ? end + 1 : NULL;
+	}
+}
+
+/*
+ * Parses major numbers as specified on lsblk command line
+ * (TODO: what about refactor and merge parse_excludes() and parse_includes().)
+ */
+static void parse_includes(const char *str0)
+{
+	const char *str = str0;
+
+	while (str && *str) {
+		char *end = NULL;
+		unsigned long n;
+
+		errno = 0;
+		n = strtoul(str, &end, 10);
+
+		if (end == str || (end && *end && *end != ','))
+			errx(EXIT_FAILURE, _("failed to parse list '%s'"), str0);
+		if (errno != 0 && (n == ULONG_MAX || n == 0))
+			err(EXIT_FAILURE, _("failed to parse list '%s'"), str0);
+		includes[nincludes++] = n;
+
+		if (nincludes == ARRAY_SIZE(includes))
+			/* TRANSLATORS: The standard value for %d is 256. */
+			errx(EXIT_FAILURE, _("the list of included devices is "
+					"too large (limit is %d devices)"),
+					(int)ARRAY_SIZE(includes));
+		str = end && *end ? end + 1 : NULL;
+	}
+}
+
+/*
+ * see set_sortdata_u64() and columns initialization in main()
+ */
+static int cmp_u64_cells(struct libscols_cell *a,
+			 struct libscols_cell *b,
+			 __attribute__((__unused__)) void *data)
+{
+	uint64_t *adata = (uint64_t *) scols_cell_get_userdata(a),
+		 *bdata = (uint64_t *) scols_cell_get_userdata(b);
+
+	if (adata == NULL && bdata == NULL)
+		return 0;
+	if (adata == NULL)
+		return -1;
+	if (bdata == NULL)
+		return 1;
+	return *adata == *bdata ? 0 : *adata >= *bdata ? 1 : -1;
+}
+
+static void device_set_dedupkey(
+			struct lsblk_device *dev,
+			struct lsblk_device *parent,
+			int id)
+{
+	struct lsblk_iter itr;
+	struct lsblk_device *child = NULL;
+
+	dev->dedupkey = device_get_data(dev, parent, id, NULL);
+	if (dev->dedupkey)
+		DBG(DEV, ul_debugobj(dev, "%s: de-duplication key: %s", dev->name, dev->dedupkey));
+
+	if (dev->npartitions == 0)
+		/* For partitions we often read from parental whole-disk sysfs,
+		 * otherwise we can close */
+		ul_path_close_dirfd(dev->sysfs);
+
+	lsblk_reset_iter(&itr, LSBLK_ITER_FORWARD);
+
+	while (lsblk_device_next_child(dev, &itr, &child) == 0)
+		device_set_dedupkey(child, dev, id);
+
+	/* Let's be careful with number of open files */
+	ul_path_close_dirfd(dev->sysfs);
+}
+
+static void devtree_set_dedupkeys(struct lsblk_devtree *tr, int id)
+{
+	struct lsblk_iter itr;
+	struct lsblk_device *dev = NULL;
+
+	lsblk_reset_iter(&itr, LSBLK_ITER_FORWARD);
+
+	while (lsblk_devtree_next_root(tr, &itr, &dev) == 0)
+		device_set_dedupkey(dev, NULL, id);
+}
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+	size_t i;
+
+	fputs(USAGE_HEADER, out);
+	fprintf(out, _(" %s [options] [<device> ...]\n"), program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("List information about block devices.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -D, --discard        print discard capabilities\n"), out);
+	fputs(_(" -E, --dedup <column> de-duplicate output by <column>\n"), out);
+	fputs(_(" -I, --include <list> show only devices with specified major numbers\n"), out);
+	fputs(_(" -J, --json           use JSON output format\n"), out);
+	fputs(_(" -O, --output-all     output all columns\n"), out);
+	fputs(_(" -P, --pairs          use key=\"value\" output format\n"), out);
+	fputs(_(" -S, --scsi           output info about SCSI devices\n"), out);
+	fputs(_(" -T, --tree[=<column>] use tree format output\n"), out);
+	fputs(_(" -a, --all            print all devices\n"), out);
+	fputs(_(" -b, --bytes          print SIZE in bytes rather than in human readable format\n"), out);
+	fputs(_(" -d, --nodeps         don't print slaves or holders\n"), out);
+	fputs(_(" -e, --exclude <list> exclude devices by major number (default: RAM disks)\n"), out);
+	fputs(_(" -f, --fs             output info about filesystems\n"), out);
+	fputs(_(" -i, --ascii          use ascii characters only\n"), out);
+	fputs(_(" -l, --list           use list format output\n"), out);
+	fputs(_(" -M, --merge          group parents of sub-trees (usable for RAIDs, Multi-path)\n"), out);
+	fputs(_(" -m, --perms          output info about permissions\n"), out);
+	fputs(_(" -n, --noheadings     don't print headings\n"), out);
+	fputs(_(" -o, --output <list>  output columns\n"), out);
+	fputs(_(" -p, --paths          print complete device path\n"), out);
+	fputs(_(" -r, --raw            use raw output format\n"), out);
+	fputs(_(" -s, --inverse        inverse dependencies\n"), out);
+	fputs(_(" -t, --topology       output info about topology\n"), out);
+	fputs(_(" -z, --zoned          print zone model\n"), out);
+	fputs(_(" -x, --sort <column>  sort output by <column>\n"), out);
+	fputs(_("     --sysroot <dir>  use specified directory as system root\n"), out);
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(22));
+
+	fprintf(out, USAGE_COLUMNS);
+
+	for (i = 0; i < ARRAY_SIZE(infos); i++)
+		fprintf(out, " %11s  %s\n", infos[i].name, _(infos[i].help));
+
+	printf(USAGE_MAN_TAIL("lsblk(8)"));
+
+	exit(EXIT_SUCCESS);
+}
+
+static void check_sysdevblock(void)
+{
+	if (access(_PATH_SYS_DEVBLOCK, R_OK) != 0)
+		err(EXIT_FAILURE, _("failed to access sysfs directory: %s"),
+		    _PATH_SYS_DEVBLOCK);
+}
+
+int main(int argc, char *argv[])
+{
+	struct lsblk _ls = {
+		.sort_id = -1,
+		.dedup_id = -1,
+		.flags = LSBLK_TREE,
+		.tree_id = COL_NAME
+	};
+	struct lsblk_devtree *tr = NULL;
+	int c, status = EXIT_FAILURE;
+	char *outarg = NULL;
+	size_t i;
+	int force_tree = 0, has_tree_col = 0;
+
+	enum {
+		OPT_SYSROOT = CHAR_MAX + 1
+	};
+
+	static const struct option longopts[] = {
+		{ "all",	no_argument,       NULL, 'a' },
+		{ "bytes",      no_argument,       NULL, 'b' },
+		{ "nodeps",     no_argument,       NULL, 'd' },
+		{ "discard",    no_argument,       NULL, 'D' },
+		{ "dedup",      required_argument, NULL, 'E' },
+		{ "zoned",      no_argument,       NULL, 'z' },
+		{ "help",	no_argument,       NULL, 'h' },
+		{ "json",       no_argument,       NULL, 'J' },
+		{ "output",     required_argument, NULL, 'o' },
+		{ "output-all", no_argument,       NULL, 'O' },
+		{ "merge",      no_argument,       NULL, 'M' },
+		{ "perms",      no_argument,       NULL, 'm' },
+		{ "noheadings",	no_argument,       NULL, 'n' },
+		{ "list",       no_argument,       NULL, 'l' },
+		{ "ascii",	no_argument,       NULL, 'i' },
+		{ "raw",        no_argument,       NULL, 'r' },
+		{ "inverse",	no_argument,       NULL, 's' },
+		{ "fs",         no_argument,       NULL, 'f' },
+		{ "exclude",    required_argument, NULL, 'e' },
+		{ "include",    required_argument, NULL, 'I' },
+		{ "topology",   no_argument,       NULL, 't' },
+		{ "paths",      no_argument,       NULL, 'p' },
+		{ "pairs",      no_argument,       NULL, 'P' },
+		{ "scsi",       no_argument,       NULL, 'S' },
+		{ "sort",	required_argument, NULL, 'x' },
+		{ "sysroot",    required_argument, NULL, OPT_SYSROOT },
+		{ "tree",       optional_argument, NULL, 'T' },
+		{ "version",    no_argument,       NULL, 'V' },
+		{ NULL, 0, NULL, 0 },
+	};
+
+	static const ul_excl_t excl[] = {       /* rows and cols in ASCII order */
+		{ 'D','O' },
+		{ 'I','e' },
+		{ 'J', 'P', 'r' },
+		{ 'O','S' },
+		{ 'O','f' },
+		{ 'O','m' },
+		{ 'O','o' },
+		{ 'O','t' },
+		{ 'P','T', 'l','r' },
+		{ 0 }
+	};
+	int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	lsblk = &_ls;
+
+	lsblk_init_debug();
+
+	while((c = getopt_long(argc, argv,
+			       "abdDzE:e:fhJlnMmo:OpPiI:rstVST::x:", longopts, NULL)) != -1) {
+
+		err_exclusive_options(c, longopts, excl, excl_st);
+
+		switch(c) {
+		case 'a':
+			lsblk->all_devices = 1;
+			break;
+		case 'b':
+			lsblk->bytes = 1;
+			break;
+		case 'd':
+			lsblk->nodeps = 1;
+			break;
+		case 'D':
+			add_uniq_column(COL_NAME);
+			add_uniq_column(COL_DALIGN);
+			add_uniq_column(COL_DGRAN);
+			add_uniq_column(COL_DMAX);
+			add_uniq_column(COL_DZERO);
+			break;
+		case 'z':
+			add_uniq_column(COL_NAME);
+			add_uniq_column(COL_ZONED);
+			break;
+		case 'e':
+			parse_excludes(optarg);
+			break;
+		case 'J':
+			lsblk->flags |= LSBLK_JSON;
+			break;
+		case 'l':
+			lsblk->flags &= ~LSBLK_TREE; /* disable the default */
+			break;
+		case 'M':
+			lsblk->merge = 1;
+			break;
+		case 'n':
+			lsblk->flags |= LSBLK_NOHEADINGS;
+			break;
+		case 'o':
+			outarg = optarg;
+			break;
+		case 'O':
+			for (ncolumns = 0 ; ncolumns < ARRAY_SIZE(infos); ncolumns++)
+				columns[ncolumns] = ncolumns;
+			break;
+		case 'p':
+			lsblk->paths = 1;
+			break;
+		case 'P':
+			lsblk->flags |= LSBLK_EXPORT;
+			lsblk->flags &= ~LSBLK_TREE;	/* disable the default */
+			break;
+		case 'i':
+			lsblk->flags |= LSBLK_ASCII;
+			break;
+		case 'I':
+			parse_includes(optarg);
+			break;
+		case 'r':
+			lsblk->flags &= ~LSBLK_TREE;	/* disable the default */
+			lsblk->flags |= LSBLK_RAW;		/* enable raw */
+			break;
+		case 's':
+			lsblk->inverse = 1;
+			break;
+		case 'f':
+			add_uniq_column(COL_NAME);
+			add_uniq_column(COL_FSTYPE);
+			add_uniq_column(COL_FSVERSION);
+			add_uniq_column(COL_LABEL);
+			add_uniq_column(COL_UUID);
+			add_uniq_column(COL_FSAVAIL);
+			add_uniq_column(COL_FSUSEPERC);
+			add_uniq_column(COL_TARGET);
+			break;
+		case 'm':
+			add_uniq_column(COL_NAME);
+			add_uniq_column(COL_SIZE);
+			add_uniq_column(COL_OWNER);
+			add_uniq_column(COL_GROUP);
+			add_uniq_column(COL_MODE);
+			break;
+		case 't':
+			add_uniq_column(COL_NAME);
+			add_uniq_column(COL_ALIOFF);
+			add_uniq_column(COL_MINIO);
+			add_uniq_column(COL_OPTIO);
+			add_uniq_column(COL_PHYSEC);
+			add_uniq_column(COL_LOGSEC);
+			add_uniq_column(COL_ROTA);
+			add_uniq_column(COL_SCHED);
+			add_uniq_column(COL_RQ_SIZE);
+			add_uniq_column(COL_RA);
+			add_uniq_column(COL_WSAME);
+			break;
+		case 'S':
+			lsblk->nodeps = 1;
+			lsblk->scsi = 1;
+			add_uniq_column(COL_NAME);
+			add_uniq_column(COL_HCTL);
+			add_uniq_column(COL_TYPE);
+			add_uniq_column(COL_VENDOR);
+			add_uniq_column(COL_MODEL);
+			add_uniq_column(COL_REV);
+			add_uniq_column(COL_SERIAL);
+			add_uniq_column(COL_TRANSPORT);
+			break;
+		case 'T':
+			force_tree = 1;
+			if (optarg) {
+				if (*optarg == '=')
+					optarg++;
+				lsblk->tree_id = column_name_to_id(optarg, strlen(optarg));
+			}
+			break;
+		case OPT_SYSROOT:
+			lsblk->sysroot = optarg;
+			break;
+		case 'E':
+			lsblk->dedup_id = column_name_to_id(optarg, strlen(optarg));
+			if (lsblk->dedup_id >= 0)
+				break;
+			errtryhelp(EXIT_FAILURE);
+			break;
+		case 'x':
+			lsblk->flags &= ~LSBLK_TREE; /* disable the default */
+			lsblk->sort_id = column_name_to_id(optarg, strlen(optarg));
+			if (lsblk->sort_id >= 0)
+				break;
+			errtryhelp(EXIT_FAILURE);
+			break;
+
+		case 'h':
+			usage();
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+
+	if (force_tree)
+		lsblk->flags |= LSBLK_TREE;
+
+	check_sysdevblock();
+
+	if (!ncolumns) {
+		add_column(COL_NAME);
+		add_column(COL_MAJMIN);
+		add_column(COL_RM);
+		add_column(COL_SIZE);
+		add_column(COL_RO);
+		add_column(COL_TYPE);
+		add_column(COL_TARGET);
+	}
+
+	if (outarg && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns),
+					 &ncolumns, column_name_to_id) < 0)
+		return EXIT_FAILURE;
+
+	if (lsblk->all_devices == 0 && nexcludes == 0 && nincludes == 0)
+		excludes[nexcludes++] = 1;	/* default: ignore RAM disks */
+
+	if (lsblk->sort_id < 0)
+		/* Since Linux 4.8 we have sort devices by default, because
+		 * /sys is no more sorted */
+		lsblk->sort_id = COL_MAJMIN;
+
+	/* For --{inverse,raw,pairs} --list we still follow parent->child relation */
+	if (!(lsblk->flags & LSBLK_TREE)
+	    && (lsblk->inverse || lsblk->flags & LSBLK_EXPORT || lsblk->flags & LSBLK_RAW))
+		lsblk->force_tree_order = 1;
+
+	if (lsblk->sort_id >= 0 && column_id_to_number(lsblk->sort_id) < 0) {
+		/* the sort column is not between output columns -- add as hidden */
+		add_column(lsblk->sort_id);
+		lsblk->sort_hidden = 1;
+	}
+
+	if (lsblk->dedup_id >= 0 && column_id_to_number(lsblk->dedup_id) < 0) {
+		/* the deduplication column is not between output columns -- add as hidden */
+		add_column(lsblk->dedup_id);
+		lsblk->dedup_hidden = 1;
+	}
+
+	lsblk_mnt_init();
+	scols_init_debug(0);
+	ul_path_init_debug();
+
+	/*
+	 * initialize output columns
+	 */
+	if (!(lsblk->table = scols_new_table()))
+		errx(EXIT_FAILURE, _("failed to allocate output table"));
+	scols_table_enable_raw(lsblk->table, !!(lsblk->flags & LSBLK_RAW));
+	scols_table_enable_export(lsblk->table, !!(lsblk->flags & LSBLK_EXPORT));
+	scols_table_enable_ascii(lsblk->table, !!(lsblk->flags & LSBLK_ASCII));
+	scols_table_enable_json(lsblk->table, !!(lsblk->flags & LSBLK_JSON));
+	scols_table_enable_noheadings(lsblk->table, !!(lsblk->flags & LSBLK_NOHEADINGS));
+
+	if (lsblk->flags & LSBLK_JSON)
+		scols_table_set_name(lsblk->table, "blockdevices");
+
+	for (i = 0; i < ncolumns; i++) {
+		struct colinfo *ci = get_column_info(i);
+		struct libscols_column *cl;
+		int id = get_column_id(i), fl = ci->flags;
+
+		if ((lsblk->flags & LSBLK_TREE)
+		    && has_tree_col == 0
+		    && id == lsblk->tree_id) {
+			fl |= SCOLS_FL_TREE;
+			fl &= ~SCOLS_FL_RIGHT;
+			has_tree_col = 1;
+		}
+
+		if (lsblk->sort_hidden && lsblk->sort_id == id)
+			fl |= SCOLS_FL_HIDDEN;
+		if (lsblk->dedup_hidden && lsblk->dedup_id == id)
+			fl |= SCOLS_FL_HIDDEN;
+
+		if (force_tree
+		    && lsblk->flags & LSBLK_JSON
+		    && has_tree_col == 0
+		    && i + 1 == ncolumns)
+			/* The "--tree --json" specified, but no column with
+			 * SCOLS_FL_TREE yet; force it for the last column
+			 */
+			fl |= SCOLS_FL_TREE;
+
+		cl = scols_table_new_column(lsblk->table, ci->name, ci->whint, fl);
+		if (!cl) {
+			warn(_("failed to allocate output column"));
+			goto leave;
+		}
+		if (!lsblk->sort_col && lsblk->sort_id == id) {
+			lsblk->sort_col = cl;
+			scols_column_set_cmpfunc(cl,
+				ci->type == COLTYPE_NUM     ? cmp_u64_cells :
+				ci->type == COLTYPE_SIZE    ? cmp_u64_cells :
+			        ci->type == COLTYPE_SORTNUM ? cmp_u64_cells : scols_cmpstr_cells,
+				NULL);
+		}
+		if (lsblk->flags & LSBLK_JSON) {
+			switch (ci->type) {
+			case COLTYPE_SIZE:
+				if (!lsblk->bytes)
+					break;
+				/* fallthrough */
+			case COLTYPE_NUM:
+				 scols_column_set_json_type(cl, SCOLS_JSON_NUMBER);
+				break;
+			case COLTYPE_BOOL:
+				scols_column_set_json_type(cl, SCOLS_JSON_BOOLEAN);
+				break;
+			default:
+				scols_column_set_json_type(cl, SCOLS_JSON_STRING);
+				break;
+			}
+		}
+	}
+
+	tr = lsblk_new_devtree();
+	if (!tr)
+		err(EXIT_FAILURE, _("failed to allocate device tree"));
+
+	if (optind == argc) {
+		int rc = lsblk->inverse ?
+			process_all_devices_inverse(tr) :
+			process_all_devices(tr);
+
+		status = rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
+	} else {
+		int cnt = 0, cnt_err = 0;
+
+		while (optind < argc) {
+			if (process_one_device(tr, argv[optind++]) != 0)
+				cnt_err++;
+			cnt++;
+		}
+		status = cnt == 0	? EXIT_FAILURE :	/* nothing */
+			 cnt == cnt_err	? LSBLK_EXIT_ALLFAILED :/* all failed */
+			 cnt_err	? LSBLK_EXIT_SOMEOK :	/* some ok */
+					  EXIT_SUCCESS;		/* all success */
+	}
+
+	if (lsblk->dedup_id > -1) {
+		devtree_set_dedupkeys(tr, lsblk->dedup_id);
+		lsblk_devtree_deduplicate_devices(tr);
+	}
+
+	devtree_to_scols(tr, lsblk->table);
+
+	if (lsblk->sort_col)
+		scols_sort_table(lsblk->table, lsblk->sort_col);
+	if (lsblk->force_tree_order)
+		scols_sort_table_by_tree(lsblk->table);
+
+	scols_print_table(lsblk->table);
+
+leave:
+	if (lsblk->sort_col)
+		unref_sortdata(lsblk->table);
+
+	scols_unref_table(lsblk->table);
+
+	lsblk_mnt_deinit();
+	lsblk_properties_deinit();
+	lsblk_unref_devtree(tr);
+
+	return status;
+}
diff --git a/misc-utils/lsblk.h b/misc-utils/lsblk.h
new file mode 100644
index 0000000..8722127
--- /dev/null
+++ b/misc-utils/lsblk.h
@@ -0,0 +1,237 @@
+/*
+ * Copyright (C) 2010-2018 Red Hat, Inc. All rights reserved.
+ * Written by Milan Broz <mbroz@redhat.com>
+ *            Karel Zak <kzak@redhat.com>
+ */
+#ifndef UTIL_LINUX_LSBLK_H
+#define UTIL_LINUX_LSBLK_H
+
+#include <stdint.h>
+#include <inttypes.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+
+#include <libsmartcols.h>
+
+#include "c.h"
+#include "list.h"
+#include "debug.h"
+
+#define LSBLK_DEBUG_INIT	(1 << 1)
+#define LSBLK_DEBUG_FILTER	(1 << 2)
+#define LSBLK_DEBUG_DEV		(1 << 3)
+#define LSBLK_DEBUG_TREE	(1 << 4)
+#define LSBLK_DEBUG_DEP		(1 << 5)
+#define LSBLK_DEBUG_ALL		0xFFFF
+
+UL_DEBUG_DECLARE_MASK(lsblk);
+#define DBG(m, x)       __UL_DBG(lsblk, LSBLK_DEBUG_, m, x)
+#define ON_DBG(m, x)    __UL_DBG_CALL(lsblk, LSBLK_DEBUG_, m, x)
+
+#define UL_DEBUG_CURRENT_MASK	UL_DEBUG_MASK(lsblk)
+#include "debugobj.h"
+
+struct lsblk {
+	struct libscols_table *table;	/* output table */
+
+	struct libscols_column *sort_col;/* sort output by this column */
+
+	int sort_id;			/* id of the sort column */
+	int tree_id;			/* od of column used for tree */
+
+	int dedup_id;
+
+	const char *sysroot;
+	int flags;			/* LSBLK_* */
+
+	unsigned int all_devices:1;	/* print all devices, including empty */
+	unsigned int bytes:1;		/* print SIZE in bytes */
+	unsigned int inverse:1;		/* print inverse dependencies */
+	unsigned int merge:1;           /* merge sub-trees */
+	unsigned int nodeps:1;		/* don't print slaves/holders */
+	unsigned int scsi:1;		/* print only device with HCTL (SCSI) */
+	unsigned int paths:1;		/* print devnames with "/dev" prefix */
+	unsigned int sort_hidden:1;	/* sort column not between output columns */
+	unsigned int dedup_hidden :1;	/* deduplication column not between output columns */
+	unsigned int force_tree_order:1;/* sort lines by parent->tree relation */
+};
+
+extern struct lsblk *lsblk;     /* global handler */
+
+struct lsblk_devprop {
+	/* udev / blkid based */
+	char *fstype;		/* detected fs, NULL or "?" if cannot detect */
+	char *fsversion;	/* filesystem version */
+	char *uuid;		/* filesystem UUID (or stack uuid) */
+	char *ptuuid;		/* partition table UUID */
+	char *pttype;		/* partition table type */
+	char *label;		/* filesystem label */
+	char *parttype;		/* partition type UUID */
+	char *partuuid;		/* partition UUID */
+	char *partlabel;	/* partition label */
+	char *partflags;	/* partition flags */
+	char *wwn;		/* storage WWN */
+	char *serial;		/* disk serial number */
+	char *model;		/* disk model */
+
+	/* lsblk specific (for --sysroot only)  */
+	char *owner;		/* user name */
+	char *group;		/* group name */
+	char *mode;		/* access mode in ls(1)-like notation */
+};
+
+/* Device dependence
+ *
+ * Note that the same device may be slave/holder for more another devices. It
+ * means we need to allocate list member rather than use @child directly.
+ */
+struct lsblk_devdep {
+	struct list_head        ls_childs;	/* item in parent->childs */
+	struct list_head	ls_parents;	/* item in child->parents */
+
+	struct lsblk_device	*child;
+	struct lsblk_device	*parent;
+};
+
+struct lsblk_device {
+	int	refcount;
+
+	struct list_head	childs;		/* list with lsblk_devdep */
+	struct list_head	parents;
+	struct list_head	ls_roots;	/* item in devtree->roots list */
+	struct list_head	ls_devices;	/* item in devtree->devices list */
+
+	struct lsblk_device	*wholedisk;	/* for partitions */
+
+	struct libscols_line	*scols_line;
+
+	struct lsblk_devprop	*properties;
+	struct stat	st;
+
+	char *name;		/* kernel name in /sys/block */
+	char *dm_name;		/* DM name (dm/block) */
+
+	char *filename;		/* path to device node */
+	char *dedupkey;		/* de-duplication key */
+
+	struct path_cxt	*sysfs;
+
+	char *mountpoint;	/* device mountpoint */
+	struct statvfs fsstat;	/* statvfs() result */
+
+	int npartitions;	/* # of partitions this device has */
+	int nholders;		/* # of devices mapped directly to this device
+				 * /sys/block/.../holders */
+	int nslaves;		/* # of devices this device maps to */
+	int maj, min;		/* devno */
+
+	uint64_t discard_granularity;	/* sunknown:-1, yes:1, not:0 */
+
+	uint64_t size;		/* device size */
+	int removable;		/* unknown:-1, yes:1, not:0 */
+
+	unsigned int	is_mounted : 1,
+			is_swap : 1,
+			is_printed : 1,
+			udev_requested : 1,
+			blkid_requested : 1,
+			file_requested : 1;
+};
+
+#define device_is_partition(_x)		((_x)->wholedisk != NULL)
+
+/*
+ * Note that lsblk tree uses bottom devices (devices without slaves) as root
+ * of the tree, and partitions are interpreted as a dependence too; it means:
+ *    sda -> sda1 -> md0
+ *
+ * The flag 'is_inverted' turns the tree over (root is device without holders):
+ *    md0 -> sda1 -> sda
+ */
+struct lsblk_devtree {
+	int	refcount;
+
+	struct list_head	roots;		/* tree root devices */
+	struct list_head	devices;	/* all devices */
+
+	unsigned int	is_inverse : 1;		/* inverse tree */
+};
+
+
+/*
+ * Generic iterator
+ */
+struct lsblk_iter {
+	struct list_head        *p;		/* current position */
+	struct list_head        *head;		/* start position */
+	int			direction;	/* LSBLK_ITER_{FOR,BACK}WARD */
+};
+
+#define LSBLK_ITER_FORWARD	0
+#define LSBLK_ITER_BACKWARD	1
+
+#define IS_ITER_FORWARD(_i)	((_i)->direction == LSBLK_ITER_FORWARD)
+#define IS_ITER_BACKWARD(_i)	((_i)->direction == LSBLK_ITER_BACKWARD)
+
+#define LSBLK_ITER_INIT(itr, list) \
+	do { \
+		(itr)->p = IS_ITER_FORWARD(itr) ? \
+				(list)->next : (list)->prev; \
+		(itr)->head = (list); \
+	} while(0)
+
+#define LSBLK_ITER_ITERATE(itr, res, restype, member) \
+	do { \
+		res = list_entry((itr)->p, restype, member); \
+		(itr)->p = IS_ITER_FORWARD(itr) ? \
+				(itr)->p->next : (itr)->p->prev; \
+	} while(0)
+
+
+/* lsblk-mnt.c */
+extern void lsblk_mnt_init(void);
+extern void lsblk_mnt_deinit(void);
+
+extern char *lsblk_device_get_mountpoint(struct lsblk_device *dev);
+
+/* lsblk-properties.c */
+extern void lsblk_device_free_properties(struct lsblk_devprop *p);
+extern struct lsblk_devprop *lsblk_device_get_properties(struct lsblk_device *dev);
+extern void lsblk_properties_deinit(void);
+
+extern const char *lsblk_parttype_code_to_string(const char *code, const char *pttype);
+
+/* lsblk-devtree.c */
+void lsblk_reset_iter(struct lsblk_iter *itr, int direction);
+struct lsblk_device *lsblk_new_device(void);
+void lsblk_ref_device(struct lsblk_device *dev);
+void lsblk_unref_device(struct lsblk_device *dev);
+int lsblk_device_new_dependence(struct lsblk_device *parent, struct lsblk_device *child);
+int lsblk_device_has_child(struct lsblk_device *dev, struct lsblk_device *child);
+int lsblk_device_next_child(struct lsblk_device *dev,
+                          struct lsblk_iter *itr,
+                          struct lsblk_device **child);
+
+int lsblk_device_is_last_parent(struct lsblk_device *dev, struct lsblk_device *parent);
+int lsblk_device_next_parent(
+                        struct lsblk_device *dev,
+                        struct lsblk_iter *itr,
+                        struct lsblk_device **parent);
+
+struct lsblk_devtree *lsblk_new_devtree(void);
+void lsblk_ref_devtree(struct lsblk_devtree *tr);
+void lsblk_unref_devtree(struct lsblk_devtree *tr);
+int lsblk_devtree_add_root(struct lsblk_devtree *tr, struct lsblk_device *dev);
+int lsblk_devtree_next_root(struct lsblk_devtree *tr,
+                            struct lsblk_iter *itr,
+                            struct lsblk_device **dev);
+int lsblk_devtree_add_device(struct lsblk_devtree *tr, struct lsblk_device *dev);
+int lsblk_devtree_next_device(struct lsblk_devtree *tr,
+                            struct lsblk_iter *itr,
+                            struct lsblk_device **dev);
+int lsblk_devtree_has_device(struct lsblk_devtree *tr, struct lsblk_device *dev);
+struct lsblk_device *lsblk_devtree_get_device(struct lsblk_devtree *tr, const char *name);
+int lsblk_devtree_remove_device(struct lsblk_devtree *tr, struct lsblk_device *dev);
+int lsblk_devtree_deduplicate_devices(struct lsblk_devtree *tr);
+
+#endif /* UTIL_LINUX_LSBLK_H */
diff --git a/misc-utils/lslocks.8 b/misc-utils/lslocks.8
new file mode 100644
index 0000000..89b1686
--- /dev/null
+++ b/misc-utils/lslocks.8
@@ -0,0 +1,108 @@
+.\" Man page for the lslocks command.
+.\" Copyright 2012 Davidlohr Bueso <dave@gnu.org>
+.\" May be distributed under the GNU General Public License
+
+.TH LSLOCKS 8 "December 2014" "util-linux" "System Administration"
+.SH NAME
+lslocks \- list local system locks
+.SH SYNOPSIS
+.B lslocks
+[options]
+
+.SH DESCRIPTION
+.B lslocks
+lists information about all the currently held file locks in a Linux system.
+.sp
+Note that lslocks also lists OFD (Open File Description) locks, these locks are
+not associated with any process (PID is \-1).  OFD locks are associated with the
+open file description on which they are acquired.  This lock type is available
+since Linux 3.15, see \fBfcntl\fR(2) for more details.
+
+.SH OPTIONS
+.TP
+.BR \-b , " \-\-bytes"
+Print the SIZE column in bytes rather than in a human-readable format.
+.TP
+.BR \-i , " \-\-noinaccessible"
+Ignore lock files which are inaccessible for the current user.
+.TP
+.BR \-J , " \-\-json"
+Use JSON output format.
+.TP
+.BR \-n , " \-\-noheadings"
+Do not print a header line.
+.TP
+.BR \-o , " \-\-output " \fIlist\fP
+Specify which output columns to print.  Use
+.B \-\-help
+to get a list of all supported columns.
+
+The default list of columns may be extended if \fIlist\fP is
+specified in the format \fI+list\fP (e.g., \fBlslocks \-o +BLOCKER\fP).
+.TP
+.B \-\-output\-all
+Output all available columns.
+.TP
+.BR \-p , " \-\-pid " \fIpid\fP
+Display only the locks held by the process with this \fIpid\fR.
+.TP
+.BR \-r , " \-\-raw"
+Use the raw output format.
+.TP
+.BR \-u , " \-\-notruncate"
+Do not truncate text in columns.
+.TP
+.BR \-V , " \-\-version"
+Display version information and exit.
+.TP
+.BR \-h , " \-\-help"
+Display help text and exit.
+
+.SH OUTPUT
+.IP "COMMAND"
+The command name of the process holding the lock.
+.IP "PID"
+The process ID of the process which holds the lock or \-1 for OFDLCK.
+.IP "TYPE"
+The type of lock; can be FLOCK (created with \fBflock\fR(2)), POSIX
+(created with \fBfcntl\fR(2) and \fBlockf\fR(3)) or OFDLCK (created with fcntl(2).
+.IP "SIZE"
+Size of the locked file.
+.IP "MODE"
+The lock's access permissions (read, write).  If the process is blocked and waiting for the lock,
+then the mode is postfixed with an '*' (asterisk).
+.IP "M"
+Whether the lock is mandatory; 0 means no (meaning the lock is only advisory), 1 means yes.
+(See \fBfcntl\fR(2).)
+.IP "START"
+Relative byte offset of the lock.
+.IP "END"
+Ending offset of the lock.
+.IP "PATH"
+Full path of the lock.  If none is found, or there are no permissions to read
+the path, it will fall back to the device's mountpoint and "..." is appended to
+the path.  The path might be truncated; use
+\fB\-\-notruncate\fR to get the full path.
+.IP "BLOCKER"
+The PID of the process which blocks the lock.
+
+.SH NOTES
+.nf
+The \fBlslocks\fR command is meant to replace the \fBlslk\fR(8) command,
+originally written by Victor A. Abell <abe@purdue.edu> and unmaintained
+since 2001.
+.fi
+
+.SH AUTHORS
+.nf
+Davidlohr Bueso <dave@gnu.org>
+.fi
+
+.SH SEE ALSO
+.BR flock (1),
+.BR fcntl (2),
+.BR lockf (3)
+
+.SH AVAILABILITY
+The lslocks command is part of the util-linux package and is available from
+https://www.kernel.org/pub/linux/utils/util-linux/.
diff --git a/misc-utils/lslocks.c b/misc-utils/lslocks.c
new file mode 100644
index 0000000..18922e5
--- /dev/null
+++ b/misc-utils/lslocks.c
@@ -0,0 +1,662 @@
+/*
+ * lslocks(8) - list local system locks
+ *
+ * Copyright (C) 2012 Davidlohr Bueso <dave@gnu.org>
+ *
+ * Very generally based on lslk(8) by Victor A. Abell <abe@purdue.edu>
+ * Since it stopped being maintained over a decade ago, this
+ * program should be considered its replacement.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <getopt.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <libmount.h>
+#include <libsmartcols.h>
+
+#include "pathnames.h"
+#include "canonicalize.h"
+#include "nls.h"
+#include "xalloc.h"
+#include "strutils.h"
+#include "c.h"
+#include "list.h"
+#include "closestream.h"
+#include "optutils.h"
+#include "procutils.h"
+
+/* column IDs */
+enum {
+	COL_SRC = 0,
+	COL_PID,
+	COL_TYPE,
+	COL_SIZE,
+	COL_MODE,
+	COL_M,
+	COL_START,
+	COL_END,
+	COL_PATH,
+	COL_BLOCKER
+};
+
+/* column names */
+struct colinfo {
+	const char *name; /* header */
+	double	   whint; /* width hint (N < 1 is in percent of termwidth) */
+	int	   flags; /* SCOLS_FL_* */
+	const char *help;
+};
+
+/* columns descriptions */
+static struct colinfo infos[] = {
+	[COL_SRC]  = { "COMMAND",15, 0, N_("command of the process holding the lock") },
+	[COL_PID]  = { "PID",     5, SCOLS_FL_RIGHT, N_("PID of the process holding the lock") },
+	[COL_TYPE] = { "TYPE",    5, SCOLS_FL_RIGHT, N_("kind of lock") },
+	[COL_SIZE] = { "SIZE",    4, SCOLS_FL_RIGHT, N_("size of the lock") },
+	[COL_MODE] = { "MODE",    5, 0, N_("lock access mode") },
+	[COL_M]    = { "M",       1, 0, N_("mandatory state of the lock: 0 (none), 1 (set)")},
+	[COL_START] = { "START", 10, SCOLS_FL_RIGHT, N_("relative byte offset of the lock")},
+	[COL_END]  = { "END",    10, SCOLS_FL_RIGHT, N_("ending offset of the lock")},
+	[COL_PATH] = { "PATH",    0, SCOLS_FL_TRUNC, N_("path of the locked file")},
+	[COL_BLOCKER] = { "BLOCKER", 0, SCOLS_FL_RIGHT, N_("PID of the process blocking the lock") }
+};
+
+static int columns[ARRAY_SIZE(infos) * 2];
+static size_t ncolumns;
+
+static pid_t pid = 0;
+
+static struct libmnt_table *tab;		/* /proc/self/mountinfo */
+
+/* basic output flags */
+static int no_headings;
+static int no_inaccessible;
+static int raw;
+static int json;
+static int bytes;
+
+struct lock {
+	struct list_head locks;
+
+	char *cmdname;
+	pid_t pid;
+	char *path;
+	char *type;
+	char *mode;
+	off_t start;
+	off_t end;
+	unsigned int mandatory :1,
+		     blocked   :1;
+	uint64_t size;
+	int id;
+};
+
+static void rem_lock(struct lock *lock)
+{
+	if (!lock)
+		return;
+
+	free(lock->path);
+	free(lock->mode);
+	free(lock->cmdname);
+	free(lock->type);
+	list_del(&lock->locks);
+	free(lock);
+}
+
+static void disable_columns_truncate(void)
+{
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(infos); i++)
+		infos[i].flags &= ~SCOLS_FL_TRUNC;
+}
+
+/*
+ * Associate the device's mountpoint for a filename
+ */
+static char *get_fallback_filename(dev_t dev)
+{
+	struct libmnt_fs *fs;
+	char *res = NULL;
+
+	if (!tab) {
+		tab = mnt_new_table_from_file(_PATH_PROC_MOUNTINFO);
+		if (!tab)
+			return NULL;
+	}
+
+	fs = mnt_table_find_devno(tab, dev, MNT_ITER_BACKWARD);
+	if (!fs)
+		return NULL;
+
+	xasprintf(&res, "%s...", mnt_fs_get_target(fs));
+	return res;
+}
+
+/*
+ * Return the absolute path of a file from
+ * a given inode number (and its size)
+ */
+static char *get_filename_sz(ino_t inode, pid_t lock_pid, size_t *size)
+{
+	struct stat sb;
+	struct dirent *dp;
+	DIR *dirp;
+	size_t len;
+	int fd;
+	char path[PATH_MAX], sym[PATH_MAX], *ret = NULL;
+
+	*size = 0;
+	memset(path, 0, sizeof(path));
+	memset(sym, 0, sizeof(sym));
+
+	/*
+	 * We know the pid so we don't have to
+	 * iterate the *entire* filesystem searching
+	 * for the damn file.
+	 */
+	sprintf(path, "/proc/%d/fd/", lock_pid);
+	if (!(dirp = opendir(path)))
+		return NULL;
+
+	if ((len = strlen(path)) >= (sizeof(path) - 2))
+		goto out;
+
+	if ((fd = dirfd(dirp)) < 0 )
+		goto out;
+
+	while ((dp = readdir(dirp))) {
+		if (!strcmp(dp->d_name, ".") ||
+		    !strcmp(dp->d_name, ".."))
+			continue;
+
+		/* care only for numerical descriptors */
+		if (!strtol(dp->d_name, (char **) NULL, 10))
+			continue;
+
+		if (!fstatat(fd, dp->d_name, &sb, 0)
+		    && inode != sb.st_ino)
+			continue;
+
+		if ((len = readlinkat(fd, dp->d_name, sym, sizeof(sym) - 1)) < 1)
+			goto out;
+
+		*size = sb.st_size;
+		sym[len] = '\0';
+
+		ret = xstrdup(sym);
+		break;
+	}
+out:
+	closedir(dirp);
+	return ret;
+}
+
+/*
+ * Return the inode number from a string
+ */
+static ino_t get_dev_inode(char *str, dev_t *dev)
+{
+	unsigned int maj = 0, min = 0;
+	ino_t inum = 0;
+
+	sscanf(str, "%02x:%02x:%ju", &maj, &min, &inum);
+
+	*dev = (dev_t) makedev(maj, min);
+	return inum;
+}
+
+static int get_local_locks(struct list_head *locks)
+{
+	int i;
+	ino_t inode = 0;
+	FILE *fp;
+	char buf[PATH_MAX], *tok = NULL;
+	size_t sz;
+	struct lock *l;
+	dev_t dev = 0;
+
+	if (!(fp = fopen(_PATH_PROC_LOCKS, "r")))
+		return -1;
+
+	while (fgets(buf, sizeof(buf), fp)) {
+
+		l = xcalloc(1, sizeof(*l));
+		INIT_LIST_HEAD(&l->locks);
+
+		for (tok = strtok(buf, " "), i = 0; tok;
+		     tok = strtok(NULL, " "), i++) {
+
+			/*
+			 * /proc/locks has *exactly* 8 "blocks" of text
+			 * separated by ' ' - check <kernel>/fs/locks.c
+			 */
+			switch (i) {
+			case 0: /* ID: */
+				tok[strlen(tok) - 1] = '\0';
+				l->id = strtos32_or_err(tok, _("failed to parse ID"));
+				break;
+			case 1: /* posix, flock, etc */
+				if (strcmp(tok, "->") == 0) {	/* optional field */
+					l->blocked = 1;
+					i--;
+				} else
+					l->type = xstrdup(tok);
+				break;
+
+			case 2: /* is this a mandatory lock? other values are advisory or noinode */
+				l->mandatory = *tok == 'M' ? 1 : 0;
+				break;
+			case 3: /* lock mode */
+				l->mode = xstrdup(tok);
+				break;
+
+			case 4: /* PID */
+				/*
+				 * If user passed a pid we filter it later when adding
+				 * to the list, no need to worry now. OFD locks use -1 PID.
+				 */
+				l->pid = strtos32_or_err(tok, _("failed to parse pid"));
+				if (l->pid > 0) {
+					l->cmdname = proc_get_command_name(l->pid);
+					if (!l->cmdname)
+						l->cmdname = xstrdup(_("(unknown)"));
+				} else
+					l->cmdname = xstrdup(_("(undefined)"));
+				break;
+
+			case 5: /* device major:minor and inode number */
+				inode = get_dev_inode(tok, &dev);
+				break;
+
+			case 6: /* start */
+				l->start = !strcmp(tok, "EOF") ? 0 :
+					   strtou64_or_err(tok, _("failed to parse start"));
+				break;
+
+			case 7: /* end */
+				/* replace '\n' character */
+				tok[strlen(tok)-1] = '\0';
+				l->end = !strcmp(tok, "EOF") ? 0 :
+					 strtou64_or_err(tok, _("failed to parse end"));
+				break;
+			default:
+				break;
+			}
+		}
+
+		l->path = get_filename_sz(inode, l->pid, &sz);
+
+		/* no permissions -- ignore */
+		if (!l->path && no_inaccessible) {
+			rem_lock(l);
+			continue;
+		}
+
+		if (!l->path) {
+			/* probably no permission to peek into l->pid's path */
+			l->path = get_fallback_filename(dev);
+			l->size = 0;
+		} else
+			l->size = sz;
+
+		list_add(&l->locks, locks);
+	}
+
+	fclose(fp);
+	return 0;
+}
+
+static int column_name_to_id(const char *name, size_t namesz)
+{
+	size_t i;
+
+	assert(name);
+
+	for (i = 0; i < ARRAY_SIZE(infos); i++) {
+		const char *cn = infos[i].name;
+
+		if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
+			return i;
+	}
+	warnx(_("unknown column: %s"), name);
+	return -1;
+}
+
+static inline int get_column_id(int num)
+{
+	assert(num >= 0);
+	assert((size_t) num < ncolumns);
+	assert(columns[num] < (int) ARRAY_SIZE(infos));
+
+	return columns[num];
+}
+
+
+static inline struct colinfo *get_column_info(unsigned num)
+{
+	return &infos[ get_column_id(num) ];
+}
+
+static pid_t get_blocker(int id, struct list_head *locks)
+{
+	struct list_head *p;
+
+	list_for_each(p, locks) {
+		struct lock *l = list_entry(p, struct lock, locks);
+
+		if (l->id == id && !l->blocked)
+			return l->pid;
+	}
+
+	return 0;
+}
+
+static void add_scols_line(struct libscols_table *table, struct lock *l, struct list_head *locks)
+{
+	size_t i;
+	struct libscols_line *line;
+	/*
+	 * Whenever cmdname or filename is NULL it is most
+	 * likely  because there's no read permissions
+	 * for the specified process.
+	 */
+	const char *notfnd = "";
+
+	assert(l);
+	assert(table);
+
+	line = scols_table_new_line(table, NULL);
+	if (!line)
+		err(EXIT_FAILURE, _("failed to allocate output line"));
+
+	for (i = 0; i < ncolumns; i++) {
+		char *str = NULL;
+
+		switch (get_column_id(i)) {
+		case COL_SRC:
+			xasprintf(&str, "%s", l->cmdname ? l->cmdname : notfnd);
+			break;
+		case COL_PID:
+			xasprintf(&str, "%d", l->pid);
+			break;
+		case COL_TYPE:
+			xasprintf(&str, "%s", l->type);
+			break;
+		case COL_SIZE:
+			if (!l->size)
+				break;
+			if (bytes)
+				xasprintf(&str, "%ju", l->size);
+			else
+				str = size_to_human_string(SIZE_SUFFIX_1LETTER, l->size);
+			break;
+		case COL_MODE:
+			xasprintf(&str, "%s%s", l->mode, l->blocked ? "*" : "");
+			break;
+		case COL_M:
+			xasprintf(&str, "%d", l->mandatory ? 1 : 0);
+			break;
+		case COL_START:
+			xasprintf(&str, "%jd", l->start);
+			break;
+		case COL_END:
+			xasprintf(&str, "%jd", l->end);
+			break;
+		case COL_PATH:
+			xasprintf(&str, "%s", l->path ? l->path : notfnd);
+			break;
+		case COL_BLOCKER:
+		{
+			pid_t bl = l->blocked && l->id ?
+						get_blocker(l->id, locks) : 0;
+			if (bl)
+				xasprintf(&str, "%d", (int) bl);
+		}
+		default:
+			break;
+		}
+
+		if (str && scols_line_refer_data(line, i, str))
+			err(EXIT_FAILURE, _("failed to add output data"));
+	}
+}
+
+static int show_locks(struct list_head *locks)
+{
+	int rc = 0;
+	size_t i;
+	struct list_head *p, *pnext;
+	struct libscols_table *table;
+
+	table = scols_new_table();
+	if (!table)
+		err(EXIT_FAILURE, _("failed to allocate output table"));
+
+	scols_table_enable_raw(table, raw);
+	scols_table_enable_json(table, json);
+	scols_table_enable_noheadings(table, no_headings);
+
+	if (json)
+		scols_table_set_name(table, "locks");
+
+	for (i = 0; i < ncolumns; i++) {
+		struct libscols_column *cl;
+		struct colinfo *col = get_column_info(i);
+
+		cl = scols_table_new_column(table, col->name, col->whint, col->flags);
+		if (!cl)
+			err(EXIT_FAILURE, _("failed to allocate output column"));
+
+		if (json) {
+			int id = get_column_id(i);
+
+			switch (id) {
+			case COL_SIZE:
+				if (!bytes)
+					break;
+				/* fallthrough */
+			case COL_PID:
+			case COL_START:
+			case COL_END:
+			case COL_BLOCKER:
+				scols_column_set_json_type(cl, SCOLS_JSON_NUMBER);
+				break;
+			case COL_M:
+				scols_column_set_json_type(cl, SCOLS_JSON_BOOLEAN);
+				break;
+			default:
+				scols_column_set_json_type(cl, SCOLS_JSON_STRING);
+				break;
+			}
+		}
+
+	}
+
+	/* prepare data for output */
+	list_for_each(p, locks) {
+		struct lock *l = list_entry(p, struct lock, locks);
+
+		if (pid && pid != l->pid)
+			continue;
+
+		add_scols_line(table, l, locks);
+	}
+
+	/* destroy the list */
+	list_for_each_safe(p, pnext, locks) {
+		struct lock *l = list_entry(p, struct lock, locks);
+		rem_lock(l);
+	}
+
+	scols_print_table(table);
+	scols_unref_table(table);
+	return rc;
+}
+
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+	size_t i;
+
+	fputs(USAGE_HEADER, out);
+
+	fprintf(out,
+		_(" %s [options]\n"), program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("List local system locks.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -b, --bytes            print SIZE in bytes rather than in human readable format\n"), out);
+	fputs(_(" -J, --json             use JSON output format\n"), out);
+	fputs(_(" -i, --noinaccessible   ignore locks without read permissions\n"), out);
+	fputs(_(" -n, --noheadings       don't print headings\n"), out);
+	fputs(_(" -o, --output <list>    define which output columns to use\n"), out);
+	fputs(_("     --output-all       output all columns\n"), out);
+	fputs(_(" -p, --pid <pid>        display only locks held by this process\n"), out);
+	fputs(_(" -r, --raw              use the raw output format\n"), out);
+	fputs(_(" -u, --notruncate       don't truncate text in columns\n"), out);
+
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(24));
+
+	fputs(USAGE_COLUMNS, out);
+
+	for (i = 0; i < ARRAY_SIZE(infos); i++)
+		fprintf(out, " %11s  %s\n", infos[i].name, _(infos[i].help));
+
+	printf(USAGE_MAN_TAIL("lslocks(8)"));
+
+	exit(EXIT_SUCCESS);
+}
+
+int main(int argc, char *argv[])
+{
+	int c, rc = 0;
+	struct list_head locks;
+	char *outarg = NULL;
+	enum {
+		OPT_OUTPUT_ALL = CHAR_MAX + 1
+	};
+	static const struct option long_opts[] = {
+		{ "bytes",      no_argument,       NULL, 'b' },
+		{ "json",       no_argument,       NULL, 'J' },
+		{ "pid",	required_argument, NULL, 'p' },
+		{ "help",	no_argument,       NULL, 'h' },
+		{ "output",     required_argument, NULL, 'o' },
+		{ "output-all",	no_argument,       NULL, OPT_OUTPUT_ALL },
+		{ "notruncate", no_argument,       NULL, 'u' },
+		{ "version",    no_argument,       NULL, 'V' },
+		{ "noheadings", no_argument,       NULL, 'n' },
+		{ "raw",        no_argument,       NULL, 'r' },
+		{ "noinaccessible", no_argument, NULL, 'i' },
+		{ NULL, 0, NULL, 0 }
+	};
+
+	static const ul_excl_t excl[] = {	/* rows and cols in ASCII order */
+		{ 'J','r' },
+		{ 0 }
+	};
+	int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	while ((c = getopt_long(argc, argv,
+				"biJp:o:nruhV", long_opts, NULL)) != -1) {
+
+		err_exclusive_options(c, long_opts, excl, excl_st);
+
+		switch(c) {
+		case 'b':
+			bytes = 1;
+			break;
+		case 'i':
+			no_inaccessible = 1;
+			break;
+		case 'J':
+			json = 1;
+			break;
+		case 'p':
+			pid = strtos32_or_err(optarg, _("invalid PID argument"));
+			break;
+		case 'o':
+			outarg = optarg;
+			break;
+		case OPT_OUTPUT_ALL:
+			for (ncolumns = 0; ncolumns < ARRAY_SIZE(infos); ncolumns++)
+				columns[ncolumns] = ncolumns;
+			break;
+		case 'n':
+			no_headings = 1;
+			break;
+		case 'r':
+			raw = 1;
+			break;
+		case 'u':
+			disable_columns_truncate();
+			break;
+
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		case 'h':
+			usage();
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+
+	INIT_LIST_HEAD(&locks);
+
+	if (!ncolumns) {
+		/* default columns */
+		columns[ncolumns++] = COL_SRC;
+		columns[ncolumns++] = COL_PID;
+		columns[ncolumns++] = COL_TYPE;
+		columns[ncolumns++] = COL_SIZE;
+		columns[ncolumns++] = COL_MODE;
+		columns[ncolumns++] = COL_M;
+		columns[ncolumns++] = COL_START;
+		columns[ncolumns++] = COL_END;
+		columns[ncolumns++] = COL_PATH;
+	}
+
+	if (outarg && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns),
+					 &ncolumns, column_name_to_id) < 0)
+		return EXIT_FAILURE;
+
+	scols_init_debug(0);
+
+	rc = get_local_locks(&locks);
+
+	if (!rc && !list_empty(&locks))
+		rc = show_locks(&locks);
+
+	mnt_unref_table(tab);
+	return rc;
+}
diff --git a/misc-utils/mcookie.1 b/misc-utils/mcookie.1
new file mode 100644
index 0000000..fcb37ed
--- /dev/null
+++ b/misc-utils/mcookie.1
@@ -0,0 +1,69 @@
+.\" mcookie.1 --
+.\" Public Domain 1995 Rickard E. Faith (faith@cs.unc.edu)
+.TH MCOOKIE 1 "December 2014" "util-linux" "User Commands"
+.SH NAME
+mcookie \- generate magic cookies for xauth
+.SH SYNOPSIS
+.B mcookie
+[options]
+.SH DESCRIPTION
+.B mcookie
+generates a 128-bit random hexadecimal number for use with the X authority
+system.  Typical usage:
+.sp
+.RS
+.B xauth add :0 . `mcookie`
+.RE
+.PP
+The "random" number generated is actually the MD5 message
+digest of random information coming from one of the sources
+.IR getrandom ()
+system call,
+.IR /dev/urandom ,
+.IR /dev/random ,
+or the
+.IR "libc pseudo-random functions" ,
+in this preference order. See also the option \fB\-\-file\fR.
+.SH OPTIONS
+.TP
+.BR \-f , " \-\-file " \fIfile
+Use this \fIfile\fR as an additional source of randomness (for example /dev/urandom).
+When \fIfile\fR is '-', characters are read from standard input.
+.TP
+.BR \-m , " \-\-max\-size " \fInumber
+Read from \fIfile\fR only this \fInumber\fR of bytes.
+This option is meant to be used when reading additional
+randomness from a file or device.
+.IP
+The
+.I number
+argument may be followed by the multiplicative suffixes KiB=1024,
+MiB=1024*1024, and so on for GiB, TiB, PiB, EiB, ZiB and YiB (the "iB" is
+optional, e.g., "K" has the same meaning as "KiB") or the suffixes
+KB=1000, MB=1000*1000, and so on for GB, TB, PB, EB, ZB and YB.
+.TP
+.BR \-v , " \-\-verbose"
+Inform where randomness originated, with amount of entropy read from each
+source.
+.TP
+.BR \-V , " \-\-version"
+Display version information and exit.
+.TP
+.BR \-h , " \-\-help"
+Display help text and exit.
+.SH FILES
+.I /dev/urandom
+.br
+.I /dev/random
+.SH BUGS
+It is assumed that none of the randomness sources will block.
+.SH SEE ALSO
+.BR md5sum (1),
+.BR X (7),
+.BR xauth (1),
+.BR rand (3)
+.SH AVAILABILITY
+The mcookie command is part of the util-linux package and is available from
+.UR https://\:www.kernel.org\:/pub\:/linux\:/utils\:/util-linux/
+Linux Kernel Archive
+.UE .
diff --git a/misc-utils/mcookie.c b/misc-utils/mcookie.c
new file mode 100644
index 0000000..3157401
--- /dev/null
+++ b/misc-utils/mcookie.c
@@ -0,0 +1,200 @@
+/* mcookie.c -- Generates random numbers for xauth
+ * Created: Fri Feb  3 10:42:48 1995 by faith@cs.unc.edu
+ * Revised: Fri Mar 19 07:48:01 1999 by faith@acm.org
+ * Public Domain 1995, 1999 Rickard E. Faith (faith@acm.org)
+ * This program comes with ABSOLUTELY NO WARRANTY.
+ *
+ * This program gathers some random bits of data and used the MD5
+ * message-digest algorithm to generate a 128-bit hexadecimal number for
+ * use with xauth(1).
+ *
+ * NOTE: Unless /dev/random is available, this program does not actually
+ * gather 128 bits of random information, so the magic cookie generated
+ * will be considerably easier to guess than one might expect.
+ *
+ * 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
+ * - added Native Language Support
+ * 1999-03-21 aeb: Added some fragments of code from Colin Plumb.
+ *
+ */
+
+#include "c.h"
+#include "md5.h"
+#include "nls.h"
+#include "closestream.h"
+#include "randutils.h"
+#include "strutils.h"
+#include "xalloc.h"
+#include "all-io.h"
+
+#include <fcntl.h>
+#include <getopt.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+enum {
+	BUFFERSIZE = 4096,
+	RAND_BYTES = 128
+};
+
+struct mcookie_control {
+	struct	UL_MD5Context ctx;
+	char	**files;
+	size_t	nfiles;
+	uint64_t maxsz;
+
+	unsigned int verbose:1;
+};
+
+/* The basic function to hash a file */
+static uint64_t hash_file(struct mcookie_control *ctl, int fd)
+{
+	unsigned char buf[BUFFERSIZE];
+	uint64_t wanted, count;
+
+	wanted = ctl->maxsz ? ctl->maxsz : sizeof(buf);
+
+	for (count = 0; count < wanted; ) {
+		size_t rdsz = sizeof(buf);
+		ssize_t r;
+
+		if (wanted - count < rdsz)
+			rdsz = wanted - count;
+
+		r = read_all(fd, (char *) buf, rdsz);
+		if (r < 0)
+			break;
+		ul_MD5Update(&ctl->ctx, buf, r);
+		count += r;
+	}
+	/* Separate files with a null byte */
+	buf[0] = '\0';
+	ul_MD5Update(&ctl->ctx, buf, 1);
+	return count;
+}
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+	fputs(USAGE_HEADER, out);
+	fprintf(out, _(" %s [options]\n"), program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("Generate magic cookies for xauth.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -f, --file <file>     use file as a cookie seed\n"), out);
+	fputs(_(" -m, --max-size <num>  limit how much is read from seed files\n"), out);
+	fputs(_(" -v, --verbose         explain what is being done\n"), out);
+
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(23));
+
+	fputs(USAGE_ARGUMENTS, out);
+	printf(USAGE_ARG_SIZE(_("<num>")));
+
+	printf(USAGE_MAN_TAIL("mcookie(1)"));
+
+	exit(EXIT_SUCCESS);
+}
+
+static void randomness_from_files(struct mcookie_control *ctl)
+{
+	size_t i;
+
+	for (i = 0; i < ctl->nfiles; i++) {
+		const char *fname = ctl->files[i];
+		size_t count;
+		int fd;
+
+		if (*fname == '-' && !*(fname + 1))
+			fd = STDIN_FILENO;
+		else
+			fd = open(fname, O_RDONLY);
+
+		if (fd < 0) {
+			warn(_("cannot open %s"), fname);
+		} else {
+			count = hash_file(ctl, fd);
+			if (ctl->verbose)
+				fprintf(stderr,
+					P_("Got %zu byte from %s\n",
+					   "Got %zu bytes from %s\n", count),
+					count, fname);
+
+			if (fd != STDIN_FILENO && close(fd))
+				err(EXIT_FAILURE, _("closing %s failed"), fname);
+		}
+	}
+}
+
+int main(int argc, char **argv)
+{
+	struct mcookie_control ctl = { .verbose = 0 };
+	size_t i;
+	unsigned char digest[UL_MD5LENGTH];
+	unsigned char buf[RAND_BYTES];
+	int c;
+
+	static const struct option longopts[] = {
+		{"file", required_argument, NULL, 'f'},
+		{"max-size", required_argument, NULL, 'm'},
+		{"verbose", no_argument, NULL, 'v'},
+		{"version", no_argument, NULL, 'V'},
+		{"help", no_argument, NULL, 'h'},
+		{NULL, 0, NULL, 0}
+	};
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	while ((c = getopt_long(argc, argv, "f:m:vVh", longopts, NULL)) != -1) {
+		switch (c) {
+		case 'v':
+			ctl.verbose = 1;
+			break;
+		case 'f':
+			if (!ctl.files)
+				ctl.files = xmalloc(sizeof(char *) * argc);
+			ctl.files[ctl.nfiles++] = optarg;
+			break;
+		case 'm':
+			ctl.maxsz = strtosize_or_err(optarg,
+						     _("failed to parse length"));
+			break;
+
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		case 'h':
+			usage();
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+
+	if (ctl.maxsz && ctl.nfiles == 0)
+		warnx(_("--max-size ignored when used without --file"));
+
+	ul_MD5Init(&ctl.ctx);
+	randomness_from_files(&ctl);
+	free(ctl.files);
+
+	ul_random_get_bytes(&buf, RAND_BYTES);
+	ul_MD5Update(&ctl.ctx, buf, RAND_BYTES);
+	if (ctl.verbose)
+		fprintf(stderr, P_("Got %d byte from %s\n",
+				   "Got %d bytes from %s\n", RAND_BYTES),
+				RAND_BYTES, random_tell_source());
+
+	ul_MD5Final(digest, &ctl.ctx);
+	for (i = 0; i < UL_MD5LENGTH; i++)
+		printf("%02x", digest[i]);
+	putchar('\n');
+
+	return EXIT_SUCCESS;
+}
diff --git a/misc-utils/namei.1 b/misc-utils/namei.1
new file mode 100644
index 0000000..84eae8b
--- /dev/null
+++ b/misc-utils/namei.1
@@ -0,0 +1,80 @@
+.TH NAMEI 1 "June 2011" "util-linux" "User Commands"
+.SH NAME
+namei \- follow a pathname until a terminal point is found
+.SH SYNOPSIS
+.B namei
+[options]
+.IR pathname ...
+.SH DESCRIPTION
+.B namei
+interprets its arguments as pathnames to any type
+of Unix file (symlinks, files, directories, and so forth).
+.B namei
+then follows each pathname until an endpoint
+is found (a file, a directory, a device node, etc).
+If it finds a symbolic link, it shows the link, and starts
+following it, indenting the output to show the context.
+.PP
+This program is useful for finding "too many levels of
+symbolic links" problems.
+.PP
+For each line of output,
+.B namei
+uses the following characters to identify the file type found:
+.LP
+.nf
+   f: = the pathname currently being resolved
+    d = directory
+    l = symbolic link (both the link and its contents are output)
+    s = socket
+    b = block device
+    c = character device
+    p = FIFO (named pipe)
+    - = regular file
+    ? = an error of some kind
+.fi
+.PP
+.B namei
+prints an informative message when
+the maximum number of symbolic links this system can have has been exceeded.
+.SH OPTIONS
+.TP
+.BR \-l , " \-\-long"
+Use the long listing format (same as \fB\-m \-o \-v\fR).
+.TP
+.BR \-m , " \-\-modes"
+Show the mode bits of each file type in the style of ls(1),
+for example 'rwxr-xr-x'.
+.TP
+.BR \-n , " \-\-nosymlinks"
+Don't follow symlinks.
+.TP
+.BR \-o , " \-\-owners"
+Show owner and group name of each file.
+.TP
+.BR \-v , " \-\-vertical"
+Vertically align the modes and owners.
+.TP
+.BR \-x , " \-\-mountpoints"
+Show mountpoint directories with a 'D' rather than a 'd'.
+.TP
+.BR \-V , " \-\-version"
+Display version information and exit.
+.TP
+.BR \-h , " \-\-help"
+Display help text and exit.
+.SH BUGS
+To be discovered.
+.SH AUTHORS
+The original
+.B namei
+program was written by Roger Southwick <rogers@amadeus.wr.tek.com>.
+.sp
+The program was rewritten by Karel Zak <kzak@redhat.com>.
+.SH SEE ALSO
+.BR ls (1),
+.BR stat (1),
+.BR symlink (7)
+.SH AVAILABILITY
+The namei command is part of the util-linux package and is available from
+https://www.kernel.org/pub/linux/utils/util-linux/.
diff --git a/misc-utils/namei.c b/misc-utils/namei.c
new file mode 100644
index 0000000..9c5f5fa
--- /dev/null
+++ b/misc-utils/namei.c
@@ -0,0 +1,450 @@
+/*
+ * Copyright (C) 2008 Karel Zak <kzak@redhat.com>
+ *
+ * This file is part of util-linux.
+ *
+ * This file is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This file is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * The original namei(1) was written by:
+ *	Roger S. Southwick (May 2, 1990)
+ *	Steve Tell (March 28, 1991)
+ *	Arkadiusz Miśkiewicz (1999-02-22)
+ *	Li Zefan (2007-09-10).
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/param.h>
+#include <pwd.h>
+#include <grp.h>
+
+#include "c.h"
+#include "xalloc.h"
+#include "nls.h"
+#include "widechar.h"
+#include "strutils.h"
+#include "closestream.h"
+#include "idcache.h"
+
+#ifndef MAXSYMLINKS
+#define MAXSYMLINKS 256
+#endif
+
+#define NAMEI_NOLINKS	(1 << 1)
+#define NAMEI_MODES	(1 << 2)
+#define NAMEI_MNTS	(1 << 3)
+#define NAMEI_OWNERS	(1 << 4)
+#define NAMEI_VERTICAL	(1 << 5)
+
+
+struct namei {
+	struct stat	st;		/* item lstat() */
+	char		*name;		/* item name */
+	char		*abslink;	/* absolute symlink path */
+	int		relstart;	/* offset of relative path in 'abslink' */
+	struct namei	*next;		/* next item */
+	int		level;
+	int		mountpoint;	/* is mount point */
+	int		noent;		/* this item not existing (stores errno from stat()) */
+};
+
+static int flags;
+static struct idcache *gcache;	/* groupnames */
+static struct idcache *ucache;	/* usernames */
+
+static void
+free_namei(struct namei *nm)
+{
+	while (nm) {
+		struct namei *next = nm->next;
+		free(nm->name);
+		free(nm->abslink);
+		free(nm);
+		nm = next;
+	}
+}
+
+static void
+readlink_to_namei(struct namei *nm, const char *path)
+{
+	char sym[PATH_MAX];
+	ssize_t sz;
+	int isrel = 0;
+
+	sz = readlink(path, sym, sizeof(sym));
+	if (sz < 1)
+		err(EXIT_FAILURE, _("failed to read symlink: %s"), path);
+	if (*sym != '/') {
+		char *p = strrchr(path, '/');
+
+		if (p) {
+			isrel = 1;
+			nm->relstart = p - path;
+			sz += nm->relstart + 1;
+		}
+	}
+	nm->abslink = xmalloc(sz + 1);
+
+	if (*sym != '/' && isrel) {
+		/* create the absolute path from the relative symlink */
+		memcpy(nm->abslink, path, nm->relstart);
+		*(nm->abslink + nm->relstart) = '/';
+		nm->relstart++;
+		memcpy(nm->abslink + nm->relstart, sym, sz - nm->relstart);
+	} else
+		/* - absolute link (foo -> /path/bar)
+		 * - or link without any subdir (foo -> bar)
+		 */
+		memcpy(nm->abslink, sym, sz);
+
+	nm->abslink[sz] = '\0';
+}
+
+static struct stat *
+dotdot_stat(const char *dirname, struct stat *st)
+{
+	char *path;
+	size_t len;
+
+#define DOTDOTDIR	"/.."
+
+	if (!dirname)
+		return NULL;
+
+	len = strlen(dirname);
+	path = xmalloc(len + sizeof(DOTDOTDIR));
+
+	memcpy(path, dirname, len);
+	memcpy(path + len, DOTDOTDIR, sizeof(DOTDOTDIR));
+
+	if (stat(path, st))
+		err(EXIT_FAILURE, _("stat of %s failed"), path);
+	free(path);
+	return st;
+}
+
+static struct namei *
+new_namei(struct namei *parent, const char *path, const char *fname, int lev)
+{
+	struct namei *nm;
+
+	if (!fname)
+		return NULL;
+	nm = xcalloc(1, sizeof(*nm));
+	if (parent)
+		parent->next = nm;
+
+	nm->level = lev;
+	nm->name = xstrdup(fname);
+
+	if (lstat(path, &nm->st) != 0) {
+		nm->noent = errno;
+		return nm;
+	}
+
+	if (S_ISLNK(nm->st.st_mode))
+		readlink_to_namei(nm, path);
+	if (flags & NAMEI_OWNERS) {
+		add_uid(ucache, nm->st.st_uid);
+		add_gid(gcache, nm->st.st_gid);
+	}
+
+	if ((flags & NAMEI_MNTS) && S_ISDIR(nm->st.st_mode)) {
+		struct stat stbuf, *sb = NULL;
+
+		if (parent && S_ISDIR(parent->st.st_mode))
+			sb = &parent->st;
+		else if (!parent || S_ISLNK(parent->st.st_mode))
+			sb = dotdot_stat(path, &stbuf);
+
+		if (sb && (sb->st_dev != nm->st.st_dev ||   /* different device */
+		           sb->st_ino == nm->st.st_ino))    /* root directory */
+			nm->mountpoint = 1;
+	}
+
+	return nm;
+}
+
+static struct namei *
+add_namei(struct namei *parent, const char *orgpath, int start, struct namei **last)
+{
+	struct namei *nm = NULL, *first = NULL;
+	char *fname, *end, *path;
+	int level = 0;
+
+	if (!orgpath)
+		return NULL;
+	if (parent) {
+		nm = parent;
+		level = parent->level + 1;
+	}
+	path = xstrdup(orgpath);
+	fname = path + start;
+
+	/* root directory */
+	if (*fname == '/') {
+		while (*fname == '/')
+			fname++; /* eat extra '/' */
+		first = nm = new_namei(nm, "/", "/", level);
+	}
+
+	for (end = fname; fname && end; ) {
+		/* set end of filename */
+		if (*fname) {
+			end = strchr(fname, '/');
+			if (end)
+				*end = '\0';
+
+			/* create a new entry */
+			nm = new_namei(nm, path, fname, level);
+		} else
+			end = NULL;
+		if (!first)
+			first = nm;
+		/* set begin of the next filename */
+		if (end) {
+			*end++ = '/';
+			while (*end == '/')
+				end++; /* eat extra '/' */
+		}
+		fname = end;
+	}
+
+	if (last)
+		*last = nm;
+
+	free(path);
+
+	return first;
+}
+
+static int
+follow_symlinks(struct namei *nm)
+{
+	int symcount = 0;
+
+	for (; nm; nm = nm->next) {
+		struct namei *next, *last;
+
+		if (nm->noent)
+			continue;
+		if (!S_ISLNK(nm->st.st_mode))
+			continue;
+		if (++symcount > MAXSYMLINKS) {
+			/* drop the rest of the list */
+			free_namei(nm->next);
+			nm->next = NULL;
+			return -1;
+		}
+		next = nm->next;
+		nm->next = add_namei(nm, nm->abslink, nm->relstart, &last);
+		if (last)
+			last->next = next;
+		else
+			nm->next = next;
+	}
+	return 0;
+}
+
+static int
+print_namei(struct namei *nm, char *path)
+{
+	int i;
+
+	if (path)
+		printf("f: %s\n", path);
+
+	for (; nm; nm = nm->next) {
+		char md[11];
+
+		if (nm->noent) {
+			int blanks = 1;
+			if (flags & NAMEI_MODES)
+				blanks += 9;
+			if (flags & NAMEI_OWNERS)
+				blanks += ucache->width + gcache->width + 2;
+			if (!(flags & NAMEI_VERTICAL))
+				blanks += 1;
+			blanks += nm->level * 2;
+			printf("%*s ", blanks, "");
+			printf("%s - %s\n", nm->name, strerror(nm->noent));
+			return -1;
+		}
+
+		xstrmode(nm->st.st_mode, md);
+
+		if (nm->mountpoint)
+			md[0] = 'D';
+
+		if (!(flags & NAMEI_VERTICAL)) {
+			for (i = 0; i < nm->level; i++)
+				fputs("  ", stdout);
+			fputc(' ', stdout);
+		}
+
+		if (flags & NAMEI_MODES)
+			printf("%s", md);
+		else
+			printf("%c", md[0]);
+
+		if (flags & NAMEI_OWNERS) {
+			printf(" %-*s", ucache->width,
+				get_id(ucache, nm->st.st_uid)->name);
+			printf(" %-*s", gcache->width,
+				get_id(gcache, nm->st.st_gid)->name);
+		}
+
+		if (flags & NAMEI_VERTICAL)
+			for (i = 0; i < nm->level; i++)
+				fputs("  ", stdout);
+
+		if (S_ISLNK(nm->st.st_mode))
+			printf(" %s -> %s\n", nm->name,
+					nm->abslink + nm->relstart);
+		else
+			printf(" %s\n", nm->name);
+	}
+	return 0;
+}
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	const char *p = program_invocation_short_name;
+	FILE *out = stdout;
+
+	if (!*p)
+		p = "namei";
+
+	fputs(USAGE_HEADER, out);
+	fprintf(out,
+	      _(" %s [options] <pathname>...\n"), p);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("Follow a pathname until a terminal point is found.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(
+		" -x, --mountpoints   show mount point directories with a 'D'\n"
+		" -m, --modes         show the mode bits of each file\n"
+		" -o, --owners        show owner and group name of each file\n"
+		" -l, --long          use a long listing format (-m -o -v) \n"
+		" -n, --nosymlinks    don't follow symlinks\n"
+		" -v, --vertical      vertical align of modes and owners\n"), out);
+	printf(USAGE_HELP_OPTIONS(21));
+
+	printf(USAGE_MAN_TAIL("namei(1)"));
+	exit(EXIT_SUCCESS);
+}
+
+static const struct option longopts[] =
+{
+	{ "help",	 no_argument, NULL, 'h' },
+	{ "version",     no_argument, NULL, 'V' },
+	{ "mountpoints", no_argument, NULL, 'x' },
+	{ "modes",	 no_argument, NULL, 'm' },
+	{ "owners",	 no_argument, NULL, 'o' },
+	{ "long",        no_argument, NULL, 'l' },
+	{ "nolinks",	 no_argument, NULL, 'n' },
+	{ "vertical",    no_argument, NULL, 'v' },
+	{ NULL, 0, NULL, 0 },
+};
+
+int
+main(int argc, char **argv)
+{
+	int c;
+	int rc = EXIT_SUCCESS;
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	while ((c = getopt_long(argc, argv, "hVlmnovx", longopts, NULL)) != -1) {
+		switch(c) {
+		case 'l':
+			flags |= (NAMEI_OWNERS | NAMEI_MODES | NAMEI_VERTICAL);
+			break;
+		case 'm':
+			flags |= NAMEI_MODES;
+			break;
+		case 'n':
+			flags |= NAMEI_NOLINKS;
+			break;
+		case 'o':
+			flags |= NAMEI_OWNERS;
+			break;
+		case 'x':
+			flags |= NAMEI_MNTS;
+			break;
+		case 'v':
+			flags |= NAMEI_VERTICAL;
+			break;
+
+		case 'h':
+			usage();
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+
+	if (optind == argc) {
+		warnx(_("pathname argument is missing"));
+		errtryhelp(EXIT_FAILURE);
+	}
+
+	ucache = new_idcache();
+	if (!ucache)
+		err(EXIT_FAILURE, _("failed to allocate UID cache"));
+	gcache = new_idcache();
+	if (!gcache)
+		err(EXIT_FAILURE, _("failed to allocate GID cache"));
+
+	for(; optind < argc; optind++) {
+		char *path = argv[optind];
+		struct namei *nm = NULL;
+		struct stat st;
+
+		if (stat(path, &st) != 0)
+			rc = EXIT_FAILURE;
+
+		nm = add_namei(NULL, path, 0, NULL);
+		if (nm) {
+			int sml = 0;
+			if (!(flags & NAMEI_NOLINKS))
+				sml = follow_symlinks(nm);
+			if (print_namei(nm, path)) {
+				rc = EXIT_FAILURE;
+				continue;
+			}
+			free_namei(nm);
+			if (sml == -1) {
+				rc = EXIT_FAILURE;
+				warnx(_("%s: exceeded limit of symlinks"), path);
+				continue;
+			}
+		}
+	}
+
+	free_idcache(ucache);
+	free_idcache(gcache);
+
+	return rc;
+}
+
diff --git a/misc-utils/rename.1 b/misc-utils/rename.1
new file mode 100644
index 0000000..6b69ffc
--- /dev/null
+++ b/misc-utils/rename.1
@@ -0,0 +1,122 @@
+.\" Written by Andries E. Brouwer (aeb@cwi.nl)
+.\" Placed in the public domain
+.\"
+.TH RENAME 1 "June 2011" "util-linux" "User Commands"
+.SH NAME
+rename \- rename files
+.SH SYNOPSIS
+.B rename
+[options]
+.IR "expression replacement file" ...
+.SH DESCRIPTION
+.B rename
+will rename the specified files by replacing the first occurrence of
+.I expression
+in their name by
+.IR replacement .
+.SH OPTIONS
+.TP
+.BR \-s , " \-\-symlink"
+Do not rename a symlink but its target.
+.TP
+.BR \-v , " \-\-verbose"
+Show which files were renamed, if any.
+.TP
+.BR \-n , " \-\-no\-act"
+Do not make any changes; add
+.B \-\-verbose
+to see what would be made.
+.TP
+.BR \-o , " \-\-no\-overwrite"
+Do not overwrite existing files.  When
+.B \-\-symlink
+is active, do not overwrite symlinks pointing to existing targets.
+.TP
+.BR \-i , " \-\-interactive"
+Ask before overwriting existing files.
+.TP
+.BR \-V , " \-\-version"
+Display version information and exit.
+.TP
+.BR \-h , " \-\-help"
+Display help text and exit.
+.SH WARNING
+The renaming has no safeguards by default or without any one of the options
+.B \-\-no-overwrite\fR,
+.B \-\-interactive
+or
+.B \-\-no\-act\fR.
+If the user has
+permission to rewrite file names, the command will perform the action without
+any questions.  For example, the result can be quite drastic when the command
+is run as root in the /lib directory.  Always make a backup before running the
+command, unless you truly know what you are doing.
+.SH INTERACTIVE MODE
+As most standard utilities rename can be used with a terminal device (tty in
+short) in canonical mode, where the line is buffered by the tty and you press
+ENTER to validate the user input.  If you put your tty in cbreak mode however,
+rename requires only a single key press to answer the prompt.  To set cbreak
+mode, run for example:
+.PP
+.RS
+.nf
+sh \-c 'stty \-icanon min 1; "$0" "$@"; stty icanon' rename \-i from to files
+.fi
+.RE
+.SH EXIT STATUS
+.RS
+.PD 0
+.TP
+.B 0
+all requested rename operations were successful
+.TP
+.B 1
+all rename operations failed
+.TP
+.B 2
+some rename operations failed
+.TP
+.B 4
+nothing was renamed
+.TP
+.B 64
+unanticipated error occurred
+.PD
+.RE
+.SH EXAMPLES
+Given the files
+.IR foo1 ", ..., " foo9 ", " foo10 ", ..., " foo278 ,
+the commands
+.PP
+.RS
+.nf
+rename foo foo00 foo?
+rename foo foo0 foo??
+.fi
+.RE
+.PP
+will turn them into
+.IR foo001 ", ..., " foo009 ", " foo010 ", ..., " foo278 .
+And
+.PP
+.RS
+.nf
+rename .htm .html *.htm
+.fi
+.RE
+.PP
+will fix the extension of your html files.
+Provide an empty string for shortening:
+.PP
+.RS
+.nf
+rename '_with_long_name' '' file_with_long_name.*
+.fi
+.RE
+.PP
+will remove the substring in the filenames.
+.SH SEE ALSO
+.BR mv (1)
+.SH AVAILABILITY
+The rename command is part of the util-linux package and is available from
+https://www.kernel.org/pub/linux/utils/util-linux/.
diff --git a/misc-utils/rename.c b/misc-utils/rename.c
new file mode 100644
index 0000000..0f0d883
--- /dev/null
+++ b/misc-utils/rename.c
@@ -0,0 +1,322 @@
+/*
+ * rename.c - aeb 2000-01-01
+ *
+--------------------------------------------------------------
+#!/bin/sh
+if [ $# -le 2 ]; then echo call: rename from to files; exit; fi
+FROM="$1"
+TO="$2"
+shift
+shift
+for i in $@; do N=`echo "$i" | sed "s/$FROM/$TO/g"`; mv "$i" "$N"; done
+--------------------------------------------------------------
+ * This shell script will do renames of files, but may fail
+ * in cases involving special characters. Here a C version.
+ */
+#include <stdio.h>
+#ifdef HAVE_STDIO_EXT_H
+#	include <stdio_ext.h>
+#endif
+#ifndef HAVE___FPURGE
+# ifdef HAVE_FPURGE
+#	define HAVE___FPURGE 1
+#	define __fpurge fpurge
+# endif
+#endif
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <getopt.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <termios.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "nls.h"
+#include "xalloc.h"
+#include "c.h"
+#include "closestream.h"
+#include "rpmatch.h"
+
+#define RENAME_EXIT_SOMEOK	2
+#define RENAME_EXIT_NOTHING	4
+#define RENAME_EXIT_UNEXPLAINED	64
+
+static int tty_cbreak = 0;
+
+static int string_replace(char *from, char *to, char *s, char *orig, char **newname)
+{
+	char *p, *q, *where;
+
+	where = strstr(s, from);
+	if (where == NULL)
+		return 1;
+	p = orig;
+	*newname = xmalloc(strlen(orig) + strlen(to) + 1);
+	q = *newname;
+	while (p < where)
+		*q++ = *p++;
+	p = to;
+	while (*p)
+		*q++ = *p++;
+	p = where + strlen(from);
+	while (*p)
+		*q++ = *p++;
+	*q = 0;
+	return 0;
+}
+
+static int ask(char *name)
+{
+	int c;
+	char buf[2];
+	printf(_("%s: overwrite `%s'? "), program_invocation_short_name, name);
+	fflush(stdout);
+	if ((c = fgetc(stdin)) == EOF) {
+		buf[0] = 'n';
+		printf("n\n");
+	}
+	else {
+		buf[0] = c;
+		if (c != '\n' && tty_cbreak) {
+#ifdef HAVE___FPURGE
+			/* Possibly purge a multi-byte character; or do a
+			   required purge of the rest of the line (including
+			   the newline) if the tty has been put back in
+			   canonical mode (for example by a shell after a
+			   SIGTSTP signal). */
+			__fpurge(stdin);
+#endif
+			printf("\n");
+		}
+		else if (c != '\n')
+			while ((c = fgetc(stdin)) != '\n' && c != EOF);
+	}
+	buf[1] = '\0';
+	if (rpmatch(buf) == RPMATCH_YES)
+		return 0;
+
+	return 1;
+}
+
+static int do_symlink(char *from, char *to, char *s, int verbose, int noact,
+                      int nooverwrite, int interactive)
+{
+	char *newname = NULL, *target = NULL;
+	int ret = 1;
+	struct stat sb;
+
+	if ( faccessat(AT_FDCWD, s, F_OK, AT_SYMLINK_NOFOLLOW) != 0 &&
+	     errno != EINVAL )
+	   /* Skip if AT_SYMLINK_NOFOLLOW is not supported; lstat() below will
+	      detect the access error */
+	{
+		warn(_("%s: not accessible"), s);
+		return 2;
+	}
+
+	if (lstat(s, &sb) == -1) {
+		warn(_("stat of %s failed"), s);
+		return 2;
+	}
+	if (!S_ISLNK(sb.st_mode)) {
+		warnx(_("%s: not a symbolic link"), s);
+		return 2;
+	}
+	target = xmalloc(sb.st_size + 1);
+	if (readlink(s, target, sb.st_size + 1) < 0) {
+		warn(_("%s: readlink failed"), s);
+		free(target);
+		return 2;
+	}
+	target[sb.st_size] = '\0';
+	if (string_replace(from, to, target, target, &newname) != 0)
+		ret = 0;
+
+	if (ret == 1 && (nooverwrite || interactive) && lstat(newname, &sb) != 0)
+		nooverwrite = interactive = 0;
+
+	if ( ret == 1 &&
+	     (nooverwrite || (interactive && (noact || ask(newname) != 0))) )
+	{
+		if (verbose)
+			printf(_("Skipping existing link: `%s' -> `%s'\n"), s, target);
+		ret = 0;
+	}
+
+	if (ret == 1) {
+		if (!noact && 0 > unlink(s)) {
+			warn(_("%s: unlink failed"), s);
+			ret = 2;
+		}
+		else if (!noact && symlink(newname, s) != 0) {
+			warn(_("%s: symlinking to %s failed"), s, newname);
+			ret = 2;
+		}
+	}
+	if (verbose && (noact || ret == 1))
+		printf("%s: `%s' -> `%s'\n", s, target, newname);
+	free(newname);
+	free(target);
+	return ret;
+}
+
+static int do_file(char *from, char *to, char *s, int verbose, int noact,
+                   int nooverwrite, int interactive)
+{
+	char *newname = NULL, *file=NULL;
+	int ret = 1;
+	struct stat sb;
+
+	if ( faccessat(AT_FDCWD, s, F_OK, AT_SYMLINK_NOFOLLOW) != 0 &&
+	     errno != EINVAL )
+	   /* Skip if AT_SYMLINK_NOFOLLOW is not supported; lstat() below will
+	      detect the access error */
+	{
+		warn(_("%s: not accessible"), s);
+		return 2;
+	}
+
+	if (lstat(s, &sb) == -1) {
+		warn(_("stat of %s failed"), s);
+		return 2;
+	}
+	if (strchr(from, '/') == NULL && strchr(to, '/') == NULL)
+		file = strrchr(s, '/');
+	if (file == NULL)
+		file = s;
+	if (string_replace(from, to, file, s, &newname) != 0)
+		return 0;
+
+	if ((nooverwrite || interactive) && access(newname, F_OK) != 0)
+		nooverwrite = interactive = 0;
+
+	if (nooverwrite || (interactive && (noact || ask(newname) != 0))) {
+		if (verbose)
+			printf(_("Skipping existing file: `%s'\n"), newname);
+		ret = 0;
+	}
+	else if (!noact && rename(s, newname) != 0) {
+		warn(_("%s: rename to %s failed"), s, newname);
+		ret = 2;
+	}
+	if (verbose && (noact || ret == 1))
+		printf("`%s' -> `%s'\n", s, newname);
+	free(newname);
+	return ret;
+}
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+	fputs(USAGE_HEADER, out);
+	fprintf(out,
+	      _(" %s [options] <expression> <replacement> <file>...\n"),
+		program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("Rename files.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -v, --verbose       explain what is being done\n"), out);
+	fputs(_(" -s, --symlink       act on the target of symlinks\n"), out);
+	fputs(_(" -n, --no-act        do not make any changes\n"), out);
+	fputs(_(" -o, --no-overwrite  don't overwrite existing files\n"), out);
+	fputs(_(" -i, --interactive   prompt before overwrite\n"), out);
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(21));
+	printf(USAGE_MAN_TAIL("rename(1)"));
+	exit(EXIT_SUCCESS);
+}
+
+int main(int argc, char **argv)
+{
+	char *from, *to;
+	int i, c, ret = 0, verbose = 0, noact = 0, nooverwrite = 0, interactive = 0;
+	struct termios tio;
+	int (*do_rename)(char *from, char *to, char *s, int verbose, int noact,
+	                 int nooverwrite, int interactive) = do_file;
+
+	static const struct option longopts[] = {
+		{"verbose", no_argument, NULL, 'v'},
+		{"version", no_argument, NULL, 'V'},
+		{"help", no_argument, NULL, 'h'},
+		{"no-act", no_argument, NULL, 'n'},
+		{"no-overwrite", no_argument, NULL, 'o'},
+		{"interactive", no_argument, NULL, 'i'},
+		{"symlink", no_argument, NULL, 's'},
+		{NULL, 0, NULL, 0}
+	};
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	while ((c = getopt_long(argc, argv, "vsVhnoi", longopts, NULL)) != -1)
+		switch (c) {
+		case 'n':
+			noact = 1;
+			break;
+		case 'v':
+			verbose = 1;
+			break;
+		case 'o':
+			nooverwrite = 1;
+			interactive = 0;
+			break;
+		case 'i':
+			interactive = 1;
+			nooverwrite = 0;
+			break;
+		case 's':
+			do_rename = do_symlink;
+			break;
+
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		case 'h':
+			usage();
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+
+	argc -= optind;
+	argv += optind;
+
+	if (argc < 3) {
+		warnx(_("not enough arguments"));
+		errtryhelp(EXIT_FAILURE);
+	}
+
+	from = argv[0];
+	to = argv[1];
+
+	if (!strcmp(from, to))
+		return RENAME_EXIT_NOTHING;
+
+	tty_cbreak = 0;
+	if (interactive && isatty(STDIN_FILENO) != 0) {
+		if (tcgetattr(STDIN_FILENO, &tio) != 0)
+			warn(_("failed to get terminal attributes"));
+		else if (!(tio.c_lflag & ICANON) && tio.c_cc[VMIN] == 1)
+			tty_cbreak = 1;
+	}
+
+	for (i = 2; i < argc; i++)
+		ret |= do_rename(from, to, argv[i], verbose, noact, nooverwrite, interactive);
+
+	switch (ret) {
+	case 0:
+		return RENAME_EXIT_NOTHING;
+	case 1:
+		return EXIT_SUCCESS;
+	case 2:
+		return EXIT_FAILURE;
+	case 3:
+		return RENAME_EXIT_SOMEOK;
+	default:
+		return RENAME_EXIT_UNEXPLAINED;
+	}
+}
diff --git a/misc-utils/test_uuidd.c b/misc-utils/test_uuidd.c
new file mode 100644
index 0000000..779b28d
--- /dev/null
+++ b/misc-utils/test_uuidd.c
@@ -0,0 +1,348 @@
+/*
+ * Copyright (C) 2006 Hewlett-Packard Development Company, L.P.
+ * Huschaam Hussain <Huschaam.Hussain@hp.com>
+ *	TSG Solution Alliances Engineering
+ *	SAP Technology Group
+ *
+ * Copyright (C) 2015 Karel Zak <kzak@redhat.com>
+ *
+ *
+ * The test heavily uses shared memory, to enlarge maximal size of shared
+ * segment use:
+ *
+ *	echo "4294967295" > /proc/sys/kernel/shmm
+ *
+ * The test is compiled against in-tree libuuid, if you want to test uuidd
+ * installed to the system then make sure that libuuid uses the same socket
+ * like the running uuidd. You can start the uuidd manually, for example:
+ *
+ *	uuidd --debug --no-fork --no-pid --socket /run/uuidd/request
+ *
+ * if the $runstatedir (as defined by build-system) is /run. If you want
+ * to overwrite the built-in default then use:
+ *
+ *	make uuidd uuidgen runstatedir=/var/run
+ */
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/shm.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include "uuid.h"
+#include "c.h"
+#include "xalloc.h"
+#include "strutils.h"
+#include "nls.h"
+
+#define LOG(level,args) if (loglev >= level) { fprintf args; }
+
+static size_t nprocesses = 4;
+static size_t nthreads = 4;
+static size_t nobjects = 4096;
+static size_t loglev = 1;
+
+struct processentry {
+	pid_t		pid;
+	int		status;
+};
+typedef struct processentry process_t;
+
+struct threadentry {
+	process_t	*proc;
+	pthread_t	tid;		/* pthread_self() / phtread_create() */
+	pthread_attr_t	thread_attr;
+	size_t		index;		/* index in object[] */
+	int		retval;		/* pthread exit() */
+};
+typedef struct threadentry thread_t;
+
+/* this is in shared memory, keep it as small as possible */
+struct objectentry {
+	uuid_t		uuid;
+	pthread_t	tid;
+	pid_t		pid;
+	size_t		idx;
+};
+typedef struct objectentry object_t;
+
+static int shmem_id;
+static object_t *objects;
+
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	printf("\n %s [options]\n", program_invocation_short_name);
+
+	printf("  -p <num>     number of nprocesses (default:%zu)\n", nprocesses);
+	printf("  -t <num>     number of nthreads (default:%zu)\n", nthreads);
+	printf("  -o <num>     number of nobjects (default:%zu)\n", nobjects);
+	printf("  -l <level>   log level (default:%zu)\n", loglev);
+	printf("  -h           display help\n");
+
+	exit(EXIT_SUCCESS);
+}
+
+static void allocate_segment(int *id, void **address, size_t number, size_t size)
+{
+	*id = shmget(IPC_PRIVATE, number * size, IPC_CREAT | 0600);
+	if (*id == -1)
+		err(EXIT_FAILURE, "shmget failed to create %zu bytes shared memory", number * size);
+
+	*address = shmat(*id, NULL, 0);
+	if (*address == (void *)-1)
+		err(EXIT_FAILURE, "shmat failed");
+
+	LOG(2, (stderr,
+	     "allocate shared memory segment [id=%d,address=0x%p]\n",
+	     *id, *address));
+
+	memset(*address, 0, number * size);
+}
+
+static void remove_segment(int id, void *address)
+{
+	if (shmdt(address) == -1)
+		err(EXIT_FAILURE, "shmdt failed");
+	if (shmctl(id, IPC_RMID, NULL) == -1)
+		err(EXIT_FAILURE, "shmctl failed");
+	LOG(2,
+	    (stderr,
+	     "remove shared memory segment [id=%d,address=0x%p]\n",
+	     id, address));
+}
+
+static void object_uuid_create(object_t * object)
+{
+	uuid_generate_time(object->uuid);
+}
+
+static void object_uuid_to_string(object_t * object, char **string_uuid)
+{
+	uuid_unparse(object->uuid, *string_uuid);
+}
+
+static int object_uuid_compare(const void *object1, const void *object2)
+{
+	uuid_t *uuid1 = &((object_t *) object1)->uuid,
+	       *uuid2 = &((object_t *) object2)->uuid;
+
+	return uuid_compare(*uuid1, *uuid2);
+}
+
+static void *create_uuids(thread_t *th)
+{
+	size_t i;
+
+	for (i = th->index; i < th->index + nobjects; i++) {
+		object_t *obj = &objects[i];
+
+		object_uuid_create(obj);
+		obj->tid = th->tid;
+		obj->pid = th->proc->pid;
+		obj->idx = th->index + i;
+	}
+	return NULL;
+}
+
+static void *thread_body(void *arg)
+{
+	thread_t *th = (thread_t *) arg;
+
+	return create_uuids(th);
+}
+
+static void create_nthreads(process_t *proc, size_t index)
+{
+	thread_t *threads;
+	size_t i, ncreated = 0;
+	int rc;
+
+	threads = xcalloc(nthreads, sizeof(thread_t));
+
+	for (i = 0; i < nthreads; i++) {
+		thread_t *th = &threads[i];
+
+		rc = pthread_attr_init(&th->thread_attr);
+		if (rc) {
+			errno = rc;
+			warn("%d: pthread_attr_init failed", proc->pid);
+			break;
+		}
+
+		th->index = index;
+		th->proc = proc;
+		rc = pthread_create(&th->tid, &th->thread_attr, &thread_body, th);
+
+		if (rc) {
+			errno = rc;
+			warn("%d: pthread_create failed", proc->pid);
+			break;
+		}
+
+		LOG(2, (stderr, "%d: started thread [tid=%jd,index=%zu]\n",
+		     proc->pid, (intmax_t) th->tid, th->index));
+		index += nobjects;
+		ncreated++;
+	}
+
+	if (ncreated != nthreads)
+		fprintf(stderr, "%d: %zu threads not created and ~%zu objects will be ignored\n",
+				proc->pid, nthreads - ncreated,
+				(nthreads - ncreated) * nobjects);
+
+	for (i = 0; i < ncreated; i++) {
+		thread_t *th = &threads[i];
+
+		rc = pthread_join(th->tid, (void *) &th->retval);
+		if (rc) {
+			errno = rc;
+			err(EXIT_FAILURE, "pthread_join failed");
+		}
+
+		LOG(2, (stderr, "%d: thread exited [tid=%jd,return=%d]\n",
+		     proc->pid, (intmax_t) th->tid, th->retval));
+	}
+
+	free(threads);
+}
+
+static void create_nprocesses(void)
+{
+	process_t *process;
+	size_t i;
+
+	process = xcalloc(nprocesses, sizeof(process_t));
+
+	for (i = 0; i < nprocesses; i++) {
+		process_t *proc = &process[i];
+
+		proc->pid = fork();
+		switch (proc->pid) {
+		case -1: /* error */
+			err(EXIT_FAILURE, "fork failed");
+			break;
+		case 0: /* child */
+			proc->pid = getpid();
+			create_nthreads(proc, i * nthreads * nobjects);
+			exit(EXIT_SUCCESS);
+			break;
+		default: /* parent */
+			LOG(2, (stderr, "started process [pid=%d]\n", proc->pid));
+			break;
+		}
+	}
+
+	for (i = 0; i < nprocesses; i++) {
+		process_t *proc = &process[i];
+
+		if (waitpid(proc->pid, &proc->status, 0) == (pid_t) - 1)
+			err(EXIT_FAILURE, "waitpid failed");
+		LOG(2,
+		    (stderr, "process exited [pid=%d,status=%d]\n",
+		     proc->pid, proc->status));
+	}
+
+	free(process);
+}
+
+static void object_dump(size_t idx, object_t *obj)
+{
+	char uuid_string[UUID_STR_LEN], *p;
+
+	p = uuid_string;
+	object_uuid_to_string(obj, &p);
+
+	fprintf(stderr, "object[%zu]: {\n", idx);
+	fprintf(stderr, "  uuid:    <%s>\n", p);
+	fprintf(stderr, "  idx:     %zu\n", obj->idx);
+	fprintf(stderr, "  process: %d\n", (int) obj->pid);
+	fprintf(stderr, "  thread:  %jd\n", (intmax_t) obj->tid);
+	fprintf(stderr, "}\n");
+}
+
+#define MSG_TRY_HELP "Try '-h' for help."
+
+int main(int argc, char *argv[])
+{
+	size_t i, nfailed = 0, nignored = 0;
+	int c;
+
+	while (((c = getopt(argc, argv, "p:t:o:l:h")) != -1)) {
+		switch (c) {
+		case 'p':
+			nprocesses = strtou32_or_err(optarg, "invalid nprocesses number argument");
+			break;
+		case 't':
+			nthreads = strtou32_or_err(optarg, "invalid nthreads number argument");
+			break;
+		case 'o':
+			nobjects = strtou32_or_err(optarg, "invalid nobjects number argument");
+			break;
+		case 'l':
+			loglev = strtou32_or_err(optarg, "invalid log level argument");
+			break;
+		case 'h':
+			usage();
+			break;
+		default:
+			fprintf(stderr, MSG_TRY_HELP);
+			exit(EXIT_FAILURE);
+		}
+	}
+
+	if (optind != argc)
+		errx(EXIT_FAILURE, "bad usage\n" MSG_TRY_HELP);
+
+	if (loglev == 1)
+		fprintf(stderr, "requested: %zu processes, %zu threads, %zu objects per thread (%zu objects = %zu bytes)\n",
+				nprocesses, nthreads, nobjects,
+				nprocesses * nthreads * nobjects,
+				nprocesses * nthreads * nobjects * sizeof(object_t));
+
+	allocate_segment(&shmem_id, (void **)&objects,
+			 nprocesses * nthreads * nobjects, sizeof(object_t));
+
+	create_nprocesses();
+
+	if (loglev >= 3) {
+		for (i = 0; i < nprocesses * nthreads * nobjects; i++)
+			object_dump(i, &objects[i]);
+	}
+
+	qsort(objects, nprocesses * nthreads * nobjects, sizeof(object_t),
+	      object_uuid_compare);
+
+	for (i = 0; i < nprocesses * nthreads * nobjects - 1; i++) {
+		object_t *obj1 = &objects[i],
+			 *obj2 = &objects[i + 1];
+
+		if (!obj1->tid) {
+			LOG(3, (stderr, "ignore unused object #%zu\n", i));
+			nignored++;
+			continue;
+		}
+
+		if (object_uuid_compare(obj1, obj2) == 0) {
+			if (loglev >= 1)
+				fprintf(stderr, "nobjects #%zu and #%zu have duplicate UUIDs\n",
+					i, i + 1);
+					object_dump(i, obj1),
+					object_dump(i + 1, obj2);
+			nfailed++;
+		}
+	}
+
+	remove_segment(shmem_id, objects);
+	if (nignored)
+		printf("%zu objects ignored\n", nignored);
+	if (!nfailed)
+		printf("test successful (no duplicate UUIDs found)\n");
+	else
+		printf("test failed (found %zu duplicate UUIDs)\n", nfailed);
+
+	return nfailed ? EXIT_FAILURE : EXIT_SUCCESS;
+}
diff --git a/misc-utils/uuidd.8 b/misc-utils/uuidd.8
new file mode 100644
index 0000000..1316184
--- /dev/null
+++ b/misc-utils/uuidd.8
@@ -0,0 +1,94 @@
+.\" -*- nroff -*-
+.\" Copyright 2007 by Theodore Ts'o.  All Rights Reserved.
+.\" This file may be copied under the terms of the GNU Public License.
+.\"
+.TH UUIDD 8 "July 2014" "util-linux" "System Administration"
+.SH NAME
+uuidd \- UUID generation daemon
+.SH SYNOPSIS
+.B uuidd
+[options]
+.SH DESCRIPTION
+The
+.B uuidd
+daemon is used by the UUID library to generate
+universally unique identifiers (UUIDs), especially time-based UUIDs,
+in a secure and guaranteed-unique fashion, even in the face of large
+numbers of threads running on different CPUs trying to grab UUIDs.
+.SH OPTIONS
+.TP
+.BR \-d , " \-\-debug"
+Run uuidd in debugging mode.  This prevents uuidd from running as a daemon.
+.TP
+.BR \-F , " \-\-no-fork"
+Do not daemonize using a double-fork.
+.TP
+.BR \-k , " \-\-kill"
+If currently a uuidd daemon is running, kill it.
+.TP
+.BR \-n , " \-\-uuids " \fInumber\fR
+When issuing a test request to a running uuidd, request a bulk response
+of
+.I number
+UUIDs.
+.TP
+.BR \-P , " \-\-no-pid"
+Do not create a pid file.
+.TP
+.BR \-p , " \-\-pid " \fIpath\fR
+Specify the pathname where the pid file should be written.  By default,
+the pid file is written to /run/uuidd/uuidd.pid.
+.TP
+.BR \-q , " \-\-quiet"
+Suppress some failure messages.
+.TP
+.BR \-r , " \-\-random"
+Test uuidd by trying to connect to a running uuidd daemon and
+request it to return a random-based UUID.
+.TP
+.BR \-S , " \-\-socket-activation"
+Do not create a socket but instead expect it to be provided by the calling
+process.  This implies \fB\-\-no-fork\fR and \fB\-\-no-pid\fR.  This option is
+intended to be used only with \fBsystemd\fR(1).  It needs to be enabled with
+a configure option.
+.TP
+.BR \-s , " \-\-socket " \fIpath\fR
+Make uuidd use this pathname for the unix-domain socket.  By default, the
+pathname used is /run/uuidd/request.  This option is primarily
+for debugging purposes, since the pathname is hard-coded in the libuuid
+library.
+.TP
+.BR \-T , " \-\-timeout " \fInumber\fR
+Make uuidd exit after \fInumber\fR seconds of inactivity.
+.TP
+.BR \-t , " \-\-time"
+Test uuidd by trying to connect to a running uuidd daemon and
+request it to return a time-based UUID.
+.TP
+.BR \-V , " \-\-version"
+Output version information and exit.
+.TP
+.BR \-h , " \-\-help"
+Display help screen and exit.
+.SH EXAMPLE
+Start up a daemon, print 42 random keys, and then stop the daemon:
+.PP
+.RS
+.nf
+uuidd \-p /tmp/uuidd.pid \-s /tmp/uuidd.socket
+uuidd \-d \-r \-n 42 \-s /tmp/uuidd.socket
+uuidd \-d \-k \-s /tmp/uuidd.socket
+.fi
+.RE
+.SH AUTHOR
+The
+.B uuidd
+daemon was written by Theodore Ts'o <tytso@mit.edu>.
+.SH "SEE ALSO"
+.BR uuid (3),
+.BR uuidgen (1)
+.SH AVAILABILITY
+The uuidd daemon is part of the util-linux package and is available from the
+.UR https://\:www.kernel.org\:/pub\:/linux\:/utils\:/util-linux/
+Linux Kernel Archive
+.UE .
diff --git a/misc-utils/uuidd.8.in b/misc-utils/uuidd.8.in
new file mode 100644
index 0000000..fda5108
--- /dev/null
+++ b/misc-utils/uuidd.8.in
@@ -0,0 +1,94 @@
+.\" -*- nroff -*-
+.\" Copyright 2007 by Theodore Ts'o.  All Rights Reserved.
+.\" This file may be copied under the terms of the GNU Public License.
+.\"
+.TH UUIDD 8 "July 2014" "util-linux" "System Administration"
+.SH NAME
+uuidd \- UUID generation daemon
+.SH SYNOPSIS
+.B uuidd
+[options]
+.SH DESCRIPTION
+The
+.B uuidd
+daemon is used by the UUID library to generate
+universally unique identifiers (UUIDs), especially time-based UUIDs,
+in a secure and guaranteed-unique fashion, even in the face of large
+numbers of threads running on different CPUs trying to grab UUIDs.
+.SH OPTIONS
+.TP
+.BR \-d , " \-\-debug"
+Run uuidd in debugging mode.  This prevents uuidd from running as a daemon.
+.TP
+.BR \-F , " \-\-no-fork"
+Do not daemonize using a double-fork.
+.TP
+.BR \-k , " \-\-kill"
+If currently a uuidd daemon is running, kill it.
+.TP
+.BR \-n , " \-\-uuids " \fInumber\fR
+When issuing a test request to a running uuidd, request a bulk response
+of
+.I number
+UUIDs.
+.TP
+.BR \-P , " \-\-no-pid"
+Do not create a pid file.
+.TP
+.BR \-p , " \-\-pid " \fIpath\fR
+Specify the pathname where the pid file should be written.  By default,
+the pid file is written to @runstatedir@/uuidd/uuidd.pid.
+.TP
+.BR \-q , " \-\-quiet"
+Suppress some failure messages.
+.TP
+.BR \-r , " \-\-random"
+Test uuidd by trying to connect to a running uuidd daemon and
+request it to return a random-based UUID.
+.TP
+.BR \-S , " \-\-socket-activation"
+Do not create a socket but instead expect it to be provided by the calling
+process.  This implies \fB\-\-no-fork\fR and \fB\-\-no-pid\fR.  This option is
+intended to be used only with \fBsystemd\fR(1).  It needs to be enabled with
+a configure option.
+.TP
+.BR \-s , " \-\-socket " \fIpath\fR
+Make uuidd use this pathname for the unix-domain socket.  By default, the
+pathname used is @runstatedir@/uuidd/request.  This option is primarily
+for debugging purposes, since the pathname is hard-coded in the libuuid
+library.
+.TP
+.BR \-T , " \-\-timeout " \fInumber\fR
+Make uuidd exit after \fInumber\fR seconds of inactivity.
+.TP
+.BR \-t , " \-\-time"
+Test uuidd by trying to connect to a running uuidd daemon and
+request it to return a time-based UUID.
+.TP
+.BR \-V , " \-\-version"
+Output version information and exit.
+.TP
+.BR \-h , " \-\-help"
+Display help screen and exit.
+.SH EXAMPLE
+Start up a daemon, print 42 random keys, and then stop the daemon:
+.PP
+.RS
+.nf
+uuidd \-p /tmp/uuidd.pid \-s /tmp/uuidd.socket
+uuidd \-d \-r \-n 42 \-s /tmp/uuidd.socket
+uuidd \-d \-k \-s /tmp/uuidd.socket
+.fi
+.RE
+.SH AUTHOR
+The
+.B uuidd
+daemon was written by Theodore Ts'o <tytso@mit.edu>.
+.SH "SEE ALSO"
+.BR uuid (3),
+.BR uuidgen (1)
+.SH AVAILABILITY
+The uuidd daemon is part of the util-linux package and is available from the
+.UR https://\:www.kernel.org\:/pub\:/linux\:/utils\:/util-linux/
+Linux Kernel Archive
+.UE .
diff --git a/misc-utils/uuidd.c b/misc-utils/uuidd.c
new file mode 100644
index 0000000..ef95946
--- /dev/null
+++ b/misc-utils/uuidd.c
@@ -0,0 +1,714 @@
+/*
+ * uuidd.c --- UUID-generation daemon
+ *
+ * Copyright (C) 2007  Theodore Ts'o
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <inttypes.h>
+#include <errno.h>
+#include <err.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <string.h>
+#include <getopt.h>
+#include <sys/signalfd.h>
+#include <poll.h>
+
+#include "uuid.h"
+#include "uuidd.h"
+#include "all-io.h"
+#include "c.h"
+#include "closestream.h"
+#include "strutils.h"
+#include "optutils.h"
+#include "monotonic.h"
+#include "timer.h"
+
+#ifdef HAVE_LIBSYSTEMD
+# include <systemd/sd-daemon.h>
+#endif
+
+#include "nls.h"
+
+/* length of binary representation of UUID */
+#define UUID_LEN	(sizeof(uuid_t))
+
+/* server loop control structure */
+struct uuidd_cxt_t {
+	const char	*cleanup_pidfile;
+	const char	*cleanup_socket;
+	uint32_t	timeout;
+	unsigned int	debug: 1,
+			quiet: 1,
+			no_fork: 1,
+			no_sock: 1;
+};
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+	fputs(USAGE_HEADER, out);
+	fprintf(out, _(" %s [options]\n"), program_invocation_short_name);
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("A daemon for generating UUIDs.\n"), out);
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -p, --pid <path>        path to pid file\n"), out);
+	fputs(_(" -s, --socket <path>     path to socket\n"), out);
+	fputs(_(" -T, --timeout <sec>     specify inactivity timeout\n"), out);
+	fputs(_(" -k, --kill              kill running daemon\n"), out);
+	fputs(_(" -r, --random            test random-based generation\n"), out);
+	fputs(_(" -t, --time              test time-based generation\n"), out);
+	fputs(_(" -n, --uuids <num>       request number of uuids\n"), out);
+	fputs(_(" -P, --no-pid            do not create pid file\n"), out);
+	fputs(_(" -F, --no-fork           do not daemonize using double-fork\n"), out);
+	fputs(_(" -S, --socket-activation do not create listening socket\n"), out);
+	fputs(_(" -d, --debug             run in debugging mode\n"), out);
+	fputs(_(" -q, --quiet             turn on quiet mode\n"), out);
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(25));
+	printf(USAGE_MAN_TAIL("uuidd(8)"));
+	exit(EXIT_SUCCESS);
+}
+
+static void create_daemon(void)
+{
+	uid_t euid;
+
+	if (daemon(0, 0))
+		err(EXIT_FAILURE, "daemon");
+
+	euid = geteuid();
+	if (setreuid(euid, euid) < 0)
+		err(EXIT_FAILURE, "setreuid");
+}
+
+static int call_daemon(const char *socket_path, int op, char *buf,
+		       size_t buflen, int *num, const char **err_context)
+{
+	char op_buf[8];
+	int op_len;
+	int s;
+	ssize_t ret;
+	int32_t reply_len = 0;
+	struct sockaddr_un srv_addr;
+
+	if (((op == UUIDD_OP_BULK_TIME_UUID) ||
+	     (op == UUIDD_OP_BULK_RANDOM_UUID)) && !num) {
+		if (err_context)
+			*err_context = _("bad arguments");
+		errno = EINVAL;
+		return -1;
+	}
+
+	if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
+		if (err_context)
+			*err_context = _("socket");
+		return -1;
+	}
+
+	srv_addr.sun_family = AF_UNIX;
+	assert(strlen(socket_path) < sizeof(srv_addr.sun_path));
+	xstrncpy(srv_addr.sun_path, socket_path, sizeof(srv_addr.sun_path));
+
+	if (connect(s, (const struct sockaddr *) &srv_addr,
+		    sizeof(struct sockaddr_un)) < 0) {
+		if (err_context)
+			*err_context = _("connect");
+		close(s);
+		return -1;
+	}
+
+	if (op == UUIDD_OP_BULK_RANDOM_UUID) {
+		if ((*num) * UUID_LEN > buflen - 4)
+			*num = (buflen - 4) / UUID_LEN;
+	}
+	op_buf[0] = op;
+	op_len = 1;
+	if ((op == UUIDD_OP_BULK_TIME_UUID) ||
+	    (op == UUIDD_OP_BULK_RANDOM_UUID)) {
+		memcpy(op_buf + 1, num, sizeof(int));
+		op_len += sizeof(int);
+	}
+
+	ret = write_all(s, op_buf, op_len);
+	if (ret < 0) {
+		if (err_context)
+			*err_context = _("write");
+		close(s);
+		return -1;
+	}
+
+	ret = read_all(s, (char *) &reply_len, sizeof(reply_len));
+	if (ret < 0) {
+		if (err_context)
+			*err_context = _("read count");
+		close(s);
+		return -1;
+	}
+	if (reply_len < 0 || (size_t) reply_len > buflen) {
+		if (err_context)
+			*err_context = _("bad response length");
+		close(s);
+		return -1;
+	}
+	ret = read_all(s, (char *) buf, reply_len);
+
+	if ((ret > 0) && (op == UUIDD_OP_BULK_TIME_UUID)) {
+		if (reply_len >= (int) (UUID_LEN + sizeof(int)))
+			memcpy(buf + UUID_LEN, num, sizeof(int));
+		else
+			*num = -1;
+	}
+	if ((ret > 0) && (op == UUIDD_OP_BULK_RANDOM_UUID)) {
+		if (reply_len >= (int) sizeof(int))
+			memcpy(buf, num, sizeof(int));
+		else
+			*num = -1;
+	}
+
+	close(s);
+
+	return ret;
+}
+
+/*
+ * Exclusively create and open a pid file with path @pidfile_path
+ *
+ * Return file descriptor of the created pid_file.
+ */
+static int create_pidfile(struct uuidd_cxt_t *cxt, const char *pidfile_path)
+{
+	int		fd_pidfile;
+	struct flock	fl;
+
+	fd_pidfile = open(pidfile_path, O_CREAT | O_RDWR, 0664);
+	if (fd_pidfile < 0) {
+		if (!cxt->quiet)
+			warn(_("cannot open %s"), pidfile_path);
+		exit(EXIT_FAILURE);
+	}
+	cxt->cleanup_pidfile = pidfile_path;
+
+	fl.l_type = F_WRLCK;
+	fl.l_whence = SEEK_SET;
+	fl.l_start = 0;
+	fl.l_len = 0;
+	fl.l_pid = 0;
+	while (fcntl(fd_pidfile, F_SETLKW, &fl) < 0) {
+		if ((errno == EAGAIN) || (errno == EINTR))
+			continue;
+		if (!cxt->quiet)
+			warn(_("cannot lock %s"), pidfile_path);
+		exit(EXIT_FAILURE);
+	}
+
+	return fd_pidfile;
+}
+
+/*
+ * Create AF_UNIX, SOCK_STREAM socket and bind to @socket_path
+ *
+ * If @will_fork is true, then make sure the descriptor
+ * of the socket is >2, so that it won't be later closed
+ * during create_daemon().
+ *
+ * Return file descriptor corresponding to created socket.
+ */
+static int create_socket(struct uuidd_cxt_t *uuidd_cxt,
+			 const char *socket_path, int will_fork)
+{
+	struct sockaddr_un	my_addr;
+	mode_t			save_umask;
+	int			s;
+
+	if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
+		if (!uuidd_cxt->quiet)
+			warn(_("couldn't create unix stream socket"));
+		exit(EXIT_FAILURE);
+	}
+
+	/*
+	 * Make sure the socket isn't using fd numbers 0-2 to avoid it
+	 * getting closed by create_daemon()
+	 */
+	while (will_fork && s <= 2) {
+		s = dup(s);
+		if (s < 0)
+			err(EXIT_FAILURE, "dup");
+	}
+
+	/*
+	 * Create the address we will be binding to.
+	 */
+	my_addr.sun_family = AF_UNIX;
+	assert(strlen(socket_path) < sizeof(my_addr.sun_path));
+	xstrncpy(my_addr.sun_path, socket_path, sizeof(my_addr.sun_path));
+	unlink(socket_path);
+	save_umask = umask(0);
+	if (bind(s, (const struct sockaddr *) &my_addr,
+		 sizeof(struct sockaddr_un)) < 0) {
+		if (!uuidd_cxt->quiet)
+			warn(_("couldn't bind unix socket %s"), socket_path);
+		exit(EXIT_FAILURE);
+	}
+	umask(save_umask);
+	uuidd_cxt->cleanup_socket = socket_path;
+
+	return s;
+}
+
+static void __attribute__((__noreturn__)) all_done(const struct uuidd_cxt_t *uuidd_cxt, int ret)
+{
+	if (uuidd_cxt->cleanup_pidfile)
+		unlink(uuidd_cxt->cleanup_pidfile);
+	if (uuidd_cxt->cleanup_socket)
+		unlink(uuidd_cxt->cleanup_socket);
+	exit(ret);
+}
+
+static void handle_signal(const struct uuidd_cxt_t *uuidd_cxt, int fd)
+{
+	struct signalfd_siginfo info;
+	ssize_t bytes;
+
+	bytes = read(fd, &info, sizeof(info));
+	if (bytes != sizeof(info)) {
+		if (errno == EAGAIN)
+			return;
+		warn(_("receiving signal failed"));
+		info.ssi_signo = 0;
+	}
+	if (info.ssi_signo == SIGPIPE)
+		return;		/* ignored */
+	all_done(uuidd_cxt, EXIT_SUCCESS);
+}
+
+static void timeout_handler(int sig __attribute__((__unused__)),
+			    siginfo_t * info,
+			    void *context __attribute__((__unused__)))
+{
+#ifdef HAVE_TIMER_CREATE
+	if (info->si_code == SI_TIMER)
+#endif
+		errx(EXIT_FAILURE, _("timed out"));
+}
+
+static void server_loop(const char *socket_path, const char *pidfile_path,
+			struct uuidd_cxt_t *uuidd_cxt)
+{
+	struct sockaddr_un	from_addr;
+	socklen_t		fromlen;
+	int32_t			reply_len = 0;
+	uuid_t			uu;
+	char			reply_buf[1024], *cp;
+	char			op, str[UUID_STR_LEN];
+	int			i, ns, len;
+	int			num;		/* intentionally uninitialized */
+	int			s = 0;
+	int			fd_pidfile = -1;
+	int			ret;
+	struct pollfd		pfd[2];
+	sigset_t		sigmask;
+	int			sigfd;
+	enum {
+				POLLFD_SIGNAL = 0,
+				POLLFD_SOCKET
+	};
+
+#ifdef HAVE_LIBSYSTEMD
+	if (!uuidd_cxt->no_sock)	/* no_sock implies no_fork and no_pid */
+#endif
+	{
+		struct ul_timer timer;
+		struct itimerval timeout;
+
+		memset(&timeout, 0, sizeof timeout);
+		timeout.it_value.tv_sec = 30;
+		if (setup_timer(&timer, &timeout, &timeout_handler))
+			err(EXIT_FAILURE, _("cannot set up timer"));
+		if (pidfile_path)
+			fd_pidfile = create_pidfile(uuidd_cxt, pidfile_path);
+		ret = call_daemon(socket_path, UUIDD_OP_GETPID, reply_buf,
+				  sizeof(reply_buf), 0, NULL);
+		cancel_timer(&timer);
+		if (ret > 0) {
+			if (!uuidd_cxt->quiet)
+				warnx(_("uuidd daemon is already running at pid %s"),
+					reply_buf);
+			exit(EXIT_FAILURE);
+		}
+
+		s = create_socket(uuidd_cxt, socket_path,
+				  (!uuidd_cxt->debug || !uuidd_cxt->no_fork));
+		if (listen(s, SOMAXCONN) < 0) {
+			if (!uuidd_cxt->quiet)
+				warn(_("couldn't listen on unix socket %s"), socket_path);
+			exit(EXIT_FAILURE);
+		}
+
+		if (!uuidd_cxt->debug && !uuidd_cxt->no_fork)
+			create_daemon();
+
+		if (pidfile_path) {
+			sprintf(reply_buf, "%8d\n", getpid());
+			if (ftruncate(fd_pidfile, 0))
+				err(EXIT_FAILURE, _("could not truncate file: %s"), pidfile_path);
+			write_all(fd_pidfile, reply_buf, strlen(reply_buf));
+			if (fd_pidfile > 1 && close_fd(fd_pidfile) != 0)
+				err(EXIT_FAILURE, _("write failed: %s"), pidfile_path);
+		}
+
+	}
+
+#ifdef HAVE_LIBSYSTEMD
+	if (uuidd_cxt->no_sock) {
+		const int r = sd_listen_fds(0);
+
+		if (r < 0) {
+			errno = r * -1;
+			err(EXIT_FAILURE, _("sd_listen_fds() failed"));
+		} else if (r == 0)
+			errx(EXIT_FAILURE,
+			     _("no file descriptors received, check systemctl status uuidd.socket"));
+		else if (1 < r)
+			errx(EXIT_FAILURE,
+			     _("too many file descriptors received, check uuidd.socket"));
+		s = SD_LISTEN_FDS_START + 0;
+	}
+#endif
+
+	sigemptyset(&sigmask);
+	sigaddset(&sigmask, SIGHUP);
+	sigaddset(&sigmask, SIGINT);
+	sigaddset(&sigmask, SIGTERM);
+	sigaddset(&sigmask, SIGALRM);
+	sigaddset(&sigmask, SIGPIPE);
+	/* Block signals so that they aren't handled according to their
+	 * default dispositions */
+	sigprocmask(SIG_BLOCK, &sigmask, NULL);
+	if ((sigfd = signalfd(-1, &sigmask, 0)) < 0)
+		err(EXIT_FAILURE, _("cannot set signal handler"));
+
+	pfd[POLLFD_SIGNAL].fd = sigfd;
+	pfd[POLLFD_SOCKET].fd = s;
+	pfd[POLLFD_SIGNAL].events = pfd[POLLFD_SOCKET].events = POLLIN | POLLERR | POLLHUP;
+
+	while (1) {
+		ret = poll(pfd, ARRAY_SIZE(pfd),
+				uuidd_cxt->timeout ?
+					(int) uuidd_cxt->timeout * 1000 : -1);
+		if (ret < 0) {
+			if (errno == EAGAIN)
+				continue;
+			warn(_("poll failed"));
+				all_done(uuidd_cxt, EXIT_FAILURE);
+		}
+		if (ret == 0) {		/* true when poll() times out */
+			if (uuidd_cxt->debug)
+				fprintf(stderr, _("timeout [%d sec]\n"), uuidd_cxt->timeout),
+			all_done(uuidd_cxt, EXIT_SUCCESS);
+		}
+		if (pfd[POLLFD_SIGNAL].revents != 0)
+			handle_signal(uuidd_cxt, sigfd);
+		if (pfd[POLLFD_SOCKET].revents == 0)
+			continue;
+		fromlen = sizeof(from_addr);
+		ns = accept(s, (struct sockaddr *) &from_addr, &fromlen);
+		if (ns < 0) {
+			if ((errno == EAGAIN) || (errno == EINTR))
+				continue;
+			err(EXIT_FAILURE, "accept");
+		}
+		len = read(ns, &op, 1);
+		if (len != 1) {
+			if (len < 0)
+				warn(_("read failed"));
+			else
+				warnx(_("error reading from client, len = %d"),
+						len);
+			goto shutdown_socket;
+		}
+		if ((op == UUIDD_OP_BULK_TIME_UUID) ||
+		    (op == UUIDD_OP_BULK_RANDOM_UUID)) {
+			if (read_all(ns, (char *) &num, sizeof(num)) != 4)
+				goto shutdown_socket;
+			if (uuidd_cxt->debug)
+				fprintf(stderr, _("operation %d, incoming num = %d\n"),
+				       op, num);
+		} else if (uuidd_cxt->debug)
+			fprintf(stderr, _("operation %d\n"), op);
+
+		switch (op) {
+		case UUIDD_OP_GETPID:
+			sprintf(reply_buf, "%d", getpid());
+			reply_len = strlen(reply_buf) + 1;
+			break;
+		case UUIDD_OP_GET_MAXOP:
+			sprintf(reply_buf, "%d", UUIDD_MAX_OP);
+			reply_len = strlen(reply_buf) + 1;
+			break;
+		case UUIDD_OP_TIME_UUID:
+			num = 1;
+			__uuid_generate_time(uu, &num);
+			if (uuidd_cxt->debug) {
+				uuid_unparse(uu, str);
+				fprintf(stderr, _("Generated time UUID: %s\n"), str);
+			}
+			memcpy(reply_buf, uu, sizeof(uu));
+			reply_len = sizeof(uu);
+			break;
+		case UUIDD_OP_RANDOM_UUID:
+			num = 1;
+			__uuid_generate_random(uu, &num);
+			if (uuidd_cxt->debug) {
+				uuid_unparse(uu, str);
+				fprintf(stderr, _("Generated random UUID: %s\n"), str);
+			}
+			memcpy(reply_buf, uu, sizeof(uu));
+			reply_len = sizeof(uu);
+			break;
+		case UUIDD_OP_BULK_TIME_UUID:
+			__uuid_generate_time(uu, &num);
+			if (uuidd_cxt->debug) {
+				uuid_unparse(uu, str);
+				fprintf(stderr, P_("Generated time UUID %s "
+						   "and %d following\n",
+						   "Generated time UUID %s "
+						   "and %d following\n", num - 1),
+				       str, num - 1);
+			}
+			memcpy(reply_buf, uu, sizeof(uu));
+			reply_len = sizeof(uu);
+			memcpy(reply_buf + reply_len, &num, sizeof(num));
+			reply_len += sizeof(num);
+			break;
+		case UUIDD_OP_BULK_RANDOM_UUID:
+			if (num < 0)
+				num = 1;
+			if (num > 1000)
+				num = 1000;
+			if (num * UUID_LEN > (int) (sizeof(reply_buf) - sizeof(num)))
+				num = (sizeof(reply_buf) - sizeof(num)) / UUID_LEN;
+			__uuid_generate_random((unsigned char *) reply_buf +
+					      sizeof(num), &num);
+			if (uuidd_cxt->debug) {
+				fprintf(stderr, P_("Generated %d UUID:\n",
+						   "Generated %d UUIDs:\n", num), num);
+				for (i = 0, cp = reply_buf + sizeof(num);
+				     i < num;
+				     i++, cp += UUID_LEN) {
+					uuid_unparse((unsigned char *)cp, str);
+					fprintf(stderr, "\t%s\n", str);
+				}
+			}
+			reply_len = (num * UUID_LEN) + sizeof(num);
+			memcpy(reply_buf, &num, sizeof(num));
+			break;
+		default:
+			if (uuidd_cxt->debug)
+				fprintf(stderr, _("Invalid operation %d\n"), op);
+			goto shutdown_socket;
+		}
+		write_all(ns, (char *) &reply_len, sizeof(reply_len));
+		write_all(ns, reply_buf, reply_len);
+	shutdown_socket:
+		close(ns);
+	}
+}
+
+static void __attribute__ ((__noreturn__)) unexpected_size(int size)
+{
+	errx(EXIT_FAILURE, _("Unexpected reply length from server %d"), size);
+}
+
+int main(int argc, char **argv)
+{
+	const char	*socket_path = UUIDD_SOCKET_PATH;
+	const char	*pidfile_path = NULL;
+	const char	*err_context = NULL;
+	char		buf[1024], *cp;
+	char		str[UUID_STR_LEN];
+	uuid_t		uu;
+	int		i, c, ret;
+	int		do_type = 0, do_kill = 0, num = 0;
+	int		no_pid = 0;
+	int		s_flag = 0;
+
+	struct uuidd_cxt_t uuidd_cxt = { .timeout = 0 };
+
+	static const struct option longopts[] = {
+		{"pid", required_argument, NULL, 'p'},
+		{"socket", required_argument, NULL, 's'},
+		{"timeout", required_argument, NULL, 'T'},
+		{"kill", no_argument, NULL, 'k'},
+		{"random", no_argument, NULL, 'r'},
+		{"time", no_argument, NULL, 't'},
+		{"uuids", required_argument, NULL, 'n'},
+		{"no-pid", no_argument, NULL, 'P'},
+		{"no-fork", no_argument, NULL, 'F'},
+		{"socket-activation", no_argument, NULL, 'S'},
+		{"debug", no_argument, NULL, 'd'},
+		{"quiet", no_argument, NULL, 'q'},
+		{"version", no_argument, NULL, 'V'},
+		{"help", no_argument, NULL, 'h'},
+		{NULL, 0, NULL, 0}
+	};
+	static const ul_excl_t excl[] = {
+		{ 'P', 'p' },
+		{ 'd', 'q' },
+		{ 'r', 't' },
+		{ 0 }
+	};
+	int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	while ((c =
+		getopt_long(argc, argv, "p:s:T:krtn:PFSdqVh", longopts,
+			    NULL)) != -1) {
+		err_exclusive_options(c, longopts, excl, excl_st);
+		switch (c) {
+		case 'd':
+			uuidd_cxt.debug = 1;
+			break;
+		case 'k':
+			do_kill++;
+			break;
+		case 'n':
+			num = strtou32_or_err(optarg,
+						_("failed to parse --uuids"));
+			break;
+		case 'p':
+			pidfile_path = optarg;
+			break;
+		case 'P':
+			no_pid = 1;
+			break;
+		case 'F':
+			uuidd_cxt.no_fork = 1;
+			break;
+		case 'S':
+#ifdef HAVE_LIBSYSTEMD
+			uuidd_cxt.no_sock = 1;
+			uuidd_cxt.no_fork = 1;
+			no_pid = 1;
+#else
+			errx(EXIT_FAILURE, _("uuidd has been built without "
+					     "support for socket activation"));
+#endif
+			break;
+		case 'q':
+			uuidd_cxt.quiet = 1;
+			break;
+		case 'r':
+			do_type = UUIDD_OP_RANDOM_UUID;
+			break;
+		case 's':
+			socket_path = optarg;
+			s_flag = 1;
+			break;
+		case 't':
+			do_type = UUIDD_OP_TIME_UUID;
+			break;
+		case 'T':
+			uuidd_cxt.timeout = strtou32_or_err(optarg,
+						_("failed to parse --timeout"));
+			break;
+
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		case 'h':
+			usage();
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+
+	if (strlen(socket_path) >= sizeof(((struct sockaddr_un *)0)->sun_path))
+		errx(EXIT_FAILURE, _("socket name too long: %s"), socket_path);
+
+	if (!no_pid && !pidfile_path)
+		pidfile_path = UUIDD_PIDFILE_PATH;
+
+	/* custom socket path and socket-activation make no sense */
+	if (s_flag && uuidd_cxt.no_sock && !uuidd_cxt.quiet)
+		warnx(_("Both --socket-activation and --socket specified. "
+			"Ignoring --socket."));
+
+	if (num && do_type) {
+		ret = call_daemon(socket_path, do_type + 2, buf,
+				  sizeof(buf), &num, &err_context);
+		if (ret < 0)
+			err(EXIT_FAILURE, _("error calling uuidd daemon (%s)"),
+					err_context ? : _("unexpected error"));
+
+		if (do_type == UUIDD_OP_TIME_UUID) {
+			if (ret != sizeof(uu) + sizeof(num))
+				unexpected_size(ret);
+
+			uuid_unparse((unsigned char *) buf, str);
+
+			printf(P_("%s and %d subsequent UUID\n",
+				  "%s and %d subsequent UUIDs\n", num - 1),
+			       str, num - 1);
+		} else {
+			printf(_("List of UUIDs:\n"));
+			cp = buf + 4;
+			if (ret != (int) (sizeof(num) + num * sizeof(uu)))
+				unexpected_size(ret);
+			for (i = 0; i < num; i++, cp += UUID_LEN) {
+				uuid_unparse((unsigned char *) cp, str);
+				printf("\t%s\n", str);
+			}
+		}
+		return EXIT_SUCCESS;
+	}
+	if (do_type) {
+		ret = call_daemon(socket_path, do_type, (char *) &uu,
+				  sizeof(uu), 0, &err_context);
+		if (ret < 0)
+			err(EXIT_FAILURE, _("error calling uuidd daemon (%s)"),
+					err_context ? : _("unexpected error"));
+		if (ret != sizeof(uu))
+		        unexpected_size(ret);
+
+		uuid_unparse(uu, str);
+
+		printf("%s\n", str);
+		return EXIT_SUCCESS;
+	}
+
+	if (do_kill) {
+		ret = call_daemon(socket_path, UUIDD_OP_GETPID, buf, sizeof(buf), 0, NULL);
+		if ((ret > 0) && ((do_kill = atoi((char *) buf)) > 0)) {
+			ret = kill(do_kill, SIGTERM);
+			if (ret < 0) {
+				if (!uuidd_cxt.quiet)
+					warn(_("couldn't kill uuidd running "
+						  "at pid %d"), do_kill);
+				return EXIT_FAILURE;
+			}
+			if (!uuidd_cxt.quiet)
+				printf(_("Killed uuidd running at pid %d.\n"),
+				       do_kill);
+		}
+		return EXIT_SUCCESS;
+	}
+
+	server_loop(socket_path, pidfile_path, &uuidd_cxt);
+	return EXIT_SUCCESS;
+}
diff --git a/misc-utils/uuidd.rc.in b/misc-utils/uuidd.rc.in
new file mode 100644
index 0000000..7943945
--- /dev/null
+++ b/misc-utils/uuidd.rc.in
@@ -0,0 +1,62 @@
+#! /bin/sh -e
+### BEGIN INIT INFO
+# Provides:          uuidd
+# Required-Start:    $time $local_fs $remote_fs
+# Required-Stop:     $time $local_fs $remote_fs
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: uuidd daemon
+# Description:       Init script for the uuid generation daemon
+### END INIT INFO
+#
+# Author:	"Theodore Ts'o" <tytso@mit.edu>
+#
+set -e
+
+PATH=/bin:/usr/bin:/sbin:/usr/sbin
+DAEMON=/usr/sbin/uuidd
+UUIDD_USER=uuidd
+UUIDD_GROUP=uuidd
+UUIDD_DIR=@runstatedir@/uuidd
+PIDFILE=$UUIDD_DIR/uuidd.pid
+
+test -x $DAEMON || exit 0
+
+. /lib/lsb/init-functions
+
+case "$1" in
+  start)
+	log_daemon_msg "Starting uuid generator" "uuidd"
+	if ! test -d $UUIDD_DIR; then
+		mkdir -p $UUIDD_DIR
+		chown -R $UUIDD_USER:$UUIDD_GROUP $UUIDD_DIR
+	fi
+	start_daemon -p $PIDFILE $DAEMON
+	log_end_msg $?
+    ;;
+  stop)
+	log_daemon_msg "Stopping uuid generator" "uuidd"
+	killproc -p $PIDFILE $DAEMON
+	log_end_msg $?
+    ;;
+  status)
+	if pidofproc -p $PIDFILE $DAEMON >/dev/null 2>&1; then
+	    echo "$DAEMON is running";
+	    exit 0;
+	else
+	    echo "$DAEMON is NOT running";
+	    if test -f $PIDFILE; then exit 2; fi
+	    exit 3;
+	fi
+    ;;
+  force-reload|restart)
+    $0 stop
+    $0 start
+    ;;
+  *)
+    echo "Usage: /etc/init.d/uuidd {start|stop|restart|force-reload}"
+    exit 1
+    ;;
+esac
+
+exit 0
diff --git a/misc-utils/uuidd.service.in b/misc-utils/uuidd.service.in
new file mode 100644
index 0000000..b4c9c46
--- /dev/null
+++ b/misc-utils/uuidd.service.in
@@ -0,0 +1,24 @@
+[Unit]
+Description=Daemon for generating UUIDs
+Documentation=man:uuidd(8)
+Requires=uuidd.socket
+
+[Service]
+ExecStart=@usrsbin_execdir@/uuidd --socket-activation
+Restart=no
+User=uuidd
+Group=uuidd
+ProtectSystem=strict
+ProtectHome=yes
+PrivateDevices=yes
+PrivateNetwork=yes
+PrivateUsers=yes
+ProtectKernelTunables=yes
+ProtectKernelModules=yes
+ProtectControlGroups=yes
+RestrictAddressFamilies=AF_UNIX
+MemoryDenyWriteExecute=yes
+SystemCallFilter=@default @file-system @basic-io @system-service @signal @io-event @network-io
+
+[Install]
+Also=uuidd.socket
diff --git a/misc-utils/uuidd.socket.in b/misc-utils/uuidd.socket.in
new file mode 100644
index 0000000..8ddcac2
--- /dev/null
+++ b/misc-utils/uuidd.socket.in
@@ -0,0 +1,8 @@
+[Unit]
+Description=UUID daemon activation socket
+
+[Socket]
+ListenStream=@runstatedir@/uuidd/request
+
+[Install]
+WantedBy=sockets.target
diff --git a/misc-utils/uuidgen.1 b/misc-utils/uuidgen.1
new file mode 100644
index 0000000..0189587
--- /dev/null
+++ b/misc-utils/uuidgen.1
@@ -0,0 +1,102 @@
+.\" Copyright 1999 Andreas Dilger (adilger@enel.ucalgary.ca)
+.\"
+.\" This file may be copied under the terms of the GNU Public License.
+.TH UUIDGEN 1 "June 2011" "util-linux" "User Commands"
+.SH NAME
+uuidgen \- create a new UUID value
+.SH SYNOPSIS
+.B uuidgen
+[options]
+.SH DESCRIPTION
+The
+.B uuidgen
+program creates (and prints)
+a new universally unique identifier (UUID) using the
+.BR libuuid (3)
+library.  The new UUID can reasonably be considered unique among
+all UUIDs created on the local system,
+and among UUIDs created on other systems in the past
+and in the future.
+.PP
+There are three types of UUIDs which
+.B uuidgen
+can generate: time-based UUIDs, random-based UUIDs, and hash-based UUIDs.
+By default
+.B uuidgen
+will generate a random-based UUID if a high-quality random number
+generator is present.  Otherwise, it will choose a time-based UUID.
+It is possible to force the generation of one of these first two
+UUID types by using the
+.B \-\-random
+or
+.B \-\-time
+options.
+.PP
+The third type of UUID is generated with the
+.B \-\-md5
+or
+.B \-\-sha1
+options, followed by
+\fB\-\-namespace\fR \fInamespace\fR
+and
+\fB\-\-name\fR \fIname\fR.
+The \fInamespace\fR may either be a well-known UUID, or else
+an alias to one of the well-known UUIDs defined in RFC 4122, that is
+.BR @dns ,
+.BR @url ,
+.BR @oid ,
+or
+.BR @x500 .
+The \fIname\fR is an arbitrary string value.  The generated UUID is the
+digest of the concatenation of the namespace UUID and the name value, hashed
+with the MD5 or SHA1 algorithms.  It is, therefore, a predictable value
+which may be useful when UUIDs are being used as handles or nonces for
+more complex values or values which shouldn't be disclosed directly.
+See the RFC for more information.
+.SH OPTIONS
+.TP
+.BR \-r , " \-\-random"
+Generate a random-based UUID.  This method creates a UUID consisting mostly
+of random bits.  It requires that the operating system have a high
+quality random number generator, such as
+.IR /dev/random .
+.TP
+.BR \-t , " \-\-time"
+Generate a time-based UUID.  This method creates a UUID based on the system
+clock plus the system's ethernet hardware address, if present.
+.TP
+.BR \-h , " \-\-help"
+Display help text and exit.
+.TP
+.BR \-V , " \-\-version"
+Display version information and exit.
+.TP
+.BR \-m , " \-\-md5"
+Use MD5 as the hash algorithm.
+.TP
+.BR \-s , " \-\-sha1"
+Use SHA1 as the hash algorithm.
+.TP
+.BR \-n , " \-\-namespace " \fInamespace\fP
+Generate the hash with the \fInamespace\fP prefix. The \fInamespace\fP is UUID,
+or '@ns' where "ns" is well-known predefined UUID addressed by namespace name
+(see above).
+.TP
+.BR \-N , " \-\-name " \fIname\fR
+Generate the hash of the \fIname\fR.
+.TP
+.BR \-x , " \-\-hex"
+Interpret name \fIname\fR as a hexadecimal string.
+.SH CONFORMING TO
+OSF DCE 1.1
+.SH EXAMPLES
+uuidgen \-\-sha1 \-\-namespace @dns \-\-name "www.example.com"
+.SH AUTHORS
+.B uuidgen
+was written by Andreas Dilger for libuuid.
+.SH SEE ALSO
+.BR libuuid (3),
+.B "RFC 4122"
+.SH AVAILABILITY
+The uuidgen command is part of the util-linux package and is available from
+https://www.kernel.org/pub/linux/utils/util-linux/.
diff --git a/misc-utils/uuidgen.c b/misc-utils/uuidgen.c
new file mode 100644
index 0000000..fa148ab
--- /dev/null
+++ b/misc-utils/uuidgen.c
@@ -0,0 +1,209 @@
+/*
+ * gen_uuid.c --- generate a DCE-compatible uuid
+ *
+ * Copyright (C) 1999, Andreas Dilger and Theodore Ts'o
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <getopt.h>
+
+#include "uuid.h"
+#include "nls.h"
+#include "c.h"
+#include "closestream.h"
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+	fputs(USAGE_HEADER, out);
+	fprintf(out,
+	      _(" %s [options]\n"), program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("Create a new UUID value.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -r, --random        generate random-based uuid\n"), out);
+	fputs(_(" -t, --time          generate time-based uuid\n"), out);
+	fputs(_(" -n, --namespace ns  generate hash-based uuid in this namespace\n"), out);
+	fputs(_(" -N, --name name     generate hash-based uuid from this name\n"), out);
+	fputs(_(" -m, --md5           generate md5 hash\n"), out);
+	fputs(_(" -s, --sha1          generate sha1 hash\n"), out);
+	fputs(_(" -x, --hex           interpret name as hex string\n"), out);
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(18));
+	printf(USAGE_MAN_TAIL("uuidgen(1)"));
+	exit(EXIT_SUCCESS);
+}
+
+static char *unhex(const char *value, size_t *valuelen)
+{
+	char c, *value2;
+	unsigned n, x;
+
+	if (*valuelen % 2 != 0) {
+badstring:
+		fprintf(stderr, "%s: not a valid hex string\n", program_invocation_short_name);
+		errtryhelp(EXIT_FAILURE);
+	}
+
+	value2 = malloc(*valuelen / 2 + 1);
+
+	for (x = n = 0; n < *valuelen; n++) {
+		c = value[n];
+		if ('0' <= c && c <= '9')
+			x += c - '0';
+		else if (('a' <= c && c <= 'f') || ('A' <= c && c <= 'F'))
+			x += (c - 'A' + 10) & 0xf;
+		else
+			goto badstring;
+
+		if (n % 2 == 0)
+			x *= 16;
+		else {
+			value2[n / 2] = x;
+			x = 0;
+		}
+	}
+	value2[n / 2] = '\0';
+
+	*valuelen = (n / 2);
+
+	return value2;
+}
+
+int
+main (int argc, char *argv[])
+{
+	int    c;
+	int    do_type = 0, is_hex = 0;
+	char   str[UUID_STR_LEN];
+	char   *namespace = NULL, *name = NULL;
+	size_t namelen = 0;
+	uuid_t ns, uu;
+
+	static const struct option longopts[] = {
+		{"random", no_argument, NULL, 'r'},
+		{"time", no_argument, NULL, 't'},
+		{"version", no_argument, NULL, 'V'},
+		{"help", no_argument, NULL, 'h'},
+		{"namespace", required_argument, NULL, 'n'},
+		{"name", required_argument, NULL, 'N'},
+		{"md5", no_argument, NULL, 'm'},
+		{"sha1", no_argument, NULL, 's'},
+		{"hex", no_argument, NULL, 'x'},
+		{NULL, 0, NULL, 0}
+	};
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	while ((c = getopt_long(argc, argv, "rtVhn:N:msx", longopts, NULL)) != -1)
+		switch (c) {
+		case 't':
+			do_type = UUID_TYPE_DCE_TIME;
+			break;
+		case 'r':
+			do_type = UUID_TYPE_DCE_RANDOM;
+			break;
+		case 'n':
+			namespace = optarg;
+			break;
+		case 'N':
+			name = optarg;
+			break;
+		case 'm':
+			do_type = UUID_TYPE_DCE_MD5;
+			break;
+		case 's':
+			do_type = UUID_TYPE_DCE_SHA1;
+			break;
+		case 'x':
+			is_hex = 1;
+			break;
+
+		case 'h':
+			usage();
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+
+	if (namespace) {
+		if (!name) {
+			fprintf(stderr, "%s: --namespace requires --name argument\n", program_invocation_short_name);
+			errtryhelp(EXIT_FAILURE);
+		}
+		if (do_type != UUID_TYPE_DCE_MD5 && do_type != UUID_TYPE_DCE_SHA1) {
+			fprintf(stderr, "%s: --namespace requires --md5 or --sha1\n", program_invocation_short_name);
+			errtryhelp(EXIT_FAILURE);
+		}
+	} else {
+		if (name) {
+			fprintf(stderr, "%s: --name requires --namespace argument\n", program_invocation_short_name);
+			errtryhelp(EXIT_FAILURE);
+		}
+		if (do_type == UUID_TYPE_DCE_MD5 || do_type == UUID_TYPE_DCE_SHA1) {
+			fprintf(stderr, "%s: --md5 or --sha1 require --namespace\n", program_invocation_short_name);
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+
+	if (name) {
+		namelen = strlen(name);
+		if (is_hex)
+			name = unhex(name, &namelen);
+	}
+
+	switch (do_type) {
+	case UUID_TYPE_DCE_TIME:
+		uuid_generate_time(uu);
+		break;
+	case UUID_TYPE_DCE_RANDOM:
+		uuid_generate_random(uu);
+		break;
+	case UUID_TYPE_DCE_MD5:
+	case UUID_TYPE_DCE_SHA1:
+		if (namespace[0] == '@' && namespace[1] != '\0') {
+			const uuid_t *uuidptr;
+
+			uuidptr = uuid_get_template(&namespace[1]);
+			if (uuidptr == NULL) {
+				fprintf(stderr, "%s: unknown namespace alias '%s'\n", program_invocation_short_name, namespace);
+				errtryhelp(EXIT_FAILURE);
+			}
+			memcpy(ns, *uuidptr, sizeof(ns));
+		} else {
+			if (uuid_parse(namespace, ns) != 0) {
+				fprintf(stderr, "%s: invalid uuid for namespace '%s'\n", program_invocation_short_name, namespace);
+				errtryhelp(EXIT_FAILURE);
+			}
+		}
+		if (do_type == UUID_TYPE_DCE_MD5)
+			uuid_generate_md5(uu, ns, name, namelen);
+		else
+			uuid_generate_sha1(uu, ns, name, namelen);
+		break;
+	default:
+		uuid_generate(uu);
+		break;
+	}
+
+	uuid_unparse(uu, str);
+
+	printf("%s\n", str);
+
+	if (is_hex)
+		free(name);
+
+	return EXIT_SUCCESS;
+}
diff --git a/misc-utils/uuidparse.1 b/misc-utils/uuidparse.1
new file mode 100644
index 0000000..ae735dc
--- /dev/null
+++ b/misc-utils/uuidparse.1
@@ -0,0 +1,78 @@
+.\" Copyright (c) 2017 Sami Kerola
+.\" The 3-Clause BSD License
+.TH UUIDPARSE "1" "2017-06-18" "util-linux" "User Commands"
+.SH NAME
+uuidparse \- a utility to parse unique identifiers
+.SH SYNOPSIS
+.B uuidparse
+[options]
+.I uuid
+.SH DESCRIPTION
+This command will parse unique identifier inputs from either command line
+arguments or standard input.  The inputs are white-space separated.
+.SH OUTPUT
+.SS Variants
+.nr WI \n(.lu-\n(.iu-\w'Microsoft'u-3n
+.TS
+tab(:);
+l lw(\n(WIu).
+NCS:T{
+Network Computing System identifier.  These were the original UUIDs.
+T}
+DCE:T{
+The Open Software Foundation's (OSF) Distributed Computing Environment UUIDs.
+T}
+Microsoft:T{
+Microsoft Windows platform globally unique identifier (GUID).
+T}
+other:T{
+Unknown variant.  Usually invalid input data.
+T}
+.TE
+.SS Types
+.TS
+tab(:);
+l l.
+nil:Special type for zero in type file.
+time-based:The DCE time based.
+DCE:The DCE time and MAC Address.
+name-based:RFC 4122 md5sum hash.
+random:RFC 4122 random.
+sha1-based:RFC 4122 sha-1 hash.
+unknown:Unknown type.  Usually invalid input data.
+.TE
+.SH OPTIONS
+.TP
+\fB\-J\fR, \fB\-\-json\fR
+Use JSON output format.
+.TP
+\fB\-n\fR, \fB\-\-noheadings\fR
+Do not print a header line.
+.TP
+\fB\-o\fR, \fB\-\-output\fR
+Specify which output columns to print.  Use \-\-help to get a list of all
+supported columns.
+.TP
+\fB\-r\fR, \fB\-\-raw\fR
+Use the raw output format.
+.TP
+\fB\-V\fR, \fB\-\-version\fR
+Display version information and exit.
+.TP
+\fB\-h\fR, \fB\-\-help\fR
+Display help text and exit.
+.SH AUTHORS
+.MT kerolasa@iki.fi
+Sami Kerola
+.ME
+.SH SEE ALSO
+.BR uuidgen (1),
+.BR libuuid (3),
+.UR https://\:tools.ietf.org\:/html\:/rfc4122
+RFC 4122
+.UE
+.SH AVAILABILITY
+The uuidparse command is part of the util-linux package and is available from
+.UR https://\:www.kernel.org\:/pub\:/linux\:/utils\:/util-linux/
+Linux Kernel Archive
+.UE .
diff --git a/misc-utils/uuidparse.c b/misc-utils/uuidparse.c
new file mode 100644
index 0000000..eae0b71
--- /dev/null
+++ b/misc-utils/uuidparse.c
@@ -0,0 +1,349 @@
+/*
+ * uuidparse.c --- Interpret uuid encoded information.  This program
+ *	violates the UUID abstraction barrier by reaching into the
+ *	guts of a UUID.
+ *
+ * Based on libuuid/src/uuid_time.c
+ * Copyright (C) 1998, 1999 Theodore Ts'o.
+ *
+ * All alterations (C) 2017 Sami Kerola
+ * The 3-Clause BSD License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, and the entire permission notice in its entirety,
+ *    including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
+ * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+#include <assert.h>
+#include <getopt.h>
+#include <libsmartcols.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <uuid.h>
+
+#include "c.h"
+#include "closestream.h"
+#include "nls.h"
+#include "optutils.h"
+#include "strutils.h"
+#include "timeutils.h"
+#include "xalloc.h"
+
+/* column IDs */
+enum {
+	COL_UUID = 0,
+	COL_VARIANT,
+	COL_TYPE,
+	COL_TIME
+};
+
+/* column names */
+struct colinfo {
+	const char *name;	/* header */
+	double whint;		/* width hint (N < 1 is in percent of termwidth) */
+	int flags;		/* SCOLS_FL_* */
+	const char *help;
+};
+
+/* columns descriptions */
+static const struct colinfo infos[] = {
+	[COL_UUID]    = {"UUID",    UUID_STR_LEN, 0, N_("unique identifier")},
+	[COL_VARIANT] = {"VARIANT", 9,  0, N_("variant name")},
+	[COL_TYPE]    = {"TYPE",    10, 0, N_("type name")},
+	[COL_TIME]    = {"TIME",    31, 0, N_("timestamp")}
+};
+
+static int columns[ARRAY_SIZE(infos) * 2];
+static size_t ncolumns;
+
+struct control {
+	unsigned int
+		json:1,
+		no_headings:1,
+		raw:1;
+};
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	size_t i;
+
+	fputs(USAGE_HEADER, stdout);
+	fprintf(stdout, _(" %s [options] <uuid ...>\n"), program_invocation_short_name);
+
+	fputs(USAGE_OPTIONS, stdout);
+	puts(_(" -J, --json             use JSON output format"));
+	puts(_(" -n, --noheadings       don't print headings"));
+	puts(_(" -o, --output <list>    COLUMNS to display (see below)"));
+	puts(_(" -r, --raw              use the raw output format"));
+	printf(USAGE_HELP_OPTIONS(24));
+
+	fputs(USAGE_COLUMNS, stdout);
+	for (i = 0; i < ARRAY_SIZE(infos); i++)
+		fprintf(stdout, " %8s  %s\n", infos[i].name, _(infos[i].help));
+
+	printf(USAGE_MAN_TAIL("uuidparse(1)"));
+	exit(EXIT_SUCCESS);
+}
+
+static int column_name_to_id(const char *name, size_t namesz)
+{
+	size_t i;
+
+	assert(name);
+
+	for (i = 0; i < ARRAY_SIZE(infos); i++) {
+		const char *cn = infos[i].name;
+		if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
+			return i;
+	}
+	warnx(_("unknown column: %s"), name);
+	return -1;
+}
+
+static int get_column_id(size_t num)
+{
+	assert(num < ncolumns);
+	assert(columns[num] < (int)ARRAY_SIZE(infos));
+	return columns[num];
+}
+
+static const struct colinfo *get_column_info(int num)
+{
+	return &infos[get_column_id(num)];
+}
+
+static void fill_table_row(struct libscols_table *tb, char const *const uuid)
+{
+	static struct libscols_line *ln;
+	size_t i;
+	uuid_t buf;
+	int invalid = 0;
+	int variant = -1, type = -1;
+
+	assert(tb);
+	assert(uuid);
+
+	ln = scols_table_new_line(tb, NULL);
+	if (!ln)
+		errx(EXIT_FAILURE, _("failed to allocate output line"));
+
+	if (uuid_parse(uuid, buf))
+		invalid = 1;
+	else {
+		variant = uuid_variant(buf);
+		type = uuid_type(buf);
+	}
+
+	for (i = 0; i < ncolumns; i++) {
+		char *str = NULL;
+
+		switch (get_column_id(i)) {
+		case COL_UUID:
+			str = xstrdup(uuid);
+			break;
+		case COL_VARIANT:
+			if (invalid) {
+				str = xstrdup(_("invalid"));
+				break;
+			}
+			switch (variant) {
+			case UUID_VARIANT_NCS:
+				str = xstrdup("NCS");
+				break;
+			case UUID_VARIANT_DCE:
+				str = xstrdup("DCE");
+				break;
+			case UUID_VARIANT_MICROSOFT:
+				str = xstrdup("Microsoft");
+				break;
+			default:
+				str = xstrdup(_("other"));
+			}
+			break;
+		case COL_TYPE:
+			if (invalid) {
+				str = xstrdup(_("invalid"));
+				break;
+			}
+			switch (type) {
+			case 0:
+				if (strspn(uuid, "0-") == 36)
+					str = xstrdup(_("nil"));
+				else
+					str = xstrdup(_("unknown"));
+				break;
+			case 1:
+				str = xstrdup(_("time-based"));
+				break;
+			case 2:
+				str = xstrdup("DCE");
+				break;
+			case 3:
+				str = xstrdup(_("name-based"));
+				break;
+			case 4:
+				str = xstrdup(_("random"));
+				break;
+			case 5:
+				str = xstrdup(_("sha1-based"));
+				break;
+			default:
+				str = xstrdup(_("unknown"));
+			}
+			break;
+		case COL_TIME:
+			if (invalid) {
+				str = xstrdup(_("invalid"));
+				break;
+			}
+			if (variant == UUID_VARIANT_DCE && type == 1) {
+				struct timeval tv;
+				char date_buf[ISO_BUFSIZ];
+
+				uuid_time(buf, &tv);
+				strtimeval_iso(&tv, ISO_TIMESTAMP_COMMA,
+					       date_buf, sizeof(date_buf));
+				str = xstrdup(date_buf);
+			}
+			break;
+		default:
+			abort();
+		}
+		if (str && scols_line_refer_data(ln, i, str))
+			errx(EXIT_FAILURE, _("failed to add output data"));
+	}
+}
+
+static void print_output(struct control const *const ctrl, int argc,
+			 char **argv)
+{
+	struct libscols_table *tb;
+	size_t i;
+
+	scols_init_debug(0);
+	tb = scols_new_table();
+	if (!tb)
+		err(EXIT_FAILURE, _("failed to allocate output table"));
+
+	if (ctrl->json) {
+		scols_table_enable_json(tb, 1);
+		scols_table_set_name(tb, "uuids");
+	}
+	scols_table_enable_noheadings(tb, ctrl->no_headings);
+	scols_table_enable_raw(tb, ctrl->raw);
+
+	for (i = 0; i < ncolumns; i++) {
+		const struct colinfo *col = get_column_info(i);
+
+		if (!scols_table_new_column(tb, col->name, col->whint,
+					    col->flags))
+			err(EXIT_FAILURE,
+			    _("failed to initialize output column"));
+	}
+
+	for (i = 0; i < (size_t) argc; i++)
+		fill_table_row(tb, argv[i]);
+
+	if (i == 0) {
+		char uuid[UUID_STR_LEN];
+
+		while (scanf(" %36[^ \t\n]%*c", uuid) && !feof(stdin))
+			fill_table_row(tb, uuid);
+	}
+	scols_print_table(tb);
+	scols_unref_table(tb);
+}
+
+int main(int argc, char **argv)
+{
+	struct control ctrl = { 0 };
+	char *outarg = NULL;
+	int c;
+
+	static const struct option longopts[] = {
+		{"json",       no_argument,       NULL, 'J'},
+		{"noheadings", no_argument,       NULL, 'n'},
+		{"output",     required_argument, NULL, 'o'},
+		{"raw",        no_argument,       NULL, 'r'},
+		{"version",    no_argument,       NULL, 'V'},
+		{"help",       no_argument,       NULL, 'h'},
+		{NULL, 0, NULL, 0}
+	};
+	static const ul_excl_t excl[] = {
+		{'J', 'r'},
+		{0}
+	};
+	int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	while ((c = getopt_long(argc, argv, "Jno:rVh", longopts, NULL)) != -1) {
+		err_exclusive_options(c, longopts, excl, excl_st);
+		switch (c) {
+		case 'J':
+			ctrl.json = 1;
+			break;
+		case 'n':
+			ctrl.no_headings = 1;
+			break;
+		case 'o':
+			outarg = optarg;
+			break;
+		case 'r':
+			ctrl.raw = 1;
+			break;
+
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		case 'h':
+			usage();
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+	argc -= optind;
+	argv += optind;
+
+	columns[ncolumns++] = COL_UUID;
+	columns[ncolumns++] = COL_VARIANT;
+	columns[ncolumns++] = COL_TYPE;
+	columns[ncolumns++] = COL_TIME;
+
+	if (outarg
+	    && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns),
+				     &ncolumns, column_name_to_id) < 0)
+		return EXIT_FAILURE;
+
+	print_output(&ctrl, argc, argv);
+
+	return EXIT_SUCCESS;
+}
diff --git a/misc-utils/whereis.1 b/misc-utils/whereis.1
new file mode 100644
index 0000000..08e351c
--- /dev/null
+++ b/misc-utils/whereis.1
@@ -0,0 +1,170 @@
+.\" Copyright (c) 1980, 1990 The Regents of the University of California.
+.\" All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. All advertising materials mentioning features or use of this software
+.\"    must display the following acknowledgement:
+.\"     This product includes software developed by the University of
+.\"     California, Berkeley and its contributors.
+.\" 4. Neither the name of the University nor the names of its contributors
+.\"    may be used to endorse or promote products derived from this software
+.\"    without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\" @(#)whereis.1 from UCB 4.2
+.TH WHEREIS 1 "October 2014" "util-linux" "User Commands"
+.SH NAME
+whereis \- locate the binary, source, and manual page files for a command
+.SH SYNOPSIS
+.B whereis
+[options]
+.RB [ \-BMS
+.IR directory "... " \fB\-f\fR ]
+.IR name ...
+.SH DESCRIPTION
+.B whereis
+locates the binary, source and manual files for the specified command names.
+The supplied names are first stripped of leading pathname components and any
+(single) trailing extension of the form
+.BI . ext
+(for example:
+.BR .c )
+Prefixes of
+.B s.
+resulting from use of source code control are also dealt with.
+.B whereis
+then attempts to locate the desired program in the standard Linux places, and
+in the places specified by
+.B $PATH
+and
+.BR $MANPATH .
+.sp
+The search restrictions (options \fB\-b\fP, \fB\-m\fP and \fB\-s\fP)
+are cumulative and apply to the subsequent \fIname\fP patterns on
+the command line.  Any new search restriction resets the search mask.
+For example,
+.RS
+.sp
+.B "whereis \-bm ls tr \-m gcc"
+.sp
+.RE
+searches for "ls" and "tr" binaries and man pages, and for "gcc" man pages only.
+.sp
+The options \fB\-B\fP, \fB\-M\fP and \fB\-S\fP reset search paths for the
+subsequent \fIname\fP patterns.  For example,
+.RS
+.sp
+.B "whereis \-m ls \-M /usr/share/man/man1 \-f cal"
+.sp
+.RE
+searches for "ls" man pages in all default paths, but for "cal" in
+the /usr/share/man/man1 directory only.
+
+.SH OPTIONS
+.IP \fB\-b\fP
+Search for binaries.
+.IP \fB\-m\fP
+Search for manuals.
+.IP \fB\-s\fP
+Search for sources.
+.IP \fB\-u\fP
+Only show the command names that have unusual entries.  A command is said to be
+unusual if it does not have just one entry of each explicitly requested type.
+Thus
+.RB ' "whereis \-m \-u *" '
+asks for those files in the current directory which have no documentation file,
+or more than one.
+.IP "\fB\-B \fIlist\fP"
+Limit the places where
+.B whereis
+searches for binaries, by a whitespace-separated list of directories.
+.IP "\fB\-M \fIlist\fP"
+Limit the places where
+.B whereis
+searches for manuals and documentation in Info format, by a
+whitespace-separated list of directories.
+.IP "\fB\-S \fIlist\fP"
+Limit the places where
+.B whereis
+searches for sources, by a whitespace-separated list of directories.
+.IP "\fB\-f\fP"
+Terminates the directory list and signals the start of filenames.  It
+.I must
+be used when any of the
+.BR \-B ,
+.BR \-M ,
+or
+.B \-S
+options is used.
+.IP "\fB\-l"
+Output the list of effective lookup paths that
+.B whereis
+is using.  When none of
+.BR \-B ,
+.BR \-M ,
+or
+.B \-S
+is specified, the option will output the hard-coded paths
+that the command was able to find on the system.
+.TP
+\fB\-h\fR, \fB\-\-help\fR
+Display help text and exit.
+.TP
+\fB\-V\fR, \fB\-\-version\fR
+Display version information and exit.
+.SH FILE SEARCH PATHS
+By default
+.B whereis
+tries to find files from hard-coded paths, which are defined with glob
+patterns.  The command attempts to use the contents of
+.B $PATH
+and
+.B $MANPATH
+environment variables as default search path.  The easiest way to know
+what paths are in use is to add the
+.B \-l
+listing option.  Effects of the
+.BR \-B ,
+.BR \-M ,
+and
+.B \-S
+are displayed with
+.BR \-l .
+.SH ENVIRONMENT
+.IP WHEREIS_DEBUG=all
+enables debug output.
+.SH EXAMPLES
+To find all files in
+.I /usr/\:bin
+which are not documented
+in
+.I /usr/\:man/\:man1
+or have no source in
+.IR /usr/\:src :
+.IP
+.B cd /usr/bin
+.br
+.B whereis \-u \-ms \-M /usr/man/man1 \-S /usr/src \-f *
+.SH AVAILABILITY
+The whereis command is part of the util-linux package and is available from
+.UR https://\:www.kernel.org\:/pub\:/linux\:/utils\:/util-linux/
+Linux Kernel Archive
+.UE .
diff --git a/misc-utils/whereis.c b/misc-utils/whereis.c
new file mode 100644
index 0000000..0247dbe
--- /dev/null
+++ b/misc-utils/whereis.c
@@ -0,0 +1,656 @@
+/*-
+ * Copyright (c) 1980 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
+ * - added Native Language Support
+ * 2011-08-12 Davidlohr Bueso <dave@gnu.org>
+ * - added $PATH lookup
+ *
+ * Copyright (C) 2013 Karel Zak <kzak@redhat.com>
+ *               2013 Sami Kerola <kerolasa@iki.fi>
+ */
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+
+#include "xalloc.h"
+#include "nls.h"
+#include "c.h"
+#include "closestream.h"
+#include "canonicalize.h"
+
+#include "debug.h"
+
+static UL_DEBUG_DEFINE_MASK(whereis);
+UL_DEBUG_DEFINE_MASKNAMES(whereis) = UL_DEBUG_EMPTY_MASKNAMES;
+
+#define WHEREIS_DEBUG_INIT	(1 << 1)
+#define WHEREIS_DEBUG_PATH	(1 << 2)
+#define WHEREIS_DEBUG_ENV	(1 << 3)
+#define WHEREIS_DEBUG_ARGV	(1 << 4)
+#define WHEREIS_DEBUG_SEARCH	(1 << 5)
+#define WHEREIS_DEBUG_STATIC	(1 << 6)
+#define WHEREIS_DEBUG_LIST	(1 << 7)
+#define WHEREIS_DEBUG_ALL	0xFFFF
+
+#define DBG(m, x)       __UL_DBG(whereis, WHEREIS_DEBUG_, m, x)
+#define ON_DBG(m, x)    __UL_DBG_CALL(whereis, WHEREIS_DEBUG_, m, x)
+
+#define UL_DEBUG_CURRENT_MASK	UL_DEBUG_MASK(whereis)
+#include "debugobj.h"
+
+static char uflag = 0;
+
+/* supported types */
+enum {
+	BIN_DIR = (1 << 1),
+	MAN_DIR = (1 << 2),
+	SRC_DIR = (1 << 3),
+
+	ALL_DIRS = BIN_DIR | MAN_DIR | SRC_DIR
+};
+
+/* directories */
+struct wh_dirlist {
+	int	type;
+	dev_t	st_dev;
+	ino_t	st_ino;
+	char	*path;
+
+	struct wh_dirlist *next;
+};
+
+static const char *bindirs[] = {
+	"/usr/bin",
+	"/usr/sbin",
+	"/bin",
+	"/sbin",
+#if defined(MULTIARCHTRIPLET)
+	"/lib/" MULTIARCHTRIPLET,
+	"/usr/lib/" MULTIARCHTRIPLET,
+	"/usr/local/lib/" MULTIARCHTRIPLET,
+#endif
+	"/usr/lib",
+	"/usr/lib64",
+	"/etc",
+	"/usr/etc",
+	"/lib",
+	"/lib64",
+	"/usr/games",
+	"/usr/games/bin",
+	"/usr/games/lib",
+	"/usr/emacs/etc",
+	"/usr/lib/emacs/*/etc",
+	"/usr/TeX/bin",
+	"/usr/tex/bin",
+	"/usr/interviews/bin/LINUX",
+
+	"/usr/X11R6/bin",
+	"/usr/X386/bin",
+	"/usr/bin/X11",
+	"/usr/X11/bin",
+	"/usr/X11R5/bin",
+
+	"/usr/local/bin",
+	"/usr/local/sbin",
+	"/usr/local/etc",
+	"/usr/local/lib",
+	"/usr/local/games",
+	"/usr/local/games/bin",
+	"/usr/local/emacs/etc",
+	"/usr/local/TeX/bin",
+	"/usr/local/tex/bin",
+	"/usr/local/bin/X11",
+
+	"/usr/contrib",
+	"/usr/hosts",
+	"/usr/include",
+
+	"/usr/g++-include",
+
+	"/usr/ucb",
+	"/usr/old",
+	"/usr/new",
+	"/usr/local",
+	"/usr/libexec",
+	"/usr/share",
+
+	"/opt/*/bin",
+	NULL
+};
+
+static const char *mandirs[] = {
+	"/usr/man/*",
+	"/usr/share/man/*",
+	"/usr/X386/man/*",
+	"/usr/X11/man/*",
+	"/usr/TeX/man/*",
+	"/usr/interviews/man/mann",
+	"/usr/share/info",
+	NULL
+};
+
+static const char *srcdirs[] = {
+	"/usr/src/*",
+	"/usr/src/lib/libc/*",
+	"/usr/src/lib/libc/net/*",
+	"/usr/src/ucb/pascal",
+	"/usr/src/ucb/pascal/utilities",
+	"/usr/src/undoc",
+	NULL
+};
+
+static void whereis_init_debug(void)
+{
+	__UL_INIT_DEBUG_FROM_ENV(whereis, WHEREIS_DEBUG_, 0, WHEREIS_DEBUG);
+}
+
+static const char *whereis_type_to_name(int type)
+{
+	switch (type) {
+	case BIN_DIR: return "bin";
+	case MAN_DIR: return "man";
+	case SRC_DIR: return "src";
+	default:      return "???";
+	}
+}
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+
+	fputs(USAGE_HEADER, out);
+	fprintf(out, _(" %s [options] [-BMS <dir>... -f] <name>\n"), program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("Locate the binary, source, and manual-page files for a command.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -b         search only for binaries\n"), out);
+	fputs(_(" -B <dirs>  define binaries lookup path\n"), out);
+	fputs(_(" -m         search only for manuals and infos\n"), out);
+	fputs(_(" -M <dirs>  define man and info lookup path\n"), out);
+	fputs(_(" -s         search only for sources\n"), out);
+	fputs(_(" -S <dirs>  define sources lookup path\n"), out);
+	fputs(_(" -f         terminate <dirs> argument list\n"), out);
+	fputs(_(" -u         search for unusual entries\n"), out);
+	fputs(_(" -l         output effective lookup paths\n"), out);
+
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(16));
+	printf(USAGE_MAN_TAIL("whereis(1)"));
+	exit(EXIT_SUCCESS);
+}
+
+static void dirlist_add_dir(struct wh_dirlist **ls0, int type, const char *dir)
+{
+	struct stat st;
+	struct wh_dirlist *prev = NULL, *ls = *ls0;
+
+	if (access(dir, R_OK) != 0)
+		return;
+	if (stat(dir, &st) != 0 || !S_ISDIR(st.st_mode))
+		return;
+
+	while (ls) {
+		if (ls->st_ino == st.st_ino &&
+		    ls->st_dev == st.st_dev &&
+		    ls->type == type) {
+			DBG(LIST, ul_debugobj(*ls0, "  ignore (already in list): %s", dir));
+			return;
+		}
+		prev = ls;
+		ls = ls->next;
+	}
+
+
+	ls = xcalloc(1, sizeof(*ls));
+	ls->st_ino = st.st_ino;
+	ls->st_dev = st.st_dev;
+	ls->type = type;
+	ls->path = canonicalize_path(dir);
+
+	if (!*ls0)
+		*ls0 = ls;		/* first in the list */
+	else {
+		assert(prev);
+		prev->next = ls;	/* add to the end of the list */
+	}
+
+	DBG(LIST, ul_debugobj(*ls0, "  add dir: %s", ls->path));
+}
+
+/* special case for '*' in the paths */
+static void dirlist_add_subdir(struct wh_dirlist **ls, int type, const char *dir)
+{
+	char buf[PATH_MAX], *d;
+	DIR *dirp;
+	struct dirent *dp;
+	char *postfix;
+	size_t len;
+
+	postfix = strchr(dir, '*');
+	if (!postfix)
+		goto ignore;
+
+	/* copy begin of the path to the buffer (part before '*') */
+	len = (postfix - dir) + 1;
+	xstrncpy(buf, dir, len);
+
+	/* remember place where to append subdirs */
+	d = buf + len - 1;
+
+	/* skip '*' */
+	postfix++;
+	if (!*postfix)
+		postfix = NULL;
+
+	/* open parental dir t scan */
+	dirp = opendir(buf);
+	if (!dirp)
+		goto ignore;
+
+	DBG(LIST, ul_debugobj(*ls, " scanning subdirs: %s [%s<subdir>%s]",
+				dir, buf, postfix ? postfix : ""));
+
+	while ((dp = readdir(dirp)) != NULL) {
+		if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
+			continue;
+		if (postfix)
+			snprintf(d, PATH_MAX - len, "%s%s", dp->d_name, postfix);
+		else
+			snprintf(d, PATH_MAX - len, "%s", dp->d_name);
+
+		dirlist_add_dir(ls, type, buf);
+	}
+	closedir(dirp);
+	return;
+ignore:
+	DBG(LIST, ul_debugobj(*ls, " ignore path: %s", dir));
+}
+
+static void construct_dirlist_from_env(const char *env,
+				       struct wh_dirlist **ls,
+				       int type)
+{
+	char *key = NULL, *tok = NULL, *pathcp, *path = getenv(env);
+
+	if (!path)
+		return;
+	pathcp = xstrdup(path);
+
+	DBG(ENV, ul_debugobj(*ls, "construct %s dirlist from: %s",
+				whereis_type_to_name(type), path));
+
+	for (tok = strtok_r(pathcp, ":", &key); tok;
+	     tok = strtok_r(NULL, ":", &key))
+		dirlist_add_dir(ls, type, tok);
+
+	free(pathcp);
+}
+
+static void construct_dirlist_from_argv(struct wh_dirlist **ls,
+					int *idx,
+					int argc,
+					char *argv[],
+					int type)
+{
+	int i;
+
+	DBG(ARGV, ul_debugobj(*ls, "construct %s dirlist from argv[%d..]",
+				whereis_type_to_name(type), *idx));
+
+	for (i = *idx; i < argc; i++) {
+		if (*argv[i] == '-')			/* end of the list */
+			break;
+
+		DBG(ARGV, ul_debugobj(*ls, "  using argv[%d]: %s", *idx, argv[*idx]));
+		dirlist_add_dir(ls, type, argv[i]);
+		*idx = i;
+	}
+}
+
+static void construct_dirlist(struct wh_dirlist **ls,
+			      int type,
+			      const char **paths)
+{
+	size_t i;
+
+	DBG(STATIC, ul_debugobj(*ls, "construct %s dirlist from static array",
+				whereis_type_to_name(type)));
+
+	for (i = 0; paths[i]; i++) {
+		if (!strchr(paths[i], '*'))
+			dirlist_add_dir(ls, type, paths[i]);
+		else
+			dirlist_add_subdir(ls, type, paths[i]);
+	}
+}
+
+static void free_dirlist(struct wh_dirlist **ls0, int type)
+{
+	struct wh_dirlist *prev = NULL, *next, *ls = *ls0;
+
+	*ls0 = NULL;
+
+	DBG(LIST, ul_debugobj(*ls0, "free dirlist"));
+
+	while (ls) {
+		if (ls->type & type) {
+			next = ls->next;
+			DBG(LIST, ul_debugobj(*ls0, " free: %s", ls->path));
+			free(ls->path);
+			free(ls);
+			ls = next;
+			if (prev)
+				prev->next = ls;
+		} else {
+			if (!prev)
+				*ls0 = ls;	/* first unremoved */
+			prev = ls;
+			ls = ls->next;
+		}
+	}
+}
+
+
+static int filename_equal(const char *cp, const char *dp)
+{
+	int i = strlen(dp);
+
+	DBG(SEARCH, ul_debug("compare '%s' and '%s'", cp, dp));
+
+	if (dp[0] == 's' && dp[1] == '.' && filename_equal(cp, dp + 2))
+		return 1;
+	if (i > 1 && !strcmp(dp + i - 2, ".Z"))
+		i -= 2;
+	else if (i > 2 && !strcmp(dp + i - 3, ".gz"))
+		i -= 3;
+	else if (i > 2 && !strcmp(dp + i - 3, ".xz"))
+		i -= 3;
+	else if (i > 3 && !strcmp(dp + i - 4, ".bz2"))
+		i -= 4;
+	else if (i > 3 && !strcmp(dp + i - 4, ".zst"))
+		i -= 4;
+	while (*cp && *dp && *cp == *dp)
+		cp++, dp++, i--;
+	if (*cp == 0 && *dp == 0)
+		return 1;
+	while (isdigit(*dp))
+		dp++;
+	if (*cp == 0 && *dp++ == '.') {
+		--i;
+		while (i > 0 && *dp)
+			if (--i, *dp++ == '.')
+				return (*dp++ == 'C' && *dp++ == 0);
+		return 1;
+	}
+	return 0;
+}
+
+static void findin(const char *dir, const char *pattern, int *count, char **wait)
+{
+	DIR *dirp;
+	struct dirent *dp;
+
+	dirp = opendir(dir);
+	if (dirp == NULL)
+		return;
+
+	DBG(SEARCH, ul_debug("find '%s' in '%s'", pattern, dir));
+
+	while ((dp = readdir(dirp)) != NULL) {
+		if (!filename_equal(pattern, dp->d_name))
+			continue;
+
+		if (uflag && *count == 0)
+			xasprintf(wait, "%s/%s", dir, dp->d_name);
+
+		else if (uflag && *count == 1 && *wait) {
+			printf("%s: %s %s/%s", pattern, *wait, dir,  dp->d_name);
+			free(*wait);
+			*wait = NULL;
+		} else
+			printf(" %s/%s", dir, dp->d_name);
+		++(*count);
+	}
+	closedir(dirp);
+}
+
+static void lookup(const char *pattern, struct wh_dirlist *ls, int want)
+{
+	char patbuf[PATH_MAX];
+	int count = 0;
+	char *wait = NULL, *p;
+
+	/* canonicalize pattern -- remove path suffix etc. */
+	p = strrchr(pattern, '/');
+	p = p ? p + 1 : (char *) pattern;
+	xstrncpy(patbuf, p, PATH_MAX);
+
+	DBG(SEARCH, ul_debug("lookup dirs for '%s' (%s), want: %s %s %s",
+				patbuf, pattern,
+				want & BIN_DIR ? "bin" : "",
+				want & MAN_DIR ? "man" : "",
+				want & SRC_DIR ? "src" : ""));
+	p = strrchr(patbuf, '.');
+	if (p)
+		*p = '\0';
+
+	if (!uflag)
+		/* if -u not specified then we always print the pattern */
+		printf("%s:", patbuf);
+
+	for (; ls; ls = ls->next) {
+		if ((ls->type & want) && ls->path)
+			findin(ls->path, patbuf, &count, &wait);
+	}
+
+	free(wait);
+
+	if (!uflag || count > 1)
+		putchar('\n');
+}
+
+static void list_dirlist(struct wh_dirlist *ls)
+{
+	while (ls) {
+		if (ls->path) {
+			switch (ls->type) {
+			case BIN_DIR:
+				printf("bin: ");
+				break;
+			case MAN_DIR:
+				printf("man: ");
+				break;
+			case SRC_DIR:
+				printf("src: ");
+				break;
+			default:
+				abort();
+			}
+			printf("%s\n", ls->path);
+		}
+		ls = ls->next;
+	}
+}
+
+int main(int argc, char **argv)
+{
+	struct wh_dirlist *ls = NULL;
+	int want = ALL_DIRS;
+	int i, want_resetable = 0, opt_f_missing = 0;
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	if (argc <= 1) {
+		warnx(_("not enough arguments"));
+		errtryhelp(EXIT_FAILURE);
+	} else {
+		/* first arg may be one of our standard longopts */
+		if (!strcmp(argv[1], "--help"))
+			usage();
+		if (!strcmp(argv[1], "--version"))
+			print_version(EXIT_SUCCESS);
+	}
+
+	whereis_init_debug();
+
+	construct_dirlist(&ls, BIN_DIR, bindirs);
+	construct_dirlist_from_env("PATH", &ls, BIN_DIR);
+
+	construct_dirlist(&ls, MAN_DIR, mandirs);
+	construct_dirlist_from_env("MANPATH", &ls, MAN_DIR);
+
+	construct_dirlist(&ls, SRC_DIR, srcdirs);
+
+	for (i = 1; i < argc; i++) {
+		const char *arg = argv[i];
+		int arg_i = i;
+
+		DBG(ARGV, ul_debug("argv[%d]: %s", i, arg));
+
+		if (*arg != '-') {
+			lookup(arg, ls, want);
+			/*
+			 * The lookup mask ("want") is cumulative and it's
+			 * resettable only when it has been already used.
+			 *
+			 *  whereis -b -m foo     :'foo' mask=BIN|MAN
+			 *  whereis -b foo bar    :'foo' and 'bar' mask=BIN|MAN
+			 *  whereis -b foo -m bar :'foo' mask=BIN; 'bar' mask=MAN
+			 */
+			want_resetable = 1;
+			continue;
+		}
+
+		for (++arg; arg && *arg; arg++) {
+			DBG(ARGV, ul_debug("  arg: %s", arg));
+
+			switch (*arg) {
+			case 'f':
+				opt_f_missing = 0;
+				break;
+			case 'u':
+				uflag = 1;
+				opt_f_missing = 0;
+				break;
+			case 'B':
+				if (*(arg + 1)) {
+					warnx(_("bad usage"));
+					errtryhelp(EXIT_FAILURE);
+				}
+				i++;
+				free_dirlist(&ls, BIN_DIR);
+				construct_dirlist_from_argv(
+					&ls, &i, argc, argv, BIN_DIR);
+				opt_f_missing = 1;
+				break;
+			case 'M':
+				if (*(arg + 1)) {
+					warnx(_("bad usage"));
+					errtryhelp(EXIT_FAILURE);
+				}
+				i++;
+				free_dirlist(&ls, MAN_DIR);
+				construct_dirlist_from_argv(
+					&ls, &i, argc, argv, MAN_DIR);
+				opt_f_missing = 1;
+				break;
+			case 'S':
+				if (*(arg + 1)) {
+					warnx(_("bad usage"));
+					errtryhelp(EXIT_FAILURE);
+				}
+				i++;
+				free_dirlist(&ls, SRC_DIR);
+				construct_dirlist_from_argv(
+					&ls, &i, argc, argv, SRC_DIR);
+				opt_f_missing = 1;
+				break;
+			case 'b':
+				if (want_resetable) {
+					want = ALL_DIRS;
+					want_resetable = 0;
+				}
+				want = want == ALL_DIRS ? BIN_DIR : want | BIN_DIR;
+				opt_f_missing = 0;
+				break;
+			case 'm':
+				if (want_resetable) {
+					want = ALL_DIRS;
+					want_resetable = 0;
+				}
+				want = want == ALL_DIRS ? MAN_DIR : want | MAN_DIR;
+				opt_f_missing = 0;
+				break;
+			case 's':
+				if (want_resetable) {
+					want = ALL_DIRS;
+					want_resetable = 0;
+				}
+				want = want == ALL_DIRS ? SRC_DIR : want | SRC_DIR;
+				opt_f_missing = 0;
+				break;
+			case 'l':
+				list_dirlist(ls);
+				break;
+
+			case 'V':
+				print_version(EXIT_SUCCESS);
+			case 'h':
+				usage();
+			default:
+				warnx(_("bad usage"));
+				errtryhelp(EXIT_FAILURE);
+			}
+
+			if (arg_i < i)		/* moved to the next argv[] item */
+				break;
+		}
+	}
+
+	free_dirlist(&ls, ALL_DIRS);
+	if (opt_f_missing)
+		errx(EXIT_FAILURE, _("option -f is missing"));
+	return EXIT_SUCCESS;
+}
diff --git a/misc-utils/wipefs.8 b/misc-utils/wipefs.8
new file mode 100644
index 0000000..303e661
--- /dev/null
+++ b/misc-utils/wipefs.8
@@ -0,0 +1,148 @@
+.\" Copyright 2009 by Karel Zak.  All Rights Reserved.
+.\" This file may be copied under the terms of the GNU Public License.
+.\"
+.TH WIPEFS 8 "December 2014" "util-linux" "System Administration"
+.SH NAME
+wipefs \- wipe a signature from a device
+.SH SYNOPSIS
+.B wipefs
+.RB [ options ]
+.IR device ...
+.sp
+.B wipefs
+.RB [ \-\-backup ]
+.B \-o
+.I offset
+.IR device ...
+.sp
+.B wipefs
+.RB [ \-\-backup ]
+.B \-a
+.IR device ...
+.SH DESCRIPTION
+.B wipefs
+can erase filesystem, raid or partition-table signatures (magic strings) from
+the specified
+.I device
+to make the signatures invisible for libblkid.
+.B wipefs
+does not erase the filesystem itself nor any other data from the device.
+
+When used without any options, wipefs lists all visible filesystems and the
+offsets of their basic signatures.  The default output is subject to change.
+So whenever possible, you should avoid using default outputs in your scripts.
+Always explicitly define expected columns by using
+.B \-\-output
+.I columns-list
+in environments where a stable output is required.
+
+.B wipefs
+calls the BLKRRPART ioctl when it has erased a partition-table signature
+to inform the kernel about the change. The ioctl is called as the last step
+and when all specified signatures from all specified devices are already erased.
+This feature can be used to wipe content on partitions devices as well as partition
+table on a disk device, for example by \fBwipefs \-a /dev/sdc1 /dev/sdc2 /dev/sdc\fR.
+
+Note that some filesystems and some partition tables store more magic strings on
+the device (e.g., FAT, ZFS, GPT).  The
+.B wipefs
+command (since v2.31) lists all the offset where a magic strings have been
+detected.
+
+When option \fB\-a\fR is used, all magic strings that are visible for libblkid are
+erased. In this case the
+.B wipefs
+scans the device again after each modification (erase) until no magic string is found.
+
+Note that by default
+.B wipefs
+does not erase nested partition tables on non-whole disk devices.
+For this the option \fB\-\-force\fR is required.
+
+.SH OPTIONS
+.TP
+.BR \-a , " \-\-all"
+Erase all available signatures.  The set of erased signatures can be
+restricted with the \fB\-t\fR option.
+.TP
+.BR \-b , " \-\-backup"
+Create a signature backup to the file $HOME/wipefs-<devname>-<offset>.bak.
+For more details see the \fBEXAMPLE\fR section.
+.TP
+.BR \-f , " \-\-force"
+Force erasure, even if the filesystem is mounted.  This is required in
+order to erase a partition-table signature on a block device.
+.TP
+.BR \-h , " \-\-help"
+Display help text and exit.
+.TP
+.BR \-J , " \-\-json"
+Use JSON output format.
+.TP
+\fB\-\-lock\fR[=\fImode\fR]
+Use exclusive BSD lock for device or file it operates.  The optional argument
+\fImode\fP can be \fByes\fR, \fBno\fR (or 1 and 0) or \fBnonblock\fR.  If the \fImode\fR
+argument is omitted, it defaults to \fB"yes"\fR.  This option overwrites
+environment variable \fB$LOCK_BLOCK_DEVICE\fR.  The default is not to use any
+lock at all, but it's recommended to avoid collisions with udevd or other
+tools.
+.TP
+.BR \-i , " \-\-noheadings"
+Do not print a header line.
+.TP
+.BR \-O , " \-\-output " \fIlist\fP
+Specify which output columns to print.  Use \-\-help to
+get a list of all supported columns.
+.TP
+.BR \-n , " \-\-no\-act"
+Causes everything to be done except for the write() call.
+.TP
+.BR \-o , " \-\-offset " \fIoffset\fP
+Specify the location (in bytes) of the signature which should be erased from the
+device.  The \fIoffset\fR number may include a "0x" prefix; then the number will be
+interpreted as a hex value.  It is possible to specify multiple \fB\-o\fR options.
+.sp
+The \fIoffset\fR argument may be followed by the multiplicative
+suffixes KiB (=1024), MiB (=1024*1024), and so on for GiB, TiB, PiB, EiB, ZiB and YiB
+(the "iB" is optional, e.g., "K" has the same meaning as "KiB"), or the suffixes
+KB (=1000), MB (=1000*1000), and so on for GB, TB, PB, EB, ZB and YB.
+.TP
+.BR \-p , " \-\-parsable"
+Print out in parsable instead of printable format.  Encode all potentially unsafe
+characters of a string to the corresponding hex value prefixed by '\\x'.
+.TP
+.BR \-q , " \-\-quiet"
+Suppress any messages after a successful signature wipe.
+.TP
+.BR \-t , " \-\-types " \fIlist\fP
+Limit the set of printed or erased signatures.  More than one type may
+be specified in a comma-separated list.  The list or individual types
+can be prefixed with 'no' to specify the types on which no action should be
+taken.  For more details see mount(8).
+.TP
+.BR \-V , " \-\-version"
+Display version information and exit.
+.SH ENVIRONMENT
+.IP LIBBLKID_DEBUG=all
+enables libblkid debug output.
+.IP LOCK_BLOCK_DEVICE=<mode>
+use exclusive BSD lock.  The mode is "1" or "0".  See \fB\-\-lock\fR for more details.
+.SH EXAMPLE
+.TP
+.B wipefs /dev/sda*
+Prints information about sda and all partitions on sda.
+.TP
+.B wipefs \-\-all \-\-backup /dev/sdb
+Erases all signatures from the device /dev/sdb and creates a signature backup
+file ~/wipefs-sdb-<offset>.bak for each signature.
+.TP
+.B dd if=~/wipefs-sdb-0x00000438.bak of=/dev/sdb seek=$((0x00000438)) bs=1 conv=notrunc
+Restores an ext2 signature from the backup file  ~/wipefs-sdb-0x00000438.bak.
+.SH AUTHORS
+Karel Zak <kzak@redhat.com>
+.SH SEE ALSO
+.BR blkid (8),
+.BR findfs (8)
+.SH AVAILABILITY
+The wipefs command is part of the util-linux package and is available from
+https://www.kernel.org/pub/linux/utils/util-linux/.
diff --git a/misc-utils/wipefs.c b/misc-utils/wipefs.c
new file mode 100644
index 0000000..77dfe6a
--- /dev/null
+++ b/misc-utils/wipefs.c
@@ -0,0 +1,851 @@
+/*
+ * wipefs - utility to wipe filesystems from device
+ *
+ * Copyright (C) 2009 Red Hat, Inc. All rights reserved.
+ * Written by Karel Zak <kzak@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <string.h>
+#include <limits.h>
+#include <libgen.h>
+
+#include <blkid.h>
+#include <libsmartcols.h>
+
+#include "nls.h"
+#include "xalloc.h"
+#include "strutils.h"
+#include "all-io.h"
+#include "match.h"
+#include "c.h"
+#include "closestream.h"
+#include "optutils.h"
+#include "blkdev.h"
+
+struct wipe_desc {
+	loff_t		offset;		/* magic string offset */
+	size_t		len;		/* length of magic string */
+	unsigned char	*magic;		/* magic string */
+
+	char		*usage;		/* raid, filesystem, ... */
+	char		*type;		/* FS type */
+	char		*label;		/* FS label */
+	char		*uuid;		/* FS uuid */
+
+	struct wipe_desc	*next;
+
+	unsigned int	on_disk : 1,
+			is_parttable : 1;
+
+};
+
+struct wipe_control {
+	char		*devname;
+	const char	*type_pattern;		/* -t <pattern> */
+	const char	*lockmode;
+
+	struct libscols_table *outtab;
+	struct wipe_desc *offsets;		/* -o <offset> -o <offset> ... */
+
+	size_t		ndevs;			/* number of devices to probe */
+
+	char		**reread;		/* devices to BLKRRPART */
+	size_t		nrereads;		/* size of reread */
+
+	unsigned int	noact : 1,
+			all : 1,
+			quiet : 1,
+			backup : 1,
+			force : 1,
+			json : 1,
+			no_headings : 1,
+			parsable : 1;
+};
+
+
+/* column IDs */
+enum {
+	COL_UUID = 0,
+	COL_LABEL,
+	COL_LEN,
+	COL_TYPE,
+	COL_OFFSET,
+	COL_USAGE,
+	COL_DEVICE
+};
+
+/* column names */
+struct colinfo {
+	const char *name;	/* header */
+	double whint;		/* width hint (N < 1 is in percent of termwidth) */
+	int flags;		/* SCOLS_FL_* */
+	const char *help;
+};
+
+/* columns descriptions */
+static const struct colinfo infos[] = {
+	[COL_UUID]    = {"UUID",     4, 0, N_("partition/filesystem UUID")},
+	[COL_LABEL]   = {"LABEL",    5, 0, N_("filesystem LABEL")},
+	[COL_LEN]     = {"LENGTH",   6, 0, N_("magic string length")},
+	[COL_TYPE]    = {"TYPE",     4, 0, N_("superblok type")},
+	[COL_OFFSET]  = {"OFFSET",   5, 0, N_("magic string offset")},
+	[COL_USAGE]   = {"USAGE",    5, 0, N_("type description")},
+	[COL_DEVICE]  = {"DEVICE",   5, 0, N_("block device name")}
+};
+
+static int columns[ARRAY_SIZE(infos) * 2];
+static size_t ncolumns;
+
+static int column_name_to_id(const char *name, size_t namesz)
+{
+	size_t i;
+
+	assert(name);
+
+	for (i = 0; i < ARRAY_SIZE(infos); i++) {
+		const char *cn = infos[i].name;
+		if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
+			return i;
+	}
+	warnx(_("unknown column: %s"), name);
+	return -1;
+}
+
+static int get_column_id(size_t num)
+{
+	assert(num < ncolumns);
+	assert(columns[num] < (int)ARRAY_SIZE(infos));
+	return columns[num];
+}
+
+static const struct colinfo *get_column_info(int num)
+{
+	return &infos[get_column_id(num)];
+}
+
+
+static void init_output(struct wipe_control *ctl)
+{
+	struct libscols_table *tb;
+	size_t i;
+
+	scols_init_debug(0);
+	tb = scols_new_table();
+	if (!tb)
+		err(EXIT_FAILURE, _("failed to allocate output table"));
+
+	if (ctl->json) {
+		scols_table_enable_json(tb, 1);
+		scols_table_set_name(tb, "signatures");
+	}
+	scols_table_enable_noheadings(tb, ctl->no_headings);
+
+	if (ctl->parsable) {
+		scols_table_enable_raw(tb, 1);
+		scols_table_set_column_separator(tb, ",");
+	}
+
+	for (i = 0; i < ncolumns; i++) {
+		const struct colinfo *col = get_column_info(i);
+		struct libscols_column *cl;
+
+		cl = scols_table_new_column(tb, col->name, col->whint,
+					    col->flags);
+		if (!cl)
+			err(EXIT_FAILURE,
+			    _("failed to initialize output column"));
+		if (ctl->json) {
+			int id = get_column_id(i);
+
+			if (id == COL_LEN)
+				scols_column_set_json_type(cl, SCOLS_JSON_NUMBER);
+		}
+	}
+	ctl->outtab = tb;
+}
+
+static void finalize_output(struct wipe_control *ctl)
+{
+	if (ctl->parsable && !ctl->no_headings
+	    && !scols_table_is_empty(ctl->outtab)) {
+		struct libscols_iter *itr = scols_new_iter(SCOLS_ITER_FORWARD);
+		struct libscols_column *cl;
+		int i = 0;
+
+		if (!itr)
+			err_oom();
+
+		fputs("# ", stdout);
+		while (scols_table_next_column(ctl->outtab, itr, &cl) == 0) {
+			struct libscols_cell *hdr = scols_column_get_header(cl);
+			const char *name = scols_cell_get_data(hdr);
+
+			if (i)
+				fputc(',', stdout);
+			fputs(name, stdout);
+			i++;
+		}
+		fputc('\n', stdout);
+		scols_free_iter(itr);
+	}
+	scols_print_table(ctl->outtab);
+	scols_unref_table(ctl->outtab);
+}
+
+static void fill_table_row(struct wipe_control *ctl, struct wipe_desc *wp)
+{
+	static struct libscols_line *ln;
+	size_t i;
+
+	ln = scols_table_new_line(ctl->outtab, NULL);
+	if (!ln)
+		errx(EXIT_FAILURE, _("failed to allocate output line"));
+
+	for (i = 0; i < ncolumns; i++) {
+		char *str = NULL;
+
+		switch (get_column_id(i)) {
+		case COL_UUID:
+			if (wp->uuid)
+				str = xstrdup(wp->uuid);
+			break;
+		case COL_LABEL:
+			if (wp->label)
+				str = xstrdup(wp->label);
+			break;
+		case COL_OFFSET:
+			xasprintf(&str, "0x%jx", (intmax_t)wp->offset);
+			break;
+		case COL_LEN:
+			xasprintf(&str, "%zu", wp->len);
+			break;
+		case COL_USAGE:
+			if (wp->usage)
+				str = xstrdup(wp->usage);
+			break;
+		case COL_TYPE:
+			if (wp->type)
+				str = xstrdup(wp->type);
+			break;
+		case COL_DEVICE:
+			if (ctl->devname) {
+				char *dev = xstrdup(ctl->devname);
+				str = xstrdup(basename(dev));
+				free(dev);
+			}
+			break;
+		default:
+			abort();
+		}
+
+		if (str && scols_line_refer_data(ln, i, str))
+			errx(EXIT_FAILURE, _("failed to add output data"));
+	}
+}
+
+static void add_to_output(struct wipe_control *ctl, struct wipe_desc *wp)
+{
+	for (/*nothing*/; wp; wp = wp->next)
+		fill_table_row(ctl, wp);
+}
+
+/* Allocates a new wipe_desc and add to the wp0 if not NULL */
+static struct wipe_desc *add_offset(struct wipe_desc **wp0, loff_t offset)
+{
+	struct wipe_desc *wp, *last = NULL;
+
+	if (wp0) {
+		/* check if already exists */
+		for (wp = *wp0; wp; wp = wp->next) {
+			if (wp->offset == offset)
+				return wp;
+			last = wp;
+		}
+	}
+
+	wp = xcalloc(1, sizeof(struct wipe_desc));
+	wp->offset = offset;
+	wp->next = NULL;
+
+	if (last)
+		last->next = wp;
+	if (wp0 && !*wp0)
+		*wp0 = wp;
+	return wp;
+}
+
+/* Read data from libblkid and if detected type pass -t and -o filters than:
+ * - allocates a new wipe_desc
+ * - add the new wipe_desc to wp0 list (if not NULL)
+ *
+ * The function always returns offset and len if libblkid detected something.
+ */
+static struct wipe_desc *get_desc_for_probe(struct wipe_control *ctl,
+					    struct wipe_desc **wp0,
+					    blkid_probe pr,
+					    loff_t *offset,
+					    size_t *len)
+{
+	const char *off, *type, *mag, *p, *use = NULL;
+	struct wipe_desc *wp;
+	int rc, ispt = 0;
+
+	*len = 0;
+
+	/* superblocks */
+	if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) == 0) {
+		rc = blkid_probe_lookup_value(pr, "SBMAGIC_OFFSET", &off, NULL);
+		if (!rc)
+			rc = blkid_probe_lookup_value(pr, "SBMAGIC", &mag, len);
+		if (rc)
+			return NULL;
+
+	/* partitions */
+	} else if (blkid_probe_lookup_value(pr, "PTTYPE", &type, NULL) == 0) {
+		rc = blkid_probe_lookup_value(pr, "PTMAGIC_OFFSET", &off, NULL);
+		if (!rc)
+			rc = blkid_probe_lookup_value(pr, "PTMAGIC", &mag, len);
+		if (rc)
+			return NULL;
+		use = N_("partition-table");
+		ispt = 1;
+	} else
+		return NULL;
+
+	*offset = strtoll(off, NULL, 10);
+
+	/* Filter out by -t <type> */
+	if (ctl->type_pattern && !match_fstype(type, ctl->type_pattern))
+		return NULL;
+
+	/* Filter out by -o <offset> */
+	if (ctl->offsets) {
+		struct wipe_desc *w = NULL;
+
+		for (w = ctl->offsets; w; w = w->next) {
+			if (w->offset == *offset)
+				break;
+		}
+		if (!w)
+			return NULL;
+
+		w->on_disk = 1; /* mark as "found" */
+	}
+
+	wp = add_offset(wp0, *offset);
+	if (!wp)
+		return NULL;
+
+	if (use || blkid_probe_lookup_value(pr, "USAGE", &use, NULL) == 0)
+		wp->usage = xstrdup(use);
+
+	wp->type = xstrdup(type);
+	wp->on_disk = 1;
+	wp->is_parttable = ispt ? 1 : 0;
+
+	wp->magic = xmalloc(*len);
+	memcpy(wp->magic, mag, *len);
+	wp->len = *len;
+
+	if (blkid_probe_lookup_value(pr, "LABEL", &p, NULL) == 0)
+		wp->label = xstrdup(p);
+
+	if (blkid_probe_lookup_value(pr, "UUID", &p, NULL) == 0)
+		wp->uuid = xstrdup(p);
+
+	return wp;
+}
+
+static blkid_probe
+new_probe(const char *devname, int mode)
+{
+	blkid_probe pr = NULL;
+
+	if (!devname)
+		return NULL;
+
+	if (mode) {
+		int fd = open(devname, mode | O_NONBLOCK);
+		if (fd < 0)
+			goto error;
+
+		pr = blkid_new_probe();
+		if (!pr || blkid_probe_set_device(pr, fd, 0, 0) != 0) {
+			close(fd);
+			goto error;
+		}
+	} else
+		pr = blkid_new_probe_from_filename(devname);
+
+	if (!pr)
+		goto error;
+
+	blkid_probe_enable_superblocks(pr, 1);
+	blkid_probe_set_superblocks_flags(pr,
+			BLKID_SUBLKS_MAGIC |	/* return magic string and offset */
+			BLKID_SUBLKS_TYPE |	/* return superblock type */
+			BLKID_SUBLKS_USAGE |	/* return USAGE= */
+			BLKID_SUBLKS_LABEL |	/* return LABEL= */
+			BLKID_SUBLKS_UUID |	/* return UUID= */
+			BLKID_SUBLKS_BADCSUM);	/* accept bad checksums */
+
+	blkid_probe_enable_partitions(pr, 1);
+	blkid_probe_set_partitions_flags(pr, BLKID_PARTS_MAGIC |
+					     BLKID_PARTS_FORCE_GPT);
+	return pr;
+error:
+	blkid_free_probe(pr);
+	err(EXIT_FAILURE, _("error: %s: probing initialization failed"), devname);
+}
+
+static struct wipe_desc *read_offsets(struct wipe_control *ctl)
+{
+	blkid_probe pr = new_probe(ctl->devname, 0);
+	struct wipe_desc *wp0 = NULL;
+
+	if (!pr)
+		return NULL;
+
+	while (blkid_do_probe(pr) == 0) {
+		size_t len = 0;
+		loff_t offset = 0;
+
+		/* add a new offset to wp0 */
+		get_desc_for_probe(ctl, &wp0, pr, &offset, &len);
+
+		/* hide last detected signature and scan again */
+		if (len) {
+			blkid_probe_hide_range(pr, offset, len);
+			blkid_probe_step_back(pr);
+		}
+	}
+
+	blkid_free_probe(pr);
+	return wp0;
+}
+
+static void free_wipe(struct wipe_desc *wp)
+{
+	while (wp) {
+		struct wipe_desc *next = wp->next;
+
+		free(wp->usage);
+		free(wp->type);
+		free(wp->magic);
+		free(wp->label);
+		free(wp->uuid);
+		free(wp);
+
+		wp = next;
+	}
+}
+
+static void do_wipe_real(struct wipe_control *ctl, blkid_probe pr,
+			struct wipe_desc *w)
+{
+	size_t i;
+
+	if (blkid_do_wipe(pr, ctl->noact) != 0)
+		err(EXIT_FAILURE, _("%s: failed to erase %s magic string at offset 0x%08jx"),
+		     ctl->devname, w->type, (intmax_t)w->offset);
+
+	if (ctl->quiet)
+		return;
+
+	printf(P_("%s: %zd byte was erased at offset 0x%08jx (%s): ",
+		  "%s: %zd bytes were erased at offset 0x%08jx (%s): ",
+		  w->len),
+	       ctl->devname, w->len, (intmax_t)w->offset, w->type);
+
+	for (i = 0; i < w->len; i++) {
+		printf("%02x", w->magic[i]);
+		if (i + 1 < w->len)
+			fputc(' ', stdout);
+	}
+	putchar('\n');
+}
+
+static void do_backup(struct wipe_desc *wp, const char *base)
+{
+	char *fname = NULL;
+	int fd;
+
+	xasprintf(&fname, "%s0x%08jx.bak", base, (intmax_t)wp->offset);
+
+	fd = open(fname, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
+	if (fd < 0)
+		goto err;
+	if (write_all(fd, wp->magic, wp->len) != 0)
+		goto err;
+	close(fd);
+	free(fname);
+	return;
+err:
+	err(EXIT_FAILURE, _("%s: failed to create a signature backup"), fname);
+}
+
+#ifdef BLKRRPART
+static void rereadpt(int fd, const char *devname)
+{
+	struct stat st;
+	int try = 0;
+
+	if (fstat(fd, &st) || !S_ISBLK(st.st_mode))
+		return;
+
+	do {
+		/*
+		 * Unfortunately, it's pretty common that the first re-read
+		 * without delay is uncuccesful. The reason is probably kernel
+		 * and/or udevd.  Let's wait a moment and try more attempts.
+		 */
+		xusleep(25000);
+
+		errno = 0;
+		ioctl(fd, BLKRRPART);
+		if (errno != EBUSY)
+			break;
+	} while (try++ < 4);
+
+	printf(_("%s: calling ioctl to re-read partition table: %m\n"), devname);
+}
+#endif
+
+static int do_wipe(struct wipe_control *ctl)
+{
+	int mode = O_RDWR, reread = 0, need_force = 0;
+	blkid_probe pr;
+	char *backup = NULL;
+	struct wipe_desc *w;
+
+	if (!ctl->force)
+		mode |= O_EXCL;
+
+	pr = new_probe(ctl->devname, mode);
+	if (!pr)
+		return -errno;
+
+	if (blkdev_lock(blkid_probe_get_fd(pr),
+			ctl->devname, ctl->lockmode) != 0) {
+		blkid_free_probe(pr);
+		return -1;
+	}
+
+	if (ctl->backup) {
+		const char *home = getenv ("HOME");
+		char *tmp = xstrdup(ctl->devname);
+
+		if (!home)
+			errx(EXIT_FAILURE, _("failed to create a signature backup, $HOME undefined"));
+		xasprintf (&backup, "%s/wipefs-%s-", home, basename(tmp));
+		free(tmp);
+	}
+
+	while (blkid_do_probe(pr) == 0) {
+		int wiped = 0;
+		size_t len = 0;
+		loff_t offset = 0;
+		struct wipe_desc *wp;
+
+		wp = get_desc_for_probe(ctl, NULL, pr, &offset, &len);
+		if (!wp)
+			goto done;
+
+		if (!ctl->force
+		    && wp->is_parttable
+		    && !blkid_probe_is_wholedisk(pr)) {
+			warnx(_("%s: ignoring nested \"%s\" partition table "
+				"on non-whole disk device"), ctl->devname, wp->type);
+			need_force = 1;
+			goto done;
+		}
+
+		if (backup)
+			do_backup(wp, backup);
+		do_wipe_real(ctl, pr, wp);
+		if (wp->is_parttable)
+			reread = 1;
+		wiped = 1;
+	done:
+		if (!wiped && len) {
+			/* if the offset has not been wiped (probably because
+			 * filtered out by -t or -o) we need to hide it for
+			 * libblkid to try another magic string for the same
+			 * superblock, otherwise libblkid will continue with
+			 * another superblock. Don't forget that the same
+			 * superblock could be detected by more magic strings
+			 * */
+			blkid_probe_hide_range(pr, offset, len);
+			blkid_probe_step_back(pr);
+		}
+		free_wipe(wp);
+	}
+
+	for (w = ctl->offsets; w; w = w->next) {
+		if (!w->on_disk && !ctl->quiet)
+			warnx(_("%s: offset 0x%jx not found"),
+					ctl->devname, (uintmax_t)w->offset);
+	}
+
+	if (need_force)
+		warnx(_("Use the --force option to force erase."));
+
+	fsync(blkid_probe_get_fd(pr));
+
+#ifdef BLKRRPART
+	if (reread && (mode & O_EXCL)) {
+		if (ctl->ndevs > 1) {
+			/*
+			 * We're going to probe more device, let's postpone
+			 * re-read PT ioctl until all is erased to avoid
+			 * situation we erase PT on /dev/sda before /dev/sdaN
+			 * devices are processed.
+			 */
+			if (!ctl->reread)
+				ctl->reread = xcalloc(ctl->ndevs, sizeof(char *));
+
+			ctl->reread[ctl->nrereads++] = ctl->devname;
+		} else
+			rereadpt(blkid_probe_get_fd(pr), ctl->devname);
+	}
+#endif
+
+	close(blkid_probe_get_fd(pr));
+	blkid_free_probe(pr);
+	free(backup);
+	return 0;
+}
+
+
+static void __attribute__((__noreturn__))
+usage(void)
+{
+	size_t i;
+
+	fputs(USAGE_HEADER, stdout);
+	printf(_(" %s [options] <device>\n"), program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, stdout);
+	puts(_("Wipe signatures from a device."));
+
+	fputs(USAGE_OPTIONS, stdout);
+	puts(_(" -a, --all           wipe all magic strings (BE CAREFUL!)"));
+	puts(_(" -b, --backup        create a signature backup in $HOME"));
+	puts(_(" -f, --force         force erasure"));
+	puts(_(" -i, --noheadings    don't print headings"));
+	puts(_(" -J, --json          use JSON output format"));
+	puts(_(" -n, --no-act        do everything except the actual write() call"));
+	puts(_(" -o, --offset <num>  offset to erase, in bytes"));
+	puts(_(" -O, --output <list> COLUMNS to display (see below)"));
+	puts(_(" -p, --parsable      print out in parsable instead of printable format"));
+	puts(_(" -q, --quiet         suppress output messages"));
+	puts(_(" -t, --types <list>  limit the set of filesystem, RAIDs or partition tables"));
+	printf(
+	     _("     --lock[=<mode>] use exclusive device lock (%s, %s or %s)\n"), "yes", "no", "nonblock");
+
+	printf(USAGE_HELP_OPTIONS(21));
+
+	fputs(USAGE_ARGUMENTS, stdout);
+	printf(USAGE_ARG_SIZE(_("<num>")));
+
+	fputs(USAGE_COLUMNS, stdout);
+	for (i = 0; i < ARRAY_SIZE(infos); i++)
+		fprintf(stdout, " %8s  %s\n", infos[i].name, _(infos[i].help));
+
+	printf(USAGE_MAN_TAIL("wipefs(8)"));
+	exit(EXIT_SUCCESS);
+}
+
+
+int
+main(int argc, char **argv)
+{
+	struct wipe_control ctl = { .devname = NULL };
+	int c;
+	char *outarg = NULL;
+	enum {
+		OPT_LOCK = CHAR_MAX + 1,
+	};
+	static const struct option longopts[] = {
+	    { "all",       no_argument,       NULL, 'a' },
+	    { "backup",    no_argument,       NULL, 'b' },
+	    { "force",     no_argument,       NULL, 'f' },
+	    { "help",      no_argument,       NULL, 'h' },
+	    { "lock",      optional_argument, NULL, OPT_LOCK },
+	    { "no-act",    no_argument,       NULL, 'n' },
+	    { "offset",    required_argument, NULL, 'o' },
+	    { "parsable",  no_argument,       NULL, 'p' },
+	    { "quiet",     no_argument,       NULL, 'q' },
+	    { "types",     required_argument, NULL, 't' },
+	    { "version",   no_argument,       NULL, 'V' },
+	    { "json",      no_argument,       NULL, 'J'},
+	    { "noheadings",no_argument,       NULL, 'i'},
+	    { "output",    required_argument, NULL, 'O'},
+	    { NULL,        0, NULL, 0 }
+	};
+
+	static const ul_excl_t excl[] = {       /* rows and cols in ASCII order */
+		{ 'O','a','o' },
+		{ 0 }
+	};
+	int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	while ((c = getopt_long(argc, argv, "abfhiJnO:o:pqt:V", longopts, NULL)) != -1) {
+
+		err_exclusive_options(c, longopts, excl, excl_st);
+
+		switch(c) {
+		case 'a':
+			ctl.all = 1;
+			break;
+		case 'b':
+			ctl.backup = 1;
+			break;
+		case 'f':
+			ctl.force = 1;
+			break;
+		case 'J':
+			ctl.json = 1;
+			break;
+		case 'i':
+			ctl.no_headings = 1;
+			break;
+		case 'O':
+			outarg = optarg;
+			break;
+		case 'n':
+			ctl.noact = 1;
+			break;
+		case 'o':
+			add_offset(&ctl.offsets, strtosize_or_err(optarg,
+					 _("invalid offset argument")));
+			break;
+		case 'p':
+			ctl.parsable = 1;
+			ctl.no_headings = 1;
+			break;
+		case 'q':
+			ctl.quiet = 1;
+			break;
+		case 't':
+			ctl.type_pattern = optarg;
+			break;
+		case OPT_LOCK:
+			ctl.lockmode = "1";
+			if (optarg) {
+				if (*optarg == '=')
+					optarg++;
+				ctl.lockmode = optarg;
+			}
+			break;
+		case 'h':
+			usage();
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+
+	if (optind == argc) {
+		warnx(_("no device specified"));
+		errtryhelp(EXIT_FAILURE);
+
+	}
+
+	if (ctl.backup && !(ctl.all || ctl.offsets))
+		warnx(_("The --backup option is meaningless in this context"));
+
+	if (!ctl.all && !ctl.offsets) {
+		/*
+		 * Print only
+		 */
+		if (ctl.parsable) {
+			/* keep it backward compatible */
+			columns[ncolumns++] = COL_OFFSET;
+			columns[ncolumns++] = COL_UUID;
+			columns[ncolumns++] = COL_LABEL;
+			columns[ncolumns++] = COL_TYPE;
+		} else {
+			/* default, may be modified by -O <list> */
+			columns[ncolumns++] = COL_DEVICE;
+			columns[ncolumns++] = COL_OFFSET;
+			columns[ncolumns++] = COL_TYPE;
+			columns[ncolumns++] = COL_UUID;
+			columns[ncolumns++] = COL_LABEL;
+		}
+
+		if (outarg
+		    && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns),
+					     &ncolumns, column_name_to_id) < 0)
+			return EXIT_FAILURE;
+
+		init_output(&ctl);
+
+		while (optind < argc) {
+			struct wipe_desc *wp;
+
+			ctl.devname = argv[optind++];
+			wp = read_offsets(&ctl);
+			if (wp)
+				add_to_output(&ctl, wp);
+			free_wipe(wp);
+		}
+		finalize_output(&ctl);
+	} else {
+		/*
+		 * Erase
+		 */
+		ctl.ndevs = argc - optind;
+
+		while (optind < argc) {
+			ctl.devname = argv[optind++];
+			do_wipe(&ctl);
+			ctl.ndevs--;
+		}
+
+#ifdef BLKRRPART
+		/* Re-read partition tables on whole-disk devices. This is
+		 * postponed until all is done to avoid conflicts.
+		 */
+		for (size_t i = 0; i < ctl.nrereads; i++) {
+			char *devname = ctl.reread[i];
+			int fd = open(devname, O_RDONLY);
+
+			if (fd >= 0) {
+				rereadpt(fd, devname);
+				close(fd);
+			}
+		}
+		free(ctl.reread);
+#endif
+	}
+	return EXIT_SUCCESS;
+}