Merge branch 'baserock/richardmaw/yakshave/util-linux-blkid' into baserock/morphbaserock/morph

Reviewed-by: Lars Wirzenius
Reviewed-by: Sam Thursfield

34 files changed, 5312 insertions, 598 deletions

diff --git a/libmount/COPYING b/libmount/COPYING
index 41fe6fd62..be1a5b3a1 100644
--- a/libmount/COPYING
+++ b/libmount/COPYING
@@ -4,5 +4,5 @@ License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later
 version.
 
-The complete text of the license is available at the
-Documentation/licenses/COPYING.LGPLv2.1 file.
+The complete text of the license is available in the
+../Documentation/licenses/COPYING.LGPLv2.1 file.
diff --git a/libmount/Makemodule.am b/libmount/Makemodule.am
index 81d550a47..8546c2f9b 100644
--- a/libmount/Makemodule.am
+++ b/libmount/Makemodule.am
@@ -1,6 +1,7 @@
 if BUILD_LIBMOUNT
 
 include libmount/src/Makemodule.am
+include libmount/python/Makemodule.am
 
 if ENABLE_GTK_DOC
 # Docs uses separate Makefiles
@@ -11,5 +12,4 @@ pkgconfig_DATA += libmount/mount.pc
 PATHFILES      += libmount/mount.pc
 EXTRA_DIST     += libmount/COPYING
 
-
 endif # BUILD_LIBMOUNT
diff --git a/libmount/docs/libmount-sections.txt b/libmount/docs/libmount-sections.txt
index 2c3dab722..6affbfbb6 100644
--- a/libmount/docs/libmount-sections.txt
+++ b/libmount/docs/libmount-sections.txt
@@ -3,6 +3,8 @@
 libmnt_cache
 mnt_new_cache
 mnt_free_cache
+mnt_ref_cache
+mnt_unref_cache
 mnt_cache_device_has_tag
 mnt_cache_find_tag_value
 mnt_cache_read_tags
@@ -36,11 +38,14 @@ mnt_context_enable_verbose
 mnt_context_get_cache
 mnt_context_get_fs
 mnt_context_get_fstab
+mnt_context_get_fstab_userdata
 mnt_context_get_fstype
+mnt_context_get_fs_userdata
 mnt_context_get_helper_status
 mnt_context_get_lock
 mnt_context_get_mflags
 mnt_context_get_mtab
+mnt_context_get_mtab_userdata
 mnt_context_get_options
 mnt_context_get_optsmode
 mnt_context_get_source
@@ -167,11 +172,15 @@ libmnt_fs
 mnt_copy_fs
 mnt_free_fs
 mnt_free_mntent
+mnt_ref_fs
+mnt_unref_fs
 mnt_fs_append_attributes
+mnt_fs_append_comment
 mnt_fs_append_options
 mnt_fs_get_attribute
 mnt_fs_get_attributes
 mnt_fs_get_bindsrc
+mnt_fs_get_comment
 mnt_fs_get_devno
 mnt_fs_get_freq
 mnt_fs_get_fs_options
@@ -209,6 +218,7 @@ mnt_fs_prepend_options
 mnt_fs_print_debug
 mnt_fs_set_attributes
 mnt_fs_set_bindsrc
+mnt_fs_set_comment
 mnt_fs_set_freq
 mnt_fs_set_fstype
 mnt_fs_set_options
@@ -279,9 +289,14 @@ libmnt_table
 mnt_free_table
 mnt_new_table
 mnt_reset_table
+mnt_ref_table
+mnt_unref_table
 mnt_new_table_from_dir
 mnt_new_table_from_file
 mnt_table_add_fs
+mnt_table_append_intro_comment
+mnt_table_append_trailing_comment
+mnt_table_enable_comments
 mnt_table_find_devno
 mnt_table_find_mountpoint
 mnt_table_find_next_fs
@@ -290,10 +305,16 @@ mnt_table_find_source
 mnt_table_find_srcpath
 mnt_table_find_tag
 mnt_table_find_target
+mnt_table_first_fs
 mnt_table_get_cache
+mnt_table_get_intro_comment
 mnt_table_get_nents
 mnt_table_get_root_fs
+mnt_table_get_trailing_comment
+mnt_table_get_userdata
+mnt_table_is_empty
 mnt_table_is_fs_mounted
+mnt_table_last_fs
 mnt_table_next_child_fs
 mnt_table_next_fs
 mnt_table_parse_dir
@@ -304,8 +325,12 @@ mnt_table_parse_stream
 mnt_table_parse_swaps
 mnt_table_remove_fs
 mnt_table_set_cache
+mnt_table_set_intro_comment
 mnt_table_set_iter
 mnt_table_set_parser_errcb
+mnt_table_set_trailing_comment
+mnt_table_set_userdata
+mnt_table_with_comments
 </SECTION>
 
 <SECTION>
@@ -322,6 +347,8 @@ mnt_diff_tables
 libmnt_update
 mnt_free_update
 mnt_new_update
+mnt_table_replace_file
+mnt_table_write_file
 mnt_update_force_rdonly
 mnt_update_get_filename
 mnt_update_get_fs
@@ -343,6 +370,7 @@ mnt_has_regular_mtab
 mnt_mangle
 mnt_match_fstype
 mnt_match_options
+mnt_tag_is_valid
 mnt_unmangle
 </SECTION>
 
diff --git a/libmount/python/Makemodule.am b/libmount/python/Makemodule.am
new file mode 100644
index 000000000..efe210efd
--- /dev/null
+++ b/libmount/python/Makemodule.am
@@ -0,0 +1,33 @@
+EXTRA_DIST += libmount/python/__init__.py
+
+if BUILD_PYLIBMOUNT
+
+pylibmountexecdir = $(pyexecdir)/libmount
+
+# Please, don't use $pythondir for the scripts. We have to use the same
+# directory for binary stuff as well as for the scripts otherwise it's
+# not possible to install 32-bit and 64-bit version on the same system.
+pylibmountexec_LTLIBRARIES = pylibmount.la
+pylibmountexec_SCRIPTS = libmount/python/__init__.py
+
+pylibmount_la_SOURCES = \
+	libmount/python/pylibmount.c \
+	libmount/python/pylibmount.h \
+	libmount/python/fs.c \
+	libmount/python/tab.c \
+	libmount/python/context.c
+
+pylibmount_la_LIBADD = libmount.la $(PYTHON_LIBS)
+
+pylibmount_la_CFLAGS = \
+	$(AM_CFLAGS) \
+	$(PYTHON_CFLAGS) \
+	-I$(ul_libmount_incdir) \
+	-fno-strict-aliasing #-ggdb3 -O0
+
+pylibmount_la_LDFLAGS = \
+	-avoid-version -module -shared -export-dynamic
+
+CLEANFILES += *.img
+
+endif # BUILD_PYLIBMOUNT
diff --git a/libmount/python/__init__.py b/libmount/python/__init__.py
new file mode 100644
index 000000000..09104e2e2
--- /dev/null
+++ b/libmount/python/__init__.py
@@ -0,0 +1,2 @@
+from .pylibmount import *
+
diff --git a/libmount/python/context.c b/libmount/python/context.c
new file mode 100644
index 000000000..408c8bd75
--- /dev/null
+++ b/libmount/python/context.c
@@ -0,0 +1,1228 @@
+/*
+ * Python bindings for the libmount library.
+ *
+ * Copyright (C) 2013, Red Hat, Inc. All rights reserved.
+ * Written by Ondrej Oprala and Karel Zak
+ *
+ * This file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this file; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include "pylibmount.h"
+
+static PyMemberDef Context_members[] = {
+	{ NULL }
+};
+
+static PyObject *Context_set_tables_errcb(ContextObjext *self, PyObject *func,
+				      void *closure __attribute__((unused)))
+{
+	if (!func) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return NULL;
+	}
+
+	if (!PyCallable_Check(func))
+		return NULL;
+	else {
+		PyObject *tmp = self->table_errcb;
+		Py_INCREF(func);
+		self->table_errcb = func;
+		Py_XDECREF(tmp);
+	}
+	return UL_IncRef(self);
+}
+
+static void Context_dealloc(ContextObjext *self)
+{
+	if (!self->cxt) /* if init fails */
+		return;
+
+	Py_XDECREF(mnt_context_get_fs_userdata(self->cxt));
+	Py_XDECREF(mnt_context_get_fstab_userdata(self->cxt));
+	Py_XDECREF(mnt_context_get_mtab_userdata(self->cxt));
+
+	mnt_free_context(self->cxt);
+	PyFree(self);
+}
+
+static PyObject *Context_new(PyTypeObject *type,
+			 PyObject *args __attribute__((unused)),
+			 PyObject *kwds __attribute__((unused)))
+{
+	ContextObjext *self = (ContextObjext*) type->tp_alloc(type, 0);
+
+	if (self) {
+		self->cxt = NULL;
+		self->table_errcb = NULL;
+	}
+
+	return (PyObject *)self;
+}
+
+/*
+ * Note there is no pointer to encapsulating object needed here, since Cxt is
+ * on top of the Context(Table(Filesystem)) hierarchy
+ */
+#define Context_HELP "Context(source=None, target=None, fstype=None, " \
+		"options=None, mflags=0, fstype_pattern=None, " \
+		"options_pattern=None, fs=None, fstab=None, optsmode=0)"
+static int Context_init(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	char *source = NULL, *target = NULL, *fstype = NULL;
+	char *options = NULL, *fstype_pattern = NULL, *options_pattern = NULL;
+	unsigned long mflags = 0;
+	int optsmode = 0, syscall_status = 1;
+	FsObject *fs = NULL;
+	TableObject *fstab = NULL;
+	int rc = 0;
+	char *kwlist[] = {
+		"source", "target", "fstype",
+		"options", "mflags", "fstype_pattern",
+		"options_pattern", "fs", "fstab",
+		"optsmode"
+	};
+
+	if (!PyArg_ParseTupleAndKeywords(
+				args, kwds, "|sssskssO!O!i", kwlist,
+				&source, &target, &fstype, &options, &mflags,
+				&fstype_pattern, &options_pattern, &FsType, &fs,
+				&TableType, &fstab, &optsmode, &syscall_status)) {
+			PyErr_SetString(PyExc_TypeError, ARG_ERR);
+			return -1;
+	}
+
+	if (self->cxt)
+		mnt_free_context(self->cxt);
+
+	self->cxt = mnt_new_context();
+	if (!self->cxt) {
+		PyErr_SetString(PyExc_MemoryError, MEMORY_ERR);
+		return -1;
+	}
+
+	if (source && (rc = mnt_context_set_source(self->cxt, source))) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+
+	if (target && (rc = mnt_context_set_target(self->cxt, target))) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+
+	if (fstype && (rc = mnt_context_set_fstype(self->cxt, fstype))) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+
+	if (options && (rc = mnt_context_set_options(self->cxt, options))) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+
+	if (fstype_pattern && (rc = mnt_context_set_fstype_pattern(self->cxt, fstype_pattern))) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+
+	if (options_pattern && (rc = mnt_context_set_options_pattern(self->cxt, options_pattern))) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+
+	if (fs && (rc = mnt_context_set_fs(self->cxt, fs->fs))) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+
+	if (fstab && (rc = mnt_context_set_fstab(self->cxt, fstab->tab))) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+
+	if (optsmode && (rc = mnt_context_set_optsmode(self->cxt, optsmode))) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+
+	mnt_context_set_mflags(self->cxt, mflags);
+	mnt_context_set_optsmode(self->cxt, optsmode);
+	mnt_context_set_tables_errcb(self->cxt, pymnt_table_parser_errcb);
+
+	return 0;
+}
+
+#define Context_enable_fake_HELP "enable_fake(enable)\n\n" \
+	"Enable/disable fake mounting (see mount(8) man page, option -f).\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_enable_fake(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	int enable;
+	char *kwlist[] = { "enable", NULL };
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &enable)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_context_enable_fake(self->cxt, enable);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_enable_force_HELP "enable_force(enable)\n\n" \
+	"Enable/disable force umounting (see umount(8) man page, option -f).\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_enable_force(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	int enable;
+	char *kwlist[] = { "enable", NULL };
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &enable)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_context_enable_force(self->cxt, enable);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_enable_lazy_HELP "enable_lazy(enable)\n\n" \
+	"Enable/disable lazy umount (see umount(8) man page, option -l).\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_enable_lazy(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	int enable;
+	char *kwlist[] = { "enable", NULL };
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &enable)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_context_enable_lazy(self->cxt, enable);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_enable_loopdel_HELP "enable_loopdel(enable)\n\n" \
+	"Enable/disable loop delete (destroy) after umount (see umount(8), option -d)\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_enable_loopdel(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	int enable;
+	char *kwlist[] = { "enable", NULL };
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &enable)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_context_enable_loopdel(self->cxt, enable);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_enable_rdonly_umount_HELP "enable_rdonly_umount(enable)\n\n" \
+	"Enable/disable read-only remount on failed umount(2)\n "\
+	"(see umount(8) man page, option -r).\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_enable_rdonly_umount(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	int enable;
+	char *kwlist[] = { "enable", NULL };
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &enable)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_context_enable_rdonly_umount(self->cxt, enable);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_enable_sloppy_HELP "enable_sloppy(enable)\n\n" \
+	"Set/unset sloppy mounting (see mount(8) man page, option -s).\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_enable_sloppy(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	int enable;
+	char *kwlist[] = { "enable", NULL };
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &enable)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_context_enable_sloppy(self->cxt, enable);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_enable_verbose_HELP "enable_verbose(enable)\n\n" \
+	"Enable/disable verbose output (TODO: not implemented yet)\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_enable_verbose(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	int enable;
+	char *kwlist[] = { "enable", NULL };
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &enable)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_context_enable_verbose(self->cxt, enable);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_enable_fork_HELP "enable_fork(enable)\n\n" \
+	"Enable/disable fork(2) call in Cxt.next_mount()(not yet implemented) (see mount(8) man\n" \
+	"page, option -F).\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_enable_fork(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	int enable;
+	char *kwlist[] = {"enable", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &enable)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_context_enable_fork(self->cxt, enable);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_disable_canonicalize_HELP "disable_canonicalize(disable)\n\n" \
+	"Enable/disable paths canonicalization and tags evaluation. The libmount context\n" \
+	"canonicalies paths when search in fstab and when prepare source and target paths\n" \
+	"for mount(2) syscall.\n" \
+	"\n" \
+	"This fuction has effect to the private (within context) fstab instance only\n" \
+	"(see Cxt.fstab).\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_disable_canonicalize(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	int disable;
+	char *kwlist[] = {"disable", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &disable)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_context_disable_canonicalize(self->cxt, disable);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_disable_helpers_HELP "disable_helpers(disable)\n\n" \
+	"Enable/disable /sbin/[u]mount.* helpers (see mount(8) man page, option -i).\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_disable_helpers(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	int disable;
+	char *kwlist[] = {"disable", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &disable)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_context_disable_helpers(self->cxt, disable);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_disable_mtab_HELP "disable_mtab(disable)\n\n" \
+	"Disable/enable mtab update (see mount(8) man page, option -n).\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_disable_mtab(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	int disable;
+	char *kwlist[] = {"disable", NULL };
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &disable)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_context_disable_mtab(self->cxt, disable);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_disable_swapmatch_HELP "disable_swapmatch(disable)\n\n" \
+	"Disable/enable swap between source and target for mount(8) if only one path\n" \
+	"is specified.\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_disable_swapmatch(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	int disable;
+	char *kwlist[] = { "disable", NULL };
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &disable)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_context_disable_swapmatch(self->cxt, disable);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+static int Context_set_source(ContextObjext *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	char *source;
+	int rc = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!(source = pystos(value)))
+		return -1;
+
+	rc = mnt_context_set_source(self->cxt, source);
+	if (rc) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+	return 0;
+}
+
+static int Context_set_mountdata(ContextObjext *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	char *mountdata;
+	int rc = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!(mountdata = pystos(value)))
+		return -1;
+
+	rc = mnt_context_set_mountdata(self->cxt, mountdata);
+	if (rc) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+	return 0;
+}
+
+static int Context_set_target(ContextObjext *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	char * target;
+	int rc = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!(target = pystos(value)))
+		return -1;
+
+	rc = mnt_context_set_target(self->cxt, target);
+	if (rc) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+	return 0;
+}
+
+static int Context_set_fstype(ContextObjext *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	char * fstype;
+	int rc = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!(fstype = pystos(value)))
+		return -1;
+
+	rc = mnt_context_set_fstype(self->cxt, fstype);
+	if (rc) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+	return 0;
+}
+
+static int Context_set_options(ContextObjext *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	char * options;
+	int rc = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!(options = pystos(value)))
+		return -1;
+
+	rc = mnt_context_set_options(self->cxt, options);
+	if (rc) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+	return 0;
+}
+
+static int Context_set_fstype_pattern(ContextObjext *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	char * fstype_pattern;
+	int rc = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!(fstype_pattern = pystos(value)))
+		return -1;
+
+	rc = mnt_context_set_fstype_pattern(self->cxt, fstype_pattern);
+	if (rc) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+	return 0;
+}
+
+static int Context_set_options_pattern(ContextObjext *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	char * options_pattern;
+	int rc = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!(options_pattern = pystos(value)))
+		return -1;
+
+	rc = mnt_context_set_options_pattern(self->cxt, options_pattern);
+	if (rc) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+	return 0;
+}
+
+static int Context_set_fs(ContextObjext *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	FsObject *fs;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!PyArg_Parse(value, "O!", &FsType, &fs)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return -1;
+	}
+	Py_INCREF(fs);
+	Py_XDECREF(mnt_context_get_fs_userdata(self->cxt));
+
+	return mnt_context_set_fs(self->cxt, fs->fs);
+}
+
+static int Context_set_fstab(ContextObjext *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	TableObject *fstab;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!PyArg_Parse(value, "O!", &TableType, &fstab)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return -1;
+	}
+	Py_INCREF(fstab);
+	Py_XDECREF(mnt_context_get_fstab_userdata(self->cxt));
+
+	return mnt_context_set_fstab(self->cxt, fstab->tab);
+}
+
+static int Context_set_optsmode(ContextObjext *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	int optsmode;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	else if (!PyLong_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return -1;
+	}
+	optsmode = PyLong_AsLong(value);
+	return mnt_context_set_optsmode(self->cxt, optsmode);
+}
+
+static int Context_set_syscall_status(ContextObjext *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	int syscall_status;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	else if (!PyLong_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return -1;
+	}
+	syscall_status = PyLong_AsLong(value);
+	return mnt_context_set_syscall_status(self->cxt, syscall_status);
+}
+
+static int Context_set_user_mflags(ContextObjext *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	unsigned long flags;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	else if (!PyLong_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return -1;
+	}
+	flags = PyLong_AsUnsignedLong(value);
+	return mnt_context_set_mflags(self->cxt, flags);
+
+}
+
+static int Context_set_mflags(ContextObjext *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	unsigned long flags;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	else if (!PyLong_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return -1;
+	}
+	flags = PyLong_AsUnsignedLong(value);
+	return mnt_context_set_mflags(self->cxt, flags);
+}
+
+/* returns a flags integer (behaviour differs from C API) */
+static PyObject *Context_get_mflags(ContextObjext *self)
+{
+	unsigned long flags;
+
+	PyObject *result;
+	mnt_context_get_mflags(self->cxt, &flags);
+	result = Py_BuildValue("k", flags);
+
+	if (!result)
+		PyErr_SetString(PyExc_RuntimeError, CONSTRUCT_ERR);
+	return result;
+
+}
+/* returns a flags integer (behaviour differs from C API) */
+static PyObject *Context_get_user_mflags(ContextObjext *self)
+{
+	unsigned long flags;
+
+	PyObject *result;
+	mnt_context_get_user_mflags(self->cxt, &flags);
+	result = Py_BuildValue("k", flags);
+
+	if (!result)
+		PyErr_SetString(PyExc_RuntimeError, CONSTRUCT_ERR);
+	return result;
+
+}
+#define Context_reset_status_HELP "reset_status()\n\n" \
+	"Resets mount(2) and mount.type statuses, so Cxt.do_mount() or\n" \
+	"Cxt.do_umount() could be again called with the same settings.\n" \
+	"\n" \
+	"BE CAREFUL -- after this soft reset the libmount will NOT parse mount\n" \
+	"options, evaluate permissions or apply stuff from fstab.\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_reset_status(ContextObjext *self)
+{
+	int rc = mnt_context_reset_status(self->cxt);
+
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_is_fake_HELP "is_fake()\n\n" \
+"Returns True if fake flag is enabled or False"
+static PyObject *Context_is_fake(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_is_fake(self->cxt));
+}
+
+#define Context_is_force_HELP "is_force()\n\n" \
+"Returns True if force umounting flag is enabled or False"
+static PyObject *Context_is_force(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_is_force(self->cxt));
+}
+
+#define Context_is_lazy_HELP "is_lazy()\n\n" \
+"Returns True if lazy umount is enabled or False"
+static PyObject *Context_is_lazy(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_is_lazy(self->cxt));
+}
+
+#define Context_is_nomtab_HELP "is_nomtab()\n\n" \
+	"Returns True if no-mtab is enabled or False"
+static PyObject *Context_is_nomtab(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_is_nomtab(self->cxt));
+}
+
+#define Context_is_rdonly_umount_HELP "is_rdonly_umount()\n\n" \
+	"Enable/disable read-only remount on failed umount(2)\n" \
+	"(see umount(8) man page, option -r).\n" \
+	"\n" \
+	"Returns self on success, raises an exception in case of error."
+static PyObject *Context_is_rdonly_umount(ContextObjext *self)
+{
+	int rc = mnt_context_is_rdonly_umount(self->cxt);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_is_restricted_HELP "is_restricted()\n\n" \
+	"Returns False for unrestricted mount (user is root), or True for non-root mounts"
+static PyObject *Context_is_restricted(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_is_restricted(self->cxt));
+}
+
+#define Context_is_sloppy_HELP "is_sloppy()\n\n" \
+	"Returns True if sloppy flag is enabled or False"
+static PyObject *Context_is_sloppy(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_is_sloppy(self->cxt));
+}
+
+#define Context_is_verbose_HELP "is_verbose()\n\n" \
+	"Returns True if verbose flag is enabled or False"
+static PyObject *Context_is_verbose(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_is_verbose(self->cxt));
+}
+#define Context_is_fs_mounted_HELP "is_fs_mounted(fs, mounted)\n\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_is_fs_mounted(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	char *kwlist[] = {"fs", "mounted", NULL};
+	FsObject *fs;
+	int mounted;
+
+	if (PyArg_ParseTupleAndKeywords(args, kwds, "O!i", kwlist,
+					&FsType, &fs, &mounted)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	return PyBool_FromLong(mnt_context_is_fs_mounted(self->cxt, fs->fs, &mounted));
+}
+
+#define Context_is_child_HELP "is_child()\n\n" \
+	"Returns True if mount -F enabled and the current context is child, or False"
+static PyObject *Context_is_child(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_is_child(self->cxt));
+}
+
+#define Context_is_fork_HELP "is_fork()\n\n" \
+	"Returns True if fork (mount -F) is enabled or False"
+static PyObject *Context_is_fork(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_is_fork(self->cxt));
+}
+
+#define Context_is_parent_HELP "is_parent()\n\n" \
+	"Returns True if mount -F enabled and the current context is parent, or False"
+static PyObject *Context_is_parent(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_is_parent(self->cxt));
+}
+
+#define Context_is_loopdel_HELP "is_loopdel()\n\n" \
+	"Returns True if loop device should be deleted after umount (umount -d) or False."
+static PyObject *Context_is_loopdel(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_is_loopdel(self->cxt));
+}
+
+#define Context_is_nocanonicalize_HELP "is_nocanonicalize()\n\n" \
+	"Returns True if no-canonicalize mode enabled or False."
+static PyObject *Context_is_nocanonicalize(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_is_nocanonicalize(self->cxt));
+}
+
+#define Context_is_nohelpers_HELP "is_nohelpers()\n\n" \
+	"Returns True if helpers are disabled (mount -i) or False."
+static PyObject *Context_is_nohelpers(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_is_nohelpers(self->cxt));
+}
+
+#define Context_syscall_called_HELP "syscall_called()\n\n" \
+	"Returns True if mount(2) syscall has been called, or False."
+static PyObject *Context_syscall_called(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_syscall_called(self->cxt));
+}
+
+#define Context_is_swapmatch_HELP "is_swapmatch()\n\n" \
+	"Returns True if swap between source and target is allowed (default is True) or False."
+static PyObject *Context_is_swapmatch(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_is_swapmatch(self->cxt));
+}
+
+#define Context_tab_applied_HELP "tab_applied()\n\n" \
+	"Returns True if fstab (or mtab) has been applied to the context, False otherwise."
+static PyObject *Context_tab_applied(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_tab_applied(self->cxt));
+}
+
+#define Context_apply_fstab_HELP "apply_fstab()\n\n" \
+	"This function is optional.\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_apply_fstab(ContextObjext *self)
+{
+	int rc = mnt_context_apply_fstab(self->cxt);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_helper_executed_HELP "helper_executed()\n\n" \
+	"Returns True if mount.type helper has been executed, or False."
+static PyObject *Context_helper_executed(ContextObjext *self)
+{
+	return PyBool_FromLong(mnt_context_helper_executed(self->cxt));
+}
+
+static PyObject *Context_get_source(ContextObjext *self)
+{
+	return PyObjectResultStr(mnt_context_get_source(self->cxt));
+}
+
+static PyObject *Context_get_target(ContextObjext *self)
+{
+	return PyObjectResultStr(mnt_context_get_target(self->cxt));
+}
+
+static PyObject *Context_get_options(ContextObjext *self)
+{
+	return PyObjectResultStr(mnt_context_get_options(self->cxt));
+}
+
+static PyObject *Context_get_fstype(ContextObjext *self)
+{
+	return PyObjectResultStr(mnt_context_get_fstype(self->cxt));
+}
+
+static PyObject *Context_get_fs(ContextObjext *self)
+{
+	return PyObjectResultFs(mnt_context_get_fs(self->cxt));
+}
+
+static PyObject *Context_get_fstab(ContextObjext *self)
+{
+	struct libmnt_table *tab = NULL;
+
+	if (mnt_context_get_fstab(self->cxt, &tab) != 0 || !tab)
+		return NULL;
+	return PyObjectResultTab(tab);
+}
+
+static PyObject *Context_get_mtab(ContextObjext *self)
+{
+	struct libmnt_table *tab = NULL;
+
+	if (mnt_context_get_mtab(self->cxt, &tab) != 0 || !tab)
+		return NULL;
+	return PyObjectResultTab(tab);
+}
+
+static PyObject *Context_get_optsmode(ContextObjext *self)
+{
+	return PyObjectResultInt(mnt_context_get_optsmode(self->cxt));
+}
+
+static PyObject *Context_get_status(ContextObjext *self)
+{
+	return PyObjectResultInt(mnt_context_get_status(self->cxt));
+}
+
+static PyObject *Context_get_syscall_errno(ContextObjext *self)
+{
+	return PyObjectResultInt(mnt_context_get_syscall_errno(self->cxt));
+}
+
+#define Context_do_mount_HELP "do_mount()\n\n" \
+	"Call mount(2) or mount.type helper. Unnecessary for Cxt.mount().\n" \
+	"\n" \
+	"Note that this function could be called only once. If you want to mount\n" \
+	"another source or target than you have to call Cxt.reset_context().\n" \
+	"\n" \
+	"If you want to call mount(2) for the same source and target with a different\n" \
+	"mount flags or fstype then call Cxt.reset_status() and then try\n" \
+	"again Cxt.do_mount().\n" \
+	"\n" \
+	"WARNING: non-zero return code does not mean that mount(2) syscall or\n" \
+	"mount.type helper wasn't successfully called.\n" \
+	"\n" \
+	"Check Cxt.status after error!\n" \
+	"\n" \
+	"Returns self on success or an exception in case of other errors."
+static PyObject *Context_do_mount(ContextObjext *self)
+{
+	int rc = mnt_context_do_mount(self->cxt);
+	return rc ? UL_RaiseExc(rc < 0 ? -rc : rc) : UL_IncRef(self);
+}
+
+#define Context_do_umount_HELP "do_umount()\n\n" \
+	"Umount filesystem by umount(2) or fork()+exec(/sbin/umount.type).\n" \
+	"Unnecessary for Cxt.umount().\n" \
+	"\n" \
+	"See also Cxt.disable_helpers().\n" \
+	"\n" \
+	"WARNING: non-zero return code does not mean that umount(2) syscall or\n" \
+	"umount.type helper wasn't successfully called.\n" \
+	"\n" \
+	"Check Cxt.status after error!\n" \
+	"\n" \
+	"Returns self on success or an exception in case of other errors."
+static PyObject *Context_do_umount(ContextObjext *self)
+{
+	int rc = mnt_context_do_umount(self->cxt);
+	return rc ? UL_RaiseExc(rc < 0 ? -rc : rc) : UL_IncRef(self);
+}
+
+#define Context_mount_HELP "mount()\n\n" \
+	"High-level, mounts filesystem by mount(2) or fork()+exec(/sbin/mount.type).\n" \
+	"\n" \
+	"This is similar to:\n" \
+	"\n" \
+	"Cxt.prepare_mount();\n" \
+	"Cxt.do_mount();\n" \
+	"Cxt.finalize_mount();\n" \
+	"\n" \
+	"See also Cxt.disable_helper().\n" \
+	"\n" \
+	"Note that this function could be called only once. If you want to mount with\n" \
+	"different setting than you have to call Cxt.reset_context(). It's NOT enough\n" \
+	"to call Cxt.reset_status() if you want call this function more than\n" \
+	"once, whole context has to be reset.\n" \
+	"\n" \
+	"WARNING: non-zero return code does not mean that mount(2) syscall or\n" \
+	"mount.type helper wasn't successfully called.\n" \
+	"\n" \
+	"Check Cxt.status after error!\n" \
+	"\n" \
+	"Returns self on success or an exception in case of other errors."
+static PyObject *Context_mount(ContextObjext *self)
+{
+	int rc = mnt_context_mount(self->cxt);
+	return rc ? UL_RaiseExc(rc < 0 ? -rc : rc) : UL_IncRef(self);
+}
+
+#define Context_umount_HELP "umount()\n\n" \
+	"High-level, umounts filesystem by umount(2) or fork()+exec(/sbin/umount.type).\n" \
+	"\n" \
+	"This is similar to:\n" \
+	"\n" \
+	"Cxt.prepare_umount();\n" \
+	"Cxt.do_umount();\n" \
+	"Cxt.finalize_umount();\n" \
+	"\n" \
+	"See also Cxt.disable_helpers().\n" \
+	"\n" \
+	"WARNING: non-zero return code does not mean that umount(2) syscall or\n" \
+	"umount.type helper wasn't successfully called.\n" \
+	"\n" \
+	"Check Cxt.status after error!\n" \
+	"\n" \
+	"Returns self on success or an exception in case of other errors."
+static PyObject *Context_umount(ContextObjext *self)
+{
+	int rc = mnt_context_umount(self->cxt);
+	return rc ? UL_RaiseExc(rc < 0 ? -rc : rc) : UL_IncRef(self);
+}
+
+#define Context_finalize_mount_HELP "finalize_mount()\n\n" \
+	"Mtab update, etc. Unnecessary for Cxt.mount(), but should be called\n" \
+	"after Cxt.do_mount(). See also Cxt.syscall_status.\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_finalize_mount(ContextObjext *self)
+{
+	int rc = mnt_context_finalize_mount(self->cxt);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_prepare_umount_HELP "prepare_umount()\n\n" \
+	"Prepare context for umounting, unnecessary for Cxt.umount().\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_prepare_umount(ContextObjext *self)
+{
+	int rc = mnt_context_prepare_umount(self->cxt);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_prepare_mount_HELP "prepare_mount()\n\n" \
+	"Prepare context for mounting, unnecessary for Cxt.mount().\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_prepare_mount(ContextObjext *self)
+{
+	int rc = mnt_context_prepare_mount(self->cxt);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_finalize_umount_HELP "finalize_umount()\n\n" \
+	"Mtab update, etc. Unnecessary for Cxt.umount(), but should be called\n" \
+	"after Cxt.do_umount(). See also Cxt.syscall_status.\n" \
+	"\n" \
+	"Returns self on success, raises LibmountError if target filesystem not found, or other exception on error."
+static PyObject *Context_finalize_umount(ContextObjext *self)
+{
+	int rc = mnt_context_finalize_umount(self->cxt);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_find_umount_fs_HELP "find_umount_fs(tgt, pfs)\n\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_find_umount_fs(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	char *kwlist[] = { "tgt", "pfs", NULL };
+	char *tgt = NULL;
+	FsObject *fs;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "sO!", kwlist, &tgt, &FsType, &fs)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+
+	rc = mnt_context_find_umount_fs(self->cxt, tgt, &fs->fs);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_append_options_HELP "append_options(optstr)\n\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_append_options(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	char *kwlist[] = {"optstr", NULL};
+	char *optstr = NULL;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &optstr)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+
+	rc = mnt_context_append_options(self->cxt, optstr);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_helper_setopt_HELP "helper_setopt(c, arg)\n\n" \
+	"This function applies [u]mount.type command line option (for example parsed\n" \
+	"by getopt or getopt_long) to cxt. All unknown options are ignored and\n" \
+	"then ValueError is raised.\n" \
+	"\n" \
+	"Returns self on success, raises ValueError if c is unknown or other exception in case of an error."
+static PyObject *Context_helper_setopt(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	int c;
+	char *arg;
+	char *kwlist[] = { "c", "arg", NULL };
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "is", kwlist, &c, &arg)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+
+	rc = mnt_context_helper_setopt(self->cxt, c, arg);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Context_init_helper_HELP "init_helper(action, flags)\n\n" \
+	"This function infors libmount that used from [u]mount.type helper.\n" \
+	"\n" \
+	"The function also calls Cxt.disable_helpers() to avoid recursive\n" \
+	"mount.type helpers calling. It you really want to call another\n" \
+	"mount.type helper from your helper than you have to explicitly enable this\n" \
+	"feature by:\n" \
+	"\n" \
+	"Cxt.disable_helpers(False);\n" \
+	"\n" \
+	"Returns self or raises an exception in case of an error."
+static PyObject *Context_init_helper(ContextObjext *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	int action, flags;
+	char *kwlist[] = {"action", "flags", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "ii", kwlist, &action, &flags)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+
+	rc = mnt_context_init_helper(self->cxt, action, flags);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+static PyGetSetDef Context_getseters[] = {
+	{"tables_errcb",	NULL, (setter)Context_set_tables_errcb, "error callback function", NULL},
+	{"status",		(getter)Context_get_status, NULL, "status", NULL},
+	{"source",		(getter)Context_get_source, (setter)Context_set_source, "source", NULL},
+	{"target",		(getter)Context_get_target, (setter)Context_set_target, "target", NULL},
+	{"fstype",		(getter)Context_get_fstype, (setter)Context_set_fstype, "fstype", NULL},
+	{"options",		(getter)Context_get_options, (setter)Context_set_options, "options", NULL},
+	{"mflags",		(getter)Context_get_mflags, (setter)Context_set_mflags, "mflags", NULL},
+	{"mountdata",		NULL, (setter)Context_set_mountdata, "mountdata", NULL},
+	{"fstype_pattern",	NULL, (setter)Context_set_fstype_pattern, "fstype_pattern", NULL},
+	{"options_pattern",	NULL, (setter)Context_set_options_pattern, "options_pattern", NULL},
+	{"fs",			(getter)Context_get_fs, (setter)Context_set_fs, "filesystem description (type, mountpoint, device, ...)", NULL},
+	{"mtab",		(getter)Context_get_mtab, NULL, "mtab entries", NULL},
+	{"fstab",		(getter)Context_get_fstab, (setter)Context_set_fstab, "fstab (or mtab for some remounts)", NULL},
+	{"optsmode",		(getter)Context_get_optsmode, (setter)Context_set_optsmode, "fstab optstr mode MNT_OPTSMODE_{AUTO,FORCE,IGNORE}", NULL},
+	{"syscall_errno",	(getter)Context_get_syscall_errno, (setter)Context_set_syscall_status, "1: not_called yet, 0: success, <0: -errno", NULL},
+	{"user_mflags",		(getter)Context_get_user_mflags, (setter)Context_set_user_mflags, "user mflags", NULL},
+	{NULL}
+};
+static PyMethodDef Context_methods[] = {
+	{"find_umount_fs",	(PyCFunction)Context_find_umount_fs, METH_VARARGS|METH_KEYWORDS, Context_find_umount_fs_HELP},
+	{"reset_status",	(PyCFunction)Context_reset_status, METH_NOARGS, Context_reset_status_HELP},
+	{"helper_executed",	(PyCFunction)Context_helper_executed, METH_NOARGS, Context_helper_executed_HELP},
+	{"init_helper",	(PyCFunction)Context_init_helper, METH_VARARGS|METH_KEYWORDS, Context_init_helper_HELP},
+	{"helper_setopt",	(PyCFunction)Context_helper_setopt, METH_VARARGS|METH_KEYWORDS, Context_helper_setopt_HELP},
+	{"append_options",	(PyCFunction)Context_append_options, METH_VARARGS|METH_KEYWORDS, Context_append_options_HELP},
+	{"apply_fstab",	(PyCFunction)Context_apply_fstab, METH_NOARGS, Context_apply_fstab_HELP},
+	{"disable_canonicalize",	(PyCFunction)Context_disable_canonicalize, METH_VARARGS|METH_KEYWORDS, Context_disable_canonicalize_HELP},
+	{"disable_helpers",	(PyCFunction)Context_disable_helpers, METH_VARARGS|METH_KEYWORDS, Context_disable_helpers_HELP},
+	{"disable_mtab",	(PyCFunction)Context_disable_mtab, METH_VARARGS|METH_KEYWORDS, Context_disable_mtab_HELP},
+	{"do_mount",	(PyCFunction)Context_do_mount, METH_NOARGS, Context_do_mount_HELP},
+	{"do_umount",	(PyCFunction)Context_do_umount, METH_NOARGS , Context_do_umount_HELP},
+	{"enable_fake",	(PyCFunction)Context_enable_fake, METH_VARARGS|METH_KEYWORDS, Context_enable_fake_HELP},
+	{"enable_force",	(PyCFunction)Context_enable_force, METH_VARARGS|METH_KEYWORDS, Context_enable_force_HELP},
+	{"enable_lazy",	(PyCFunction)Context_enable_lazy, METH_VARARGS|METH_KEYWORDS, Context_enable_lazy_HELP},
+	{"enable_loopdel",	(PyCFunction)Context_enable_loopdel, METH_VARARGS|METH_KEYWORDS, Context_enable_loopdel_HELP},
+	{"enable_rdonly_umount",	(PyCFunction)Context_enable_rdonly_umount, METH_VARARGS|METH_KEYWORDS, Context_enable_rdonly_umount_HELP},
+	{"enable_sloppy",	(PyCFunction)Context_enable_sloppy, METH_VARARGS|METH_KEYWORDS, Context_enable_sloppy_HELP},
+	{"enable_verbose",	(PyCFunction)Context_enable_verbose, METH_VARARGS|METH_KEYWORDS, Context_enable_verbose_HELP},
+	{"enable_fork",	(PyCFunction)Context_enable_fork, METH_VARARGS|METH_KEYWORDS, Context_enable_fork_HELP},
+	{"finalize_mount",	(PyCFunction)Context_finalize_mount, METH_NOARGS, Context_finalize_mount_HELP},
+	{"finalize_umount",	(PyCFunction)Context_finalize_umount, METH_NOARGS, Context_finalize_umount_HELP},
+	{"is_fake",	(PyCFunction)Context_is_fake, METH_NOARGS, Context_is_fake_HELP},
+	{"is_force",	(PyCFunction)Context_is_force, METH_NOARGS, Context_is_force_HELP},
+	{"is_fork",	(PyCFunction)Context_is_fork, METH_NOARGS, Context_is_fork_HELP},
+	{"is_fs_mounted",	(PyCFunction)Context_is_fs_mounted, METH_VARARGS|METH_KEYWORDS, Context_is_fs_mounted_HELP},
+	{"is_lazy",	(PyCFunction)Context_is_lazy, METH_NOARGS, Context_is_lazy_HELP},
+	{"is_nomtab",	(PyCFunction)Context_is_nomtab, METH_NOARGS, Context_is_nomtab_HELP},
+	{"is_rdonly_umount",	(PyCFunction)Context_is_rdonly_umount, METH_NOARGS, Context_is_rdonly_umount_HELP},
+	{"is_restricted",	(PyCFunction)Context_is_restricted, METH_NOARGS, Context_is_restricted_HELP},
+	{"is_sloppy",	(PyCFunction)Context_is_sloppy, METH_NOARGS, Context_is_sloppy_HELP},
+	{"is_verbose",	(PyCFunction)Context_is_verbose, METH_NOARGS, Context_is_verbose_HELP},
+	{"is_child",	(PyCFunction)Context_is_child, METH_NOARGS, Context_is_child_HELP},
+	{"is_parent",	(PyCFunction)Context_is_parent, METH_NOARGS, Context_is_parent_HELP},
+	{"is_loopdel",	(PyCFunction)Context_is_loopdel, METH_NOARGS, Context_is_loopdel_HELP},
+	{"is_nocanonicalize",	(PyCFunction)Context_is_nocanonicalize, METH_NOARGS, Context_is_nocanonicalize_HELP},
+	{"is_nohelpers",	(PyCFunction)Context_is_nohelpers, METH_NOARGS, Context_is_nohelpers_HELP},
+	{"is_swapmatch",	(PyCFunction)Context_is_swapmatch, METH_NOARGS, Context_is_swapmatch_HELP},
+	{"mount",	(PyCFunction)Context_mount, METH_NOARGS, Context_mount_HELP},
+	{"prepare_mount",	(PyCFunction)Context_prepare_mount, METH_NOARGS, Context_prepare_mount_HELP},
+	{"prepare_umount",	(PyCFunction)Context_prepare_umount, METH_NOARGS, Context_prepare_umount_HELP},
+	{"umount",	(PyCFunction)Context_umount, METH_NOARGS, Context_umount_HELP},
+	{"syscall_called",	(PyCFunction)Context_syscall_called, METH_NOARGS, Context_syscall_called_HELP},
+	{"disable_swapmatch",	(PyCFunction)Context_disable_swapmatch, METH_VARARGS|METH_KEYWORDS, Context_disable_swapmatch_HELP},
+	{"tab_applied",	(PyCFunction)Context_tab_applied, METH_NOARGS, Context_tab_applied_HELP},
+	{NULL}
+};
+
+static PyObject *Context_repr(ContextObjext *self)
+{
+	return PyUnicode_FromFormat("<libmount.Context object at %p, restricted=%s>",
+			self, mnt_context_is_restricted(self->cxt) ? "True" : "False");
+}
+
+PyTypeObject ContextType = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	"libmount.Context", /*tp_name*/
+	sizeof(ContextObjext), /*tp_basicsize*/
+	0, /*tp_itemsize*/
+	(destructor)Context_dealloc, /*tp_dealloc*/
+	0, /*tp_print*/
+	0, /*tp_getattr*/
+	0, /*tp_setattr*/
+	0, /*tp_compare*/
+	(reprfunc) Context_repr,
+	0, /*tp_as_number*/
+	0, /*tp_as_sequence*/
+	0, /*tp_as_mapping*/
+	0, /*tp_hash */
+	0, /*tp_call*/
+	0, /*tp_str*/
+	0, /*tp_getattro*/
+	0, /*tp_setattro*/
+	0, /*tp_as_buffer*/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
+	Context_HELP, /* tp_doc */
+	0, /* tp_traverse */
+	0, /* tp_clear */
+	0, /* tp_richcompare */
+	0, /* tp_weaklistoffset */
+	0, /* tp_iter */
+	0, /* tp_iternext */
+	Context_methods, /* tp_methods */
+	Context_members, /* tp_members */
+	Context_getseters, /* tp_getset */
+	0, /* tp_base */
+	0, /* tp_dict */
+	0, /* tp_descr_get */
+	0, /* tp_descr_set */
+	0, /* tp_dictoffset */
+	(initproc)Context_init, /* tp_init */
+	0, /* tp_alloc */
+	Context_new, /* tp_new */
+};
+
+void Context_AddModuleObject(PyObject *mod)
+{
+	if (PyType_Ready(&ContextType) < 0)
+		return;
+
+	DBG(CXT, pymnt_debug("add to module"));
+
+	Py_INCREF(&ContextType);
+	PyModule_AddObject(mod, "Context", (PyObject *)&ContextType);
+}
+
+
diff --git a/libmount/python/fs.c b/libmount/python/fs.c
new file mode 100644
index 000000000..0789d3797
--- /dev/null
+++ b/libmount/python/fs.c
@@ -0,0 +1,850 @@
+/*
+ * Python bindings for the libmount library.
+ *
+ * Copyright (C) 2013, Red Hat, Inc. All rights reserved.
+ * Written by Ondrej Oprala and Karel Zak
+ *
+ * This file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this file; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/*
+ * TODO:
+ * mnt_fs_match_{source,target}
+ * mnt_fs_get_{attribute,option}
+ */
+
+#include "pylibmount.h"
+#include <errno.h>
+
+#define Fs_HELP "Fs(source=None, root=None, target=None, fstype=None, options=None, attributes=None, freq=0, passno=0)"
+
+static PyMemberDef Fs_members[] = {
+	{NULL}
+};
+
+static PyObject *Fs_get_tag(FsObject *self)
+{
+	const char *tag = NULL, *val = NULL;
+	PyObject *result;
+
+	if (mnt_fs_get_tag(self->fs, &tag, &val) != 0)
+		return NULL;
+
+	result = Py_BuildValue("(ss)", tag, val);
+	if (!result)
+		PyErr_SetString(PyExc_RuntimeError, CONSTRUCT_ERR);
+	return result;
+}
+
+static PyObject *Fs_get_id(FsObject *self)
+{
+	return PyObjectResultInt(mnt_fs_get_id(self->fs));
+}
+
+static PyObject *Fs_get_parent_id(FsObject *self)
+{
+	return PyObjectResultInt(mnt_fs_get_parent_id(self->fs));
+}
+
+static PyObject *Fs_get_devno(FsObject *self)
+{
+	return PyObjectResultInt(mnt_fs_get_devno(self->fs));
+}
+
+#define Fs_print_debug_HELP "print_debug()\n\n"
+static PyObject *Fs_print_debug(FsObject *self)
+{
+	PySys_WriteStdout("------ fs: %p\n", self->fs);
+	PySys_WriteStdout("source: %s\n", mnt_fs_get_source(self->fs));
+	PySys_WriteStdout("target: %s\n", mnt_fs_get_target(self->fs));
+	PySys_WriteStdout("fstype: %s\n", mnt_fs_get_fstype(self->fs));
+
+	if (mnt_fs_get_options(self->fs))
+		PySys_WriteStdout("optstr: %s\n", mnt_fs_get_options(self->fs));
+	if (mnt_fs_get_vfs_options(self->fs))
+		PySys_WriteStdout("VFS-optstr: %s\n", mnt_fs_get_vfs_options(self->fs));
+	if (mnt_fs_get_fs_options(self->fs))
+		PySys_WriteStdout("FS-opstr: %s\n", mnt_fs_get_fs_options(self->fs));
+	if (mnt_fs_get_user_options(self->fs))
+		PySys_WriteStdout("user-optstr: %s\n", mnt_fs_get_user_options(self->fs));
+	if (mnt_fs_get_optional_fields(self->fs))
+		PySys_WriteStdout("optional-fields: '%s'\n", mnt_fs_get_optional_fields(self->fs));
+	if (mnt_fs_get_attributes(self->fs))
+		PySys_WriteStdout("attributes: %s\n", mnt_fs_get_attributes(self->fs));
+
+	if (mnt_fs_get_root(self->fs))
+		PySys_WriteStdout("root:   %s\n", mnt_fs_get_root(self->fs));
+
+	if (mnt_fs_get_swaptype(self->fs))
+		PySys_WriteStdout("swaptype: %s\n", mnt_fs_get_swaptype(self->fs));
+	if (mnt_fs_get_size(self->fs))
+		PySys_WriteStdout("size: %jd\n", mnt_fs_get_size(self->fs));
+	if (mnt_fs_get_usedsize(self->fs))
+		PySys_WriteStdout("usedsize: %jd\n", mnt_fs_get_usedsize(self->fs));
+	if (mnt_fs_get_priority(self->fs))
+		PySys_WriteStdout("priority: %d\n", mnt_fs_get_priority(self->fs));
+
+	if (mnt_fs_get_bindsrc(self->fs))
+		PySys_WriteStdout("bindsrc: %s\n", mnt_fs_get_bindsrc(self->fs));
+	if (mnt_fs_get_freq(self->fs))
+		PySys_WriteStdout("freq:   %d\n", mnt_fs_get_freq(self->fs));
+	if (mnt_fs_get_passno(self->fs))
+		PySys_WriteStdout("pass:   %d\n", mnt_fs_get_passno(self->fs));
+	if (mnt_fs_get_id(self->fs))
+		PySys_WriteStdout("id:     %d\n", mnt_fs_get_id(self->fs));
+	if (mnt_fs_get_parent_id(self->fs))
+		PySys_WriteStdout("parent: %d\n", mnt_fs_get_parent_id(self->fs));
+	if (mnt_fs_get_devno(self->fs))
+		PySys_WriteStdout("devno:  %d:%d\n", major(mnt_fs_get_devno(self->fs)),
+						minor(mnt_fs_get_devno(self->fs)));
+	if (mnt_fs_get_tid(self->fs))
+		PySys_WriteStdout("tid:    %d\n", mnt_fs_get_tid(self->fs));
+	if (mnt_fs_get_comment(self->fs))
+		PySys_WriteStdout("comment: '%s'\n", mnt_fs_get_comment(self->fs));
+	return UL_IncRef(self);
+}
+/*
+ ** Fs getters/setters
+ */
+
+static PyObject *Fs_get_comment(FsObject *self, void *closure __attribute__((unused)))
+{
+	return PyObjectResultStr(mnt_fs_get_comment(self->fs));
+}
+
+static int Fs_set_comment(FsObject *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	char *comment = NULL;
+	int rc = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!(comment = pystos(value)))
+		return -1;
+
+	rc = mnt_fs_set_comment(self->fs, comment);
+	if (rc) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+	return 0;
+}
+/* source */
+static PyObject *Fs_get_source(FsObject *self)
+{
+	return PyObjectResultStr(mnt_fs_get_source(self->fs));
+}
+
+static int Fs_set_source(FsObject *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	char *source = NULL;
+	int rc = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!(source = pystos(value)))
+		return -1;
+
+	rc = mnt_fs_set_source(self->fs, source);
+	if (rc) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+	return 0;
+}
+
+static PyObject *Fs_get_srcpath(FsObject *self)
+{
+	return PyObjectResultStr(mnt_fs_get_srcpath(self->fs));
+}
+
+static PyObject *Fs_get_root(FsObject *self)
+{
+	return PyObjectResultStr(mnt_fs_get_root(self->fs));
+}
+
+static int Fs_set_root(FsObject *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	char *root = NULL;
+	int rc = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!(root = pystos(value)))
+		return -1;
+
+	rc = mnt_fs_set_root(self->fs, root);
+	if (rc) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+	return 0;
+}
+
+static PyObject *Fs_get_target(FsObject *self)
+{
+	return PyObjectResultStr(mnt_fs_get_target(self->fs));
+}
+
+static int Fs_set_target(FsObject *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	char *target = NULL;
+	int rc = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!(target = pystos(value)))
+		return -1;
+
+	rc = mnt_fs_set_target(self->fs, target);
+	if (rc) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+	return 0;
+}
+
+static PyObject *Fs_get_fstype(FsObject *self)
+{
+	return PyObjectResultStr(mnt_fs_get_fstype(self->fs));
+}
+
+static int Fs_set_fstype(FsObject *self, PyObject *value,
+			void *closure __attribute__((unused)))
+{
+	char *fstype = NULL;
+	int rc = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!(fstype = pystos(value)))
+		return -1;
+
+	rc = mnt_fs_set_fstype(self->fs, fstype);
+	if (rc) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+	return 0;
+}
+
+static PyObject *Fs_get_options(FsObject *self)
+{
+	return PyObjectResultStr(mnt_fs_get_options(self->fs));
+}
+
+static int Fs_set_options(FsObject *self, PyObject *value,
+			void *closure __attribute__((unused)))
+{
+	char *options = NULL;
+	int rc = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!(options = pystos(value)))
+		return -1;
+
+	rc = mnt_fs_set_options(self->fs, options);
+	if (rc) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+	return 0;
+}
+
+static PyObject *Fs_get_vfs_options(FsObject *self)
+{
+	return PyObjectResultStr(mnt_fs_get_vfs_options(self->fs));
+}
+
+
+static PyObject *Fs_get_optional_fields(FsObject *self)
+{
+	return PyObjectResultStr(mnt_fs_get_optional_fields(self->fs));
+}
+
+
+static PyObject *Fs_get_fs_options(FsObject *self)
+{
+	return PyObjectResultStr(mnt_fs_get_fs_options(self->fs));
+}
+
+
+static PyObject *Fs_get_user_options(FsObject *self)
+{
+	return PyObjectResultStr(mnt_fs_get_user_options(self->fs));
+}
+
+
+static PyObject *Fs_get_attributes(FsObject *self)
+{
+	return PyObjectResultStr(mnt_fs_get_attributes(self->fs));
+}
+
+static int Fs_set_attributes(FsObject *self, PyObject *value,
+			void *closure __attribute__((unused)))
+{
+	char *attributes = NULL;
+	int rc = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!(attributes = pystos(value)))
+		return -1;
+
+	rc = mnt_fs_set_attributes(self->fs, attributes);
+	if (rc) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+	return 0;
+}
+
+static PyObject *Fs_get_freq(FsObject *self, void *closure __attribute__((unused)))
+{
+	return PyObjectResultInt(mnt_fs_get_freq(self->fs));
+}
+
+static int Fs_set_freq(FsObject *self, PyObject *value,
+				void *closure __attribute__((unused)))
+{
+	int freq = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+
+	} else if (!PyLong_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return -1;
+	}
+
+	freq = PyLong_AsLong(value);
+	if (freq == -1 && PyErr_Occurred()) {
+		PyErr_SetString(PyExc_RuntimeError, "type conversion failed");
+		return -1;
+	}
+	return mnt_fs_set_freq(self->fs, freq);
+}
+
+static PyObject *Fs_get_passno(FsObject *self)
+{
+	return PyObjectResultInt(mnt_fs_get_passno(self->fs));
+}
+
+static int Fs_set_passno(FsObject *self, PyObject *value, void *closure __attribute__((unused)))
+{
+	int passno = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	} else if (!PyLong_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return -1;
+	}
+
+	passno = PyLong_AsLong(value);
+	if (passno == -1 && PyErr_Occurred()) {
+		PyErr_SetString(PyExc_RuntimeError, "type conversion failed");
+		return -1;
+	}
+	return mnt_fs_set_passno(self->fs, passno);
+}
+
+static PyObject *Fs_get_swaptype(FsObject *self)
+{
+	return PyObjectResultStr(mnt_fs_get_swaptype(self->fs));
+}
+
+static PyObject *Fs_get_size(FsObject *self)
+{
+	return PyObjectResultInt(mnt_fs_get_size(self->fs));
+}
+
+static PyObject *Fs_get_usedsize(FsObject *self)
+{
+	return PyObjectResultInt(mnt_fs_get_usedsize(self->fs));
+}
+
+static PyObject *Fs_get_priority(FsObject *self)
+{
+	return PyObjectResultInt(mnt_fs_get_priority(self->fs));
+}
+
+#define Fs_get_propagation_HELP "get_propagation(flags)\n\n\
+Note that this function set flags to zero if not found any propagation flag\n\
+in mountinfo file. The kernel default is MS_PRIVATE, this flag is not stored\n\
+in the mountinfo file.\n\
+\n\
+Returns self or raises an exception in case of an error."
+static PyObject *Fs_get_propagation(FsObject *self, PyObject *args, PyObject *kwds)
+{
+	unsigned long flags;
+	char *kwlist[] = {"flags", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "k", kwlist, &flags)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	return PyObjectResultInt(mnt_fs_get_propagation(self->fs, &flags));
+}
+
+static PyObject *Fs_get_tid(FsObject *self)
+{
+	return PyObjectResultInt(mnt_fs_get_tid(self->fs));
+}
+
+#define Fs_is_kernel_HELP "is_kernel()\n\nReturns 1 if the filesystem " \
+			  "description is read from kernel e.g. /proc/mounts."
+static PyObject *Fs_is_kernel(FsObject *self)
+{
+	return PyBool_FromLong(mnt_fs_is_kernel(self->fs));
+}
+
+#define Fs_is_netfs_HELP "is_netfs()\n\nReturns 1 if the filesystem is " \
+			 "a network filesystem"
+static PyObject *Fs_is_netfs(FsObject *self)
+{
+	return PyBool_FromLong(mnt_fs_is_netfs(self->fs));
+}
+
+#define Fs_is_pseudofs_HELP "is_pseudofs()\n\nReturns 1 if the filesystem is "\
+			    "a pseudo fs type (proc, cgroups)"
+static PyObject *Fs_is_pseudofs(FsObject *self)
+{
+	return PyBool_FromLong(mnt_fs_is_pseudofs(self->fs));
+}
+
+#define Fs_is_swaparea_HELP "is_swaparea()\n\nReturns 1 if the filesystem " \
+			    "uses \"swap\" as a type"
+static PyObject *Fs_is_swaparea(FsObject *self)
+{
+	return PyBool_FromLong(mnt_fs_is_swaparea(self->fs));
+}
+
+#define Fs_append_attributes_HELP "append_attributes(optstr)\n\n" \
+				  "Appends mount attributes."
+static PyObject *Fs_append_attributes(FsObject *self, PyObject *args, PyObject *kwds)
+{
+	char *kwlist[] = {"optstr", NULL};
+	char *optstr = NULL;
+	int rc;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &optstr)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_fs_append_attributes(self->fs, optstr);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Fs_append_options_HELP "append_options(optstr)\n\n" \
+			"Parses (splits) optstr and appends results to VFS, " \
+			"FS and userspace lists of options."
+static PyObject *Fs_append_options(FsObject *self, PyObject *args, PyObject *kwds)
+{
+	char *kwlist[] = {"optstr", NULL};
+	char *optstr = NULL;
+	int rc;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &optstr)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_fs_append_options(self->fs, optstr);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Fs_prepend_attributes_HELP "prepend_attributes(optstr)\n\n" \
+				   "Prepends mount attributes."
+static PyObject *Fs_prepend_attributes(FsObject *self, PyObject *args, PyObject *kwds)
+{
+	char *kwlist[] = {"optstr", NULL};
+	char *optstr = NULL;
+	int rc;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &optstr)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_fs_prepend_attributes(self->fs, optstr);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Fs_prepend_options_HELP "prepend_options(optstr)\n\n" \
+			"Parses (splits) optstr and prepends results to VFS, " \
+			"FS and userspace lists of options."
+static PyObject *Fs_prepend_options(FsObject *self, PyObject *args, PyObject *kwds)
+{
+	char *kwlist[] = {"optstr", NULL};
+	char *optstr = NULL;
+	int rc;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &optstr)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_fs_prepend_options(self->fs, optstr);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Fs_match_fstype_HELP "match_fstype(pattern)\n\n" \
+		"pattern: filesystem name or comma delimited list(string) of names\n\n" \
+		"The pattern list of filesystem can be prefixed with a global\n" \
+		"\"no\" prefix to invert matching of the whole list. The \"no\" could\n" \
+		"also be used for individual items in the pattern list. So,\n" \
+		"\"nofoo,bar\" has the same meaning as \"nofoo,nobar\".\n" \
+		"\"bar\" : \"nofoo,bar\"	-> False   (global \"no\" prefix)\n" \
+		"\"bar\" : \"foo,bar\"		-> True\n" \
+		"\"bar\" : \"foo,nobar\"	-> False\n\n" \
+		"Returns True if type is matching, else False."
+static PyObject *Fs_match_fstype(FsObject *self, PyObject *args, PyObject *kwds)
+{
+	char *kwlist[] = {"pattern", NULL};
+	char *pattern = NULL;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &pattern)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	return PyBool_FromLong(mnt_fs_match_fstype(self->fs, pattern));
+}
+
+#define Fs_match_options_HELP "match_options(options)\n\n" \
+		"options: comma delimited list of options (and nooptions)\n" \
+		"Returns True if fs type is matching to options else False."
+static PyObject *Fs_match_options(FsObject *self, PyObject *args, PyObject *kwds)
+{
+	char *kwlist[] = {"options", NULL};
+	char *options = NULL;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &options)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	return PyBool_FromLong(mnt_fs_match_options(self->fs, options));
+}
+
+#define Fs_streq_srcpath_HELP "streq_srcpath(srcpath)\n\n" \
+		"Compares fs source path with path. The tailing slash is ignored.\n" \
+		"Returns True if fs source path equal to path, otherwise False."
+static PyObject *Fs_streq_srcpath(FsObject *self, PyObject *args, PyObject *kwds)
+{
+	char *kwlist[] = {"srcpath", NULL};
+	char *srcpath = NULL;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &srcpath)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	return PyBool_FromLong(mnt_fs_streq_srcpath(self->fs, srcpath));
+}
+
+#define Fs_streq_target_HELP "streq_target(target)\n\n" \
+		"Compares fs target path with path. The tailing slash is ignored.\n" \
+		"See also Fs.match_target().\n" \
+		"Returns True if fs target path equal to path, otherwise False."
+static PyObject *Fs_streq_target(FsObject *self, PyObject *args, PyObject *kwds)
+{
+	char *kwlist[] = {"target", NULL};
+	char *target = NULL;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &target)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	return PyBool_FromLong(mnt_fs_streq_target(self->fs, target));
+}
+
+#define Fs_copy_fs_HELP "copy_fs(dest=None)\n\n" \
+		"If dest is None, a new object is created, if any fs " \
+		"field is already set, then the field is NOT overwritten."
+static PyObject *Fs_copy_fs(FsObject *self, PyObject *args, PyObject *kwds);
+
+static PyMethodDef Fs_methods[] = {
+	{"get_propagation",	(PyCFunction)Fs_get_propagation, METH_VARARGS|METH_KEYWORDS, Fs_get_propagation_HELP},
+	{"mnt_fs_append_attributes",	(PyCFunction)Fs_append_attributes, METH_VARARGS|METH_KEYWORDS, Fs_append_attributes_HELP},
+	{"append_options",	(PyCFunction)Fs_append_options, METH_VARARGS|METH_KEYWORDS, Fs_append_options_HELP},
+	{"mnt_fs_prepend_attributes",	(PyCFunction)Fs_prepend_attributes, METH_VARARGS|METH_KEYWORDS, Fs_prepend_attributes_HELP},
+	{"prepend_options",	(PyCFunction)Fs_prepend_options, METH_VARARGS|METH_KEYWORDS, Fs_prepend_options_HELP},
+	{"copy_fs",		(PyCFunction)Fs_copy_fs, METH_VARARGS|METH_KEYWORDS, Fs_copy_fs_HELP},
+	{"is_kernel",		(PyCFunction)Fs_is_kernel, METH_NOARGS, Fs_is_kernel_HELP},
+	{"is_netfs",		(PyCFunction)Fs_is_netfs, METH_NOARGS, Fs_is_netfs_HELP},
+	{"is_pseudofs",		(PyCFunction)Fs_is_pseudofs, METH_NOARGS, Fs_is_pseudofs_HELP},
+	{"is_swaparea",		(PyCFunction)Fs_is_swaparea, METH_NOARGS, Fs_is_swaparea_HELP},
+	{"match_fstype",	(PyCFunction)Fs_match_fstype, METH_VARARGS|METH_KEYWORDS, Fs_match_fstype_HELP},
+	{"match_options",	(PyCFunction)Fs_match_options, METH_VARARGS|METH_KEYWORDS, Fs_match_options_HELP},
+	{"streq_srcpath",	(PyCFunction)Fs_streq_srcpath, METH_VARARGS|METH_KEYWORDS, Fs_streq_srcpath_HELP},
+	{"streq_target",	(PyCFunction)Fs_streq_target, METH_VARARGS|METH_KEYWORDS, Fs_streq_target_HELP},
+	{"print_debug",		(PyCFunction)Fs_print_debug, METH_NOARGS, Fs_print_debug_HELP},
+	{NULL}
+};
+
+static void Fs_destructor(FsObject *self)
+{
+	DBG(FS, pymnt_debug_h(self->fs, "destrutor py-obj: %p, py-refcnt=%d",
+				self, (int) ((PyObject *) self)->ob_refcnt));
+	mnt_unref_fs(self->fs);
+	PyFree(self);
+}
+
+static PyObject *Fs_new(PyTypeObject *type, PyObject *args __attribute__((unused)),
+		PyObject *kwds __attribute__((unused)))
+{
+	FsObject *self = (FsObject*)type->tp_alloc(type, 0);
+
+	if (self) {
+		self->fs = NULL;
+		DBG(FS, pymnt_debug_h(self, "new"));
+	}
+	return (PyObject *) self;
+}
+
+static int Fs_init(FsObject *self, PyObject *args, PyObject *kwds)
+{
+	char *source = NULL, *root = NULL, *target = NULL;
+	char *fstype = NULL, *options = NULL, *attributes =NULL;
+	int freq = 0; int passno = 0;
+	int rc = 0;
+	char *kwlist[] = {
+		"source", "root", "target",
+		"fstype", "options", "attributes",
+		"freq", "passno", NULL
+	};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|ssssssii", kwlist,
+				&source, &root, &target, &fstype, &options,
+				&attributes, &freq, &passno)) {
+		PyErr_SetString(PyExc_TypeError, "Invalid type");
+		return -1;
+	}
+
+	DBG(FS, pymnt_debug_h(self, "init"));
+
+	if (self->fs)
+		mnt_unref_fs(self->fs);
+
+	self->fs = mnt_new_fs();		/* new FS with refcount=1 */
+
+	if (source && (rc = mnt_fs_set_source(self->fs, source))) {
+		PyErr_SetString(PyExc_MemoryError, MEMORY_ERR);
+		return rc;
+	}
+	if (root && (rc = mnt_fs_set_root(self->fs, root))) {
+		PyErr_SetString(PyExc_MemoryError, MEMORY_ERR);
+		return rc;
+	}
+	if (target && (rc = mnt_fs_set_target(self->fs, target))) {
+		PyErr_SetString(PyExc_MemoryError, MEMORY_ERR);
+		return rc;
+	}
+	if (fstype && (rc = mnt_fs_set_fstype(self->fs, fstype))) {
+		PyErr_SetString(PyExc_MemoryError, MEMORY_ERR);
+		return rc;
+	}
+	if (options && (rc = mnt_fs_set_options(self->fs, options))) {
+		PyErr_SetString(PyExc_MemoryError, MEMORY_ERR);
+		return rc;
+	}
+	if (attributes && (rc = mnt_fs_set_attributes(self->fs, attributes))) {
+		PyErr_SetString(PyExc_MemoryError, MEMORY_ERR);
+		return rc;
+	}
+
+	mnt_fs_set_freq(self->fs, freq);
+	mnt_fs_set_passno(self->fs, passno);
+	mnt_fs_set_userdata(self->fs, self); /* store a pointer to self, convenient when resetting the table */
+	return 0;
+}
+
+/*
+ * missing:
+ * attribute
+ * option
+ */
+static PyGetSetDef Fs_getseters[] = {
+	{"id",		(getter)Fs_get_id, NULL, "mountinfo[1]: ID", NULL},
+	{"parent",	(getter)Fs_get_parent_id, NULL, "mountinfo[2]: parent", NULL},
+	{"devno",	(getter)Fs_get_devno, NULL, "mountinfo[3]: st_dev", NULL},
+	{"comment",	(getter)Fs_get_comment, (setter)Fs_set_comment, "fstab entry comment", NULL},
+	{"source",	(getter)Fs_get_source, (setter)Fs_set_source, "fstab[1], mountinfo[10], swaps[1]: source dev, file, dir or TAG", NULL},
+	{"srcpath",	(getter)Fs_get_srcpath, NULL, "mount source path or NULL in case of error or when the path is not defined.", NULL},
+	{"root",	(getter)Fs_get_root, (setter)Fs_set_root, "mountinfo[4]: root of the mount within the FS", NULL},
+	{"target",	(getter)Fs_get_target, (setter)Fs_set_target, "mountinfo[5], fstab[2]: mountpoint", NULL},
+	{"fstype",	(getter)Fs_get_fstype, (setter)Fs_set_fstype, "mountinfo[9], fstab[3]: filesystem type", NULL},
+	{"options",	(getter)Fs_get_options, (setter)Fs_set_options, "fstab[4]: merged options", NULL},
+	{"vfs_options",	(getter)Fs_get_vfs_options, NULL, "mountinfo[6]: fs-independent (VFS) options", NULL},
+	{"opt_fields",	(getter)Fs_get_optional_fields, NULL, "mountinfo[7]: optional fields", NULL},
+	{"fs_options",	(getter)Fs_get_fs_options, NULL, "mountinfo[11]: fs-dependent options", NULL},
+	{"usr_options",	(getter)Fs_get_user_options, NULL, "userspace mount options", NULL},
+	{"attributes",	(getter)Fs_get_attributes, (setter)Fs_set_attributes, "mount attributes", NULL},
+	{"freq",	(getter)Fs_get_freq, (setter)Fs_set_freq, "fstab[5]: dump frequency in days", NULL},
+	{"passno",	(getter)Fs_get_passno, (setter)Fs_set_passno, "fstab[6]: pass number on parallel fsck", NULL},
+	{"swaptype",	(getter)Fs_get_swaptype, NULL, "swaps[2]: device type", NULL},
+	{"size",	(getter)Fs_get_size, NULL, "saps[3]: swaparea size", NULL},
+	{"usedsize",	(getter)Fs_get_usedsize, NULL, "swaps[4]: used size", NULL},
+	{"priority",	(getter)Fs_get_priority, NULL, "swaps[5]: swap priority", NULL},
+	{"tag",		(getter)Fs_get_tag, NULL, "(Name, Value)", NULL},
+	{"tid",		(getter)Fs_get_tid, NULL, "/proc/<tid>/mountinfo, otherwise zero", NULL},
+	{NULL}
+};
+
+static PyObject *Fs_repr(FsObject *self)
+{
+	const char *src = mnt_fs_get_source(self->fs),
+		   *tgt = mnt_fs_get_target(self->fs),
+		   *type = mnt_fs_get_fstype(self->fs);
+
+	return PyUnicode_FromFormat(
+			"<libmount.Fs object at %p, "
+			"source=%s, target=%s, fstype=%s>",
+			self,
+			src ? src : "None",
+			tgt ? tgt : "None",
+			type ? type : "None");
+}
+
+PyObject *PyObjectResultFs(struct libmnt_fs *fs)
+{
+	FsObject *result;
+
+	if (!fs) {
+		PyErr_SetString(LibmountError, "internal exception");
+		return NULL;
+	}
+
+	result = mnt_fs_get_userdata(fs);
+	if (result) {
+		Py_INCREF(result);
+		DBG(FS, pymnt_debug_h(fs, "result py-obj %p: already exists, py-refcnt=%d",
+				result, (int) ((PyObject *) result)->ob_refcnt));
+		return (PyObject *) result;
+	}
+
+	/* Creating an encapsualing object: increment the refcount, so that code
+	 * such as tab.next_fs() doesn't call the destructor, which would free
+	 * our fs struct as well
+	 */
+	result = PyObject_New(FsObject, &FsType);
+	if (!result) {
+		UL_RaiseExc(ENOMEM);
+		return NULL;
+	}
+
+	Py_INCREF(result);
+	mnt_ref_fs(fs);
+
+	DBG(FS, pymnt_debug_h(fs, "result py-obj %p new, py-refcnt=%d",
+				result, (int) ((PyObject *) result)->ob_refcnt));
+	result->fs = fs;
+	mnt_fs_set_userdata(fs, result);
+	return (PyObject *) result;
+}
+
+static PyObject *Fs_copy_fs(FsObject *self, PyObject *args, PyObject *kwds)
+{
+	PyObject *dest = NULL;
+	char *kwlist[] = {"dest", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &dest)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	if (PyObject_TypeCheck(dest, &FsType)) {	/* existing object passed as argument */
+		if (!mnt_copy_fs(((FsObject *)dest)->fs, self->fs))
+			return NULL;
+		DBG(FS, pymnt_debug_h(dest, "copy data"));
+		return (PyObject *)dest;
+
+	} else if (dest == Py_None) {			/* create new object */
+		FsObject *result = PyObject_New(FsObject, &FsType);
+
+		DBG(FS, pymnt_debug_h(result, "new copy"));
+		result->fs = mnt_copy_fs(NULL, self->fs);
+		mnt_fs_set_userdata(result->fs, result);	/* keep a pointer to encapsulating object */
+		return (PyObject *)result;
+	}
+
+	PyErr_SetString(PyExc_TypeError, ARG_ERR);
+	return NULL;
+}
+
+
+PyTypeObject FsType = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	"libmount.Fs", /*tp_name*/
+	sizeof(FsObject), /*tp_basicsize*/
+	0, /*tp_itemsize*/
+	(destructor)Fs_destructor, /*tp_dealloc*/
+	0, /*tp_print*/
+	0, /*tp_getattr*/
+	0, /*tp_setattr*/
+	0, /*tp_compare*/
+	(reprfunc)Fs_repr, /*tp_repr*/
+	0, /*tp_as_number*/
+	0, /*tp_as_sequence*/
+	0, /*tp_as_mapping*/
+	0, /*tp_hash */
+	0, /*tp_call*/
+	0, /*tp_str*/
+	0, /*tp_getattro*/
+	0, /*tp_setattro*/
+	0, /*tp_as_buffer*/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
+	Fs_HELP, /* tp_doc */
+	0, /* tp_traverse */
+	0, /* tp_clear */
+	0, /* tp_richcompare */
+	0, /* tp_weaklistoffset */
+	0, /* tp_iter */
+	0, /* tp_iternext */
+	Fs_methods, /* tp_methods */
+	Fs_members, /* tp_members */
+	Fs_getseters, /* tp_getset */
+	0, /* tp_base */
+	0, /* tp_dict */
+	0, /* tp_descr_get */
+	0, /* tp_descr_set */
+	0, /* tp_dictoffset */
+	(initproc)Fs_init, /* tp_init */
+	0, /* tp_alloc */
+	Fs_new, /* tp_new */
+};
+
+void FS_AddModuleObject(PyObject *mod)
+{
+	if (PyType_Ready(&FsType) < 0)
+		return;
+
+	DBG(FS, pymnt_debug("add to module"));
+	Py_INCREF(&FsType);
+	PyModule_AddObject(mod, "Fs", (PyObject *)&FsType);
+}
+
diff --git a/libmount/python/pylibmount.c b/libmount/python/pylibmount.c
new file mode 100644
index 000000000..c538bb543
--- /dev/null
+++ b/libmount/python/pylibmount.c
@@ -0,0 +1,301 @@
+/*
+ * Python bindings for the libmount library.
+ *
+ * Copyright (C) 2013, Red Hat, Inc. All rights reserved.
+ * Written by Ondrej Oprala and Karel Zak
+ *
+ * This file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this file; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include "pylibmount.h"
+
+/* Libmount-specific Exception class */
+PyObject *LibmountError;
+int pylibmount_debug_mask;
+
+PyObject *UL_IncRef(void *killme)
+{
+	Py_INCREF(killme);
+	return killme;
+}
+
+void PyFree(void *o)
+{
+#if PY_MAJOR_VERSION >= 3
+	Py_TYPE(o)->tp_free((PyObject *)o);
+#else
+	((PyObject *)o)->ob_type->tp_free((PyObject *)o);
+#endif
+}
+
+/* Demultiplexer for various possible error conditions across the libmount library */
+void *UL_RaiseExc(int e)
+{
+	/* TODO: Do we need to deal with -1/1? */
+	switch (e) {
+		case ENOMEM:
+			PyErr_SetString(PyExc_MemoryError, strerror(e));
+			break;
+		case EINVAL:
+			PyErr_SetString(PyExc_TypeError, strerror(e));
+			break;
+		/* libmount-specific errors */
+		case MNT_ERR_APPLYFLAGS:
+			PyErr_SetString(LibmountError, "Failed to apply MS_PROPAGATION flags");
+			break;
+		case MNT_ERR_MOUNTOPT:
+			PyErr_SetString(LibmountError, "Failed to parse/use userspace mount options");
+			break;
+		case MNT_ERR_NOFSTAB:
+			PyErr_SetString(LibmountError, "Failed to detect filesystem type");
+			break;
+		case MNT_ERR_NOFSTYPE:
+			PyErr_SetString(LibmountError, "Required mount source undefined");
+			break;
+		case MNT_ERR_NOSOURCE:
+			PyErr_SetString(LibmountError, "Loopdev setup failed");
+			break;
+		case MNT_ERR_AMBIFS:
+			PyErr_SetString(LibmountError, "Libblkid detected more filesystems on the device");
+			break;
+		/* some other errno */
+		default:
+			PyErr_SetString(PyExc_Exception, strerror(e));
+			break;
+	}
+	return NULL;
+}
+
+/*
+ * General functions
+ */
+PyObject *PyObjectResultInt(int i)
+{
+	PyObject *result = Py_BuildValue("i", i);
+	if (!result)
+		PyErr_SetString(PyExc_RuntimeError, CONSTRUCT_ERR);
+	return result;
+}
+
+PyObject *PyObjectResultStr(const char *s)
+{
+	PyObject *result;
+	if (!s)
+		/* TODO: maybe lie about it and return "":
+		 * which would allow for
+		 * fs = libmount.Fs()
+		 * fs.comment += "comment"
+		return Py_BuildValue("s", ""); */
+		Py_RETURN_NONE;
+	result = Py_BuildValue("s", s);
+	if (!result)
+		PyErr_SetString(PyExc_RuntimeError, CONSTRUCT_ERR);
+	return result;
+}
+
+/* wrapper around a common use case for PyUnicode_AsASCIIString() */
+char *pystos(PyObject *pys)
+{
+#if PY_MAJOR_VERSION >= 3
+	if (!PyUnicode_Check(pys)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	return (char *)PyUnicode_1BYTE_DATA(pys);
+#else
+	if (!PyString_Check(pys)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	return PyString_AsString(pys);
+#endif
+}
+
+/*
+ * the libmount module
+ */
+#define PYLIBMOUNT_DESC \
+	"Python API for the util-linux libmount library.\n\n" \
+	"Please note that none of the classes' attributes may be deleted.\n" \
+	"This is not a complete mapping to the libmount C API, nor is it\n" \
+	"attempting to be one.\n" "Iterator functions only allow forward\n" \
+	"iteration for now. Contex.get_{user_,}mflags() differs from the C API\n" \
+	"and returns the flags directly. Fs.get_tag() differs from the C API\n" \
+	"and returns a (tag, value) tuple. Every attribute is \"filtered\"" \
+	"through appropriate getters/setters, no values are set directly."
+
+
+struct module_state {
+    PyObject *error;
+};
+
+#if PY_MAJOR_VERSION >= 3
+#define GETSTATE(m) ((struct module_state*)PyModule_GetState(m))
+#else
+#define GETSTATE(m) (&_state)
+static struct module_state _state;
+#endif
+
+static PyObject *
+error_out(PyObject *m __attribute__((unused))) {
+    struct module_state *st = GETSTATE(m);
+    PyErr_SetString(st->error, "something bad happened");
+    return NULL;
+}
+
+static PyMethodDef pylibmount_methods[] = {
+    {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
+    {NULL, NULL}
+};
+
+#if PY_MAJOR_VERSION >= 3
+
+static int pylibmount_traverse(PyObject *m, visitproc visit, void *arg) {
+    Py_VISIT(GETSTATE(m)->error);
+    return 0;
+}
+
+static int pylibmount_clear(PyObject *m) {
+    Py_CLEAR(GETSTATE(m)->error);
+    return 0;
+}
+
+static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        "pylibmount",
+        NULL,
+        sizeof(struct module_state),
+        pylibmount_methods,
+        NULL,
+        pylibmount_traverse,
+        pylibmount_clear,
+        NULL
+};
+#define INITERROR return NULL
+PyObject * PyInit_pylibmount(void);
+PyObject * PyInit_pylibmount(void)
+#else
+#define INITERROR return
+# ifndef PyMODINIT_FUNC
+#  define PyMODINIT_FUNC void
+# endif
+PyMODINIT_FUNC initpylibmount(void);
+PyMODINIT_FUNC initpylibmount(void)
+#endif
+{
+#if PY_MAJOR_VERSION >= 3
+	PyObject *m = PyModule_Create(&moduledef);
+#else
+	PyObject *m = Py_InitModule3("pylibmount", pylibmount_methods, PYLIBMOUNT_DESC);
+#endif
+
+	if (!m)
+		INITERROR;
+	/*
+	 * init debug stuff
+	 */
+	if (!(pylibmount_debug_mask & PYMNT_DEBUG_INIT)) {
+		char *str = getenv("PYLIBMOUNT_DEBUG");
+
+		pylibmount_debug_mask = 0;
+		if (str)
+			pylibmount_debug_mask = strtoul(str, 0, 0);
+
+		pylibmount_debug_mask |= PYMNT_DEBUG_INIT;
+	}
+
+	if (pylibmount_debug_mask && pylibmount_debug_mask != PYMNT_DEBUG_INIT)
+		DBG(INIT, pymnt_debug("library debug mask: 0x%04x",
+					pylibmount_debug_mask));
+	mnt_init_debug(0);
+
+	/*
+	 * Add module objects
+	 */
+	LibmountError = PyErr_NewException("libmount.Error", NULL, NULL);
+	Py_INCREF(LibmountError);
+	PyModule_AddObject(m, "Error", (PyObject *)LibmountError);
+
+	FS_AddModuleObject(m);
+	Table_AddModuleObject(m);
+	Context_AddModuleObject(m);
+
+	/*
+	 * mount(8) userspace options masks (MNT_MAP_USERSPACE map)
+	 */
+	PyModule_AddIntConstant(m, "MNT_MS_COMMENT", MNT_MS_COMMENT);
+	PyModule_AddIntConstant(m, "MNT_MS_GROUP", MNT_MS_GROUP);
+	PyModule_AddIntConstant(m, "MNT_MS_HELPER", MNT_MS_HELPER);
+	PyModule_AddIntConstant(m, "MNT_MS_LOOP", MNT_MS_LOOP);
+	PyModule_AddIntConstant(m, "MNT_MS_NETDEV", MNT_MS_NETDEV);
+	PyModule_AddIntConstant(m, "MNT_MS_NOAUTO", MNT_MS_NOAUTO);
+	PyModule_AddIntConstant(m, "MNT_MS_NOFAIL", MNT_MS_NOFAIL);
+	PyModule_AddIntConstant(m, "MNT_MS_OFFSET", MNT_MS_OFFSET);
+	PyModule_AddIntConstant(m, "MNT_MS_OWNER", MNT_MS_OWNER);
+	PyModule_AddIntConstant(m, "MNT_MS_SIZELIMIT", MNT_MS_SIZELIMIT);
+	PyModule_AddIntConstant(m, "MNT_MS_ENCRYPTION", MNT_MS_ENCRYPTION);
+	PyModule_AddIntConstant(m, "MNT_MS_UHELPER", MNT_MS_UHELPER);
+	PyModule_AddIntConstant(m, "MNT_MS_USER", MNT_MS_USER);
+	PyModule_AddIntConstant(m, "MNT_MS_USERS", MNT_MS_USERS);
+	PyModule_AddIntConstant(m, "MNT_MS_XCOMMENT", MNT_MS_XCOMMENT);
+
+	/*
+	 * mount(2) MS_* masks (MNT_MAP_LINUX map)
+	 */
+	PyModule_AddIntConstant(m, "MS_BIND", MS_BIND);
+	PyModule_AddIntConstant(m, "MS_DIRSYNC", MS_DIRSYNC);
+	PyModule_AddIntConstant(m, "MS_I_VERSION", MS_I_VERSION);
+	PyModule_AddIntConstant(m, "MS_MANDLOCK", MS_MANDLOCK);
+	PyModule_AddIntConstant(m, "MS_MGC_MSK", MS_MGC_MSK);
+	PyModule_AddIntConstant(m, "MS_MGC_VAL", MS_MGC_VAL);
+	PyModule_AddIntConstant(m, "MS_MOVE", MS_MOVE);
+	PyModule_AddIntConstant(m, "MS_NOATIME", MS_NOATIME);
+	PyModule_AddIntConstant(m, "MS_NODEV", MS_NODEV);
+	PyModule_AddIntConstant(m, "MS_NODIRATIME", MS_NODIRATIME);
+	PyModule_AddIntConstant(m, "MS_NOEXEC", MS_NOEXEC);
+	PyModule_AddIntConstant(m, "MS_NOSUID", MS_NOSUID);
+	PyModule_AddIntConstant(m, "MS_OWNERSECURE", MS_OWNERSECURE);
+	PyModule_AddIntConstant(m, "MS_PRIVATE", MS_PRIVATE);
+	PyModule_AddIntConstant(m, "MS_PROPAGATION", MS_PROPAGATION);
+	PyModule_AddIntConstant(m, "MS_RDONLY", MS_RDONLY);
+	PyModule_AddIntConstant(m, "MS_REC", MS_REC);
+	PyModule_AddIntConstant(m, "MS_RELATIME", MS_RELATIME);
+	PyModule_AddIntConstant(m, "MS_REMOUNT", MS_REMOUNT);
+	PyModule_AddIntConstant(m, "MS_SECURE", MS_SECURE);
+	PyModule_AddIntConstant(m, "MS_SHARED", MS_SHARED);
+	PyModule_AddIntConstant(m, "MS_SILENT", MS_SILENT);
+	PyModule_AddIntConstant(m, "MS_SLAVE", MS_SLAVE);
+	PyModule_AddIntConstant(m, "MS_STRICTATIME", MS_STRICTATIME);
+	PyModule_AddIntConstant(m, "MS_SYNCHRONOUS", MS_SYNCHRONOUS);
+	PyModule_AddIntConstant(m, "MS_UNBINDABLE", MS_UNBINDABLE);
+
+	/* Will we need these directly?
+	PyModule_AddIntConstant(m, "MNT_ERR_AMBIFS", MNT_ERR_AMBIFS);
+	PyModule_AddIntConstant(m, "MNT_ERR_APPLYFLAGS", MNT_ERR_APPLYFLAGS);
+	PyModule_AddIntConstant(m, "MNT_ERR_LOOPDEV", MNT_ERR_LOOPDEV);
+	PyModule_AddIntConstant(m, "MNT_ERR_MOUNTOPT", MNT_ERR_MOUNTOPT);
+	PyModule_AddIntConstant(m, "MNT_ERR_NOFSTAB", MNT_ERR_NOFSTAB);
+	PyModule_AddIntConstant(m, "MNT_ERR_NOFSTYPE", MNT_ERR_NOFSTYPE);
+	PyModule_AddIntConstant(m, "MNT_ERR_NOSOURCE", MNT_ERR_NOSOURCE);
+	*/
+
+	/* Still useful for functions using iterators internally */
+	PyModule_AddIntConstant(m, "MNT_ITER_FORWARD", MNT_ITER_FORWARD);
+	PyModule_AddIntConstant(m, "MNT_ITER_BACKWARD", MNT_ITER_BACKWARD);
+
+#if PY_MAJOR_VERSION >= 3
+	return m;
+#endif
+}
+
diff --git a/libmount/python/pylibmount.h b/libmount/python/pylibmount.h
new file mode 100644
index 000000000..1a08796dc
--- /dev/null
+++ b/libmount/python/pylibmount.h
@@ -0,0 +1,126 @@
+#ifndef UTIL_LINUX_PYLIBMOUNT_H
+#define UTIL_LINUX_PYLIBMOUNT_H
+
+#include <Python.h>
+#include <structmember.h>
+
+#include "libmount.h"
+
+#define CONFIG_PYLIBMOUNT_DEBUG
+
+#define PYMNT_DEBUG_INIT	(1 << 1)
+#define PYMNT_DEBUG_TAB		(1 << 2)
+#define PYMNT_DEBUG_FS		(1 << 3)
+#define PYMNT_DEBUG_CXT		(1 << 4)
+
+#ifdef CONFIG_PYLIBMOUNT_DEBUG
+# include <stdio.h>
+# include <stdarg.h>
+
+# define DBG(m, x)	do { \
+				if ((PYMNT_DEBUG_ ## m) & pylibmount_debug_mask) { \
+					fprintf(stderr, "%d: pylibmount: %6s: ", getpid(), # m); \
+					x; \
+				} \
+			} while (0)
+
+extern int pylibmount_debug_mask;
+
+static inline void __attribute__ ((__format__ (__printf__, 1, 2)))
+pymnt_debug(const char *mesg, ...)
+{
+	va_list ap;
+	va_start(ap, mesg);
+	vfprintf(stderr, mesg, ap);
+	va_end(ap);
+	fputc('\n', stderr);
+}
+
+static inline void __attribute__ ((__format__ (__printf__, 2, 3)))
+pymnt_debug_h(void *handler, const char *mesg, ...)
+{
+	va_list ap;
+
+	if (handler)
+		fprintf(stderr, "[%p]: ", handler);
+	va_start(ap, mesg);
+	vfprintf(stderr, mesg, ap);
+	va_end(ap);
+	fputc('\n', stderr);
+}
+
+#else /* !CONFIG_PYLIBMOUNT_DEBUG */
+# define DBG(m,x) do { ; } while (0)
+#endif
+
+
+#define NODEL_ATTR	"This attribute cannot be deleted"
+#define CONSTRUCT_ERR	"Error during object construction"
+#define ARG_ERR		"Invalid number or type of arguments"
+#define NOFS_ERR	"No filesystems to mount"
+#define MEMORY_ERR	strerror(ENOMEM)
+#define CONV_ERR	"Type conversion failed"
+
+/*
+ * fs.c
+ */
+typedef struct {
+	PyObject_HEAD
+	struct libmnt_fs *fs;
+} FsObject;
+
+extern PyTypeObject FsType;
+
+extern PyObject *PyObjectResultFs(struct libmnt_fs *fs);
+extern void FS_AddModuleObject(PyObject *mod);
+
+/*
+ * tab.c
+ */
+typedef struct {
+	PyObject_HEAD
+
+	struct libmnt_table		*tab;
+	struct libmnt_iter		*iter;
+	PyObject			*errcb;
+} TableObject;
+
+extern PyTypeObject TableType;
+
+extern PyObject *PyObjectResultTab(struct libmnt_table *tab);
+
+extern void Table_unref(struct libmnt_table *tab);
+extern void Table_AddModuleObject(PyObject *mod);
+
+extern int pymnt_table_parser_errcb(struct libmnt_table *tb, const char *filename, int line);
+
+/*
+ * context.c
+ */
+typedef struct {
+	PyObject_HEAD
+
+	struct libmnt_context		*cxt;
+	PyObject			*table_errcb;
+
+} ContextObjext;
+
+extern PyTypeObject ContextType;
+extern void Context_AddModuleObject(PyObject *mod);
+
+/*
+ * misc
+ */
+extern PyObject *LibmountError;
+extern PyObject *UL_IncRef(void *killme);
+extern void *UL_RaiseExc(int e);
+
+extern PyObject *PyObjectResultInt(int i);
+extern PyObject *PyObjectResultStr(const char *s);
+
+extern char *pystos(PyObject *pys);
+extern void PyFree(void *o);
+
+
+
+#endif /* UTIL_LINUX_PYLIBMOUNT */
diff --git a/libmount/python/tab.c b/libmount/python/tab.c
new file mode 100644
index 000000000..6f255aef7
--- /dev/null
+++ b/libmount/python/tab.c
@@ -0,0 +1,781 @@
+/*
+ * Python bindings for the libmount library.
+ *
+ * Copyright (C) 2013, Red Hat, Inc. All rights reserved.
+ * Written by Ondrej Oprala and Karel Zak
+ *
+ * This file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this file; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include "pylibmount.h"
+
+static PyMemberDef Table_members[] = {
+	{ NULL }
+};
+
+static int Table_set_parser_errcb(TableObject *self, PyObject *func,
+				  void *closure __attribute__((unused)))
+{
+	PyObject *tmp;
+
+	if (!func) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+
+	if (!PyCallable_Check(func))
+		return -1;
+
+	tmp = self->errcb;
+	Py_INCREF(func);
+	self->errcb = func;
+	Py_XDECREF(tmp);
+	return 0;
+}
+
+static PyObject *Table_get_intro_comment(TableObject *self,
+				void *closure __attribute__((unused)))
+{
+	return PyObjectResultStr(mnt_table_get_intro_comment(self->tab));
+}
+
+static int Table_set_intro_comment(TableObject *self, PyObject *value,
+				void *closure __attribute__((unused)))
+{
+	char *comment = NULL;
+	int rc = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!(comment = pystos(value)))
+		return -1;
+
+	if ((rc = mnt_table_set_intro_comment(self->tab, comment))) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+	return 0;
+}
+
+static PyObject *Table_get_trailing_comment(TableObject *self,
+				void *closure __attribute__((unused)))
+{
+	return PyObjectResultStr(mnt_table_get_trailing_comment(self->tab));
+}
+
+static int Table_set_trailing_comment(TableObject *self, PyObject *value,
+				void *closure __attribute__((unused)))
+{
+	char *comment = NULL;
+	int rc = 0;
+
+	if (!value) {
+		PyErr_SetString(PyExc_TypeError, NODEL_ATTR);
+		return -1;
+	}
+	if (!(comment = pystos(value)))
+		return -1;
+
+	if ((rc = mnt_table_set_trailing_comment(self->tab, comment))) {
+		UL_RaiseExc(-rc);
+		return -1;
+	}
+	return 0;
+}
+
+#define Table_enable_comments_HELP "enable_comments(enable)\n\n" \
+	"Enables parsing of comments.\n\n" \
+	"The initial (intro) file comment is accessible by\n" \
+	"Tab.intro_comment. The intro and the comment of the first fstab" \
+	"entry has to be separated by blank line.  The filesystem comments are\n" \
+	"accessible by Fs.comment. The tailing fstab comment is accessible\n" \
+	"by Tab.trailing_comment.\n" \
+	"\n" \
+	"<informalexample>\n" \
+	"<programlisting>\n" \
+	"#\n" \
+	"# Intro comment\n" \
+	"#\n" \
+	"\n" \
+	"# this comments belongs to the first fs\n" \
+	"LABEL=foo /mnt/foo auto defaults 1 2\n" \
+	"# this comments belongs to the second fs\n" \
+	"LABEL=bar /mnt/bar auto defaults 1 2 \n" \
+	"# tailing comment\n" \
+	"</programlisting>\n" \
+	"</informalexample>"
+static PyObject *Table_enable_comments(TableObject *self, PyObject *args,
+					PyObject *kwds)
+{
+	int enable = 0;
+	char *kwlist[] = {"enable", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &enable)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	mnt_table_enable_comments(self->tab, enable);
+	Py_INCREF(self);
+	return (PyObject *)self;
+}
+
+#define Table_replace_file_HELP "replace_file(filename)\n\n" \
+		"This function replaces filename with the new content from TableObject."
+static PyObject *Table_replace_file(TableObject *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	char *filename = NULL;
+	char *kwlist[] = {"filename", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &filename)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_table_replace_file(self->tab, filename);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Table_write_file_HELP "write_file(path)\n\n" \
+		"This function writes tab to file(stream)"
+static PyObject *Table_write_file(TableObject *self, PyObject *args, PyObject *kwds)
+{
+	int rc;
+	//PyObject *stream = NULL;
+	FILE *f = NULL;
+	char *path = NULL;
+	char *kwlist[] = {"path", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist,
+					&path)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	if (!(f = fopen(path, "w")))
+		return UL_RaiseExc(errno);
+	rc = mnt_table_write_file(self->tab, f);
+	fclose(f);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Table_find_devno_HELP "find_devno(devno, [direction])\n\n" \
+		"Note that zero could be valid device number for root pseudo " \
+		"filesystem (e.g. tmpfs)\n" \
+		"Returns a tab entry or None"
+static PyObject *Table_find_devno(TableObject *self, PyObject *args, PyObject *kwds)
+{
+	dev_t devno;
+	int direction = MNT_ITER_BACKWARD;
+	char *kwlist[] = {"devno", "direction", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "I|i", kwlist, &devno, &direction)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	return PyObjectResultFs(mnt_table_find_devno(self->tab, devno, direction));
+}
+
+#define Table_find_mountpoint_HELP "find_mountpoint(path, [direction])\n\n" \
+		"Returns a tab entry or None."
+static PyObject *Table_find_mountpoint(TableObject *self, PyObject *args, PyObject *kwds)
+{
+	char *path;
+	int direction = MNT_ITER_BACKWARD;
+	char *kwlist[] = {"path", "direction", NULL};
+
+	if (! PyArg_ParseTupleAndKeywords(args, kwds, "s|i", kwlist, &path, &direction)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	return PyObjectResultFs(mnt_table_find_mountpoint(self->tab, path, direction));
+}
+
+#define Table_find_pair_HELP "find_pair(source, target, [direction])\n\n" \
+		"Returns a tab entry or None."
+static PyObject *Table_find_pair(TableObject *self, PyObject *args, PyObject *kwds)
+{
+	char *kwlist[] = {"source", "target", "direction", NULL};
+	char *source;
+	char *target;
+	int direction = MNT_ITER_BACKWARD;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "ss|i", kwlist, &source, &target, &direction)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	return PyObjectResultFs(mnt_table_find_pair(self->tab, source, target, direction));
+}
+
+#define Table_find_source_HELP "find_source(source, [direction])\n\n" \
+		"Returns a tab entry or None."
+static PyObject *Table_find_source(TableObject *self, PyObject *args, PyObject *kwds)
+{
+	char *kwlist[] = {"source", "direction", NULL};
+	char *source;
+	int direction = MNT_ITER_BACKWARD;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|i", kwlist, &source, &direction)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	return PyObjectResultFs(mnt_table_find_source(self->tab, source, direction));
+}
+
+#define Table_find_target_HELP "find_target(target, [direction])\n\n" \
+		"Try to lookup an entry in given tab, possible are three iterations, first\n" \
+		"with path, second with realpath(path) and third with realpath(path)\n" \
+		"against realpath(fs->target). The 2nd and 3rd iterations are not performed\n" \
+		"when tb cache is not set (cache not implemented yet).\n" \
+		"\n" \
+		"Returns a tab entry or None."
+static PyObject *Table_find_target(TableObject *self, PyObject *args, PyObject *kwds)
+{
+	char *kwlist[] = {"target", "direction", NULL};
+	char *target;
+	int direction = MNT_ITER_BACKWARD;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|i", kwlist, &target, &direction)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	return PyObjectResultFs(mnt_table_find_target(self->tab, target, direction));
+}
+
+#define Table_find_srcpath_HELP "find_srcpath(srcpath, [direction])\n\n" \
+		"Try to lookup an entry in given tab, possible are four iterations, first\n" \
+		"with path, second with realpath(path), third with tags (LABEL, UUID, ..)\n" \
+		"from path and fourth with realpath(path) against realpath(entry->srcpath).\n" \
+		"\n" \
+		"The 2nd, 3rd and 4th iterations are not performed when tb cache is not\n" \
+		"set (not implemented yet).\n" \
+		"\n" \
+		"Note that None is a valid source path; it will be replaced with \"none\". The\n" \
+		"\"none\" is used in /proc/{mounts,self/mountinfo} for pseudo filesystems.\n" \
+		"\n" \
+		"Returns a tab entry or None."
+static PyObject *Table_find_srcpath(TableObject *self, PyObject *args, PyObject *kwds)
+{
+	char *kwlist[] = {"srcpath", "direction", NULL};
+	char *srcpath;
+	int direction = MNT_ITER_BACKWARD;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|i", kwlist, &srcpath, &direction)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	return PyObjectResultFs(mnt_table_find_srcpath(self->tab, srcpath, direction));
+}
+
+#define Table_find_tag_HELP "find_tag(tag, val, [direction])\n\n" \
+		"Try to lookup an entry in given tab, first attempt is lookup by tag and\n" \
+		"val, for the second attempt the tag is evaluated (converted to the device\n" \
+		"name) and Tab.find_srcpath() is preformed. The second attempt is not\n" \
+		"performed when tb cache is not set (not implemented yet).\n" \
+		"\n" \
+		"Returns a tab entry or NULL."
+static PyObject *Table_find_tag(TableObject *self, PyObject *args, PyObject *kwds)
+{
+	char *kwlist[] = {"tag", "val", "direction", NULL};
+	char *tag;
+	char *val;
+	int direction = MNT_ITER_BACKWARD;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "ss|i", kwlist, &tag, &val, &direction)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	return PyObjectResultFs(mnt_table_find_tag(self->tab, tag, val, direction));
+}
+
+static PyObject *Table_get_nents(TableObject *self)
+{
+	return PyObjectResultInt(mnt_table_get_nents(self->tab));
+}
+
+#define Table_is_fs_mounted_HELP "is_fs_mounted(fstab_fs)\n\n" \
+		"Checks if the fstab_fs entry is already in the tb table. The \"swap\" is\n" \
+		"ignored. This function explicitly compares source, target and root of the\n" \
+		"filesystems.\n" \
+		"\n" \
+		"Note that source and target are canonicalized only if a cache for tb is\n" \
+		"defined (not implemented yet). The target canonicalization may\n" \
+		"trigger automount on autofs mountpoints!\n" \
+		"\n" \
+		"Don't use it if you want to know if a device is mounted, just use\n" \
+		"Tab.find_source() for the device.\n" \
+		"\n" \
+		"This function is designed mostly for \"mount -a\".\n" \
+		"\n" \
+		"Returns a boolean value."
+static PyObject *Table_is_fs_mounted(TableObject *self, PyObject *args, PyObject *kwds)
+{
+	FsObject *fs;
+	char *kwlist[] = {"fstab_fs", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", kwlist, &FsType, &fs)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	return PyBool_FromLong(mnt_table_is_fs_mounted(self->tab, fs->fs));
+}
+
+#define Table_parse_file_HELP "parse_file(file)\n\n" \
+		"Parses whole table (e.g. /etc/mtab) and appends new records to the tab.\n" \
+		"\n" \
+		"The libmount parser ignores broken (syntax error) lines, these lines are\n" \
+		"reported to caller by errcb() function (see Tab.parser_errcb).\n" \
+		"\n" \
+		"Returns self or raises an exception in case of an error."
+static PyObject *Table_parse_file(TableObject *self, PyObject* args, PyObject *kwds)
+{
+	int rc;
+	char *file = NULL;
+	char *kwlist[] = {"file", NULL};
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &file)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_table_parse_file(self->tab, file);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Table_parse_fstab_HELP "parse_fstab([fstab])\n\n" \
+		"This function parses /etc/fstab and appends new lines to the tab. If the\n" \
+		"filename is a directory then Tab.parse_dir() is called.\n" \
+		"\n" \
+		"See also Tab.parser_errcb.\n" \
+		"\n" \
+		"Returns self or raises an exception in case of an error."
+static PyObject *Table_parse_fstab(TableObject *self, PyObject* args, PyObject *kwds)
+{
+	int rc;
+	char *fstab = NULL;
+	char *kwlist[] = {"fstab", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|s", kwlist, &fstab)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_table_parse_fstab(self->tab, fstab);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Table_parse_mtab_HELP "parse_mtab([mtab])\n\n" \
+		"This function parses /etc/mtab or /proc/self/mountinfo\n" \
+		"/run/mount/utabs or /proc/mounts.\n" \
+		"\n" \
+		"See also Tab.parser_errcb().\n" \
+		"\n" \
+		"Returns self or raises an exception in case of an error."
+static PyObject *Table_parse_mtab(TableObject *self, PyObject* args, PyObject *kwds)
+{
+	int rc;
+	char *mtab = NULL;
+	char *kwlist[] = {"mtab", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|s", kwlist, &mtab)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_table_parse_mtab(self->tab, mtab);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Table_parse_dir_HELP "parse_dir(dir)\n\n" \
+		"The directory:\n" \
+		"- files are sorted by strverscmp(3)\n" \
+		"- files that start with \".\" are ignored (e.g. \".10foo.fstab\")\n" \
+		"- files without the \".fstab\" extension are ignored\n" \
+		"\n" \
+		"Returns self or raises an exception in case of an error."
+static PyObject *Table_parse_dir(TableObject *self, PyObject* args, PyObject *kwds)
+{
+	int rc;
+	char *dir = NULL;
+	char *kwlist[] = {"dir", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &dir)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_table_parse_dir(self->tab, dir);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Table_parse_swaps_HELP "parse_swaps(swaps)\n\n" \
+		"This function parses /proc/swaps and appends new lines to the tab"
+static PyObject *Table_parse_swaps(TableObject *self, PyObject* args, PyObject *kwds)
+{
+	int rc;
+	char *swaps = NULL;
+	char *kwlist[] = {"swaps", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &swaps)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_table_parse_swaps(self->tab, swaps);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Table_add_fs_HELP "add_fs(fs)\n\nAdds a new entry to tab.\n" \
+		"Returns self or raises an exception in case of an error."
+
+static PyObject *Table_add_fs(TableObject *self, PyObject* args, PyObject *kwds)
+{
+	int rc;
+	FsObject *fs = NULL;
+	char *kwlist[] = {"fs", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", kwlist, &FsType, &fs)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	Py_INCREF(fs);
+	rc = mnt_table_add_fs(self->tab, fs->fs);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Table_remove_fs_HELP "remove_fs(fs)\n\n" \
+		"Returns self or raises an exception in case of an error."
+static PyObject *Table_remove_fs(TableObject *self, PyObject* args, PyObject *kwds)
+{
+	int rc;
+	FsObject *fs = NULL;
+	char *kwlist[] = {"fs", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", kwlist, &FsType, &fs)) {
+		PyErr_SetString(PyExc_TypeError, ARG_ERR);
+		return NULL;
+	}
+	rc = mnt_table_remove_fs(self->tab, fs->fs);
+	Py_DECREF(fs);
+	return rc ? UL_RaiseExc(-rc) : UL_IncRef(self);
+}
+
+#define Table_next_fs_HELP "next_fs()\n\n" \
+		"Returns the next Fs on success, raises an exception in case " \
+		"of an error and None at end of list.\n" \
+		"\n" \
+		"Example:\n" \
+		"<informalexample>\n" \
+		"<programlisting>\n" \
+		"import libmount\n" \
+		"import functools\n" \
+		"for fs in iter(functools.partial(tb.next_fs), None):\n" \
+		"    dir = Fs.target\n" \
+		"    print \"mount point: {:s}\".format(dir)\n" \
+		"\n" \
+		"</programlisting>\n" \
+		"</informalexample>\n" \
+		"\n" \
+		"lists all mountpoints from fstab in backward order."
+static PyObject *Table_next_fs(TableObject *self)
+{
+	struct libmnt_fs *fs;
+	int rc;
+
+	/* Reset the builtin iterator after reaching the end of the list */
+	rc = mnt_table_next_fs(self->tab, self->iter, &fs);
+	if (rc == 1) {
+		mnt_reset_iter(self->iter, MNT_ITER_FORWARD);
+		Py_RETURN_NONE;
+	} else if (rc)
+		return UL_RaiseExc(-rc);
+
+	return PyObjectResultFs(fs);
+}
+
+static PyMethodDef Table_methods[] = {
+	{"enable_comments", (PyCFunction)Table_enable_comments, METH_VARARGS|METH_KEYWORDS, Table_enable_comments_HELP},
+	{"find_pair", (PyCFunction)Table_find_pair, METH_VARARGS|METH_KEYWORDS, Table_find_pair_HELP},
+	{"find_source", (PyCFunction)Table_find_source, METH_VARARGS|METH_KEYWORDS, Table_find_source_HELP},
+	{"find_srcpath", (PyCFunction)Table_find_srcpath, METH_VARARGS|METH_KEYWORDS, Table_find_srcpath_HELP},
+	{"find_tag", (PyCFunction)Table_find_tag, METH_VARARGS|METH_KEYWORDS, Table_find_tag_HELP},
+	{"find_target", (PyCFunction)Table_find_target, METH_VARARGS|METH_KEYWORDS, Table_find_target_HELP},
+	{"find_devno", (PyCFunction)Table_find_devno, METH_VARARGS|METH_KEYWORDS, Table_find_devno_HELP},
+	{"find_mountpoint", (PyCFunction)Table_find_mountpoint, METH_VARARGS|METH_KEYWORDS, Table_find_mountpoint_HELP},
+	{"parse_file", (PyCFunction)Table_parse_file, METH_VARARGS|METH_KEYWORDS, Table_parse_file_HELP},
+	{"parse_fstab", (PyCFunction)Table_parse_fstab, METH_VARARGS|METH_KEYWORDS, Table_parse_fstab_HELP},
+	{"parse_mtab", (PyCFunction)Table_parse_mtab, METH_VARARGS|METH_KEYWORDS, Table_parse_mtab_HELP},
+	{"parse_dir", (PyCFunction)Table_parse_dir, METH_VARARGS|METH_KEYWORDS, Table_parse_dir_HELP},
+	{"parse_swaps", (PyCFunction)Table_parse_swaps, METH_VARARGS|METH_KEYWORDS, Table_parse_swaps_HELP},
+	{"is_fs_mounted", (PyCFunction)Table_is_fs_mounted, METH_VARARGS|METH_KEYWORDS, Table_is_fs_mounted_HELP},
+	{"add_fs", (PyCFunction)Table_add_fs, METH_VARARGS|METH_KEYWORDS, Table_add_fs_HELP},
+	{"remove_fs", (PyCFunction)Table_remove_fs, METH_VARARGS|METH_KEYWORDS, Table_remove_fs_HELP},
+	{"next_fs", (PyCFunction)Table_next_fs, METH_NOARGS, Table_next_fs_HELP},
+	{"write_file", (PyCFunction)Table_write_file, METH_VARARGS|METH_KEYWORDS, Table_write_file_HELP},
+	{"replace_file", (PyCFunction)Table_replace_file, METH_VARARGS|METH_KEYWORDS, Table_replace_file_HELP},
+	{NULL}
+};
+
+/* mnt_free_tab() with a few necessary additions */
+void Table_unref(struct libmnt_table *tab)
+{
+	struct libmnt_fs *fs;
+	struct libmnt_iter *iter;
+
+	if (!tab)
+		return;
+
+	DBG(TAB, pymnt_debug_h(tab, "un-referencing filesystems"));
+
+	iter = mnt_new_iter(MNT_ITER_BACKWARD);
+
+	/* remove pylibmount specific references to the entries */
+	while (mnt_table_next_fs(tab, iter, &fs) == 0)
+		Py_XDECREF(mnt_fs_get_userdata(fs));
+
+	DBG(TAB, pymnt_debug_h(tab, "un-referencing table"));
+
+	mnt_unref_table(tab);
+	mnt_free_iter(iter);
+}
+
+static void Table_destructor(TableObject *self)
+{
+	DBG(TAB, pymnt_debug_h(self->tab, "destrutor py-obj: %p, py-refcnt=%d",
+				self, (int) ((PyObject *) self)->ob_refcnt));
+	Table_unref(self->tab);
+	self->tab = NULL;
+
+	mnt_free_iter(self->iter);
+	Py_XDECREF(self->errcb);
+	PyFree(self);
+}
+
+static PyObject *Table_new(PyTypeObject *type,
+			   PyObject *args __attribute__((unused)),
+			   PyObject *kwds __attribute__((unused)))
+{
+	TableObject *self = (TableObject*)type->tp_alloc(type, 0);
+
+	if (self) {
+		DBG(TAB, pymnt_debug_h(self, "new"));
+
+		self->tab = NULL;
+		self->iter = NULL;
+		self->errcb = NULL;
+	}
+	return (PyObject *)self;
+}
+
+/* explicit tab.__init__() serves as mnt_reset_table(tab) would in C
+ * and as mnt_new_table{,_from_dir,_from_file}() with proper arguments */
+#define Table_HELP "Table(path=None, errcb=None)"
+static int Table_init(TableObject *self, PyObject *args, PyObject *kwds)
+{
+	struct libmnt_cache *cache;
+	char *path = NULL;
+	char *kwlist[] = {"path", "errcb", NULL};
+	PyObject *errcb = NULL;
+	struct stat buf;
+
+	memset (&buf, 0, sizeof(struct stat));
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|sO",
+					kwlist, &path, &errcb))
+		return -1;
+
+	DBG(TAB, pymnt_debug_h(self, "init"));
+
+	Table_unref(self->tab);
+	self->tab = NULL;
+
+	if (self->iter)
+		mnt_reset_iter(self->iter, MNT_ITER_FORWARD);
+	else
+		self->iter = mnt_new_iter(MNT_ITER_FORWARD);
+
+	if (errcb) {
+		PyObject *tmp;
+		if (!PyCallable_Check(errcb))
+			return -1;
+		tmp = self->errcb;
+		Py_INCREF(errcb);
+		self->errcb = errcb;
+		Py_XDECREF(tmp);
+	} else {
+		Py_XDECREF(self->errcb);
+		self->errcb = NULL;
+	}
+
+	if (path) {
+		DBG(TAB, pymnt_debug_h(self, "init: path defined (%s)", path));
+
+		if (stat(path, &buf)) {
+			/* TODO: weird */
+			PyErr_SetFromErrno(PyExc_RuntimeError);
+			return -1;
+		}
+		if (S_ISREG(buf.st_mode))
+			self->tab = mnt_new_table_from_file(path);
+		else if (S_ISDIR(buf.st_mode))
+			self->tab = mnt_new_table_from_dir(path);
+	} else {
+		DBG(TAB, pymnt_debug_h(self, "init: allocate empty table"));
+		self->tab = mnt_new_table();
+	}
+
+	/* Always set custom handler when using libmount from python */
+	mnt_table_set_parser_errcb(self->tab, pymnt_table_parser_errcb);
+	mnt_table_set_userdata(self->tab, self);
+
+	cache = mnt_new_cache();		/* TODO: make it optional? */
+	if (!cache)
+		return -1;
+	mnt_table_set_cache(self->tab, cache);
+	mnt_unref_cache(cache);
+
+	return 0;
+}
+
+/* Handler for the tab->errcb callback */
+int pymnt_table_parser_errcb(struct libmnt_table *tb, const char *filename, int line)
+{
+	int rc = 0;
+	PyObject *obj;
+
+	obj = mnt_table_get_userdata(tb);
+	if (obj && ((TableObject*) obj)->errcb) {
+		PyObject *arglist, *result;
+
+		arglist = Py_BuildValue("(Osi)", obj, filename, line);
+		if (!arglist)
+			return -ENOMEM;
+
+		/* A python callback was set, so tb is definitely encapsulated in an object */
+		result = PyEval_CallObject(((TableObject *)obj)->errcb, arglist);
+		Py_DECREF(arglist);
+
+		if (!result)
+			return -EINVAL;
+		if (!PyArg_Parse(result, "i", &rc))
+			rc = -EINVAL;
+		Py_DECREF(result);
+	}
+	return rc;
+}
+
+PyObject *PyObjectResultTab(struct libmnt_table *tab)
+{
+	TableObject *result;
+
+	if (!tab) {
+		PyErr_SetString(LibmountError, "internal exception");
+		return NULL;
+	}
+
+	result = mnt_table_get_userdata(tab);
+	if (result) {
+		Py_INCREF(result);
+		DBG(TAB, pymnt_debug_h(tab, "result py-obj %p: already exists, py-refcnt=%d",
+				result, (int) ((PyObject *) result)->ob_refcnt));
+		return (PyObject *) result;
+	}
+
+	/* Creating an encapsualing object: increment the refcount, so that
+	 * code such as: cxt.get_fstab() doesn't call the destructor, which
+	 * would free our tab struct as well
+	 */
+	result = PyObject_New(TableObject, &TableType);
+	if (!result) {
+		UL_RaiseExc(ENOMEM);
+		return NULL;
+	}
+
+	Py_INCREF(result);
+	mnt_ref_table(tab);
+
+	DBG(TAB, pymnt_debug_h(tab, "result py-obj %p new, py-refcnt=%d",
+				result, (int) ((PyObject *) result)->ob_refcnt));
+	result->tab = tab;
+	result->iter = mnt_new_iter(MNT_ITER_FORWARD);
+	mnt_table_set_userdata(result->tab, result);
+	result->errcb = NULL;
+	return (PyObject *) result;
+}
+
+static PyGetSetDef Table_getseters[] = {
+	{"nents",		(getter)Table_get_nents, NULL, "number of valid entries in tab", NULL},
+	{"intro_comment",	(getter)Table_get_intro_comment, (setter)Table_set_intro_comment, "fstab intro comment", NULL},
+	{"trailing_comment",	(getter)Table_get_trailing_comment, (setter)Table_set_trailing_comment, "fstab trailing comment", NULL},
+	{"errcb",		NULL, (setter)Table_set_parser_errcb, "parser error callback", NULL},
+	{NULL}
+};
+
+
+static PyObject *Table_repr(TableObject *self)
+{
+	return PyUnicode_FromFormat(
+			"<libmount.Table object at %p, entries=%d, comments_enabled=%s, errcb=%s>",
+			self,
+			mnt_table_get_nents(self->tab),
+			mnt_table_with_comments(self->tab) ? "True" : "False",
+			self->errcb ? pystos(PyObject_Repr(self->errcb)) : "None");
+}
+
+PyTypeObject TableType = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	"libmount.Table", /*tp_name*/
+	sizeof(TableObject), /*tp_basicsize*/
+	0, /*tp_itemsize*/
+	(destructor)Table_destructor, /*tp_dealloc*/
+	0, /*tp_print*/
+	0, /*tp_getattr*/
+	0, /*tp_setattr*/
+	0, /*tp_compare*/
+	(reprfunc) Table_repr, /*tp_repr*/
+	0, /*tp_as_number*/
+	0, /*tp_as_sequence*/
+	0, /*tp_as_mapping*/
+	0, /*tp_hash */
+	0, /*tp_call*/
+	0, /*tp_str*/
+	0, /*tp_getattro*/
+	0, /*tp_setattro*/
+	0, /*tp_as_buffer*/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
+	Table_HELP, /* tp_doc */
+	0, /* tp_traverse */
+	0, /* tp_clear */
+	0, /* tp_richcompare */
+	0, /* tp_weaklistoffset */
+	0, /* tp_iter */
+	0, /* tp_iternext */
+	Table_methods, /* tp_methods */
+	Table_members, /* tp_members */
+	Table_getseters, /* tp_getset */
+	0, /* tp_base */
+	0, /* tp_dict */
+	0, /* tp_descr_get */
+	0, /* tp_descr_set */
+	0, /* tp_dictoffset */
+	(initproc)Table_init, /* tp_init */
+	0, /* tp_alloc */
+	Table_new, /* tp_new */
+};
+
+void Table_AddModuleObject(PyObject *mod)
+{
+	if (PyType_Ready(&TableType) < 0)
+		return;
+
+	DBG(TAB, pymnt_debug("add to module"));
+
+	Py_INCREF(&TableType);
+	PyModule_AddObject(mod, "Table", (PyObject *)&TableType);
+}
+
diff --git a/libmount/python/test_mount_context.py b/libmount/python/test_mount_context.py
new file mode 100755
index 000000000..7aea444b1
--- /dev/null
+++ b/libmount/python/test_mount_context.py
@@ -0,0 +1,173 @@
+import os
+import sys
+import stat
+import errno
+
+# use "import libmount" for in a standard way installed python binding
+import pylibmount as mnt
+
+def usage(tss):
+	print("\nUsage:\n\t{:s} <test> [testoptions]\nTests:\n".format(sys.argv[0]))
+	for i in tss:
+		print("\t{15:-s}".format(i[0]))
+		if i[2] != "":
+			print(" {:s}\n".format(i[2]))
+
+	print("\n")
+	return 1
+
+def mnt_run_test(tss, argv):
+	rc = -1
+	if ((len(argv) < 2) or (argv[1] == "--help") or (argv[1] == "-h")):
+		return usage(tss)
+
+	#mnt_init_debug(0)
+
+	i=()
+	for i in tss:
+		if i[0] == argv[1]:
+			rc = i[1](i, argv[1:])
+			if rc:
+				print("FAILED [rc={:d}]".format(rc))
+			break
+
+	if ((rc < 0) and (i == ())):
+		return usage(tss)
+	return not not rc #because !!rc is too mainstream for python
+
+def test_mount(ts, argv):
+	idx = 1
+	rc = 0
+
+	if len(argv) < 2:
+		return -errno.EINVAL
+
+	cxt = mnt.Context()
+
+	if argv[idx] == "-o":
+		cxt.options = argv[idx+1]
+		idx += 2
+	if argv[idx] == "-t":
+		cxt.fstype = argv[idx+1]
+		idx += 2
+	if len(argv) == idx + 1:
+		cxt.target = argv[idx]
+		idx+=1
+	elif (len(argv) == idx + 2):
+		cxt.source = argv[idx]
+		idx += 1
+		cxt.target = argv[idx]
+		idx += 1
+
+	try:
+		cxt.mount()
+	except Exception:
+		print("failed to mount")
+		return -1
+	print("successfully mounted")
+	return rc
+
+def test_umount(ts, argv):
+	idx = 1
+	rc = 0
+	if len(argv) < 2:
+		return -errno.EINVAL
+
+	cxt = mnt.Context()
+
+	if argv[idx] == "-t":
+		cxt.options = argv[idx+1]
+		idx += 2
+
+	if argv[idx] == "-f":
+		cxt.enable_force(True)
+
+	if argv[idx] == "-l":
+		cxt.enable_lazy(True)
+		idx += 1
+	elif argv[idx] ==  "-r":
+		cxt.enable_rdonly_umount(True)
+		idx += 1
+
+	if len(argv) == idx + 1:
+		cxt.target = argv[idx]
+		idx += 1
+	else:
+		return -errno.EINVAL
+	try:
+		cxt.umount()
+	except Exception:
+		print("failed to umount")
+		return 1
+	print("successfully umounted")
+	return rc
+
+def test_flags(ts, argv):
+	idx = 1
+	rc = 0
+	opt = ""
+	flags = 0
+	cxt = mnt.Context()
+
+	if argv[idx] == "-o":
+		cxt.options = argv[idx + 1]
+		idx += 2
+	if len(argv) == idx + 1:
+		cxt.target = argv[idx]
+		idx += 1
+
+	try:
+		cxt.prepare_mount()
+	# catch ioerror here
+	except IOError as e:
+		print("failed to prepare mount {:s}".format(e.strerror))
+
+	opt = cxt.fs.options
+	if (opt):
+		print("options: {:s}", opt)
+
+	print("flags: {08:lx}".format(cxt.mflags()))
+	return rc
+
+def test_mountall(ts, argv):
+	mntrc = 1
+	ignored = 1
+	idx = 1
+	cxt = mnt.Context()
+
+	if len(argv) > 2:
+		if argv[idx] == "-O":
+			cxt.options_pattern = argv[idx+1]
+			idx += 2
+		if argv[idx] == "-t":
+			cxt.fstype_pattern = argv[idx+1]
+			idx += 2
+
+	i = ()
+	while (cxt.next_mount()):
+		tgt = i.target
+		if (ignored == 1):
+			print("{:s}: ignored: not match".format(tgt))
+		elif (ignored == 2):
+			print("{:s}: ignored: already mounted".format(tgt))
+		elif (not cxt.status):
+			if (mntrc > 0):
+				# ?? errno = mntrc
+				print("{:s}: mount failed".format(tgt))
+			else:
+				print("{:s}: mount failed".format(tgt))
+		else:
+			print("{:s}: successfully mounted".format(tgt))
+
+	return 0
+
+
+tss = (
+	( "--mount",  test_mount,  "[-o <opts>] [-t <type>] <spec>|<src> <target>" ),
+	( "--umount", test_umount, "[-t <type>] [-f][-l][-r] <src>|<target>" ),
+	( "--mount-all", test_mountall,  "[-O <pattern>] [-t <pattern] mount all filesystems from fstab" ),
+	( "--flags", test_flags,   "[-o <opts>] <spec>" )
+)
+os.umask(stat.S_IWGRP | stat.S_IWOTH) #to be compatible with mount(8)
+
+sys.exit(mnt_run_test(tss, sys.argv))
diff --git a/libmount/python/test_mount_tab.py b/libmount/python/test_mount_tab.py
new file mode 100755
index 000000000..1f63b9554
--- /dev/null
+++ b/libmount/python/test_mount_tab.py
@@ -0,0 +1,164 @@
+import os
+import sys
+import stat
+import errno
+import functools as ft
+
+# use "import libmount" for in a standard way installed python binding
+import pylibmount as mnt
+
+def usage(tss):
+	print("\nUsage:\n\t{:s} <test> [testoptions]\nTests:\n".format(sys.argv[0]))
+	for i in tss:
+		print("\t{15:-s}".format(i[0]))
+		if i[2] != "":
+			print(" {:s}\n".format(i[2]))
+
+	print("\n")
+	return 1
+
+def mnt_run_test(tss, argv):
+	rc = -1
+	if ((len(argv) < 2) or (argv[1] == "--help") or (argv[1] == "-h")):
+		return usage(tss)
+
+	#mnt_init_debug(0)
+
+	i=()
+	for i in tss:
+		if i[0] == argv[1]:
+			rc = i[1](i, argv[1:])
+			if rc:
+				print("FAILED [rc={:d}]".format(rc))
+			break
+
+	if ((rc < 0) and (i == ())):
+		return usage(tss)
+	return not not rc #because !!rc is too mainstream for python
+
+def parser_errcb(tb, fname, line):
+	print("{:s}:{:d}: parse error".format(fname, line))
+	return 1
+
+def create_table(f, comments):
+	if not f:
+		return None
+
+	tb = mnt.Table()
+	tb.enable_comments(comments)
+	tb.errcb = parser_errcb
+
+	try:
+		tb.parse_file(f)
+	except Exception:
+		print("{:s}: parsing failed".format(f))
+		return None
+	return tb
+
+def test_copy_fs(ts, argv):
+	rc = -1
+	tb = create_table(argv[1], False)
+	fs = tb.find_target("/", mnt.MNT_ITER_FORWARD)
+	if not fs:
+		return rc
+
+	print("ORIGINAL:")
+	fs.print_debug()
+
+	fs = fs.copy_fs(None)
+	if not fs:
+		return rc
+	print("COPY:")
+	fs.print_debug()
+	return 0
+
+def test_parse(ts, argv):
+	parse_comments = False
+
+	if len(argv) == 3 and argv[2] == "--comments":
+		parse_comments = True
+	tb = create_table(argv[1], parse_comments)
+
+	if tb.intro_comment:
+		print("Initial comment:\n\"{:s}\"".format(tb.intro_comment))
+	#while ((fs = tb.next_fs()) != None):
+	for fs in iter(ft.partial(tb.next_fs), None):
+		fs.print_debug()
+	if tb.trailing_comment:
+		print("Trailing comment:\n\"{:s}\"".format(tb.trailing_comment))
+	return 0
+
+def test_find(ts, argv, dr):
+	if len(argv) != 4:
+		print("try --help")
+		return -errno.EINVAL
+
+	f, find, what = argv[1:]
+
+	tb = create_table(f, False)
+	if find.lower() == "source":
+		fs = tb.find_source(what, dr)
+	elif find.lower() == "target":
+		fs = tb.find_target(what, dr)
+
+	if not fs:
+		print("{:s}: not found {:s} '{:s}'".format(f, find, what))
+	else:
+		fs.print_debug()
+	return 0
+
+def test_find_fw(ts, argv):
+	return test_find(ts, argv, mnt.MNT_ITER_FORWARD)
+
+def test_find_bw(ts, argv):
+	return test_find(ts, argv, mnt.MNT_ITER_BACKWARD)
+
+def test_find_pair(ts, argv):
+	rc = -1
+	tb = create_table(argv[1], False)
+	fs = tb.find_pair(argv[2], argv[3], mnt.MNT_ITER_FORWARD)
+	if not fs:
+		return rc
+	fs.print_debug()
+	return 0
+
+def test_is_mounted(ts, argv):
+	rc = -1
+	tb = mnt.Tab(path="/proc/self/mountinfo")
+	if not tb:
+		print("failed to parse mountinto")
+		return rc
+
+	fstab = create_table(argv[1], False)
+	if not fstab:
+		return rc
+	fs = ()
+	for fs in ft.iter(tb.next_fs(), -1):
+		if tb.is_fs_mounted(fs):
+			print("{:s} already mounted on {:s}".format(fs.source, fs.target))
+		else:
+			print("{:s} not mounted on {:s}".format(fs.source, fs.target))
+	return 0
+
+def test_find_mountpoint(ts, argv):
+	rc = -1
+	tb = mnt.Table("/proc/self/mountinfo")
+	if not tb:
+		return rc
+	fs = tb.find_mountpoint(argv[1], mnt.MNT_ITER_BACKWARD)
+	if not fs:
+		return rc
+	fs.print_debug()
+	return 0
+
+
+tss = (
+	( "--parse",    test_parse,        "<file> [--comments] parse and print(tab" ),
+	( "--find-forward",  test_find_fw, "<file> <source|target> <string>" ),
+	( "--find-backward", test_find_bw, "<file> <source|target> <string>" ),
+	( "--find-pair",     test_find_pair, "<file> <source> <target>" ),
+	( "--find-mountpoint", test_find_mountpoint, "<path>" ),
+	( "--copy-fs",       test_copy_fs, "<file>  copy root FS from the file" ),
+	( "--is-mounted",    test_is_mounted, "<fstab> check what from <file> are already mounted" ),
+)
+sys.exit(mnt_run_test(tss, sys.argv))
diff --git a/libmount/python/test_mount_tab_update.py b/libmount/python/test_mount_tab_update.py
new file mode 100755
index 000000000..a16e9e341
--- /dev/null
+++ b/libmount/python/test_mount_tab_update.py
@@ -0,0 +1,59 @@
+import os
+import sys
+import stat
+import errno
+
+# use "import libmount" for in a standard way installed python binding
+import pylibmount as mnt
+
+def usage(tss):
+	print("\nUsage:\n\t{:s} <test> [testoptions]\nTests:\n".format(sys.argv[0]))
+	for i in tss:
+		print("\t{15:-s}".format(i[0]))
+		if i[2] != "":
+			print(" {:s}\n".format(i[2]))
+
+	print("\n")
+	return 1
+
+def mnt_run_test(tss, argv):
+	rc = -1
+	if ((len(argv) < 2) or (argv[1] == "--help") or (argv[1] == "-h")):
+		return usage(tss)
+
+	#mnt_init_debug(0)
+
+	i=()
+	for i in tss:
+		if i[0] == argv[1]:
+			rc = i[1](i, argv[1:])
+			if rc:
+				print("FAILED [rc={:d}]".format(rc))
+			break
+
+	if ((rc < 0) and (i == ())):
+		return usage(tss)
+	return not not rc #because !!rc is too mainstream for python
+
+def test_replace(ts, argv):
+	fs = mnt.Fs()
+	tb = mnt.Table()
+
+	if (len(argv) < 3):
+		return -1
+	tb.enable_comments(True)
+	tb.parse_fstab()
+
+	fs.source = argv[1]
+	fs.target = argv[2]
+	#TODO: resolve None + string
+	fs.comment = "# this is new filesystem\n"
+	tb.add_fs(fs)
+	tb.replace_file(os.environ["LIBMOUNT_FSTAB"])
+	return 0
+
+tss = (
+	( "--replace",test_replace, "<src> <target>                Add a line to LIBMOUNT_FSTAB and replace the original file" ),
+)
+
+sys.exit(mnt_run_test(tss, sys.argv))
diff --git a/libmount/src/Makemodule.am b/libmount/src/Makemodule.am
index 494e02a34..9101811f5 100644
--- a/libmount/src/Makemodule.am
+++ b/libmount/src/Makemodule.am
@@ -26,23 +26,26 @@ libmount_la_SOURCES = \
 	libmount/src/test.c \
 	libmount/src/utils.c \
 	libmount/src/version.c \
-	$(mountinc_HEADERS)
+	$(nodist_mountinc_HEADERS)
 
 nodist_libmount_la_SOURCES = libmount/src/mountP.h
 
 libmount_la_LIBADD = libcommon.la libblkid.la $(SELINUX_LIBS)
 
 libmount_la_CFLAGS = \
+	$(SOLIB_CFLAGS) \
 	-I$(ul_libblkid_incdir) \
 	-I$(ul_libmount_incdir) \
 	-I$(top_srcdir)/libmount/src
 
 libmount_la_DEPENDENCIES = \
-	$(libmount_la_LIBADD) \
+	libcommon.la \
+	libblkid.la \
 	libmount/src/libmount.sym \
 	libmount/src/libmount.h.in
 
 libmount_la_LDFLAGS = \
+	$(SOLIB_LDFLAGS) \
 	-Wl,--version-script=$(top_srcdir)/libmount/src/libmount.sym \
 	-version-info $(LIBMOUNT_VERSION_INFO)
 
diff --git a/libmount/src/cache.c b/libmount/src/cache.c
index 7b651228a..92f469456 100644
--- a/libmount/src/cache.c
+++ b/libmount/src/cache.c
@@ -10,7 +10,7 @@
  * @title: Cache
  * @short_description: paths and tags (UUID/LABEL) caching
  *
- * The cache is a very simple API for work with tags (LABEL, UUID, ...) and
+ * The cache is a very simple API for working with tags (LABEL, UUID, ...) and
  * paths. The cache uses libblkid as a backend for TAGs resolution.
  *
  * All returned paths are always canonicalized.
@@ -48,6 +48,7 @@ struct libmnt_cache {
 	struct mnt_cache_entry	*ents;
 	size_t			nents;
 	size_t			nallocs;
+	int			refcount;
 
 	/* blkid_evaluate_tag() works in two ways:
 	 *
@@ -72,6 +73,7 @@ struct libmnt_cache *mnt_new_cache(void)
 	if (!cache)
 		return NULL;
 	DBG(CACHE, mnt_debug_h(cache, "alloc"));
+	cache->refcount = 1;
 	return cache;
 }
 
@@ -79,7 +81,8 @@ struct libmnt_cache *mnt_new_cache(void)
  * mnt_free_cache:
  * @cache: pointer to struct libmnt_cache instance
  *
- * Deallocates the cache.
+ * Deallocates the cache. This function does not care about reference count. Don't
+ * use this function directly -- it's better to use use mnt_unref_cache().
  */
 void mnt_free_cache(struct libmnt_cache *cache)
 {
@@ -89,6 +92,7 @@ void mnt_free_cache(struct libmnt_cache *cache)
 		return;
 
 	DBG(CACHE, mnt_debug_h(cache, "free"));
+	WARN_REFCOUNT(CACHE, cache, cache->refcount);
 
 	for (i = 0; i < cache->nents; i++) {
 		struct mnt_cache_entry *e = &cache->ents[i];
@@ -102,7 +106,39 @@ void mnt_free_cache(struct libmnt_cache *cache)
 	free(cache);
 }
 
-/* note that the @key could be tha same pointer as @value */
+/**
+ * mnt_ref_cache:
+ * @cache: cache pointer
+ *
+ * Increments reference counter.
+ */
+void mnt_ref_cache(struct libmnt_cache *cache)
+{
+	if (cache) {
+		cache->refcount++;
+		/*DBG(CACHE, mnt_debug_h(cache, "ref=%d", cache->refcount));*/
+	}
+}
+
+/**
+ * mnt_unref_cache:
+ * @cache: cache pointer
+ *
+ * De-increments reference counter, on zero the cache is automatically
+ * deallocated by mnt_free_cache().
+ */
+void mnt_unref_cache(struct libmnt_cache *cache)
+{
+	if (cache) {
+		cache->refcount--;
+		/*DBG(CACHE, mnt_debug_h(cache, "unref=%d", cache->refcount));*/
+		if (cache->refcount <= 0)
+			mnt_free_cache(cache);
+	}
+}
+
+
+/* note that the @key could be the same pointer as @value */
 static int cache_add_entry(struct libmnt_cache *cache, char *key,
 					char *value, int flag)
 {
@@ -135,7 +171,7 @@ static int cache_add_entry(struct libmnt_cache *cache, char *key,
 	return 0;
 }
 
-/* add tag to the cache, @devname has to be allocated string */
+/* add tag to the cache, @devname has to be an allocated string */
 static int cache_add_tag(struct libmnt_cache *cache, const char *tagname,
 				const char *tagval, char *devname, int flag)
 {
@@ -270,13 +306,13 @@ int mnt_cache_read_tags(struct libmnt_cache *cache, const char *devname)
 
 	DBG(CACHE, mnt_debug_h(cache, "tags for %s requested", devname));
 
-	/* check is device is already cached */
+	/* check if device is already cached */
 	for (i = 0; i < cache->nents; i++) {
 		struct mnt_cache_entry *e = &cache->ents[i];
 		if (!(e->flag & MNT_CACHE_TAGREAD))
 			continue;
 		if (strcmp(e->value, devname) == 0)
-			/* tags has been already read */
+			/* tags have already been read */
 			return 0;
 	}
 
@@ -335,7 +371,7 @@ error:
  * @token: tag name (e.g "LABEL")
  * @value: tag value
  *
- * Look up @cache to check it @tag+@value are associated with @devname.
+ * Look up @cache to check if @tag+@value are associated with @devname.
  *
  * Returns: 1 on success or 0.
  */
@@ -421,7 +457,7 @@ char *mnt_get_fstype(const char *devname, int *ambi, struct libmnt_cache *cache)
 
 	rc = blkid_do_safeprobe(pr);
 
-	DBG(CACHE, mnt_debug_h(cache, "liblkid rc=%d", rc));
+	DBG(CACHE, mnt_debug_h(cache, "libblkid rc=%d", rc));
 
 	if (!rc && !blkid_probe_lookup_value(pr, "TYPE", &data, NULL))
 		type = strdup(data);
@@ -493,7 +529,7 @@ error:
  *	- /dev/loopN to the loop backing filename
  *	- empty path (NULL) to 'none'
  *
- * Returns: new allocated string with path, result has to be always deallocated
+ * Returns: newly allocated string with path, result always has to be deallocated
  *          by free().
  */
 char *mnt_pretty_path(const char *path, struct libmnt_cache *cache)
@@ -583,22 +619,18 @@ error:
 char *mnt_resolve_spec(const char *spec, struct libmnt_cache *cache)
 {
 	char *cn = NULL;
+	char *t = NULL, *v = NULL;
 
 	if (!spec)
 		return NULL;
 
-	if (strchr(spec, '=')) {
-		char *tag, *val;
-
-		if (!blkid_parse_tag_string(spec, &tag, &val)) {
-			cn = mnt_resolve_tag(tag, val, cache);
-
-			free(tag);
-			free(val);
-		}
-	} else
+	if (blkid_parse_tag_string(spec, &t, &v) == 0 && mnt_valid_tagname(t))
+		cn = mnt_resolve_tag(t, v, cache);
+	else
 		cn = mnt_resolve_path(spec, cache);
 
+	free(t);
+	free(v);
 	return cn;
 }
 
@@ -624,7 +656,7 @@ int test_resolve_path(struct libmnt_test *ts, int argc, char *argv[])
 		p = mnt_resolve_path(line, cache);
 		printf("%s : %s\n", line, p);
 	}
-	mnt_free_cache(cache);
+	mnt_unref_cache(cache);
 	return 0;
 }
 
@@ -647,7 +679,7 @@ int test_resolve_spec(struct libmnt_test *ts, int argc, char *argv[])
 		p = mnt_resolve_spec(line, cache);
 		printf("%s : %s\n", line, p);
 	}
-	mnt_free_cache(cache);
+	mnt_unref_cache(cache);
 	return 0;
 }
 
@@ -663,6 +695,7 @@ int test_read_tags(struct libmnt_test *ts, int argc, char *argv[])
 
 	while(fgets(line, sizeof(line), stdin)) {
 		size_t sz = strlen(line);
+		char *t = NULL, *v = NULL;
 
 		if (sz > 0 && line[sz - 1] == '\n')
 			line[sz - 1] = '\0';
@@ -674,16 +707,14 @@ int test_read_tags(struct libmnt_test *ts, int argc, char *argv[])
 			if (mnt_cache_read_tags(cache, line) < 0)
 				fprintf(stderr, "%s: read tags failed\n", line);
 
-		} else if (strchr(line, '=')) {
-			char *tag, *val;
+		} else if (blkid_parse_tag_string(line, &t, &v) == 0) {
 			const char *cn = NULL;
 
-			if (!blkid_parse_tag_string(line, &tag, &val)) {
-				cn = cache_find_tag(cache, tag, val);
+			if (mnt_valid_tagname(t))
+				cn = cache_find_tag(cache, t, v);
+			free(t);
+			free(v);
 
-				free(tag);
-				free(val);
-			}
 			if (cn)
 				printf("%s: %s\n", line, cn);
 			else
@@ -700,7 +731,7 @@ int test_read_tags(struct libmnt_test *ts, int argc, char *argv[])
 				e->key + strlen(e->key) + 1);
 	}
 
-	mnt_free_cache(cache);
+	mnt_unref_cache(cache);
 	return 0;
 
 }
diff --git a/libmount/src/context.c b/libmount/src/context.c
index af16f6472..8dca3c12a 100644
--- a/libmount/src/context.c
+++ b/libmount/src/context.c
@@ -89,10 +89,8 @@ void mnt_free_context(struct libmnt_context *cxt)
 	free(cxt->fstype_pattern);
 	free(cxt->optstr_pattern);
 
-	if (!(cxt->flags & MNT_FL_EXTERN_FSTAB))
-		mnt_free_table(cxt->fstab);
-	if (!(cxt->flags & MNT_FL_EXTERN_CACHE))
-		mnt_free_cache(cxt->cache);
+	mnt_unref_table(cxt->fstab);
+	mnt_unref_cache(cxt->cache);
 
 	mnt_context_clear_loopdev(cxt);
 	mnt_free_lock(cxt->lock);
@@ -108,11 +106,11 @@ void mnt_free_context(struct libmnt_context *cxt)
  * mnt_reset_context:
  * @cxt: mount context
  *
- * Resets all information in the context that are directly related to
- * the latest mount (spec, source, target, mount options, ....)
+ * Resets all information in the context that is directly related to
+ * the latest mount (spec, source, target, mount options, ...).
  *
- * The match patters, cached fstab, cached canonicalized paths and tags and
- * [e]uid are not reseted. You have to use
+ * The match patterns, cached fstab, cached canonicalized paths and tags and
+ * [e]uid are not reset. You have to use
  *
  *	mnt_context_set_fstab(cxt, NULL);
  *	mnt_context_set_cache(cxt, NULL);
@@ -120,7 +118,7 @@ void mnt_free_context(struct libmnt_context *cxt)
  *	mnt_context_set_options_pattern(cxt, NULL);
  *
  *
- * to reset these stuff.
+ * to reset this stuff.
  *
  * Returns: 0 on success, negative number in case of error.
  */
@@ -136,10 +134,8 @@ int mnt_reset_context(struct libmnt_context *cxt)
 
 	fl = cxt->flags;
 
-	if (!(cxt->flags & MNT_FL_EXTERN_FS))
-		mnt_free_fs(cxt->fs);
-
-	mnt_free_table(cxt->mtab);
+	mnt_unref_fs(cxt->fs);
+	mnt_unref_table(cxt->mtab);
 
 	free(cxt->helper);
 	free(cxt->orig_user);
@@ -164,9 +160,7 @@ int mnt_reset_context(struct libmnt_context *cxt)
 	mnt_context_reset_status(cxt);
 	mnt_context_set_tabfilter(cxt, NULL, NULL);
 
-	/* restore non-resetable flags */
-	cxt->flags |= (fl & MNT_FL_EXTERN_FSTAB);
-	cxt->flags |= (fl & MNT_FL_EXTERN_CACHE);
+	/* restore non-resettable flags */
 	cxt->flags |= (fl & MNT_FL_NOMTAB);
 	cxt->flags |= (fl & MNT_FL_FAKE);
 	cxt->flags |= (fl & MNT_FL_SLOPPY);
@@ -225,7 +219,7 @@ static int set_flag(struct libmnt_context *cxt, int flag, int enable)
  * mnt_context_is_restricted:
  * @cxt: mount context
  *
- * Returns: 0 for unrestricted mount (user is root), or 1 for non-root mounts
+ * Returns: 0 for an unrestricted mount (user is root), or 1 for non-root mounts
  */
 int mnt_context_is_restricted(struct libmnt_context *cxt)
 {
@@ -235,9 +229,9 @@ int mnt_context_is_restricted(struct libmnt_context *cxt)
 /**
  * mnt_context_set_optsmode
  * @cxt: mount context
- * @mode: MNT_OMASK_* flags
+ * @mode: MNT_OMODE_* flags
  *
- * Controls how to use mount optionsmsource and target paths from fstab/mtab.
+ * Controls how to use mount optionssource and target paths from fstab/mtab.
  *
  * @MNT_OMODE_IGNORE: ignore mtab/fstab options
  *
@@ -247,7 +241,7 @@ int mnt_context_is_restricted(struct libmnt_context *cxt)
  *
  * @MNT_OMODE_REPLACE: replace existing options with options from mtab/fstab
  *
- * @MNT_OMODE_FORCE: always read mtab/fstab (although source and target is defined)
+ * @MNT_OMODE_FORCE: always read mtab/fstab (although source and target are defined)
  *
  * @MNT_OMODE_FSTAB: read from fstab
  *
@@ -262,8 +256,8 @@ int mnt_context_is_restricted(struct libmnt_context *cxt)
  * Notes:
  *
  * - MNT_OMODE_USER is always used if mount context is in restricted mode
- * - MNT_OMODE_AUTO is used if nothing other is defined
- * - the flags are eavaluated in this order: MNT_OMODE_NOTAB, MNT_OMODE_FORCE,
+ * - MNT_OMODE_AUTO is used if nothing else is defined
+ * - the flags are evaluated in this order: MNT_OMODE_NOTAB, MNT_OMODE_FORCE,
  *   MNT_OMODE_FSTAB, MNT_OMODE_MTAB and then the mount options from fstab/mtab
  *   are set according to MNT_OMODE_{IGNORE,APPEND,PREPAND,REPLACE}
  *
@@ -282,7 +276,7 @@ int mnt_context_set_optsmode(struct libmnt_context *cxt, int mode)
  * mnt_context_get_optsmode
  * @cxt: mount context
  *
- * Returns: MNT_OMASK_* mask or zero.
+ * Returns: MNT_OMODE_* mask or zero.
  */
 
 int mnt_context_get_optsmode(struct libmnt_context *cxt)
@@ -297,12 +291,12 @@ int mnt_context_get_optsmode(struct libmnt_context *cxt)
  * @disable: TRUE or FALSE
  *
  * Enable/disable paths canonicalization and tags evaluation. The libmount context
- * canonicalies paths when search in fstab and when prepare source and target paths
+ * canonicalizes paths when searching in fstab and when preparing source and target paths
  * for mount(2) syscall.
  *
- * This fuction has effect to the private (within context) fstab instance only
+ * This fuction has an effect on the private (within context) fstab instance only
  * (see mnt_context_set_fstab()). If you want to use an external fstab then you
- * need manage your private struct libmnt_cache (see mnt_table_set_cache(fstab,
+ * need to manage your private struct libmnt_cache (see mnt_table_set_cache(fstab,
  * NULL).
  *
  * Returns: 0 on success, negative number in case of error.
@@ -316,7 +310,7 @@ int mnt_context_disable_canonicalize(struct libmnt_context *cxt, int disable)
  * mnt_context_is_nocanonicalize:
  * @cxt: mount context
  *
- * Returns: 1 if no-canonicalize mode enabled or 0.
+ * Returns: 1 if no-canonicalize mode is enabled or 0.
  */
 int mnt_context_is_nocanonicalize(struct libmnt_context *cxt)
 {
@@ -389,10 +383,13 @@ int mnt_context_is_parent(struct libmnt_context *cxt)
  * mnt_context_is_child:
  * @cxt: mount context
  *
- * Return: 1 if mount -F enabled and the current context is child, or 0
+ * Return: 1 f the current context is child, or 0
  */
 int mnt_context_is_child(struct libmnt_context *cxt)
 {
+	/* See mnt_fork_context(), the for fork flag is always disabled
+	 * for children to avoid recursive forking.
+	 */
 	return !mnt_context_is_fork(cxt) && cxt->pid;
 }
 
@@ -415,7 +412,7 @@ int mnt_context_enable_rdonly_umount(struct libmnt_context *cxt, int enable)
  * mnt_context_is_rdonly_umount
  * @cxt: mount context
  *
- * See also mnt_context_enable_rdonly_umount() and see umount(8) man page,
+ * See also mnt_context_enable_rdonly_umount() and umount(8) man page,
  * option -r.
  *
  * Returns: 1 if read-only remount failed umount(2) is enables or 0
@@ -607,7 +604,7 @@ int mnt_context_is_verbose(struct libmnt_context *cxt)
  * @cxt: mount context
  * @enable: TRUE or FALSE
  *
- * Enable/disable loop delete (destroy) after umount (see umount(8), option -d)
+ * Enable/disable the loop delete (destroy) after umount (see umount(8), option -d)
  *
  * Returns: 0 on success, negative number in case of error.
  */
@@ -633,12 +630,13 @@ int mnt_context_is_loopdel(struct libmnt_context *cxt)
  * @fs: filesystem description
  *
  * The mount context uses private @fs by default. This function allows to
- * overwrite the private @fs with an external instance. Note that the external
- * @fs instance is not deallocated by mnt_free_context() or mnt_reset_context().
+ * overwrite the private @fs with an external instance. This function
+ * increments @fs reference counter (and deincrement reference counter of the
+ * old fs).
  *
  * The @fs will be modified by mnt_context_set_{source,target,options,fstype}
- * functions, If the @fs is NULL then all current FS specific setting (source,
- * target, etc., exclude spec) is reseted.
+ * functions, If the @fs is NULL, then all current FS specific settings (source,
+ * target, etc., exclude spec) are reset.
  *
  * Returns: 0 on success, negative number in case of error.
  */
@@ -646,10 +644,9 @@ int mnt_context_set_fs(struct libmnt_context *cxt, struct libmnt_fs *fs)
 {
 	if (!cxt)
 		return -EINVAL;
-	if (!(cxt->flags & MNT_FL_EXTERN_FS))
-		mnt_free_fs(cxt->fs);
 
-	set_flag(cxt, MNT_FL_EXTERN_FS, fs != NULL);
+	mnt_ref_fs(fs);			/* new */
+	mnt_unref_fs(cxt->fs);		/* old */
 	cxt->fs = fs;
 	return 0;
 }
@@ -662,25 +659,64 @@ int mnt_context_set_fs(struct libmnt_context *cxt, struct libmnt_fs *fs)
  * Note that the FS is modified by mnt_context_set_{source,target,options,fstype}
  * functions.
  *
- * Returns: pointer to FS description or NULL in case of calloc() errrr.
+ * Returns: pointer to FS description or NULL in case of a calloc() error.
  */
 struct libmnt_fs *mnt_context_get_fs(struct libmnt_context *cxt)
 {
 	assert(cxt);
 	if (!cxt)
 		return NULL;
-	if (!cxt->fs) {
+	if (!cxt->fs)
 		cxt->fs = mnt_new_fs();
-		cxt->flags &= ~MNT_FL_EXTERN_FS;
-	}
 	return cxt->fs;
 }
 
 /**
+ * mnt_context_get_fs_userdata:
+ * @cxt: mount context
+ *
+ * Returns: pointer to userdata or NULL.
+ */
+void *mnt_context_get_fs_userdata(struct libmnt_context *cxt)
+{
+	assert(cxt);
+	return cxt->fs ? mnt_fs_get_userdata(cxt->fs) : NULL;
+}
+
+/**
+ * mnt_context_get_fstab_userdata:
+ * @cxt: mount context
+ *
+ * Returns: pointer to userdata or NULL.
+ */
+void *mnt_context_get_fstab_userdata(struct libmnt_context *cxt)
+{
+	assert(cxt);
+	return cxt->fstab ? mnt_table_get_userdata(cxt->fstab) : NULL;
+}
+
+/**
+ * mnt_context_get_mtab_userdata:
+ * @cxt: mount context
+ *
+ * Returns: pointer to userdata or NULL.
+ */
+void *mnt_context_get_mtab_userdata(struct libmnt_context *cxt)
+{
+	assert(cxt);
+	return cxt->mtab ? mnt_table_get_userdata(cxt->mtab) : NULL;
+}
+
+/**
  * mnt_context_set_source:
  * @cxt: mount context
  * @source: mount source (device, directory, UUID, LABEL, ...)
  *
+ * Note that libmount does not interpret "nofail" (MNT_MS_NOFAIL)
+ * mount option. The real return code is always returned, when
+ * the device does not exist then it's usually MNT_ERR_NOSOURCE
+ * from libmount or ENOENT, ENOTDIR, ENOTBLK, ENXIO from moun(2).
+ *
  * Returns: 0 on success, negative number in case of error.
  */
 int mnt_context_set_source(struct libmnt_context *cxt, const char *source)
@@ -693,7 +729,7 @@ int mnt_context_set_source(struct libmnt_context *cxt, const char *source)
  * mnt_context_get_source:
  * @cxt: mount context
  *
- * Returns: returns pointer or NULL in case of error pr if not set.
+ * Returns: returns pointer or NULL in case of error or if not set.
  */
 const char *mnt_context_get_source(struct libmnt_context *cxt)
 {
@@ -718,7 +754,7 @@ int mnt_context_set_target(struct libmnt_context *cxt, const char *target)
  * mnt_context_get_target:
  * @cxt: mount context
  *
- * Returns: returns pointer or NULL in case of error pr if not set.
+ * Returns: returns pointer or NULL in case of error or if not set.
  */
 const char *mnt_context_get_target(struct libmnt_context *cxt)
 {
@@ -731,8 +767,8 @@ const char *mnt_context_get_target(struct libmnt_context *cxt)
  * @cxt: mount context
  * @fstype: filesystem type
  *
- * Note that the @fstype has to be the real FS type. For patterns with
- * comma-separated list of filesystems or for "nofs" notation use
+ * Note that the @fstype has to be a FS type. For patterns with
+ * comma-separated list of filesystems or for the "nofs" notation, use
  * mnt_context_set_fstype_pattern().
  *
  * Returns: 0 on success, negative number in case of error.
@@ -747,7 +783,7 @@ int mnt_context_set_fstype(struct libmnt_context *cxt, const char *fstype)
  * mnt_context_get_fstype:
  * @cxt: mount context
  *
- * Returns: pointer or NULL in case of error pr if not set.
+ * Returns: pointer or NULL in case of error or if not set.
  */
 const char *mnt_context_get_fstype(struct libmnt_context *cxt)
 {
@@ -788,8 +824,8 @@ int mnt_context_append_options(struct libmnt_context *cxt, const char *optstr)
  * This function returns mount options set by mnt_context_set_options() or
  * mnt_context_append_options().
  *
- * Note that *after* mnt_context_prepare_mount() may the mount options string
- * also includes options set by mnt_context_set_mflags() or another options
+ * Note that *after* mnt_context_prepare_mount(), the mount options string
+ * may also include options set by mnt_context_set_mflags() or other options
  * generated by this library.
  *
  * Returns: pointer or NULL
@@ -857,15 +893,19 @@ int mnt_context_set_options_pattern(struct libmnt_context *cxt, const char *patt
  * @cxt: mount context
  * @tb: fstab
  *
- * The mount context reads /etc/fstab to the the private struct libmnt_table by default.
+ * The mount context reads /etc/fstab to the private struct libmnt_table by default.
  * This function allows to overwrite the private fstab with an external
- * instance. Note that the external instance is not deallocated by mnt_free_context().
+ * instance.
+ *
+ * This function modify the @tb reference counter. This function does not set
+ * the cache for the @tb. You have to explicitly call mnt_table_set_cache(tb,
+ * mnt_context_get_cache(cxt));
  *
  * The fstab is used read-only and is not modified, it should be possible to
- * share the fstab between more mount contexts (TODO: tests it.)
+ * share the fstab between more mount contexts (TODO: test it.)
  *
- * If the @tb argument is NULL then the current private fstab instance is
- * reseted.
+ * If the @tb argument is NULL, then the current private fstab instance is
+ * reset.
  *
  * Returns: 0 on success, negative number in case of error.
  */
@@ -874,10 +914,10 @@ int mnt_context_set_fstab(struct libmnt_context *cxt, struct libmnt_table *tb)
 	assert(cxt);
 	if (!cxt)
 		return -EINVAL;
-	if (!(cxt->flags & MNT_FL_EXTERN_FSTAB))
-		mnt_free_table(cxt->fstab);
 
-	set_flag(cxt, MNT_FL_EXTERN_FSTAB, tb != NULL);
+	mnt_ref_table(tb);		/* new */
+	mnt_unref_table(cxt->fstab);	/* old */
+
 	cxt->fstab = tb;
 	return 0;
 }
@@ -893,8 +933,6 @@ int mnt_context_set_fstab(struct libmnt_context *cxt, struct libmnt_table *tb)
  */
 int mnt_context_get_fstab(struct libmnt_context *cxt, struct libmnt_table **tb)
 {
-	struct libmnt_cache *cache;
-
 	assert(cxt);
 	if (!cxt)
 		return -EINVAL;
@@ -906,18 +944,12 @@ int mnt_context_get_fstab(struct libmnt_context *cxt, struct libmnt_table **tb)
 			return -ENOMEM;
 		if (cxt->table_errcb)
 			mnt_table_set_parser_errcb(cxt->fstab, cxt->table_errcb);
-		cxt->flags &= ~MNT_FL_EXTERN_FSTAB;
+		mnt_table_set_cache(cxt->fstab, mnt_context_get_cache(cxt));
 		rc = mnt_table_parse_fstab(cxt->fstab, NULL);
 		if (rc)
 			return rc;
 	}
 
-	cache = mnt_context_get_cache(cxt);
-
-	/*  never touch an external fstab */
-	if (!(cxt->flags & MNT_FL_EXTERN_FSTAB))
-		mnt_table_set_cache(cxt->fstab, cache);
-
 	if (tb)
 		*tb = cxt->fstab;
 	return 0;
@@ -929,14 +961,12 @@ int mnt_context_get_fstab(struct libmnt_context *cxt, struct libmnt_table **tb)
  * @tb: returns mtab
  *
  * See also mnt_table_parse_mtab() for more details about mtab/mountinfo. The
- * result will deallocated by mnt_free_context(@cxt).
+ * result will be deallocated by mnt_free_context(@cxt).
  *
  * Returns: 0 on success, negative number in case of error.
  */
 int mnt_context_get_mtab(struct libmnt_context *cxt, struct libmnt_table **tb)
 {
-	struct libmnt_cache *cache;
-
 	assert(cxt);
 	if (!cxt)
 		return -EINVAL;
@@ -954,14 +984,12 @@ int mnt_context_get_mtab(struct libmnt_context *cxt, struct libmnt_table **tb)
 					cxt->table_fltrcb,
 					cxt->table_fltrcb_data);
 
+		mnt_table_set_cache(cxt->mtab, mnt_context_get_cache(cxt));
 		rc = mnt_table_parse_mtab(cxt->mtab, cxt->mtab_path);
 		if (rc)
 			return rc;
 	}
 
-	cache = mnt_context_get_cache(cxt);
-	mnt_table_set_cache(cxt->mtab, cache);
-
 	if (tb)
 		*tb = cxt->mtab;
 
@@ -971,8 +999,8 @@ int mnt_context_get_mtab(struct libmnt_context *cxt, struct libmnt_table **tb)
 }
 
 /*
- * Allows to specify filter for tab file entries. The filter is called by
- * table parser. Currently used for mtab and utab only.
+ * Allows to specify a filter for tab file entries. The filter is called by
+ * the table parser. Currently used for mtab and utab only.
  */
 int mnt_context_set_tabfilter(struct libmnt_context *cxt,
 			      int (*fltr)(struct libmnt_fs *, void *),
@@ -1004,7 +1032,7 @@ int mnt_context_set_tabfilter(struct libmnt_context *cxt,
  * callback and cache for tags and paths is set according to the @cxt setting.
  * See also mnt_table_parse_file().
  *
- * It's strongly recommended use mnt_context_get_mtab() and
+ * It's strongly recommended to use the mnt_context_get_mtab() and
  * mnt_context_get_fstab() functions for mtab and fstab files. This function
  * does not care about LIBMOUNT_* env.variables and does not merge userspace
  * options.
@@ -1016,7 +1044,6 @@ int mnt_context_set_tabfilter(struct libmnt_context *cxt,
 int mnt_context_get_table(struct libmnt_context *cxt,
 			  const char *filename, struct libmnt_table **tb)
 {
-	struct libmnt_cache *cache;
 	int rc;
 
 	assert(cxt);
@@ -1033,14 +1060,11 @@ int mnt_context_get_table(struct libmnt_context *cxt,
 
 	rc = mnt_table_parse_file(*tb, filename);
 	if (rc) {
-		mnt_free_table(*tb);
+		mnt_unref_table(*tb);
 		return rc;
 	}
 
-	cache = mnt_context_get_cache(cxt);
-	if (cache)
-		mnt_table_set_cache(*tb, cache);
-
+	mnt_table_set_cache(*tb, mnt_context_get_cache(cxt));
 	return 0;
 }
 
@@ -1065,6 +1089,11 @@ int mnt_context_set_tables_errcb(struct libmnt_context *cxt,
 	if (!cxt)
 		return -EINVAL;
 
+	if (cxt->mtab)
+		mnt_table_set_parser_errcb(cxt->mtab, cb);
+	if (cxt->fstab)
+		mnt_table_set_parser_errcb(cxt->fstab, cb);
+
 	cxt->table_errcb = cb;
 	return 0;
 }
@@ -1074,12 +1103,15 @@ int mnt_context_set_tables_errcb(struct libmnt_context *cxt,
  * @cxt: mount context
  * @cache: cache instance or nULL
  *
- * The mount context maintains a private struct libmnt_cache by default.  This function
- * allows to overwrite the private cache with an external instance. Note that
- * the external instance is not deallocated by mnt_free_context().
+ * The mount context maintains a private struct libmnt_cache by default. This
+ * function allows to overwrite the private cache with an external instance.
+ * This function increments cache reference counter.
  *
- * If the @cache argument is NULL then the current private cache instance is
- * reseted.
+ * If the @cache argument is NULL, then the current cache instance is reset.
+ * This function apply the cache to fstab and mtab instances (if already
+ * exists).
+ *
+ * The old cache instance reference counter is de-incremented.
  *
  * Returns: 0 on success, negative number in case of error.
  */
@@ -1087,11 +1119,17 @@ int mnt_context_set_cache(struct libmnt_context *cxt, struct libmnt_cache *cache
 {
 	if (!cxt)
 		return -EINVAL;
-	if (!(cxt->flags & MNT_FL_EXTERN_CACHE))
-		mnt_free_cache(cxt->cache);
 
-	set_flag(cxt, MNT_FL_EXTERN_CACHE, cache != NULL);
+	mnt_ref_cache(cache);			/* new */
+	mnt_unref_cache(cxt->cache);		/* old */
+
 	cxt->cache = cache;
+
+	if (cxt->mtab)
+		mnt_table_set_cache(cxt->mtab, cache);
+	if (cxt->fstab)
+		mnt_table_set_cache(cxt->fstab, cache);
+
 	return 0;
 }
 
@@ -1110,10 +1148,9 @@ struct libmnt_cache *mnt_context_get_cache(struct libmnt_context *cxt)
 		return NULL;
 
 	if (!cxt->cache) {
-		cxt->cache = mnt_new_cache();
-		if (!cxt->cache)
-			return NULL;
-		cxt->flags &= ~MNT_FL_EXTERN_CACHE;
+		struct libmnt_cache *cache = mnt_new_cache();
+		mnt_context_set_cache(cxt, cache);
+		mnt_unref_cache(cache);
 	}
 	return cxt->cache;
 }
@@ -1125,7 +1162,7 @@ struct libmnt_cache *mnt_context_get_cache(struct libmnt_context *cxt)
  * @release: callback to release (delallocate) password
  *
  * Sets callbacks for encryption password (e.g encrypted loopdev). This
- * function is deprecated (encrypted loops are no ore supported).
+ * function is deprecated (encrypted loops are no longer supported).
  *
  * Returns: 0 on success, negative number in case of error.
  */
@@ -1151,7 +1188,7 @@ int mnt_context_set_passwd_cb(struct libmnt_context *cxt,
  *
  * The default behavior is to ignore all signals (except SIGALRM and
  * SIGTRAP for mtab udate) when the lock is locked. If this behavior
- * is unacceptable then use:
+ * is unacceptable, then use:
  *
  *	lc = mnt_context_get_lock(cxt);
  *	if (lc)
@@ -1197,7 +1234,7 @@ struct libmnt_lock *mnt_context_get_lock(struct libmnt_context *cxt)
  *
  *	mnt_context_set_options(cxt, "noexec,nosuid");
  *
- * these both calls have the same effect.
+ * both of these calls have the same effect.
  *
  * Returns: 0 on success, negative number in case of error.
  */
@@ -1227,7 +1264,7 @@ int mnt_context_set_mflags(struct libmnt_context *cxt, unsigned long flags)
  * @flags: returns MS_* mount flags
  *
  * Converts mount options string to MS_* flags and bitewise-OR the result with
- * already defined flags (see mnt_context_set_mflags()).
+ * the already defined flags (see mnt_context_set_mflags()).
  *
  * Returns: 0 on success, negative number in case of error.
  */
@@ -1268,7 +1305,7 @@ int mnt_context_get_mflags(struct libmnt_context *cxt, unsigned long *flags)
  *
  * Sets userspace mount flags.
  *
- * See also notest for mnt_context_set_mflags().
+ * See also notes for mnt_context_set_mflags().
  *
  * Returns: 0 on success, negative number in case of error.
  */
@@ -1287,7 +1324,7 @@ int mnt_context_set_user_mflags(struct libmnt_context *cxt, unsigned long flags)
  * @flags: returns mount flags
  *
  * Converts mount options string to MNT_MS_* flags and bitewise-OR the result
- * with already defined flags (see mnt_context_set_user_mflags()).
+ * with the already defined flags (see mnt_context_set_user_mflags()).
  *
  * Returns: 0 on success, negative number in case of error.
  */
@@ -1321,7 +1358,7 @@ int mnt_context_get_user_mflags(struct libmnt_context *cxt, unsigned long *flags
  * function allows to overwrite this behavior, and @data will be used instead
  * of mount options.
  *
- * The libmount does not deallocated the data by mnt_free_context(). Note that
+ * The libmount does not deallocate the data by mnt_free_context(). Note that
  * NULL is also valid mount data.
  *
  * Returns: 0 on success, negative number in case of error.
@@ -1362,7 +1399,7 @@ int mnt_context_prepare_srcpath(struct libmnt_context *cxt)
 		return mnt_fs_set_source(cxt->fs, "none");
 
 	/* ignore filesystems without source or filesystems
-	 * where the source is quasi-path (//foo/bar)
+	 * where the source is a quasi-path (//foo/bar)
 	 */
 	if (!src || mnt_fs_is_netfs(cxt->fs))
 		return 0;
@@ -1504,8 +1541,8 @@ int mnt_context_prepare_target(struct libmnt_context *cxt)
 }
 
 /*
- * It's usully no error when we're not able to detect filesystem type -- we
- * will try to use types from /{etc,proc}/filesystems.
+ * It's usually no error when we're not able to detect the filesystem type -- we
+ * will try to use the types from /{etc,proc}/filesystems.
  */
 int mnt_context_guess_fstype(struct libmnt_context *cxt)
 {
@@ -1595,6 +1632,7 @@ int mnt_context_prepare_helper(struct libmnt_context *cxt, const char *name,
 	if (mnt_context_is_nohelpers(cxt)
 	    || !type
 	    || !strcmp(type, "none")
+	    || strstr(type, "/..")		/* don't try to smuggle path */
 	    || mnt_fs_is_swaparea(cxt->fs))
 		return 0;
 
@@ -1798,8 +1836,8 @@ static int apply_table(struct libmnt_context *cxt, struct libmnt_table *tb,
 			 *
 			 *	mount /foo/bar
 			 *
-			 * the path could be a mountpoint as well as source (for
-			 * example bind mount, symlink to device, ...).
+			 * the path could be a mountpoint as well as a source (for
+			 * example bind mount, symlink to a device, ...).
 			 */
 			if (src && !mnt_fs_get_tag(cxt->fs, NULL, NULL))
 				fs = mnt_table_find_target(tb, src, direction);
@@ -1869,7 +1907,7 @@ int mnt_context_apply_fstab(struct libmnt_context *cxt)
 		DBG(CXT, mnt_debug_h(cxt, "force fstab usage for non-root users!"));
 		cxt->optsmode = MNT_OMODE_USER;
 	} else if (cxt->optsmode == 0) {
-		DBG(CXT, mnt_debug_h(cxt, "use default optmode"));
+		DBG(CXT, mnt_debug_h(cxt, "use default optsmode"));
 		cxt->optsmode = MNT_OMODE_AUTO;
 	} else if (cxt->optsmode & MNT_OMODE_NOTAB) {
 		cxt->optsmode &= ~MNT_OMODE_FSTAB;
@@ -1944,7 +1982,7 @@ int mnt_context_tab_applied(struct libmnt_context *cxt)
 }
 
 /*
- * This is not public function!
+ * This is not a public function!
  *
  * Returns 1 if *only propagation flags* change is requested.
  */
@@ -1974,7 +2012,7 @@ int mnt_context_propagation_only(struct libmnt_context *cxt)
  * Global libmount status.
  *
  * The real exit code of the mount.type helper has to be tested by
- * mnt_context_get_helper_status(). The mnt_context_get_status() only inform
+ * mnt_context_get_helper_status(). The mnt_context_get_status() only informs
  * that exec() has been successful.
  *
  * Returns: 1 if mount.type or mount(2) syscall has been successfully called.
@@ -2046,7 +2084,7 @@ int mnt_context_get_syscall_errno(struct libmnt_context *cxt)
  *
  * The @status should be 0 on success, or negative number on error (-errno).
  *
- * This function should be used only if [u]mount(2) syscall is NOT called by
+ * This function should only be used if the [u]mount(2) syscall is NOT called by
  * libmount code.
  *
  * Returns: 0 or negative number in case of error.
@@ -2086,11 +2124,11 @@ int mnt_context_strerror(struct libmnt_context *cxt __attribute__((__unused__)),
  * @action: MNT_ACT_{UMOUNT,MOUNT}
  * @flags: not used now
  *
- * This function infors libmount that used from [u]mount.type helper.
+ * This function informs libmount that used from [u]mount.type helper.
  *
  * The function also calls mnt_context_disable_helpers() to avoid recursive
  * mount.type helpers calling. It you really want to call another
- * mount.type helper from your helper than you have to explicitly enable this
+ * mount.type helper from your helper, then you have to explicitly enable this
  * feature by:
  *
  *	 mnt_context_disable_helpers(cxt, FALSE);
@@ -2120,7 +2158,7 @@ int mnt_context_init_helper(struct libmnt_context *cxt, int action,
  * @c: getopt() result
  * @arg: getopt() optarg
  *
- * This function applies [u]mount.type command line option (for example parsed
+ * This function applies the [u]mount.type command line option (for example parsed
  * by getopt or getopt_long) to @cxt. All unknown options are ignored and
  * then 1 is returned.
  *
@@ -2145,7 +2183,7 @@ int mnt_context_helper_setopt(struct libmnt_context *cxt, int c, char *arg)
  * @fs: filesystem
  * @mounted: returns 1 for mounted and 0 for non-mounted filesystems
  *
- * Please, read mnt_table_is_fs_mounted() description!
+ * Please, read the mnt_table_is_fs_mounted() description!
  *
  * Returns: 0 on success and negative number in case of error.
  */
@@ -2308,7 +2346,7 @@ int test_mount(struct libmnt_test *ts, int argc, char *argv[])
 		mnt_context_set_target(cxt, argv[idx++]);
 	}
 
-	/* this is unnecessary! -- libmount is able to internaly
+	/* this is unnecessary! -- libmount is able to internally
 	 * create and manage the lock
 	 */
 	lock = mnt_context_get_lock(cxt);
@@ -2317,7 +2355,7 @@ int test_mount(struct libmnt_test *ts, int argc, char *argv[])
 
 	rc = mnt_context_mount(cxt);
 	if (rc)
-		printf("failed to mount: %m\n");
+		warn("failed to mount");
 	else
 		printf("successfully mounted\n");
 
diff --git a/libmount/src/context_loopdev.c b/libmount/src/context_loopdev.c
index 576b7f55a..44a7216b8 100644
--- a/libmount/src/context_loopdev.c
+++ b/libmount/src/context_loopdev.c
@@ -47,10 +47,10 @@ int mnt_context_is_loopdev(struct libmnt_context *cxt)
 	/* Automatically create a loop device from a regular file if a
 	 * filesystem is not specified or the filesystem is known for libblkid
 	 * (these filesystems work with block devices only). The file size
-	 * should be at least 1KiB otherwise we will create empty loopdev where
-	 * is no mountable filesystem...
+	 * should be at least 1KiB, otherwise we will create an empty loopdev with
+	 * no mountable filesystem...
 	 *
-	 * Note that there is not a restriction (on kernel side) that prevents regular
+	 * Note that there is no restriction (on kernel side) that would prevent a regular
 	 * file as a mount(2) source argument. A filesystem that is able to mount
 	 * regular files could be implemented.
 	 */
@@ -73,7 +73,7 @@ int mnt_context_is_loopdev(struct libmnt_context *cxt)
 }
 
 
-/* Check, if there already exists a mounted loop device on the mountpoint node
+/* Check if there already exists a mounted loop device on the mountpoint node
  * with the same parameters.
  */
 static int __attribute__((nonnull))
@@ -86,6 +86,8 @@ is_mounted_same_loopfile(struct libmnt_context *cxt,
 	struct libmnt_iter itr;
 	struct libmnt_fs *fs;
 	struct libmnt_cache *cache;
+	const char *bf;
+	int rc = 0;
 
 	assert(cxt);
 	assert(cxt->fs);
@@ -100,39 +102,36 @@ is_mounted_same_loopfile(struct libmnt_context *cxt,
 	cache = mnt_context_get_cache(cxt);
 	mnt_reset_iter(&itr, MNT_ITER_BACKWARD);
 
-	/* Search for mountpoint node in mtab, procceed if any of these has the
+	bf = cache ? mnt_resolve_path(backing_file, cache) : backing_file;
+
+	/* Search for a mountpoint node in mtab, proceed if any of these have the
 	 * loop option set or the device is a loop device
 	 */
-	while (mnt_table_next_fs(tb, &itr, &fs) == 0) {
+	while (rc == 0 && mnt_table_next_fs(tb, &itr, &fs) == 0) {
 		const char *src = mnt_fs_get_source(fs);
 		const char *opts = mnt_fs_get_user_options(fs);
 		char *val;
 		size_t len;
-		int res = 0;
 
 		if (!src || !mnt_fs_match_target(fs, target, cache))
 			continue;
 
+		rc = 0;
+
 		if (strncmp(src, "/dev/loop", 9) == 0) {
-			res = loopdev_is_used((char *) src, backing_file,
-					offset, LOOPDEV_FL_OFFSET);
+			rc = loopdev_is_used((char *) src, bf, offset, LOOPDEV_FL_OFFSET);
 
 		} else if (opts && (cxt->user_mountflags & MNT_MS_LOOP) &&
 		    mnt_optstr_get_option(opts, "loop", &val, &len) == 0 && val) {
 
 			val = strndup(val, len);
-			res = loopdev_is_used((char *) val, backing_file,
-					offset, LOOPDEV_FL_OFFSET);
+			rc = loopdev_is_used((char *) val, bf, offset, LOOPDEV_FL_OFFSET);
 			free(val);
 		}
-
-		if (res) {
-			DBG(CXT, mnt_debug_h(cxt, "%s already mounted", backing_file));
-			return 1;
-		}
 	}
-
-	return 0;
+	if (rc)
+		DBG(CXT, mnt_debug_h(cxt, "%s already mounted", backing_file));
+	return rc;
 }
 
 int mnt_context_setup_loopdev(struct libmnt_context *cxt)
@@ -282,7 +281,7 @@ int mnt_context_setup_loopdev(struct libmnt_context *cxt)
 		if ((cxt->user_mountflags & MNT_MS_LOOP) &&
 		    loopcxt_is_autoclear(&lc)) {
 			/*
-			 * autoclear flag accepted by kernel, don't store
+			 * autoclear flag accepted by the kernel, don't store
 			 * the "loop=" option to mtab.
 			 */
 			cxt->user_mountflags &= ~MNT_MS_LOOP;
@@ -298,7 +297,7 @@ int mnt_context_setup_loopdev(struct libmnt_context *cxt)
 			mnt_context_set_mflags(cxt, cxt->mountflags | MS_RDONLY);
 
 		/* we have to keep the device open until mount(1),
-		 * otherwise it will auto-cleared by kernel
+		 * otherwise it will be auto-cleared by kernel
 		 */
 		cxt->loopdev_fd = loopcxt_get_fd(&lc);
 		loopcxt_set_fd(&lc, -1, 0);
diff --git a/libmount/src/context_mount.c b/libmount/src/context_mount.c
index d6691eb6a..89d1f4f29 100644
--- a/libmount/src/context_mount.c
+++ b/libmount/src/context_mount.c
@@ -21,6 +21,7 @@
 
 #include "linux_version.h"
 #include "mountP.h"
+#include "strutils.h"
 
 /*
  * Kernel supports only one MS_PROPAGATION flag change by one mount(2) syscall,
@@ -101,6 +102,30 @@ static int init_propagation(struct libmnt_context *cxt)
 	return 0;
 }
 
+#if defined(HAVE_LIBSELINUX) || defined(HAVE_SMACK)
+struct libmnt_optname {
+	const char *name;
+	size_t namesz;
+};
+
+#define DEF_OPTNAME(n)		{ .name = n, .namesz = sizeof(n) - 1 }
+#define DEF_OPTNAME_LAST	{ .name = NULL }
+
+static int is_option(const char *name, size_t namesz,
+		     const struct libmnt_optname *names)
+{
+	const struct libmnt_optname *p;
+
+	for (p = names; p && p->name; p++) {
+		if (p->namesz == namesz
+		    && strncmp(name, p->name, namesz) == 0)
+			return 1;
+	}
+
+	return 0;
+}
+#endif /* HAVE_LIBSELINUX || HAVE_SMACK */
+
 /*
  * this has to be called after mnt_context_evaluate_permissions()
  */
@@ -113,6 +138,25 @@ static int fix_optstr(struct libmnt_context *cxt)
 	struct libmnt_fs *fs;
 #ifdef HAVE_LIBSELINUX
 	int se_fix = 0, se_rem = 0;
+	static const struct libmnt_optname selinux_options[] = {
+		DEF_OPTNAME("context"),
+		DEF_OPTNAME("fscontext"),
+		DEF_OPTNAME("defcontext"),
+		DEF_OPTNAME("rootcontext"),
+		DEF_OPTNAME("seclabel"),
+		DEF_OPTNAME_LAST
+	};
+#endif
+#ifdef HAVE_SMACK
+	int sm_rem = 0;
+	static const struct libmnt_optname smack_options[] = {
+		DEF_OPTNAME("smackfsdef"),
+		DEF_OPTNAME("smackfsfloor"),
+		DEF_OPTNAME("smackfshat"),
+		DEF_OPTNAME("smackfsroot"),
+		DEF_OPTNAME("smackfstransmute"),
+		DEF_OPTNAME_LAST
+	};
 #endif
 	assert(cxt);
 	assert(cxt->fs);
@@ -129,8 +173,8 @@ static int fix_optstr(struct libmnt_context *cxt)
 
 	/*
 	 * The "user" options is our business (so we can modify the option),
-	 * but exception is command line for /sbin/mount.<type> helpers. Let's
-	 * save the original user=<name> to call the helpers with unchanged
+	 * the exception is command line for /sbin/mount.<type> helpers. Let's
+	 * save the original user=<name> to call the helpers with an unchanged
 	 * "user" setting.
 	 */
 	if (cxt->user_mountflags & MNT_MS_USER) {
@@ -168,7 +212,6 @@ static int fix_optstr(struct libmnt_context *cxt)
 		free(fs->user_optstr);
 		fs->user_optstr = NULL;
 	}
-
 	if (cxt->mountflags & MS_PROPAGATION) {
 		rc = init_propagation(cxt);
 		if (rc)
@@ -198,13 +241,15 @@ static int fix_optstr(struct libmnt_context *cxt)
 
 	if (!se_rem) {
 		/* de-duplicate SELinux options */
-		mnt_optstr_deduplicate_option(&fs->fs_optstr, "context");
-		mnt_optstr_deduplicate_option(&fs->fs_optstr, "fscontext");
-		mnt_optstr_deduplicate_option(&fs->fs_optstr, "defcontext");
-		mnt_optstr_deduplicate_option(&fs->fs_optstr, "rootcontext");
-		mnt_optstr_deduplicate_option(&fs->fs_optstr, "seclabel");
+		const struct libmnt_optname *p;
+		for (p = selinux_options; p && p->name; p++)
+			mnt_optstr_deduplicate_option(&fs->fs_optstr, p->name);
 	}
 #endif
+#ifdef HAVE_SMACK
+	if (access("/sys/fs/smackfs", F_OK) != 0)
+		sm_rem = 1;
+#endif
 	while (!mnt_optstr_next_option(&next, &name, &namesz, &val, &valsz)) {
 
 		if (namesz == 3 && !strncmp(name, "uid", 3))
@@ -212,12 +257,9 @@ static int fix_optstr(struct libmnt_context *cxt)
 		else if (namesz == 3 && !strncmp(name, "gid", 3))
 			rc = mnt_optstr_fix_gid(&fs->fs_optstr, val, valsz, &next);
 #ifdef HAVE_LIBSELINUX
-		else if ((se_rem || se_fix) &&
-			 namesz >= 7 && (!strncmp(name, "context", 7) ||
-					 !strncmp(name, "fscontext", 9) ||
-					 !strncmp(name, "defcontext", 10) ||
-					 !strncmp(name, "rootcontext", 11) ||
-					 !strncmp(name, "seclabel", 8))) {
+		else if ((se_rem || se_fix)
+			 && is_option(name, namesz, selinux_options)) {
+
 			if (se_rem) {
 				/* remove context= option */
 				next = name;
@@ -231,6 +273,15 @@ static int fix_optstr(struct libmnt_context *cxt)
 							val, valsz, &next);
 		}
 #endif
+#ifdef HAVE_SMACK
+		else if (sm_rem && is_option(name, namesz, smack_options)) {
+
+			next = name;
+			rc = mnt_optstr_remove_option_at(&fs->fs_optstr,
+					name,
+					val ? val + valsz : name + namesz);
+		}
+#endif
 		if (rc)
 			goto done;
 	}
@@ -255,7 +306,7 @@ done:
 }
 
 /*
- * Converts already evaluated and fixed options to the form that is compatible
+ * Converts the already evaluated and fixed options to the form that is compatible
  * with /sbin/mount.type helpers.
  */
 static int generate_helper_optstr(struct libmnt_context *cxt, char **optstr)
@@ -278,13 +329,13 @@ static int generate_helper_optstr(struct libmnt_context *cxt, char **optstr)
 	if (cxt->user_mountflags & MNT_MS_USER) {
 		/*
 		 * This is unnecessary for real user-mounts as mount.<type>
-		 * helpers have to always follow fstab rather than mount
-		 * options on command line.
+		 * helpers always have to follow fstab rather than mount
+		 * options on the command line.
 		 *
-		 * But if you call mount.<type> as root then the helper follows
-		 * command line. If there is (for example) "user,exec" in fstab
+		 * However, if you call mount.<type> as root, then the helper follows
+		 * the command line. If there is (for example) "user,exec" in fstab,
 		 * then we have to manually append the "exec" back to the options
-		 * string, bacause there is nothing like MS_EXEC (we have only
+		 * string, bacause there is nothing like MS_EXEC (we only have
 		 * MS_NOEXEC in mount flags and we don't care about the original
 		 * mount string in libmount for VFS options).
 		 */
@@ -330,7 +381,7 @@ err:
 /*
  * this has to be called before fix_optstr()
  *
- * Note that user=<name> maybe be used by some filesystems as filesystem
+ * Note that user=<name> may be used by some filesystems as a filesystem
  * specific option (e.g. cifs). Yes, developers of such filesystems have
  * allocated pretty hot place in hell...
  */
@@ -361,7 +412,7 @@ static int evaluate_permissions(struct libmnt_context *cxt)
 		/*
 		 * user mount
 		 */
-		if (!(cxt->flags & MNT_FL_TAB_APPLIED))
+		if (!mnt_context_tab_applied(cxt))
 		{
 			DBG(CXT, mnt_debug_h(cxt, "perms: fstab not applied, ignore user mount"));
 			return -EPERM;
@@ -433,7 +484,7 @@ static int evaluate_permissions(struct libmnt_context *cxt)
 /*
  * mnt_context_helper_setopt() backend
  *
- * This function applies mount.type command line option (for example parsed
+ * This function applies the mount.type command line option (for example parsed
  * by getopt() or getopt_long()) to @cxt. All unknown options are ignored and
  * then 1 is returned.
  *
@@ -519,7 +570,7 @@ static int exec_helper(struct libmnt_context *cxt)
 
 		/*
 		 * TODO: remove the exception for "nfs", -s is documented
-		 *       for years should be usable everywhere.
+		 *       for years and should be usable everywhere.
 		 */
 		if (mnt_context_is_sloppy(cxt) &&
 		    type && startswith(type, "nfs"))
@@ -651,7 +702,7 @@ static int do_mount(struct libmnt_context *cxt, const char *try_type)
 		return -EINVAL;
 	if (!src) {
 		/* unnecessary, should be already resolved in
-		 * mnt_context_prepare_srcpath(), but for sure... */
+		 * mnt_context_prepare_srcpath(), but to be sure... */
 		DBG(CXT, mnt_debug_h(cxt, "WARNING: source is NULL -- using \"none\"!"));
 		src = "none";
 	}
@@ -831,10 +882,10 @@ int mnt_context_prepare_mount(struct libmnt_context *cxt)
  * Call mount(2) or mount.type helper. Unnecessary for mnt_context_mount().
  *
  * Note that this function could be called only once. If you want to mount
- * another source or target than you have to call mnt_reset_context().
+ * another source or target, then you have to call mnt_reset_context().
  *
- * If you want to call mount(2) for the same source and target with a different
- * mount flags or fstype then call mnt_context_reset_status() and then try
+ * If you want to call mount(2) for the same source and target with different
+ * mount flags or fstype, then call mnt_context_reset_status() and then try
  * again mnt_context_do_mount().
  *
  * WARNING: non-zero return code does not mean that mount(2) syscall or
@@ -867,7 +918,7 @@ int mnt_context_do_mount(struct libmnt_context *cxt)
 	type = mnt_fs_get_fstype(cxt->fs);
 	if (type) {
 		if (strchr(type, ','))
-			/* this only happens if fstab contains list of filesystems */
+			/* this only happens if fstab contains a list of filesystems */
 			res = do_mount_by_pattern(cxt, type);
 		else
 			res = do_mount(cxt, NULL);
@@ -935,7 +986,7 @@ int mnt_context_finalize_mount(struct libmnt_context *cxt)
  * mnt_context_mount:
  * @cxt: mount context
  *
- * High-level, mounts filesystem by mount(2) or fork()+exec(/sbin/mount.type).
+ * High-level, mounts the filesystem by mount(2) or fork()+exec(/sbin/mount.type).
  *
  * This is similar to:
  *
@@ -945,10 +996,10 @@ int mnt_context_finalize_mount(struct libmnt_context *cxt)
  *
  * See also mnt_context_disable_helpers().
  *
- * Note that this function could be called only once. If you want to mount with
- * different setting than you have to call mnt_reset_context(). It's NOT enough
- * to call mnt_context_reset_status() if you want call this function more than
- * once, whole context has to be reseted.
+ * Note that this function should be called only once. If you want to mount with
+ * different settings, then you have to call mnt_reset_context(). It's NOT enough
+ * to call mnt_context_reset_status(). If you want to call this function more than
+ * once, the whole context has to be reset.
  *
  * WARNING: non-zero return code does not mean that mount(2) syscall or
  *          mount.type helper wasn't successfully called.
@@ -973,11 +1024,6 @@ int mnt_context_mount(struct libmnt_context *cxt)
 		rc = mnt_context_prepare_update(cxt);
 	if (!rc)
 		rc = mnt_context_do_mount(cxt);
-
-	/* TODO: if mtab update is expected then check if the
-	 * target is really mounted read-write to avoid 'ro' in
-	 * mtab and 'rw' in /proc/mounts.
-	 */
 	if (!rc)
 		rc = mnt_context_update_tabs(cxt);
 	return rc;
@@ -989,7 +1035,7 @@ int mnt_context_mount(struct libmnt_context *cxt)
  * @itr: iterator
  * @fs: returns the current filesystem
  * @mntrc: returns the return code from mnt_context_mount()
- * @ignored: returns 1 for not matching and 2 for already mounted filesystems
+ * @ignored: returns 1 for non-matching and 2 for already mounted filesystems
  *
  * This function tries to mount the next filesystem from fstab (as returned by
  * mnt_context_get_fstab()). See also mnt_context_set_fstab().
@@ -1057,11 +1103,11 @@ int mnt_context_next_mount(struct libmnt_context *cxt,
 	/* ignore noauto filesystems */
 	   (o && mnt_optstr_get_option(o, "noauto", NULL, NULL) == 0) ||
 
-	/* ignore filesystems not match with options patterns */
+	/* ignore filesystems which don't match options patterns */
 	   (cxt->fstype_pattern && !mnt_fs_match_fstype(*fs,
 					cxt->fstype_pattern)) ||
 
-	/* ignore filesystems not match with type patterns */
+	/* ignore filesystems which don't match type patterns */
 	   (cxt->optstr_pattern && !mnt_fs_match_options(*fs,
 					cxt->optstr_pattern))) {
 		if (ignored)
diff --git a/libmount/src/context_umount.c b/libmount/src/context_umount.c
index 4a8659c9c..dc16852c0 100644
--- a/libmount/src/context_umount.c
+++ b/libmount/src/context_umount.c
@@ -23,7 +23,7 @@
  * umount2 flags
  */
 #ifndef MNT_FORCE
-# define MNT_FORCE        0x00000001	/* Attempt to forcibily umount */
+# define MNT_FORCE        0x00000001	/* Attempt to forcibly umount */
 #endif
 
 #ifndef MNT_DETACH
@@ -39,8 +39,8 @@
 #endif
 
 /*
- * Called by mtab parser to filter out entries, nonzero means that
- * entry has to be filter out.
+ * Called by mtab parser to filter out entries, non-zero means that
+ * an entry has to be filtered out.
  */
 static int mtab_filter(struct libmnt_fs *fs, void *data)
 {
@@ -71,19 +71,25 @@ int mnt_context_find_umount_fs(struct libmnt_context *cxt,
 	struct libmnt_cache *cache = NULL;
 	char *cn_tgt = NULL, *loopdev = NULL;
 
+	if (pfs)
+		*pfs = NULL;
+
 	if (!cxt || !tgt || !pfs)
 		return -EINVAL;
 
 	DBG(CXT, mnt_debug_h(cxt, "umount: lookup FS for '%s'", tgt));
 
+	if (!*tgt)
+		return 1; /* empty string is not an error */
+
 	/*
-	 * The mtab file maybe huge and on systems with utab we have to merge
+	 * The mtab file may be huge and on systems with utab we have to merge
 	 * userspace mount options into /proc/self/mountinfo. This all is
 	 * expensive. The mtab filter allows to filter out entries, then
 	 * mtab and utab are very tiny files.
 	 *
 	 * *but*... the filter uses mnt_fs_streq_{target,srcpath} functions
-	 * where LABEL, UUID or symlinks are to canonicalized. It means that
+	 * where LABEL, UUID or symlinks are canonicalized. It means that
 	 * it's usable only for canonicalized stuff (e.g. kernel mountinfo).
 	 */
 	if (!cxt->mtab_writable	&& *tgt == '/' &&
@@ -92,7 +98,7 @@ int mnt_context_find_umount_fs(struct libmnt_context *cxt,
 		struct stat st;
 
 		if (stat(tgt, &st) == 0 && S_ISDIR(st.st_mode)) {
-			/* we'll canonicalized /proc/self/mountinfo */
+			/* we'll canonicalize /proc/self/mountinfo */
 			cache = mnt_context_get_cache(cxt);
 			cn_tgt = mnt_resolve_path(tgt, cache);
 			if (cn_tgt)
@@ -155,7 +161,10 @@ try_loopdev:
 		struct stat st;
 
 		if (stat(tgt, &st) == 0 && S_ISREG(st.st_mode)) {
-			int count = loopdev_count_by_backing_file(tgt, &loopdev);
+			int count;
+			const char *bf = cache ? mnt_resolve_path(tgt, cache) : tgt;
+
+			count = loopdev_count_by_backing_file(bf, &loopdev);
 			if (count == 1) {
 				DBG(CXT, mnt_debug_h(cxt,
 					"umount: %s --> %s (retry)", tgt, loopdev));
@@ -169,15 +178,21 @@ try_loopdev:
 		}
 	}
 
-	*pfs = fs;
+	if (pfs)
+		*pfs = fs;
 	free(loopdev);
 
+	DBG(CXT, mnt_debug_h(cxt, "umount fs: %s", fs ? mnt_fs_get_target(fs) :
+							"<not found>"));
 	return fs ? 0 : 1;
 err:
 	free(loopdev);
 	return rc;
 }
 
+/* this is umount replacement to mnt_context_apply_fstab(), use
+ * mnt_context_tab_applied() to check result.
+ */
 static int lookup_umount_fs(struct libmnt_context *cxt)
 {
 	const char *tgt;
@@ -197,8 +212,8 @@ static int lookup_umount_fs(struct libmnt_context *cxt)
 	if (rc < 0)
 		return rc;
 	if (rc == 1 || !fs) {
-		DBG(CXT, mnt_debug_h(cxt, "umount: cannot find %s in mtab", tgt));
-		return 0;
+		DBG(CXT, mnt_debug_h(cxt, "umount: cannot find '%s' in mtab", tgt));
+		return 0;	/* this is correct! */
 	}
 
 	if (fs != cxt->fs) {
@@ -237,7 +252,7 @@ static int is_associated_fs(const char *devname, struct libmnt_fs *fs)
 	if (!src)
 		return 0;
 
-	/* check for offset option in @fs */
+	/* check for the offset option in @fs */
 	optstr = (char *) mnt_fs_get_user_options(fs);
 
 	if (optstr &&
@@ -300,7 +315,7 @@ static int evaluate_permissions(struct libmnt_context *cxt)
 
 	DBG(CXT, mnt_debug_h(cxt, "umount: evaluating permissions"));
 
-	if (!(cxt->flags & MNT_FL_TAB_APPLIED)) {
+	if (!mnt_context_tab_applied(cxt)) {
 		DBG(CXT, mnt_debug_h(cxt,
 				"cannot find %s in mtab and you are not root",
 				mnt_fs_get_target(cxt->fs)));
@@ -317,7 +332,7 @@ static int evaluate_permissions(struct libmnt_context *cxt)
 	}
 
 	/*
-	 * User mounts has to be in /etc/fstab
+	 * User mounts have to be in /etc/fstab
 	 */
 	rc = mnt_context_get_fstab(cxt, &fstab);
 	if (rc)
@@ -336,18 +351,20 @@ static int evaluate_permissions(struct libmnt_context *cxt)
 	 *	/dev/sda1 /mnt/zip auto user,noauto  0 0
 	 *	/dev/sda4 /mnt/zip auto user,noauto  0 0
 	 * then "mount /dev/sda4" followed by "umount /mnt/zip" used to fail.
-	 * So, we must not look for file, but for the pair (dev,file) in fstab.
+	 * So, we must not look for the file, but for the pair (dev,file) in fstab.
 	  */
 	fs = mnt_table_find_pair(fstab, src, tgt, MNT_ITER_FORWARD);
 	if (!fs) {
 		/*
 		 * It's possible that there is /path/file.img in fstab and
-		 * /dev/loop0 in mtab -- then we have to check releation
+		 * /dev/loop0 in mtab -- then we have to check the relation
 		 * between loopdev and the file.
 		 */
 		fs = mnt_table_find_target(fstab, tgt, MNT_ITER_FORWARD);
 		if (fs) {
-			const char *dev = mnt_fs_get_srcpath(cxt->fs);		/* devname from mtab */
+			struct libmnt_cache *cache = mnt_context_get_cache(cxt);
+			const char *sp = mnt_fs_get_srcpath(cxt->fs);		/* devname from mtab */
+			const char *dev = sp && cache ? mnt_resolve_path(sp, cache) : sp;
 
 			if (!dev || !is_associated_fs(dev, fs))
 				fs = NULL;
@@ -384,7 +401,7 @@ static int evaluate_permissions(struct libmnt_context *cxt)
 		return 0;
 	}
 	/*
-	 * Check user=<username> setting from mtab if there is user, owner or
+	 * Check user=<username> setting from mtab if there is a user, owner or
 	 * group option in /etc/fstab
 	 */
 	if (u_flags & (MNT_MS_USER | MNT_MS_OWNER | MNT_MS_GROUP)) {
@@ -409,6 +426,8 @@ static int evaluate_permissions(struct libmnt_context *cxt)
 		if (optstr && !mnt_optstr_get_option(optstr,
 					"user", &mtab_user, &sz) && sz)
 			ok = !strncmp(curr_user, mtab_user, sz);
+
+		free(curr_user);
 	}
 
 	if (ok) {
@@ -539,7 +558,7 @@ int mnt_context_umount_setopt(struct libmnt_context *cxt, int c, char *arg)
 	return rc;
 }
 
-/* Check whether the kernel supports UMOUNT_NOFOLLOW flag */
+/* Check whether the kernel supports the UMOUNT_NOFOLLOW flag */
 static int umount_nofollow_support(void)
 {
 	int res = umount2("", UMOUNT_UNUSED);
@@ -860,7 +879,7 @@ int mnt_context_umount(struct libmnt_context *cxt)
  *	mnt_context_set_options_pattern() to simulate umount -a -O pattern
  *	mnt_context_set_fstype_pattern()  to simulate umount -a -t pattern
  *
- * If the filesystem is not mounted or does not match defined criteria,
+ * If the filesystem is not mounted or does not match the defined criteria,
  * then the function mnt_context_next_umount() returns zero, but the @ignored is
  * non-zero. Note that the root filesystem is always ignored.
  *
@@ -909,11 +928,11 @@ int mnt_context_next_umount(struct libmnt_context *cxt,
 
 	DBG(CXT, mnt_debug_h(cxt, "next-umount: trying %s", tgt));
 
-	/* ignore filesystems not match with options patterns */
+	/* ignore filesystems which don't match options patterns */
 	if ((cxt->fstype_pattern && !mnt_fs_match_fstype(*fs,
 					cxt->fstype_pattern)) ||
 
-	/* ignore filesystems not match with type patterns */
+	/* ignore filesystems which don't match type patterns */
 	   (cxt->optstr_pattern && !mnt_fs_match_options(*fs,
 					cxt->optstr_pattern))) {
 		if (ignored)
diff --git a/libmount/src/fs.c b/libmount/src/fs.c
index c95cdc7e7..3ab614503 100644
--- a/libmount/src/fs.c
+++ b/libmount/src/fs.c
@@ -21,6 +21,9 @@
 /**
  * mnt_new_fs:
  *
+ * The initial refcount is 1, and needs to be decremented to
+ * release the resources of the filesystem.
+ *
  * Returns: newly allocated struct libmnt_fs.
  */
 struct libmnt_fs *mnt_new_fs(void)
@@ -29,8 +32,9 @@ struct libmnt_fs *mnt_new_fs(void)
 	if (!fs)
 		return NULL;
 
-	/*DBG(FS, mnt_debug_h(fs, "alloc"));*/
+	fs->refcount = 1;
 	INIT_LIST_HEAD(&fs->ents);
+	/*DBG(FS, mnt_debug_h(fs, "alloc"));*/
 	return fs;
 }
 
@@ -38,7 +42,10 @@ struct libmnt_fs *mnt_new_fs(void)
  * mnt_free_fs:
  * @fs: fs pointer
  *
- * Deallocates the fs.
+ * Deallocates the fs. This function does not care about reference count. Don't
+ * use this function directly -- it's better to use use mnt_unref_fs().
+ *
+ * The reference counting is supported since util-linux v2.24.
  */
 void mnt_free_fs(struct libmnt_fs *fs)
 {
@@ -47,6 +54,7 @@ void mnt_free_fs(struct libmnt_fs *fs)
 	list_del(&fs->ents);
 
 	/*DBG(FS, mnt_debug_h(fs, "free"));*/
+	WARN_REFCOUNT(FS, fs, fs->refcount);
 
 	free(fs->source);
 	free(fs->bindsrc);
@@ -62,6 +70,7 @@ void mnt_free_fs(struct libmnt_fs *fs)
 	free(fs->user_optstr);
 	free(fs->attrs);
 	free(fs->opt_fields);
+	free(fs->comment);
 
 	free(fs);
 }
@@ -74,8 +83,46 @@ void mnt_free_fs(struct libmnt_fs *fs)
  */
 void mnt_reset_fs(struct libmnt_fs *fs)
 {
-	if (fs)
-		memset(fs, 0, sizeof(*fs));
+	int ref;
+
+	if (!fs)
+		return;
+
+	ref = fs->refcount;
+	memset(fs, 0, sizeof(*fs));
+	INIT_LIST_HEAD(&fs->ents);
+	fs->refcount = ref;
+}
+
+/**
+ * mnt_ref_fs:
+ * @fs: fs pointer
+ *
+ * Increments reference counter.
+ */
+void mnt_ref_fs(struct libmnt_fs *fs)
+{
+	if (fs) {
+		fs->refcount++;
+		/*DBG(FS, mnt_debug_h(fs, "ref=%d", fs->refcount));*/
+	}
+}
+
+/**
+ * mnt_unref_fs:
+ * @fs: fs pointer
+ *
+ * De-increments reference counter, on zero the @fs is automatically
+ * deallocated by mnt_free_fs().
+ */
+void mnt_unref_fs(struct libmnt_fs *fs)
+{
+	if (fs) {
+		fs->refcount--;
+		/*DBG(FS, mnt_debug_h(fs, "unref=%d", fs->refcount));*/
+		if (fs->refcount <= 0)
+			mnt_free_fs(fs);
+	}
 }
 
 static inline int update_str(char **dest, const char *src)
@@ -106,7 +153,7 @@ static inline int cpy_str_at_offset(void *new, const void *old, size_t offset)
 	char **n = (char **) (new + offset);
 
 	if (*n)
-		return 0;	/* already set, not overwrite */
+		return 0;	/* already set, don't overwrite */
 
 	return update_str(n, *o);
 }
@@ -117,7 +164,7 @@ static inline int cpy_str_at_offset(void *new, const void *old, size_t offset)
  * @src: source FS
  *
  * If @dest is NULL, then a new FS is allocated, if any @dest field is already
- * set then the field is NOT overwrited.
+ * set, then the field is NOT overwritten.
  *
  * This function does not copy userdata (se mnt_fs_set_userdata()). A new copy is
  * not linked with any existing mnt_tab.
@@ -250,7 +297,12 @@ err:
 void *mnt_fs_get_userdata(struct libmnt_fs *fs)
 {
 	assert(fs);
-	return fs ? fs->userdata : NULL;
+
+	if (!fs)
+		return NULL;
+
+	/*DBG(FS, mnt_debug_h(fs, "get userdata [%p]", fs->userdata));*/
+	return fs->userdata;
 }
 
 /**
@@ -267,6 +319,8 @@ int mnt_fs_set_userdata(struct libmnt_fs *fs, void *data)
 	assert(fs);
 	if (!fs)
 		return -EINVAL;
+
+	/*DBG(FS, mnt_debug_h(fs, "set userdata [%p]", fs->userdata));*/
 	fs->userdata = data;
 	return 0;
 }
@@ -310,7 +364,7 @@ const char *mnt_fs_get_source(struct libmnt_fs *fs)
 }
 
 /*
- * Used by parser ONLY (@source has to be freed on error)
+ * Used by the parser ONLY (@source has to be freed on error)
  */
 int __mnt_fs_set_source_ptr(struct libmnt_fs *fs, char *source)
 {
@@ -318,9 +372,12 @@ int __mnt_fs_set_source_ptr(struct libmnt_fs *fs, char *source)
 
 	assert(fs);
 
-	if (source && *source != '/' && strchr(source, '=')) {
-		if (blkid_parse_tag_string(source, &t, &v) != 0)
-			return -1;
+	if (source && blkid_parse_tag_string(source, &t, &v) == 0 &&
+	    !mnt_valid_tagname(t)) {
+		/* parsable but unknown tag -- ignore */
+		free(t);
+		free(v);
+		t = v = NULL;
 	}
 
 	if (fs->source != source)
@@ -370,7 +427,7 @@ int mnt_fs_set_source(struct libmnt_fs *fs, const char *source)
  * @fs: fs
  * @path: source path
  *
- * Compares @fs source path with @path. The tailing slash is ignored.
+ * Compares @fs source path with @path. The trailing slash is ignored.
  * See also mnt_fs_match_source().
  *
  * Returns: 1 if @fs source path equal to @path, otherwise 0.
@@ -399,7 +456,7 @@ int mnt_fs_streq_srcpath(struct libmnt_fs *fs, const char *path)
  * @fs: fs
  * @path: mount point
  *
- * Compares @fs target path with @path. The tailing slash is ignored.
+ * Compares @fs target path with @path. The trailing slash is ignored.
  * See also mnt_fs_match_target().
  *
  * Returns: 1 if @fs target path equal to @path, otherwise 0.
@@ -418,8 +475,8 @@ int mnt_fs_streq_target(struct libmnt_fs *fs, const char *path)
  *
  * "TAG" is NAME=VALUE (e.g. LABEL=foo)
  *
- * The TAG is the first column in the fstab file. The TAG or "srcpath" has to
- * be always set for all entries.
+ * The TAG is the first column in the fstab file. The TAG or "srcpath" always has
+ * to be set for all entries.
  *
  * See also mnt_fs_get_source().
  *
@@ -441,7 +498,7 @@ int mnt_fs_streq_target(struct libmnt_fs *fs, const char *path)
  *   </programlisting>
  * </informalexample>
  *
- * Returns: 0 on success or negative number in case that a TAG is not defined.
+ * Returns: 0 on success or negative number in case a TAG is not defined.
  */
 int mnt_fs_get_tag(struct libmnt_fs *fs, const char **name, const char **value)
 {
@@ -502,10 +559,10 @@ static int mnt_fs_get_flags(struct libmnt_fs *fs)
 /**
  * mnt_fs_get_propagation:
  * @fs: mountinfo entry
- * @flags: returns propagation MS_* flags as present in mountinfo file
+ * @flags: returns propagation MS_* flags as present in the mountinfo file
  *
- * Note that this function set @flags to zero if not found any propagation flag
- * in mountinfo file. The kernel default is MS_PRIVATE, this flag is not stored
+ * Note that this function sets @flags to zero if no propagation flags are found
+ * in the mountinfo file. The kernel default is MS_PRIVATE, this flag is not stored
  * in the mountinfo file.
  *
  * Returns: 0 on success or negative number in case of error.
@@ -594,7 +651,7 @@ const char *mnt_fs_get_fstype(struct libmnt_fs *fs)
 	return fs ? fs->fstype : NULL;
 }
 
-/* Used by struct libmnt_file parser only */
+/* Used by the struct libmnt_file parser only */
 int __mnt_fs_set_fstype_ptr(struct libmnt_fs *fs, char *fstype)
 {
 	assert(fs);
@@ -670,7 +727,7 @@ static char *merge_optstr(const char *vfs, const char *fs)
 	if (!strcmp(vfs, fs))
 		return strdup(vfs);		/* e.g. "aaa" and "aaa" */
 
-	/* leave space for leading "r[ow],", "," and trailing zero */
+	/* leave space for the leading "r[ow],", "," and the trailing zero */
 	sz = strlen(vfs) + strlen(fs) + 5;
 	res = malloc(sz);
 	if (!res)
@@ -701,7 +758,7 @@ static char *merge_optstr(const char *vfs, const char *fs)
  * mnt_fs_strdup_options:
  * @fs: fstab/mtab/mountinfo entry pointer
  *
- * Merges all mount options (VFS, FS and userspace) to the one options string
+ * Merges all mount options (VFS, FS and userspace) to one options string
  * and returns the result. This function does not modigy @fs.
  *
  * Returns: pointer to string (can be freed by free(3)) or NULL in case of error.
@@ -757,10 +814,10 @@ const char *mnt_fs_get_optional_fields(struct libmnt_fs *fs)
  * @fs: fstab/mtab/mountinfo entry pointer
  * @optstr: options string
  *
- * Splits @optstr to VFS, FS and userspace mount options and update relevat
+ * Splits @optstr to VFS, FS and userspace mount options and updates relevant
  * parts of @fs.
  *
- * Returns: 0 on success, or negative number icase of error.
+ * Returns: 0 on success, or negative number in case of error.
  */
 int mnt_fs_set_options(struct libmnt_fs *fs, const char *optstr)
 {
@@ -774,8 +831,12 @@ int mnt_fs_set_options(struct libmnt_fs *fs, const char *optstr)
 		if (rc)
 			return rc;
 		n = strdup(optstr);
-		if (!n)
+		if (!n) {
+			free(u);
+			free(v);
+			free(f);
 			return -ENOMEM;
+		}
 	}
 
 	free(fs->fs_optstr);
@@ -799,7 +860,7 @@ int mnt_fs_set_options(struct libmnt_fs *fs, const char *optstr)
  * Parses (splits) @optstr and appends results to VFS, FS and userspace lists
  * of options.
  *
- * If @optstr is NULL then @fs is not modified and 0 is returned.
+ * If @optstr is NULL, then @fs is not modified and 0 is returned.
  *
  * Returns: 0 on success or negative number in case of error.
  */
@@ -815,6 +876,9 @@ int mnt_fs_append_options(struct libmnt_fs *fs, const char *optstr)
 		return 0;
 
 	rc = mnt_split_optstr((char *) optstr, &u, &v, &f, 0, 0);
+	if (rc)
+		return rc;
+
 	if (!rc && v)
 		rc = mnt_optstr_append_option(&fs->vfs_optstr, v, NULL);
 	if (!rc && f)
@@ -836,10 +900,10 @@ int mnt_fs_append_options(struct libmnt_fs *fs, const char *optstr)
  * @fs: fstab/mtab/mountinfo entry
  * @optstr: mount options
  *
- * Parses (splits) @optstr and prepands results to VFS, FS and userspace lists
+ * Parses (splits) @optstr and prepends the results to VFS, FS and userspace lists
  * of options.
  *
- * If @optstr is NULL then @fs is not modified and 0 is returned.
+ * If @optstr is NULL, then @fs is not modified and 0 is returned.
  *
  * Returns: 0 on success or negative number in case of error.
  */
@@ -855,6 +919,9 @@ int mnt_fs_prepend_options(struct libmnt_fs *fs, const char *optstr)
 		return 0;
 
 	rc = mnt_split_optstr((char *) optstr, &u, &v, &f, 0, 0);
+	if (rc)
+		return rc;
+
 	if (!rc && v)
 		rc = mnt_optstr_prepend_option(&fs->vfs_optstr, v, NULL);
 	if (!rc && f)
@@ -925,10 +992,10 @@ const char *mnt_fs_get_attributes(struct libmnt_fs *fs)
  * @optstr: options string
  *
  * Sets mount attributes. The attributes are mount(2) and mount(8) independent
- * options, these options are not send to kernel and are not interpreted by
+ * options, these options are not sent to the kernel and are not interpreted by
  * libmount. The attributes are stored in /run/mount/utab only.
  *
- * The atrtributes are managed by libmount in userspace only. It's possible
+ * The attributes are managed by libmount in userspace only. It's possible
  * that information stored in userspace will not be available for libmount
  * after CLONE_FS unshare. Be careful, and don't use attributes if possible.
  *
@@ -1221,7 +1288,7 @@ dev_t mnt_fs_get_devno(struct libmnt_fs *fs)
  * mnt_fs_get_tid:
  * @fs: /proc/tid/mountinfo entry
  *
- * Returns: TID (task ID) for filesystems read from mountinfo file
+ * Returns: TID (task ID) for filesystems read from the mountinfo file
  */
 pid_t mnt_fs_get_tid(struct libmnt_fs *fs)
 {
@@ -1233,10 +1300,10 @@ pid_t mnt_fs_get_tid(struct libmnt_fs *fs)
  * mnt_fs_get_option:
  * @fs: fstab/mtab/mountinfo entry pointer
  * @name: option name
- * @value: returns pointer to the begin of the value (e.g. name=VALUE) or NULL
+ * @value: returns pointer to the beginning of the value (e.g. name=VALUE) or NULL
  * @valsz: returns size of options value or 0
  *
- * Returns: 0 on success, 1 when not found the @name or negative number in case of error.
+ * Returns: 0 on success, 1 when @name not found or negative number in case of error.
  */
 int mnt_fs_get_option(struct libmnt_fs *fs, const char *name,
 		char **value, size_t *valsz)
@@ -1259,10 +1326,10 @@ int mnt_fs_get_option(struct libmnt_fs *fs, const char *name,
  * mnt_fs_get_attribute:
  * @fs: fstab/mtab/mountinfo entry pointer
  * @name: option name
- * @value: returns pointer to the begin of the value (e.g. name=VALUE) or NULL
+ * @value: returns pointer to the beginning of the value (e.g. name=VALUE) or NULL
  * @valsz: returns size of options value or 0
  *
- * Returns: 0 on success, 1 when not found the @name or negative number in case of error.
+ * Returns: 0 on success, 1 when @name not found or negative number in case of error.
  */
 int mnt_fs_get_attribute(struct libmnt_fs *fs, const char *name,
 		char **value, size_t *valsz)
@@ -1278,6 +1345,67 @@ int mnt_fs_get_attribute(struct libmnt_fs *fs, const char *name,
 }
 
 /**
+ * mnt_fs_get_comment:
+ * @fs: fstab/mtab/mountinfo entry pointer
+ *
+ * Returns: 0 on success, 1 when not found the @name or negative number in case of error.
+ */
+const char *mnt_fs_get_comment(struct libmnt_fs *fs)
+{
+	assert(fs);
+	if (!fs)
+		return NULL;
+	return fs->comment;
+}
+
+/**
+ * mnt_fs_set_comment:
+ * @fs: fstab entry pointer
+ * @comm: comment string
+ *
+ * Note that the comment has to be terminated by '\n' (new line), otherwise
+ * the whole filesystem entry will be written as a comment to the tabfile (e.g.
+ * fstab).
+ *
+ * Returns: 0 on success or <0 in case of error.
+ */
+int mnt_fs_set_comment(struct libmnt_fs *fs, const char *comm)
+{
+	char *p = NULL;
+
+	assert(fs);
+	if (!fs)
+		return -EINVAL;
+	if (comm) {
+		p = strdup(comm);
+		if (!p)
+			return -ENOMEM;
+	}
+
+	free(fs->comment);
+	fs->comment = p;
+	return 0;
+}
+
+/**
+ * mnt_fs_append_comment:
+ * @fs: fstab entry pointer
+ * @comm: comment string
+ *
+ * See also mnt_fs_set_comment().
+ *
+ * Returns: 0 on success or <0 in case of error.
+ */
+int mnt_fs_append_comment(struct libmnt_fs *fs, const char *comm)
+{
+	assert(fs);
+	if (!fs)
+		return -EINVAL;
+
+	return append_string(&fs->comment, comm);
+}
+
+/**
  * mnt_fs_match_target:
  * @fs: filesystem
  * @target: mountpoint path
@@ -1291,7 +1419,7 @@ int mnt_fs_get_attribute(struct libmnt_fs *fs, const char *name,
  *
  * The 2nd and 3rd attempts are not performed when @cache is NULL.
  *
- * Returns: 1 if @fs target is equal to @target else 0.
+ * Returns: 1 if @fs target is equal to @target, else 0.
  */
 int mnt_fs_match_target(struct libmnt_fs *fs, const char *target,
 			struct libmnt_cache *cache)
@@ -1326,7 +1454,7 @@ int mnt_fs_match_target(struct libmnt_fs *fs, const char *target,
  * @source: tag or path (device or so) or NULL
  * @cache: tags/paths cache or NULL
  *
- * Possible are four attempts:
+ * Four attempts are possible:
  *	1) compare @source with @fs->source
  *	2) compare realpath(@source) with @fs->source
  *	3) compare realpath(@source) with realpath(@fs->source)
@@ -1335,7 +1463,7 @@ int mnt_fs_match_target(struct libmnt_fs *fs, const char *target,
  * The 2nd, 3rd and 4th attempts are not performed when @cache is NULL. The
  * 2nd and 3rd attempts are not performed if @fs->source is tag.
  *
- * Returns: 1 if @fs source is equal to @source else 0.
+ * Returns: 1 if @fs source is equal to @source, else 0.
  */
 int mnt_fs_match_source(struct libmnt_fs *fs, const char *source,
 			struct libmnt_cache *cache)
@@ -1379,14 +1507,14 @@ int mnt_fs_match_source(struct libmnt_fs *fs, const char *source,
 			return 1;
 	}
 	if (src || mnt_fs_get_tag(fs, &t, &v))
-		/* src path does not match and tag is not defined */
+		/* src path does not match and the tag is not defined */
 		return 0;
 
 	/* read @source's tags to the cache */
 	if (mnt_cache_read_tags(cache, cn) < 0) {
 		if (errno == EACCES) {
 			/* we don't have permissions to read TAGs from
-			 * @source, but can translate @fs tag to devname.
+			 * @source, but can translate the @fs tag to devname.
 			 *
 			 * (because libblkid uses udev symlinks and this is
 			 * accessible for non-root uses)
@@ -1398,7 +1526,7 @@ int mnt_fs_match_source(struct libmnt_fs *fs, const char *source,
 		return 0;
 	}
 
-	/* 4) has the @source a tag that matches with tag from @fs ? */
+	/* 4) has the @source a tag that matches with the tag from @fs ? */
 	if (mnt_cache_device_has_tag(cache, cn, t, v))
 		return 1;
 
@@ -1412,7 +1540,7 @@ int mnt_fs_match_source(struct libmnt_fs *fs, const char *source,
  *
  * For more details see mnt_match_fstype().
  *
- * Returns: 1 if @fs type is matching to @types else 0. The function returns
+ * Returns: 1 if @fs type is matching to @types, else 0. The function returns
  * 0 when types is NULL.
  */
 int mnt_fs_match_fstype(struct libmnt_fs *fs, const char *types)
@@ -1428,7 +1556,7 @@ int mnt_fs_match_fstype(struct libmnt_fs *fs, const char *types)
  *
  * For more details see mnt_match_options().
  *
- * Returns: 1 if @fs type is matching to @options else 0. The function returns
+ * Returns: 1 if @fs type is matching to @options, else 0. The function returns
  * 0 when types is NULL.
  */
 int mnt_fs_match_options(struct libmnt_fs *fs, const char *options)
@@ -1493,6 +1621,8 @@ int mnt_fs_print_debug(struct libmnt_fs *fs, FILE *file)
 						minor(mnt_fs_get_devno(fs)));
 	if (mnt_fs_get_tid(fs))
 		fprintf(file, "tid:    %d\n", mnt_fs_get_tid(fs));
+	if (mnt_fs_get_comment(fs))
+		fprintf(file, "comment: '%s'\n", mnt_fs_get_comment(fs));
 
 	return 0;
 }
@@ -1501,7 +1631,7 @@ int mnt_fs_print_debug(struct libmnt_fs *fs, FILE *file)
  * mnt_free_mntent:
  * @mnt: mount entry
  *
- * Deallocates "mntent.h" mount entry.
+ * Deallocates the "mntent.h" mount entry.
  */
 void mnt_free_mntent(struct mntent *mnt)
 {
@@ -1519,11 +1649,11 @@ void mnt_free_mntent(struct mntent *mnt)
  * @fs: filesystem
  * @mnt: mount description (as described in mntent.h)
  *
- * Copies information from @fs to struct mntent @mnt. If @mnt is already set
+ * Copies the information from @fs to struct mntent @mnt. If @mnt is already set,
  * then the struct mntent items are reallocated and updated. See also
  * mnt_free_mntent().
  *
- * Returns: 0 on success and negative number in case of error.
+ * Returns: 0 on success and a negative number in case of error.
  */
 int mnt_fs_to_mntent(struct libmnt_fs *fs, struct mntent **mnt)
 {
diff --git a/libmount/src/init.c b/libmount/src/init.c
index 4e5f489c4..a14637d75 100644
--- a/libmount/src/init.c
+++ b/libmount/src/init.c
@@ -8,7 +8,7 @@
 /**
  * SECTION: init
  * @title: Library initialization
- * @short_description: initialize debuging
+ * @short_description: initialize debugging
  */
 
 #include <stdarg.h>
@@ -19,13 +19,13 @@ int libmount_debug_mask;
 
 /**
  * mnt_init_debug:
- * @mask: debug mask (0xffff to enable full debuging)
+ * @mask: debug mask (0xffff to enable full debugging)
  *
- * If the @mask is not specified then this function reads
- * LIBMOUNT_DEBUG environment variable to get the mask.
+ * If the @mask is not specified, then this function reads
+ * the LIBMOUNT_DEBUG environment variable to get the mask.
  *
- * Already initialized debugging stuff cannot be changed. It does not
- * have effect to call this function twice.
+ * Already initialized debugging stuff cannot be changed. Calling
+ * this function twice has no effect.
  */
 void mnt_init_debug(int mask)
 {
@@ -40,7 +40,7 @@ void mnt_init_debug(int mask)
 
 	libmount_debug_mask |= MNT_DEBUG_INIT;
 
-	if (libmount_debug_mask && libmount_debug_mask != MNT_DEBUG_INIT) {
+	if (libmount_debug_mask != MNT_DEBUG_INIT) {
 		const char *ver = NULL;
 		const char **features = NULL, **p;
 
diff --git a/libmount/src/iter.c b/libmount/src/iter.c
index d7b8adbef..016f88e35 100644
--- a/libmount/src/iter.c
+++ b/libmount/src/iter.c
@@ -10,8 +10,8 @@
  * @title: Iterator
  * @short_description: unified iterator
  *
- * The iterator keeps direction and last position for access to the internal
- * library tables/lists.
+ * The iterator keeps the direction and the last position
+ * for access to the internal library tables/lists.
  */
 #include <stdio.h>
 #include <string.h>
@@ -38,7 +38,7 @@ struct libmnt_iter *mnt_new_iter(int direction)
  * mnt_free_iter:
  * @itr: iterator pointer
  *
- * Deallocates iterator.
+ * Deallocates the iterator.
  */
 void mnt_free_iter(struct libmnt_iter *itr)
 {
@@ -48,9 +48,9 @@ void mnt_free_iter(struct libmnt_iter *itr)
 /**
  * mnt_reset_iter:
  * @itr: iterator pointer
- * @direction: MNT_INTER_{FOR,BACK}WARD or -1 to keep the derection unchanged
+ * @direction: MNT_INTER_{FOR,BACK}WARD or -1 to keep the direction unchanged
  *
- * Resets iterator.
+ * Resets the iterator.
  */
 void mnt_reset_iter(struct libmnt_iter *itr, int direction)
 {
diff --git a/libmount/src/libmount.h.in b/libmount/src/libmount.h.in
index db479e186..8c8e739c9 100644
--- a/libmount/src/libmount.h.in
+++ b/libmount/src/libmount.h.in
@@ -41,7 +41,7 @@ struct libmnt_cache;
 /**
  * libmnt_lock:
  *
- * Stores information about locked file (e.g. /etc/mtab)
+ * Stores information about the locked file (e.g. /etc/mtab)
  */
 struct libmnt_lock;
 
@@ -197,6 +197,7 @@ extern char *mnt_mangle(const char *str)
 extern char *mnt_unmangle(const char *str)
 			__ul_attribute__((warn_unused_result));
 
+extern int mnt_tag_is_valid(const char *tag);
 extern int mnt_fstype_is_netfs(const char *type);
 extern int mnt_fstype_is_pseudofs(const char *type);
 
@@ -216,6 +217,9 @@ extern struct libmnt_cache *mnt_new_cache(void)
 			__ul_attribute__((warn_unused_result));
 extern void mnt_free_cache(struct libmnt_cache *cache);
 
+extern void mnt_ref_cache(struct libmnt_cache *cache);
+extern void mnt_unref_cache(struct libmnt_cache *cache);
+
 extern int mnt_cache_read_tags(struct libmnt_cache *cache, const char *devname);
 
 extern int mnt_cache_device_has_tag(struct libmnt_cache *cache,
@@ -302,6 +306,8 @@ extern int mnt_lock_block_signals(struct libmnt_lock *ml, int enable);
 extern struct libmnt_fs *mnt_new_fs(void)
 			__ul_attribute__((warn_unused_result));
 extern void mnt_free_fs(struct libmnt_fs *fs);
+extern void mnt_ref_fs(struct libmnt_fs *fs);
+extern void mnt_unref_fs(struct libmnt_fs *fs);
 
 extern void mnt_reset_fs(struct libmnt_fs *fs);
 extern struct libmnt_fs *mnt_copy_fs(struct libmnt_fs *dest,
@@ -369,6 +375,10 @@ extern off_t mnt_fs_get_size(struct libmnt_fs *fs);
 extern off_t mnt_fs_get_usedsize(struct libmnt_fs *fs);
 extern int mnt_fs_get_priority(struct libmnt_fs *fs);
 
+extern const char *mnt_fs_get_comment(struct libmnt_fs *fs);
+extern int mnt_fs_set_comment(struct libmnt_fs *fs, const char *comm);
+extern int mnt_fs_append_comment(struct libmnt_fs *fs, const char *comm);
+
 extern int mnt_fs_match_target(struct libmnt_fs *fs, const char *target,
 			       struct libmnt_cache *cache);
 extern int mnt_fs_match_source(struct libmnt_fs *fs, const char *source,
@@ -406,12 +416,31 @@ extern struct libmnt_table *mnt_new_table(void)
 			__ul_attribute__((warn_unused_result));
 extern void mnt_free_table(struct libmnt_table *tb);
 
+extern void mnt_ref_table(struct libmnt_table *tb);
+extern void mnt_unref_table(struct libmnt_table *tb);
+
 extern int mnt_reset_table(struct libmnt_table *tb);
 extern int mnt_table_get_nents(struct libmnt_table *tb);
+extern int mnt_table_is_empty(struct libmnt_table *tb);
+
+extern int mnt_table_set_userdata(struct libmnt_table *tb, void *data);
+extern void *mnt_table_get_userdata(struct libmnt_table *tb);
+
+extern void mnt_table_enable_comments(struct libmnt_table *tb, int enable);
+extern int mnt_table_with_comments(struct libmnt_table *tb);
+extern const char *mnt_table_get_intro_comment(struct libmnt_table *tb);
+extern int mnt_table_set_intro_comment(struct libmnt_table *tb, const char *comm);
+extern int mnt_table_append_intro_comment(struct libmnt_table *tb, const char *comm);
+extern int mnt_table_set_trailing_comment(struct libmnt_table *tb, const char *comm);
+extern const char *mnt_table_get_trailing_comment(struct libmnt_table *tb);
+extern int mnt_table_append_trailing_comment(struct libmnt_table *tb, const char *comm);
+
 extern int mnt_table_set_cache(struct libmnt_table *tb, struct libmnt_cache *mpc);
 extern struct libmnt_cache *mnt_table_get_cache(struct libmnt_table *tb);
 extern int mnt_table_add_fs(struct libmnt_table *tb, struct libmnt_fs *fs);
 extern int mnt_table_remove_fs(struct libmnt_table *tb, struct libmnt_fs *fs);
+extern int mnt_table_first_fs(struct libmnt_table *tb, struct libmnt_fs **fs);
+extern int mnt_table_last_fs(struct libmnt_table *tb, struct libmnt_fs **fs);
 extern int mnt_table_next_fs(struct libmnt_table *tb, struct libmnt_iter *itr,
 			     struct libmnt_fs **fs);
 extern int mnt_table_next_child_fs(struct libmnt_table *tb, struct libmnt_iter *itr,
@@ -449,6 +478,9 @@ extern struct libmnt_update *mnt_new_update(void)
 			__ul_attribute__((warn_unused_result));
 extern void mnt_free_update(struct libmnt_update *upd);
 
+extern int mnt_table_replace_file(struct libmnt_table *tb, const char *filename);
+extern int mnt_table_write_file(struct libmnt_table *tb, FILE *file);
+
 extern int mnt_update_is_ready(struct libmnt_update *upd);
 extern int mnt_update_set_fs(struct libmnt_update *upd, unsigned long mountflags,
 	                      const char *target, struct libmnt_fs *fs);
@@ -578,6 +610,10 @@ extern const char *mnt_context_get_source(struct libmnt_context *cxt);
 extern const char *mnt_context_get_target(struct libmnt_context *cxt);
 extern const char *mnt_context_get_fstype(struct libmnt_context *cxt);
 
+extern void *mnt_context_get_mtab_userdata(struct libmnt_context *cxt);
+extern void *mnt_context_get_fstab_userdata(struct libmnt_context *cxt);
+extern void *mnt_context_get_fs_userdata(struct libmnt_context *cxt);
+
 extern int mnt_context_set_options(struct libmnt_context *cxt, const char *optstr);
 extern int mnt_context_append_options(struct libmnt_context *cxt, const char *optstr);
 
@@ -715,10 +751,10 @@ extern int mnt_context_set_syscall_status(struct libmnt_context *cxt, int status
 #define MS_NODIRATIME   0x800	/* 2048: Don't update directory access times */
 #endif
 #ifndef MS_BIND
-#define	MS_BIND		0x1000	/* 4096: Mount existing tree also elsewhere */
+#define	MS_BIND		0x1000	/* 4096: Mount existing tree elsewhere as well */
 #endif
 #ifndef MS_MOVE
-#define MS_MOVE		0x2000	/* 8192: Atomically move tree */
+#define MS_MOVE		0x2000	/* 8192: Atomically move the tree */
 #endif
 #ifndef MS_REC
 #define MS_REC		0x4000	/* 16384: Recursive loopback */
diff --git a/libmount/src/libmount.sym b/libmount/src/libmount.sym
index 2ea483989..d1180d35b 100644
--- a/libmount/src/libmount.sym
+++ b/libmount/src/libmount.sym
@@ -256,3 +256,38 @@ global:
 	mnt_context_find_umount_fs;
 	mnt_table_find_mountpoint;
 } MOUNT_2.22;
+
+MOUNT_2.24 {
+global:
+	mnt_context_get_fstab_userdata;
+	mnt_context_get_fs_userdata;
+	mnt_context_get_mtab_userdata;
+	mnt_fs_append_comment;
+	mnt_fs_get_comment;
+	mnt_fs_set_comment;
+	mnt_ref_cache;
+	mnt_ref_fs;
+	mnt_ref_table;
+	mnt_table_append_intro_comment;
+	mnt_table_append_trailing_comment;
+	mnt_table_enable_comments;
+	mnt_table_first_fs;
+	mnt_table_get_intro_comment;
+	mnt_table_get_trailing_comment;
+	mnt_table_get_userdata;
+	mnt_table_is_empty;
+	mnt_table_last_fs;
+	mnt_table_replace_file;
+	mnt_table_set_intro_comment;
+	mnt_table_set_trailing_comment;
+	mnt_table_set_userdata;
+	mnt_table_with_comments;
+	mnt_table_write_file;
+	mnt_unref_cache;
+	mnt_unref_fs;
+	mnt_unref_table;
+} MOUNT_2.23;
+
+MOUNT_2.25 {
+	mnt_tag_is_valid;
+} MOUNT_2.24;
diff --git a/libmount/src/lock.c b/libmount/src/lock.c
index e73edf54b..d9b6f5939 100644
--- a/libmount/src/lock.c
+++ b/libmount/src/lock.c
@@ -10,9 +10,9 @@
  * @title: Locking
  * @short_description: locking methods for /etc/mtab or another libmount files
  *
- * The mtab lock is backwardly compatible with the standard linux /etc/mtab
+ * The mtab lock is backwards compatible with the standard linux /etc/mtab
  * locking.  Note, it's necessary to use the same locking schema in all
- * application that access the file.
+ * applications that access the file.
  */
 #include <sys/time.h>
 #include <time.h>
@@ -21,6 +21,8 @@
 #include <limits.h>
 #include <sys/file.h>
 
+#include "strutils.h"
+#include "closestream.h"
 #include "pathnames.h"
 #include "mountP.h"
 
@@ -246,7 +248,7 @@ static void mnt_lockalrm_handler(int sig __attribute__((__unused__)))
 
 /*
  * Waits for F_SETLKW, unfortunately we have to use SIGALRM here to interrupt
- * fcntl() to avoid never ending waiting.
+ * fcntl() to avoid neverending waiting.
  *
  * Returns: 0 on success, 1 on timeout, -errno on error.
  */
@@ -292,7 +294,7 @@ static int mnt_wait_mtab_lock(struct libmnt_lock *ml, struct flock *fl, time_t m
  * soon as the lock file is deleted by the first mount, and immediately
  * afterwards a third mount comes, creates a new /etc/mtab~, applies
  * flock to that, and also proceeds, so that the second and third mount
- * now both are scribbling in /etc/mtab.
+ * are now both scribbling in /etc/mtab.
  *
  * The new code uses a link() instead of a creat(), where we proceed
  * only if it was us that created the lock, and hence we always have
@@ -307,13 +309,13 @@ static int mnt_wait_mtab_lock(struct libmnt_lock *ml, struct flock *fl, time_t m
  * The original mount locking code has used sleep(1) between attempts and
  * maximal number of attempts has been 5.
  *
- * There was very small number of attempts and extremely long waiting (1s)
+ * There was a very small number of attempts and extremely long waiting (1s)
  * that is useless on machines with large number of mount processes.
  *
- * Now we wait few thousand microseconds between attempts and we have a global
- * time limit (30s) rather than limit for number of attempts. The advantage
+ * Now we wait for a few thousand microseconds between attempts and we have a global
+ * time limit (30s) rather than a limit for the number of attempts. The advantage
  * is that this method also counts time which we spend in fcntl(F_SETLKW) and
- * number of attempts is not restricted.
+ * the number of attempts is not restricted.
  * -- kzak@redhat.com [Mar-2007]
  *
  *
@@ -326,7 +328,7 @@ static int mnt_wait_mtab_lock(struct libmnt_lock *ml, struct flock *fl, time_t m
  * -- kzak@redhat.com [May-2009]
  */
 
-/* maximum seconds between first and last attempt */
+/* maximum seconds between the first and the last attempt */
 #define MOUNTLOCK_MAXTIME		30
 
 /* sleep time (in microseconds, max=999999) between attempts */
@@ -339,9 +341,9 @@ static void unlock_mtab(struct libmnt_lock *ml)
 
 	if (!ml->locked && ml->lockfile && ml->linkfile)
 	{
-		/* We have (probably) all files, but we don't own the lock,
+		/* We (probably) have all the files, but we don't own the lock,
 		 * Really? Check it! Maybe ml->locked wasn't set properly
-		 * because code was interrupted by signal. Paranoia? Yes.
+		 * because the code was interrupted by a signal. Paranoia? Yes.
 		 *
 		 * We own the lock when linkfile == lockfile.
 		 */
@@ -491,10 +493,10 @@ failed:
  * mnt_lock_file
  * @ml: pointer to struct libmnt_lock instance
  *
- * Creates lock file (e.g. /etc/mtab~). Note that this function may
+ * Creates a lock file (e.g. /etc/mtab~). Note that this function may
  * use alarm().
  *
- * Your application has to always call mnt_unlock_file() before exit.
+ * Your application always has to call mnt_unlock_file() before exit.
  *
  * Traditional mtab locking scheme:
  *
@@ -521,7 +523,7 @@ int mnt_lock_file(struct libmnt_lock *ml)
  * mnt_unlock_file:
  * @ml: lock struct
  *
- * Unlocks the file. The function could be called independently on the
+ * Unlocks the file. The function could be called independently of the
  * lock status (for example from exit(3)).
  */
 void mnt_unlock_file(struct libmnt_lock *ml)
@@ -573,7 +575,9 @@ void increment_data(const char *filename, int verbose, int loopno)
 		err(EXIT_FAILURE, "%d: failed to open: %s", getpid(), filename);
 
 	fprintf(f, "%ld", num);
-	fclose(f);
+
+	if (close_stream(f) != 0)
+		err(EXIT_FAILURE, "write failed: %s", filename);
 
 	if (verbose)
 		fprintf(stderr, "%d: %s: %ld --> %ld (loop=%d)\n", getpid(),
@@ -667,7 +671,7 @@ int test_lock(struct libmnt_test *ts, int argc, char *argv[])
 		mnt_free_lock(lock);
 		lock = NULL;
 
-		/* The mount command usually finish after mtab update. We
+		/* The mount command usually finishes after a mtab update. We
 		 * simulate this via short sleep -- it's also enough to make
 		 * concurrent processes happy.
 		 */
diff --git a/libmount/src/mountP.h b/libmount/src/mountP.h
index e064a6849..9362c0042 100644
--- a/libmount/src/mountP.h
+++ b/libmount/src/mountP.h
@@ -55,6 +55,13 @@
 # include <stdio.h>
 # include <stdarg.h>
 
+# define WARN_REFCOUNT(m, o, r) \
+			do { \
+				if ((MNT_DEBUG_ ## m) & libmount_debug_mask && r != 0) \
+					fprintf(stderr, "%d: libmount: %8s: [%p]: *** deallocates with refcount=%d\n", \
+							getpid(), # m, o, r); \
+			} while (0)
+
 # define ON_DBG(m, x)	do { \
 				if ((MNT_DEBUG_ ## m) & libmount_debug_mask) { \
 					x; \
@@ -100,6 +107,7 @@ mnt_debug_h(void *handler, const char *mesg, ...)
 }
 
 #else /* !CONFIG_LIBMOUNT_DEBUG */
+# define WARN_REFCOUNT(m,o,r)  do { ; } while (0)
 # define ON_DBG(m,x) do { ; } while (0)
 # define DBG(m,x) do { ; } while (0)
 # define DBG_FLUSH do { ; } while(0)
@@ -129,13 +137,11 @@ extern int mnt_run_test(struct libmnt_test *tests, int argc, char *argv[]);
 #endif
 
 /* utils.c */
-extern int endswith(const char *s, const char *sx)
-			__attribute__((nonnull));
-extern int startswith(const char *s, const char *sx)
-			__attribute__((nonnull));
-
 extern char *stripoff_last_component(char *path);
 
+extern int mnt_valid_tagname(const char *tagname);
+extern int append_string(char **a, const char *b);
+
 extern int is_file_empty(const char *name);
 
 extern int mkdir_p(const char *path, mode_t mode);
@@ -200,12 +206,13 @@ struct libmnt_iter {
 
 
 /*
- * This struct represents one entry in mtab/fstab/mountinfo file.
+ * This struct represents one entry in a mtab/fstab/mountinfo file.
  * (note that fstab[1] means the first column from fstab, and so on...)
  */
 struct libmnt_fs {
 	struct list_head ents;
 
+	int		refcount;	/* reference counter */
 	int		id;		/* mountinfo[1]: ID */
 	int		parent;		/* mountinfo[2]: parent */
 	dev_t		devno;		/* mountinfo[3]: st_dev */
@@ -240,6 +247,8 @@ struct libmnt_fs {
 	int		flags;		/* MNT_FS_* flags */
 	pid_t		tid;		/* /proc/<tid>/mountinfo otherwise zero */
 
+	char		*comment;	/* fstab comment */
+
 	void		*userdata;	/* library independent data */
 };
 
@@ -261,7 +270,11 @@ struct libmnt_fs {
  */
 struct libmnt_table {
 	int		fmt;		/* MNT_FMT_* file format */
-	int		nents;		/* number of valid entries */
+	int		nents;		/* number of entries */
+	int		refcount;	/* reference counter */
+	int		comms;		/* enable/disable comment parsing */
+	char		*comm_intro;	/* First comment in file */
+	char		*comm_tail;	/* Last comment in file */
 
 	struct libmnt_cache *cache;		/* canonicalized paths/tags cache */
 
@@ -273,6 +286,7 @@ struct libmnt_table {
 
 
 	struct list_head	ents;	/* list of entries (libmnt_fs) */
+	void		*userdata;
 };
 
 extern struct libmnt_table *__mnt_new_table_from_file(const char *filename, int fmt);
@@ -373,17 +387,13 @@ struct libmnt_context
 #define MNT_FL_FORK		(1 << 12)
 #define MNT_FL_NOSWAPMATCH	(1 << 13)
 
-#define MNT_FL_EXTERN_FS	(1 << 15)	/* cxt->fs is not private */
-#define MNT_FL_EXTERN_FSTAB	(1 << 16)	/* cxt->fstab is not private */
-#define MNT_FL_EXTERN_CACHE	(1 << 17)	/* cxt->cache is not private */
-
 #define MNT_FL_MOUNTDATA	(1 << 20)
 #define MNT_FL_TAB_APPLIED	(1 << 21)	/* mtab/fstab merged to cxt->fs */
 #define MNT_FL_MOUNTFLAGS_MERGED (1 << 22)	/* MS_* flags was read from optstr */
 #define MNT_FL_SAVED_USER	(1 << 23)
 #define MNT_FL_PREPARED		(1 << 24)
 #define MNT_FL_HELPER		(1 << 25)	/* [u]mount.<type> */
-#define MNT_FL_LOOPDEV_READY	(1 << 26)	/* /dev/loop<N> initialized by library */
+#define MNT_FL_LOOPDEV_READY	(1 << 26)	/* /dev/loop<N> initialized by the library */
 #define MNT_FL_MOUNTOPTS_FIXED  (1 << 27)
 
 /* default flags */
diff --git a/libmount/src/optmap.c b/libmount/src/optmap.c
index 7c0a23508..5b25b8f29 100644
--- a/libmount/src/optmap.c
+++ b/libmount/src/optmap.c
@@ -58,6 +58,7 @@
  * mount/mount.h.
  */
 #include "mountP.h"
+#include "strutils.h"
 
 /*
  * fs-independent mount flags (built-in MNT_LINUX_MAP)
@@ -78,7 +79,7 @@ static const struct libmnt_optmap linux_flags_map[] =
 
    { "dirsync",  MS_DIRSYNC },                /* synchronous directory modifications */
    { "remount",  MS_REMOUNT, MNT_NOMTAB },    /* alter flags of mounted FS */
-   { "bind",     MS_BIND },                   /* Remount part of tree elsewhere */
+   { "bind",     MS_BIND },                   /* Remount part of the tree elsewhere */
    { "rbind",    MS_BIND | MS_REC },          /* Idem, plus mounted subtrees */
 #ifdef MS_NOSUB
    { "sub",      MS_NOSUB, MNT_INVERT },      /* allow submounts */
@@ -133,7 +134,7 @@ static const struct libmnt_optmap userspace_opts_map[] =
    { "defaults", 0, 0 },               /* default options */
 
    { "auto",    MNT_MS_NOAUTO, MNT_NOHLPS | MNT_INVERT | MNT_NOMTAB },  /* Can be mounted using -a */
-   { "noauto",  MNT_MS_NOAUTO, MNT_NOHLPS | MNT_NOMTAB },  /* Can  only be mounted explicitly */
+   { "noauto",  MNT_MS_NOAUTO, MNT_NOHLPS | MNT_NOMTAB },  /* Can only be mounted explicitly */
 
    { "user[=]", MNT_MS_USER },                             /* Allow ordinary user to mount (mtab) */
    { "nouser",  MNT_MS_USER, MNT_INVERT | MNT_NOMTAB },    /* Forbid ordinary user to mount */
@@ -148,7 +149,7 @@ static const struct libmnt_optmap userspace_opts_map[] =
    { "nogroup", MNT_MS_GROUP, MNT_INVERT | MNT_NOMTAB },   /* Device group has no special privs */
 
    /*
-    * Note that traditional init scripts assume _netdev option in /etc/mtab to
+    * Note that traditional init scripts assume the _netdev option in /etc/mtab to
     * umount network block devices on shutdown.
     */
    { "_netdev", MNT_MS_NETDEV },                           /* Device requires network */
@@ -194,7 +195,7 @@ const struct libmnt_optmap *mnt_get_builtin_optmap(int id)
 }
 
 /*
- * Lookups for the @name in @maps and returns a map and in @mapent
+ * Looks up the @name in @maps and returns a map and in @mapent
  * returns the map entry
  */
 const struct libmnt_optmap *mnt_optmap_get_entry(
diff --git a/libmount/src/optstr.c b/libmount/src/optstr.c
index 5e9e70807..2cd55685e 100644
--- a/libmount/src/optstr.c
+++ b/libmount/src/optstr.c
@@ -8,10 +8,10 @@
 /**
  * SECTION: optstr
  * @title: Options string
- * @short_description: low-level API for work with mount options
+ * @short_description: low-level API for working with mount options
  *
- * This is simple and low-level API to work with mount options that are stored
- * in string.
+ * This is a simple and low-level API to working with mount options that are stored
+ * in a string.
  */
 #include <ctype.h>
 
@@ -39,8 +39,8 @@ struct libmnt_optloc {
 		(e && (e)->name && !strchr((e)->name, '=') && !((e)->mask & MNT_PREFIX))
 
 /*
- * Parses the first option from @optstr. The @optstr pointer is set to begin of
- * the next option.
+ * Parses the first option from @optstr. The @optstr pointer is set to the beginning
+ * of the next option.
  *
  * Returns -EINVAL on parse error, 1 at the end of optstr and 0 on success.
  */
@@ -72,12 +72,12 @@ static int mnt_optstr_parse_next(char **optstr,	 char **name, size_t *namesz,
 
 	for (p = optstr0; p && *p; p++) {
 		if (!start)
-			start = p;		/* begin of the option item */
+			start = p;		/* beginning of the option item */
 		if (*p == '"')
 			open_quote ^= 1;	/* reverse the status */
 		if (open_quote)
 			continue;		/* still in quoted block */
-		if (!sep && *p == '=')
+		if (!sep && p > start && *p == '=')
 			sep = p;		/* name and value separator */
 		if (*p == ',')
 			stop = p;		/* terminate the option item */
@@ -111,7 +111,7 @@ error:
 }
 
 /*
- * Locates the first option that match with @name. The @end is set to
+ * Locates the first option that matches @name. The @end is set to the
  * char behind the option (it means ',' or \0).
  *
  * Returns negative number on parse error, 1 when not found and 0 on success.
@@ -150,11 +150,11 @@ static int mnt_optstr_locate_option(char *optstr, const char *name,
 
 /**
  * mnt_optstr_next_option:
- * @optstr: option string, returns position to next option
- * @name: returns option name
- * @namesz: returns option name length
- * @value: returns option value or NULL
- * @valuesz: returns option value length or zero
+ * @optstr: option string, returns the position of the next option
+ * @name: returns the option name
+ * @namesz: returns the option name length
+ * @value: returns the option value or NULL
+ * @valuesz: returns the option value length or zero
  *
  * Parses the first option in @optstr.
  *
@@ -214,11 +214,11 @@ static int __mnt_optstr_append_option(char **optstr,
 
 /**
  * mnt_optstr_append_option:
- * @optstr: option string or NULL, returns reallocated string
+ * @optstr: option string or NULL, returns a reallocated string
  * @name: value name
  * @value: value
  *
- * Returns: 0 on success or -1 in case of error. After error the @optstr should
+ * Returns: 0 on success or -1 in case of error. After an error the @optstr should
  *          be unmodified.
  */
 int mnt_optstr_append_option(char **optstr, const char *name, const char *value)
@@ -238,11 +238,11 @@ int mnt_optstr_append_option(char **optstr, const char *name, const char *value)
 
 /**
  * mnt_optstr_prepend_option:
- * @optstr: option string or NULL, returns reallocated string
+ * @optstr: option string or NULL, returns a reallocated string
  * @name: value name
  * @value: value
  *
- * Returns: 0 on success or -1 in case of error. After error the @optstr should
+ * Returns: 0 on success or -1 in case of error. After an error the @optstr should
  *          be unmodified.
  */
 int mnt_optstr_prepend_option(char **optstr, const char *name, const char *value)
@@ -275,9 +275,9 @@ int mnt_optstr_prepend_option(char **optstr, const char *name, const char *value
 
 /**
  * mnt_optstr_get_option:
- * @optstr: string with comma separated list of options
+ * @optstr: string with a comma separated list of options
  * @name: requested option name
- * @value: returns pointer to the begin of the value (e.g. name=VALUE) or NULL
+ * @value: returns a pointer to the beginning of the value (e.g. name=VALUE) or NULL
  * @valsz: returns size of the value or 0
  *
  * Returns: 0 on success, 1 when not found the @name or negative number in case
@@ -306,7 +306,7 @@ int mnt_optstr_get_option(const char *optstr, const char *name,
 
 /**
  * mnt_optstr_deduplicate_option:
- * @optstr: string with comma separated list of options
+ * @optstr: string with a comma separated list of options
  * @name: requested option name
  *
  * Removes all instances of @name except the last one.
@@ -331,12 +331,12 @@ int mnt_optstr_deduplicate_option(char **optstr, const char *name)
 		rc = mnt_optstr_locate_option(opt, name, &ol);
 		if (!rc) {
 			if (begin) {
-				/* remove previous instance */
+				/* remove the previous instance */
 				size_t shift = strlen(*optstr);
 
 				mnt_optstr_remove_option_at(optstr, begin, end);
 
-				/* now all offset are not valied anymore - recount */
+				/* now all the offsets are not valid anymore - recount */
 				shift -= strlen(*optstr);
 				ol.begin -= shift;
 				ol.end -= shift;
@@ -351,7 +351,7 @@ int mnt_optstr_deduplicate_option(char **optstr, const char *name)
 }
 
 /*
- * The result never starts or ends with comma or contains two commas
+ * The result never starts or ends with a comma or contains two commas
  *    (e.g. ",aaa,bbb" or "aaa,,bbb" or "aaa,")
  */
 int mnt_optstr_remove_option_at(char **optstr, char *begin, char *end)
@@ -387,14 +387,14 @@ insert_value(char **str, char *pos, const char *substr, char **next)
 	/* is it necessary to prepend '=' before the substring ? */
 	sep = !(pos > *str && *(pos - 1) == '=');
 
-	/* save an offset of the place where we need add substr */
+	/* save an offset of the place where we need to add substr */
 	posoff = pos - *str;
 
 	p = realloc(*str, strsz + sep + subsz + 1);
 	if (!p)
 		return -ENOMEM;
 
-	/* zeroize new allocated memory -- valgind loves is... */
+	/* zeroize the newly allocated memory -- valgrind loves us... */
 	memset(p + strsz, 0, sep + subsz + 1);
 
 	/* set pointers to the reallocated string */
@@ -402,7 +402,7 @@ insert_value(char **str, char *pos, const char *substr, char **next)
 	pos = p + posoff;
 
 	if (possz)
-		/* create a room for new substring */
+		/* create a room for the new substring */
 		memmove(pos + subsz + sep, pos, possz + 1);
 	if (sep)
 		*pos++ = '=';
@@ -420,11 +420,11 @@ insert_value(char **str, char *pos, const char *substr, char **next)
 
 /**
  * mnt_optstr_set_option:
- * @optstr: string with comma separated list of options
+ * @optstr: string with a comma separated list of options
  * @name: requested option
  * @value: new value or NULL
  *
- * Set or unset option @value.
+ * Set or unset the option @value.
  *
  * Returns: 0 on success, 1 when not found the @name or negative number in case
  * of error.
@@ -473,7 +473,7 @@ int mnt_optstr_set_option(char **optstr, const char *name, const char *value)
 
 /**
  * mnt_optstr_remove_option:
- * @optstr: string with comma separated list of options
+ * @optstr: string with a comma separated list of options
  * @name: requested option name
  *
  * Returns: 0 on success, 1 when not found the @name or negative number in case
@@ -510,13 +510,13 @@ int mnt_optstr_remove_option(char **optstr, const char *name)
  *
  *	mnt_split_optstr(optstr, &u, NULL, NULL, MNT_NOMTAB, 0);
  *
- * returns all userspace options, the options that does not belong to
+ * returns all userspace options, the options that do not belong to
  * mtab are ignored.
  *
  * Note that FS options are all options that are undefined in MNT_USERSPACE_MAP
  * or MNT_LINUX_MAP.
  *
- * Returns: 0 on success, or negative number in case of error.
+ * Returns: 0 on success, or a negative number in case of error.
  */
 int mnt_split_optstr(const char *optstr, char **user, char **vfs,
 		     char **fs, int ignore_user, int ignore_vfs)
@@ -540,7 +540,7 @@ int mnt_split_optstr(const char *optstr, char **user, char **vfs,
 	if (user)
 		*user = NULL;
 
-	while(!mnt_optstr_next_option(&str, &name, &namesz, &val, &valsz)) {
+	while (!mnt_optstr_next_option(&str, &name, &namesz, &val, &valsz)) {
 		int rc = 0;
 		const struct libmnt_optmap *ent = NULL;
 		const struct libmnt_optmap *m =
@@ -567,12 +567,18 @@ int mnt_split_optstr(const char *optstr, char **user, char **vfs,
 			rc = __mnt_optstr_append_option(fs, name, namesz,
 								val, valsz);
 		if (rc) {
-			if (vfs)
+			if (vfs) {
 				free(*vfs);
-			if (fs)
+				*vfs = NULL;
+			}
+			if (fs) {
 				free(*fs);
-			if (user)
+				*fs = NULL;
+			}
+			if (user) {
 				free(*user);
+				*user = NULL;
+			}
 			return rc;
 		}
 	}
@@ -582,21 +588,21 @@ int mnt_split_optstr(const char *optstr, char **user, char **vfs,
 
 /**
  * mnt_optstr_get_options
- * @optstr: string with comma separated list of options
+ * @optstr: string with a comma separated list of options
  * @subset: returns newly allocated string with options
  * @map: options map
  * @ignore: mask of the options that should be ignored
  *
- * Extracts options from @optstr that belongs to the @map, for example:
+ * Extracts options from @optstr that belong to the @map, for example:
  *
  *	 mnt_optstr_get_options(optstr, &p,
  *			mnt_get_builtin_optmap(MNT_LINUX_MAP),
  *			MNT_NOMTAB);
  *
- * the 'p' returns all VFS options, the options that does not belong to mtab
+ * the 'p' returns all VFS options, the options that do not belong to mtab
  * are ignored.
  *
- * Returns: 0 on success, or negative number in case of error.
+ * Returns: 0 on success, or a negative number in case of error.
  */
 int mnt_optstr_get_options(const char *optstr, char **subset,
 			    const struct libmnt_optmap *map, int ignore)
@@ -652,8 +658,8 @@ int mnt_optstr_get_options(const char *optstr, char **subset,
  *
  *	"bind,noexec,foo,bar" --returns->   MS_BIND|MS_NOEXEC
  *
- * Note that @flags are not zeroized by this function! This function set/unset
- * bites in the @flags only.
+ * Note that @flags are not zeroized by this function! This function sets/unsets
+ * bits in the @flags only.
  *
  * Returns: 0 on success or negative number in case of error
  */
@@ -747,8 +753,8 @@ int mnt_optstr_apply_flags(char **optstr, unsigned long flags,
 	fl = flags;
 
 	/*
-	 * There is a convetion that 'rw/ro' flags is always at the begin of
-	 * the string (athough the 'rw' is unnecessary).
+	 * There is a convention that 'rw/ro' flags are always at the beginning of
+	 * the string (although the 'rw' is unnecessary).
 	 */
 	if (map == mnt_get_builtin_optmap(MNT_LINUX_MAP)) {
 		const char *o = (fl & MS_RDONLY) ? "ro" : "rw";
@@ -774,7 +780,7 @@ int mnt_optstr_apply_flags(char **optstr, unsigned long flags,
 	if (next && *next) {
 		/*
 		 * scan @optstr and remove options that are missing in
-		 * the @flags
+		 * @flags
 		 */
 		while(!mnt_optstr_next_option(&next, &name, &namesz,
 							&val, &valsz)) {
@@ -856,7 +862,7 @@ err:
  * modify @optstr and returns zero if libmount is compiled without SELinux
  * support.
  *
- * Returns: 0 on success, negative number in case of error.
+ * Returns: 0 on success, a negative number in case of error.
  */
 #ifndef HAVE_LIBSELINUX
 int mnt_optstr_fix_secontext(char **optstr __attribute__ ((__unused__)),
@@ -910,7 +916,7 @@ int mnt_optstr_fix_secontext(char **optstr,
 		return -EINVAL;
 
 
-	/* create quoted string from the raw context */
+	/* create a quoted string from the raw context */
 	sz = strlen((char *) raw);
 	if (!sz)
 		return -EINVAL;
@@ -947,8 +953,8 @@ static int set_uint_value(char **optstr, unsigned int num,
 }
 
 /*
- * @optstr: string with comma separated list of options
- * @value: pointer to the begin of the uid value
+ * @optstr: string with a comma separated list of options
+ * @value: pointer to the beginning of the uid value
  * @valsz: size of the value
  * @next: returns pointer to the next option (optional argument)
 
@@ -958,7 +964,7 @@ static int set_uint_value(char **optstr, unsigned int num,
  *	if (!mnt_optstr_get_option(optstr, "uid", &val, &valsz))
  *		mnt_optstr_fix_uid(&optstr, val, valsz, NULL);
  *
- * Returns: 0 on success, negative number in case of error.
+ * Returns: 0 on success, a negative number in case of error.
  */
 int mnt_optstr_fix_uid(char **optstr, char *value, size_t valsz, char **next)
 {
@@ -998,14 +1004,14 @@ int mnt_optstr_fix_uid(char **optstr, char *value, size_t valsz, char **next)
 }
 
 /*
- * @optstr: string with comma separated list of options
- * @value: pointer to the begin of the uid value
+ * @optstr: string with a comma separated list of options
+ * @value: pointer to the beginning of the uid value
  * @valsz: size of the value
  * @next: returns pointer to the next option (optional argument)
 
  * Translates "groupname" or "usergid" to the real GID.
  *
- * Returns: 0 on success, negative number in case of error.
+ * Returns: 0 on success, a negative number in case of error.
  */
 int mnt_optstr_fix_gid(char **optstr, char *value, size_t valsz, char **next)
 {
@@ -1328,7 +1334,7 @@ int main(int argc, char *argv[])
 {
 	struct libmnt_test tss[] = {
 		{ "--append", test_append, "<optstr> <name> [<value>]  append value to optstr" },
-		{ "--prepend",test_prepend,"<optstr> <name> [<value>]  prepend  value to optstr" },
+		{ "--prepend",test_prepend,"<optstr> <name> [<value>]  prepend value to optstr" },
 		{ "--set",    test_set,    "<optstr> <name> [<value>]  (un)set value" },
 		{ "--get",    test_get,    "<optstr> <name>            search name in optstr" },
 		{ "--remove", test_remove, "<optstr> <name>            remove name in optstr" },
diff --git a/libmount/src/tab.c b/libmount/src/tab.c
index 11a297814..b023504ad 100644
--- a/libmount/src/tab.c
+++ b/libmount/src/tab.c
@@ -11,9 +11,9 @@
  * @short_description: container for entries from fstab, mtab or mountinfo
  *
  * Note that mnt_table_find_* functions are mount(8) compatible. These functions
- * try to find an entry in more iterations where the first attempt is always
+ * try to find an entry in more iterations, where the first attempt is always
  * based on comparison with unmodified (non-canonicalized or un-evaluated)
- * paths or tags. For example fstab with two entries:
+ * paths or tags. For example a fstab with two entries:
  * <informalexample>
  *   <programlisting>
  *	LABEL=foo	/foo	auto   rw
@@ -39,7 +39,7 @@
  *	mnt_table_find_source(tb, "UUID=anyuuid", &fs);
  *  </programlisting>
  * </informalexample>
- * will returns the first entry (if UUID matches with the device).
+ * will return the first entry (if UUID matches with the device).
  */
 #include <blkid.h>
 
@@ -47,6 +47,8 @@
 #include "strutils.h"
 #include "loopdev.h"
 
+static int is_mountinfo(struct libmnt_table *tb);
+
 /**
  * mnt_new_table:
  *
@@ -66,7 +68,7 @@ struct libmnt_table *mnt_new_table(void)
 		return NULL;
 
 	DBG(TAB, mnt_debug_h(tb, "alloc"));
-
+	tb->refcount = 1;
 	INIT_LIST_HEAD(&tb->ents);
 	return tb;
 }
@@ -75,7 +77,8 @@ struct libmnt_table *mnt_new_table(void)
  * mnt_reset_table:
  * @tb: tab pointer
  *
- * Dealocates all entries (filesystems) from the table
+ * Removes all entries (filesystems) from the table. The filesystems with zero
+ * reference count will be deallocated.
  *
  * Returns: 0 on success or negative number in case of error.
  */
@@ -89,7 +92,7 @@ int mnt_reset_table(struct libmnt_table *tb)
 	while (!list_empty(&tb->ents)) {
 		struct libmnt_fs *fs = list_entry(tb->ents.next,
 				                  struct libmnt_fs, ents);
-		mnt_free_fs(fs);
+		mnt_table_remove_fs(tb, fs);
 	}
 
 	tb->nents = 0;
@@ -97,10 +100,46 @@ int mnt_reset_table(struct libmnt_table *tb)
 }
 
 /**
+ * mnt_ref_table:
+ * @tb: table pointer
+ *
+ * Increments reference counter.
+ */
+void mnt_ref_table(struct libmnt_table *tb)
+{
+	if (tb) {
+		tb->refcount++;
+		/*DBG(FS, mnt_debug_h(tb, "ref=%d", tb->refcount));*/
+	}
+}
+
+/**
+ * mnt_unref_table:
+ * @tb: table pointer
+ *
+ * De-increments reference counter, on zero the @tb is automatically
+ * deallocated by mnt_free_table().
+ */
+void mnt_unref_table(struct libmnt_table *tb)
+{
+	if (tb) {
+		tb->refcount--;
+		/*DBG(FS, mnt_debug_h(tb, "unref=%d", tb->refcount));*/
+		if (tb->refcount <= 0)
+			mnt_free_table(tb);
+	}
+}
+
+
+/**
  * mnt_free_table:
  * @tb: tab pointer
  *
- * Deallocates tab struct and all entries.
+ * Deallocates the table. This function does not care about reference count. Don't
+ * use this function directly -- it's better to use use mnt_unref_table().
+ *
+ * The table entries (filesystems) are unrefrenced by mnt_reset_table() and
+ * cache by mnt_unref_cache().
  */
 void mnt_free_table(struct libmnt_table *tb)
 {
@@ -109,7 +148,12 @@ void mnt_free_table(struct libmnt_table *tb)
 
 	mnt_reset_table(tb);
 
+	WARN_REFCOUNT(TAB, tb, tb->refcount);
 	DBG(TAB, mnt_debug_h(tb, "free"));
+
+	mnt_unref_cache(tb->cache);
+	free(tb->comm_intro);
+	free(tb->comm_tail);
 	free(tb);
 }
 
@@ -117,26 +161,228 @@ void mnt_free_table(struct libmnt_table *tb)
  * mnt_table_get_nents:
  * @tb: pointer to tab
  *
- * Returns: number of valid entries in tab.
+ * Returns: number of entries in table.
  */
 int mnt_table_get_nents(struct libmnt_table *tb)
 {
-	assert(tb);
 	return tb ? tb->nents : 0;
 }
 
 /**
+ * mnt_table_is_empty:
+ * @tb: pointer to tab
+ *
+ * Returns: 1 if the table is without filesystems, or 0.
+ */
+int mnt_table_is_empty(struct libmnt_table *tb)
+{
+	assert(tb);
+	return tb == NULL || list_empty(&tb->ents) ? 1 : 0;
+}
+
+/**
+ * mnt_table_set_userdata:
+ * @tb: pointer to tab
+ * @data: pointer to user data
+ *
+ * Sets pointer to the private user data.
+ *
+ * Returns: 0 on success or negative number in case of error.
+ */
+int mnt_table_set_userdata(struct libmnt_table *tb, void *data)
+{
+	assert(tb);
+	if (!tb)
+		return -EINVAL;
+
+	tb->userdata = data;
+	return 0;
+}
+
+/**
+ * mnt_table_get_userdata:
+ * @tb: pointer to tab
+ *
+ * Returns: pointer to user's data.
+ */
+void *mnt_table_get_userdata(struct libmnt_table *tb)
+{
+	assert(tb);
+	return tb ? tb->userdata : NULL;
+}
+
+/**
+ * mnt_table_enable_comments:
+ * @tb: pointer to tab
+ * @enable: TRUE or FALSE
+ *
+ * Enables parsing of comments.
+ *
+ * The initial (intro) file comment is accessible by
+ * mnt_table_get_intro_comment(). The intro and the comment of the first fstab
+ * entry has to be separated by blank line.  The filesystem comments are
+ * accessible by mnt_fs_get_comment(). The trailing fstab comment is accessible
+ * by mnt_table_get_trailing_comment().
+ *
+ * <informalexample>
+ *  <programlisting>
+ *	#
+ *	# Intro comment
+ *	#
+ *
+ *	# this comments belongs to the first fs
+ *	LABEL=foo /mnt/foo auto defaults 1 2
+ *	# this comments belongs to the second fs
+ *	LABEL=bar /mnt/bar auto defaults 1 2 
+ *	# tailing comment
+ *  </programlisting>
+ * </informalexample>
+ */
+void mnt_table_enable_comments(struct libmnt_table *tb, int enable)
+{
+	assert(tb);
+	if (tb)
+		tb->comms = enable;
+}
+
+/**
+ * mnt_table_with_comments:
+ * @tb: pointer to table
+ *
+ * Returns: 1 if comments parsing is enabled, or 0.
+ */
+int mnt_table_with_comments(struct libmnt_table *tb)
+{
+	assert(tb);
+	return tb ? tb->comms : 0;
+}
+
+/**
+ * mnt_table_get_intro_comment:
+ * @tb: pointer to tab
+ *
+ * Returns: initial comment in tb
+ */
+const char *mnt_table_get_intro_comment(struct libmnt_table *tb)
+{
+	assert(tb);
+	return tb ? tb->comm_intro : NULL;
+}
+
+/**
+ * mnt_table_set_into_comment:
+ * @tb: pointer to tab
+ * @comm: comment or NULL
+ *
+ * Sets the initial comment in tb.
+ *
+ * Returns: 0 on success or negative number in case of error.
+ */
+int mnt_table_set_intro_comment(struct libmnt_table *tb, const char *comm)
+{
+	char *p = NULL;
+
+	assert(tb);
+	if (!tb)
+		return -EINVAL;
+	if (comm) {
+		p = strdup(comm);
+		if (!p)
+			return -ENOMEM;
+	}
+	free(tb->comm_intro);
+	tb->comm_intro = p;
+	return 0;
+}
+
+/**
+ * mnt_table_append_into_comment:
+ * @tb: pointer to tab
+ * @comm: comment of NULL
+ *
+ * Appends the initial comment in tb.
+ *
+ * Returns: 0 on success or negative number in case of error.
+ */
+int mnt_table_append_intro_comment(struct libmnt_table *tb, const char *comm)
+{
+	assert(tb);
+	if (!tb)
+		return -EINVAL;
+	return append_string(&tb->comm_intro, comm);
+}
+
+/**
+ * mnt_table_get_trailing_comment:
+ * @tb: pointer to tab
+ *
+ * Returns: table trailing comment
+ */
+const char *mnt_table_get_trailing_comment(struct libmnt_table *tb)
+{
+	assert(tb);
+	return tb ? tb->comm_tail : NULL;
+}
+
+/**
+ * mnt_table_set_trailing_comment
+ * @tb: pointer to tab
+ * @comm: comment string
+ *
+ * Sets the trailing comment in table.
+ *
+ * Returns: 0 on success or negative number in case of error.
+ */
+int mnt_table_set_trailing_comment(struct libmnt_table *tb, const char *comm)
+{
+	char *p = NULL;
+
+	assert(tb);
+	if (!tb)
+		return -EINVAL;
+	if (comm) {
+		p = strdup(comm);
+		if (!p)
+			return -ENOMEM;
+	}
+	free(tb->comm_tail);
+	tb->comm_tail = p;
+	return 0;
+}
+
+/**
+ * mnt_table_append_trailing_comment:
+ * @tb: pointer to tab
+ * @comm: comment of NULL
+ *
+ * Appends to the trailing table comment.
+ *
+ * Returns: 0 on success or negative number in case of error.
+ */
+int mnt_table_append_trailing_comment(struct libmnt_table *tb, const char *comm)
+{
+	assert(tb);
+	if (!tb)
+		return -EINVAL;
+	return append_string(&tb->comm_tail, comm);
+}
+
+/**
  * mnt_table_set_cache:
  * @tb: pointer to tab
  * @mpc: pointer to struct libmnt_cache instance
  *
- * Setups a cache for canonicalized paths and evaluated tags (LABEL/UUID). The
+ * Sets up a cache for canonicalized paths and evaluated tags (LABEL/UUID). The
  * cache is recommended for mnt_table_find_*() functions.
  *
  * The cache could be shared between more tabs. Be careful when you share the
  * same cache between more threads -- currently the cache does not provide any
  * locking method.
  *
+ * This function increments cache refrence counter. It's recomented to use
+ * mnt_unref_cache() after mnt_table_set_cache() if you want to keep the cache
+ * referenced by @tb only.
+ *
  * See also mnt_new_cache().
  *
  * Returns: 0 on success or negative number in case of error.
@@ -146,6 +392,9 @@ int mnt_table_set_cache(struct libmnt_table *tb, struct libmnt_cache *mpc)
 	assert(tb);
 	if (!tb)
 		return -EINVAL;
+
+	mnt_ref_cache(mpc);			/* new */
+	mnt_unref_cache(tb->cache);		/* old */
 	tb->cache = mpc;
 	return 0;
 }
@@ -167,7 +416,9 @@ struct libmnt_cache *mnt_table_get_cache(struct libmnt_table *tb)
  * @tb: tab pointer
  * @fs: new entry
  *
- * Adds a new entry to tab.
+ * Adds a new entry to tab and increment @fs reference counter. Don't forget to
+ * use mnt_unref_fs() after mnt_table_add_fs() you want to keep the @fs
+ * referenced by the table only.
  *
  * Returns: 0 on success or negative number in case of error.
  */
@@ -179,11 +430,12 @@ int mnt_table_add_fs(struct libmnt_table *tb, struct libmnt_fs *fs)
 	if (!tb || !fs)
 		return -EINVAL;
 
+	mnt_ref_fs(fs);
 	list_add_tail(&fs->ents, &tb->ents);
+	tb->nents++;
 
 	DBG(TAB, mnt_debug_h(tb, "add entry: %s %s",
 			mnt_fs_get_source(fs), mnt_fs_get_target(fs)));
-	tb->nents++;
 	return 0;
 }
 
@@ -192,6 +444,10 @@ int mnt_table_add_fs(struct libmnt_table *tb, struct libmnt_fs *fs)
  * @tb: tab pointer
  * @fs: new entry
  *
+ * Removes the @fs from the table and de-increment reference counter of the @fs. The
+ * filesystem with zero reference counter will be deallocated. Don't forget to use
+ * mnt_ref_fs() before call mnt_table_remove_fs() if you want to use @fs later.
+ *
  * Returns: 0 on success or negative number in case of error.
  */
 int mnt_table_remove_fs(struct libmnt_table *tb, struct libmnt_fs *fs)
@@ -201,7 +457,11 @@ int mnt_table_remove_fs(struct libmnt_table *tb, struct libmnt_fs *fs)
 
 	if (!tb || !fs)
 		return -EINVAL;
+
 	list_del(&fs->ents);
+	INIT_LIST_HEAD(&fs->ents);	/* otherwise FS still points to the list */
+
+	mnt_unref_fs(fs);
 	tb->nents--;
 	return 0;
 }
@@ -211,18 +471,18 @@ int mnt_table_remove_fs(struct libmnt_table *tb, struct libmnt_fs *fs)
  * @tb: mountinfo file (/proc/self/mountinfo)
  * @root: returns pointer to the root filesystem (/)
  *
- * The function uses parent ID from mountinfo file to determine root filesystem
+ * The function uses the parent ID from the mountinfo file to determine the root filesystem
  * (the filesystem with the smallest ID). The function is designed mostly for
- * applications where is necessary to sort mountpoints by IDs to get the tree
+ * applications where it is necessary to sort mountpoints by IDs to get the tree
  * of the mountpoints (e.g. findmnt default output).
  *
- * If you're not sure than use
+ * If you're not sure, then use
  *
  *	mnt_table_find_target(tb, "/", MNT_ITER_BACKWARD);
  *
- * this is more robust and usable for arbitrary tab file (including fstab).
+ * this is more robust and usable for arbitrary tab files (including fstab).
  *
- * Returns: 0 on success or less then zero case of error.
+ * Returns: 0 on success or negative number in case of error.
  */
 int mnt_table_get_root_fs(struct libmnt_table *tb, struct libmnt_fs **root)
 {
@@ -233,16 +493,16 @@ int mnt_table_get_root_fs(struct libmnt_table *tb, struct libmnt_fs **root)
 	assert(tb);
 	assert(root);
 
-	if (!tb || !root)
+	if (!tb || !root || !is_mountinfo(tb))
 		return -EINVAL;
 
 	DBG(TAB, mnt_debug_h(tb, "lookup root fs"));
 
+	*root = NULL;
+
 	mnt_reset_iter(&itr, MNT_ITER_FORWARD);
 	while(mnt_table_next_fs(tb, &itr, &fs) == 0) {
 		int id = mnt_fs_get_parent_id(fs);
-		if (!id)
-			break;		/* @tab is not mountinfo file? */
 
 		if (!*root || id < root_id) {
 			*root = fs;
@@ -250,7 +510,7 @@ int mnt_table_get_root_fs(struct libmnt_table *tb, struct libmnt_fs **root)
 		}
 	}
 
-	return root_id ? 0 : -EINVAL;
+	return *root ? 0 : -EINVAL;
 }
 
 /**
@@ -260,10 +520,10 @@ int mnt_table_get_root_fs(struct libmnt_table *tb, struct libmnt_fs **root)
  * @parent: parental FS
  * @chld: returns the next child filesystem
  *
- * Note that filesystems are returned in the order how was mounted (according to
+ * Note that filesystems are returned in the order of mounting (according to
  * IDs in /proc/self/mountinfo).
  *
- * Returns: 0 on success, negative number in case of error or 1 at end of list.
+ * Returns: 0 on success, negative number in case of error or 1 at the end of list.
  */
 int mnt_table_next_child_fs(struct libmnt_table *tb, struct libmnt_iter *itr,
 			struct libmnt_fs *parent, struct libmnt_fs **chld)
@@ -271,15 +531,13 @@ int mnt_table_next_child_fs(struct libmnt_table *tb, struct libmnt_iter *itr,
 	struct libmnt_fs *fs;
 	int parent_id, lastchld_id = 0, chld_id = 0;
 
-	if (!tb || !itr || !parent)
+	if (!tb || !itr || !parent || !is_mountinfo(tb))
 		return -EINVAL;
 
-	DBG(TAB, mnt_debug_h(tb, "lookup next child of %s",
+	DBG(TAB, mnt_debug_h(tb, "lookup next child of '%s'",
 				mnt_fs_get_target(parent)));
 
 	parent_id = mnt_fs_get_id(parent);
-	if (!parent_id)
-		return -EINVAL;
 
 	/* get ID of the previously returned child */
 	if (itr->head && itr->p != itr->head) {
@@ -298,7 +556,7 @@ int mnt_table_next_child_fs(struct libmnt_table *tb, struct libmnt_iter *itr,
 
 		id = mnt_fs_get_id(fs);
 
-		/* avoid infinite loop. This only happens in rare cases
+		/* avoid an infinite loop. This only happens in rare cases
 		 * such as in early userspace when the rootfs is its own parent */
 		if (id == parent_id)
 			continue;
@@ -310,7 +568,7 @@ int mnt_table_next_child_fs(struct libmnt_table *tb, struct libmnt_iter *itr,
 		}
 	}
 
-	if (!chld_id)
+	if (!*chld)
 		return 1;	/* end of iterator */
 
 	/* set the iterator to the @chld for the next call */
@@ -325,7 +583,7 @@ int mnt_table_next_child_fs(struct libmnt_table *tb, struct libmnt_iter *itr,
  * @itr: iterator
  * @fs: returns the next tab entry
  *
- * Returns: 0 on success, negative number in case of error or 1 at end of list.
+ * Returns: 0 on success, negative number in case of error or 1 at the end of list.
  *
  * Example:
  * <informalexample>
@@ -334,11 +592,10 @@ int mnt_table_next_child_fs(struct libmnt_table *tb, struct libmnt_iter *itr,
  *		const char *dir = mnt_fs_get_target(fs);
  *		printf("mount point: %s\n", dir);
  *	}
- *	mnt_free_table(fi);
  *   </programlisting>
  * </informalexample>
  *
- * lists all mountpoints from fstab in backward order.
+ * lists all mountpoints from fstab in reverse order.
  */
 int mnt_table_next_fs(struct libmnt_table *tb, struct libmnt_iter *itr, struct libmnt_fs **fs)
 {
@@ -363,14 +620,54 @@ int mnt_table_next_fs(struct libmnt_table *tb, struct libmnt_iter *itr, struct l
 }
 
 /**
+ * mnt_table_first_fs:
+ * @tb: tab pointer
+ * @fs: returns the first tab entry
+ *
+ * Returns: 0 on success, negative number in case of error or 1 at the end of list.
+ */
+int mnt_table_first_fs(struct libmnt_table *tb, struct libmnt_fs **fs)
+{
+	assert(tb);
+	assert(fs);
+
+	if (!tb || !fs)
+		return -EINVAL;
+	if (list_empty(&tb->ents))
+		return 1;
+	*fs = list_first_entry(&tb->ents, struct libmnt_fs, ents);
+	return 0;
+}
+
+/**
+ * mnt_table_last_fs:
+ * @tb: tab pointer
+ * @fs: returns the last tab entry
+ *
+ * Returns: 0 on success, negative number in case of error or 1 at the end of list.
+ */
+int mnt_table_last_fs(struct libmnt_table *tb, struct libmnt_fs **fs)
+{
+	assert(tb);
+	assert(fs);
+
+	if (!tb || !fs)
+		return -EINVAL;
+	if (list_empty(&tb->ents))
+		return 1;
+	*fs = list_last_entry(&tb->ents, struct libmnt_fs, ents);
+	return 0;
+}
+
+/**
  * mnt_table_find_next_fs:
  * @tb: table
  * @itr: iterator
- * @match_func: function returns 1 or 0
+ * @match_func: function returning 1 or 0
  * @userdata: extra data for match_func
  * @fs: returns pointer to the next matching table entry
  *
- * This function allows search in @tb.
+ * This function allows searching in @tb.
  *
  * Returns: negative number in case of error, 1 at end of table or 0 o success.
  */
@@ -431,7 +728,7 @@ int mnt_table_set_iter(struct libmnt_table *tb, struct libmnt_iter *itr, struct
  * @path: directory
  * @direction: MNT_ITER_{FORWARD,BACKWARD}
  *
- * Same like mnt_get_mountpoint(), but this function does not rely on
+ * Same as mnt_get_mountpoint(), except this function does not rely on
  * st_dev numbers.
  *
  * Returns: a tab entry or NULL.
@@ -442,12 +739,12 @@ struct libmnt_fs *mnt_table_find_mountpoint(struct libmnt_table *tb,
 {
 	char *mnt;
 
-	if (!tb || !path)
+	if (!tb || !path || !*path)
 		return NULL;
 	if (direction != MNT_ITER_FORWARD && direction != MNT_ITER_BACKWARD)
 		return NULL;
 
-	DBG(TAB, mnt_debug_h(tb, "lookup MOUNTPOINT: %s", path));
+	DBG(TAB, mnt_debug_h(tb, "lookup MOUNTPOINT: '%s'", path));
 
 	mnt = strdup(path);
 	if (!mnt)
@@ -478,10 +775,10 @@ struct libmnt_fs *mnt_table_find_mountpoint(struct libmnt_table *tb,
  * @path: mountpoint directory
  * @direction: MNT_ITER_{FORWARD,BACKWARD}
  *
- * Try to lookup an entry in given tab, possible are three iterations, first
- * with @path, second with realpath(@path) and third with realpath(@path)
+ * Try to lookup an entry in the given tab, three iterations are possible, the first
+ * with @path, the second with realpath(@path) and the third with realpath(@path)
  * against realpath(fs->target). The 2nd and 3rd iterations are not performed
- * when @tb cache is not set (see mnt_table_set_cache()).
+ * when the @tb cache is not set (see mnt_table_set_cache()).
  *
  * Returns: a tab entry or NULL.
  */
@@ -494,12 +791,12 @@ struct libmnt_fs *mnt_table_find_target(struct libmnt_table *tb, const char *pat
 	assert(tb);
 	assert(path);
 
-	if (!tb || !path)
+	if (!tb || !path || !*path)
 		return NULL;
 	if (direction != MNT_ITER_FORWARD && direction != MNT_ITER_BACKWARD)
 		return NULL;
 
-	DBG(TAB, mnt_debug_h(tb, "lookup TARGET: %s", path));
+	DBG(TAB, mnt_debug_h(tb, "lookup TARGET: '%s'", path));
 
 	/* native @target */
 	mnt_reset_iter(&itr, direction);
@@ -510,6 +807,8 @@ struct libmnt_fs *mnt_table_find_target(struct libmnt_table *tb, const char *pat
 	if (!tb->cache || !(cn = mnt_resolve_path(path, tb->cache)))
 		return NULL;
 
+	DBG(TAB, mnt_debug_h(tb, "lookup canonical TARGET: '%s'", cn));
+
 	/* canonicalized paths in struct libmnt_table */
 	mnt_reset_iter(&itr, direction);
 	while(mnt_table_next_fs(tb, &itr, &fs) == 0) {
@@ -519,7 +818,7 @@ struct libmnt_fs *mnt_table_find_target(struct libmnt_table *tb, const char *pat
 
 	/* non-canonicaled path in struct libmnt_table
 	 * -- note that mountpoint in /proc/self/mountinfo is already
-	 *    canonicalized by kernel
+	 *    canonicalized by the kernel
 	 */
 	mnt_reset_iter(&itr, direction);
 	while(mnt_table_next_fs(tb, &itr, &fs) == 0) {
@@ -545,11 +844,11 @@ struct libmnt_fs *mnt_table_find_target(struct libmnt_table *tb, const char *pat
  * @path: source path (devname or dirname) or NULL
  * @direction: MNT_ITER_{FORWARD,BACKWARD}
  *
- * Try to lookup an entry in given tab, possible are four iterations, first
- * with @path, second with realpath(@path), third with tags (LABEL, UUID, ..)
- * from @path and fourth with realpath(@path) against realpath(entry->srcpath).
+ * Try to lookup an entry in the given tab, four iterations are possible, the first
+ * with @path, the second with realpath(@path), the third with tags (LABEL, UUID, ..)
+ * from @path and the fourth with realpath(@path) against realpath(entry->srcpath).
  *
- * The 2nd, 3rd and 4th iterations are not performed when @tb cache is not
+ * The 2nd, 3rd and 4th iterations are not performed when the @tb cache is not
  * set (see mnt_table_set_cache()).
  *
  * Note that NULL is a valid source path; it will be replaced with "none". The
@@ -561,17 +860,17 @@ struct libmnt_fs *mnt_table_find_srcpath(struct libmnt_table *tb, const char *pa
 {
 	struct libmnt_iter itr;
 	struct libmnt_fs *fs = NULL;
-	int ntags = 0;
+	int ntags = 0, nents;
 	char *cn;
 	const char *p;
 
 	assert(tb);
-	if (!tb || !path)
+	if (!tb || !path || !*path)
 		return NULL;
 	if (direction != MNT_ITER_FORWARD && direction != MNT_ITER_BACKWARD)
 		return NULL;
 
-	DBG(TAB, mnt_debug_h(tb, "lookup srcpath: %s", path));
+	DBG(TAB, mnt_debug_h(tb, "lookup SRCPATH: '%s'", path));
 
 	/* native paths */
 	mnt_reset_iter(&itr, direction);
@@ -585,8 +884,12 @@ struct libmnt_fs *mnt_table_find_srcpath(struct libmnt_table *tb, const char *pa
 	if (!path || !tb->cache || !(cn = mnt_resolve_path(path, tb->cache)))
 		return NULL;
 
+	DBG(TAB, mnt_debug_h(tb, "lookup canonical SRCPATH: '%s'", cn));
+
+	nents = mnt_table_get_nents(tb);
+
 	/* canonicalized paths in struct libmnt_table */
-	if (ntags < mnt_table_get_nents(tb)) {
+	if (ntags < nents) {
 		mnt_reset_iter(&itr, direction);
 		while(mnt_table_next_fs(tb, &itr, &fs) == 0) {
 			if (mnt_fs_streq_srcpath(fs, cn))
@@ -612,9 +915,9 @@ struct libmnt_fs *mnt_table_find_srcpath(struct libmnt_table *tb, const char *pa
 					return fs;
 			}
 		} else if (rc < 0 && errno == EACCES) {
-			/* @path is unaccessible, try evaluate all TAGs in @tb
+			/* @path is inaccessible, try evaluating all TAGs in @tb
 			 * by udev symlinks -- this could be expensive on systems
-			 * with huge fstab/mtab */
+			 * with a huge fstab/mtab */
 			 while(mnt_table_next_fs(tb, &itr, &fs) == 0) {
 				 const char *t, *v, *x;
 				 if (mnt_fs_get_tag(fs, &t, &v))
@@ -629,7 +932,7 @@ struct libmnt_fs *mnt_table_find_srcpath(struct libmnt_table *tb, const char *pa
 	}
 
 	/* non-canonicalized paths in struct libmnt_table */
-	if (ntags <= mnt_table_get_nents(tb)) {
+	if (ntags <= nents) {
 		mnt_reset_iter(&itr, direction);
 		while(mnt_table_next_fs(tb, &itr, &fs) == 0) {
 			if (mnt_fs_is_netfs(fs) || mnt_fs_is_pseudofs(fs))
@@ -655,9 +958,9 @@ struct libmnt_fs *mnt_table_find_srcpath(struct libmnt_table *tb, const char *pa
  * @val: tag value
  * @direction: MNT_ITER_{FORWARD,BACKWARD}
  *
- * Try to lookup an entry in given tab, first attempt is lookup by @tag and
+ * Try to lookup an entry in the given tab, the first attempt is to lookup by @tag and
  * @val, for the second attempt the tag is evaluated (converted to the device
- * name) and mnt_table_find_srcpath() is preformed. The second attempt is not
+ * name) and mnt_table_find_srcpath() is performed. The second attempt is not
  * performed when @tb cache is not set (see mnt_table_set_cache()).
 
  * Returns: a tab entry or NULL.
@@ -672,7 +975,7 @@ struct libmnt_fs *mnt_table_find_tag(struct libmnt_table *tb, const char *tag,
 	assert(tag);
 	assert(val);
 
-	if (!tb || !tag || !val)
+	if (!tb || !tag || !*tag || !val)
 		return NULL;
 	if (direction != MNT_ITER_FORWARD && direction != MNT_ITER_BACKWARD)
 		return NULL;
@@ -703,16 +1006,17 @@ struct libmnt_fs *mnt_table_find_tag(struct libmnt_table *tb, const char *tag,
  * @source: TAG or path
  * @direction: MNT_ITER_{FORWARD,BACKWARD}
  *
- * This is high-level API for mnt_table_find_{srcpath,tag}. You needn't to care
- * about @source format (device, LABEL, UUID, ...). This function parses @source
- * and calls mnt_table_find_tag() or mnt_table_find_srcpath().
+ * This is a high-level API for mnt_table_find_{srcpath,tag}. You needn't care
+ * about the @source format (device, LABEL, UUID, ...). This function parses
+ * the @source and calls mnt_table_find_tag() or mnt_table_find_srcpath().
  *
  * Returns: a tab entry or NULL.
  */
 struct libmnt_fs *mnt_table_find_source(struct libmnt_table *tb,
 					const char *source, int direction)
 {
-	struct libmnt_fs *fs = NULL;
+	struct libmnt_fs *fs;
+	char *t = NULL, *v = NULL;
 
 	assert(tb);
 
@@ -721,20 +1025,15 @@ struct libmnt_fs *mnt_table_find_source(struct libmnt_table *tb,
 	if (direction != MNT_ITER_FORWARD && direction != MNT_ITER_BACKWARD)
 		return NULL;
 
-	DBG(TAB, mnt_debug_h(tb, "lookup SOURCE: %s", source));
-
-	if (source && strchr(source, '=')) {
-		char *tag, *val;
+	DBG(TAB, mnt_debug_h(tb, "lookup SOURCE: '%s'", source));
 
-		if (blkid_parse_tag_string(source, &tag, &val) == 0) {
-
-			fs = mnt_table_find_tag(tb, tag, val, direction);
-
-			free(tag);
-			free(val);
-		}
-	} else
+	if (blkid_parse_tag_string(source, &t, &v) || !mnt_valid_tagname(t))
 		fs = mnt_table_find_srcpath(tb, source, direction);
+	else
+		fs = mnt_table_find_tag(tb, t, v, direction);
+
+	free(t);
+	free(v);
 
 	return fs;
 }
@@ -747,7 +1046,7 @@ struct libmnt_fs *mnt_table_find_source(struct libmnt_table *tb,
  * @direction: MNT_ITER_{FORWARD,BACKWARD}
  *
  * This function is implemented by mnt_fs_match_source() and
- * mnt_fs_match_target() functions. It means that this is more expensive that
+ * mnt_fs_match_target() functions. It means that this is more expensive than
  * others mnt_table_find_* function, because every @tab entry is fully evaluated.
  *
  * Returns: a tab entry or NULL.
@@ -761,7 +1060,7 @@ struct libmnt_fs *mnt_table_find_pair(struct libmnt_table *tb, const char *sourc
 	assert(tb);
 	assert(target);
 
-	if (!tb || !target)
+	if (!tb || !target || !*target || !source || !*source)
 		return NULL;
 	if (direction != MNT_ITER_FORWARD && direction != MNT_ITER_BACKWARD)
 		return NULL;
@@ -785,7 +1084,7 @@ struct libmnt_fs *mnt_table_find_pair(struct libmnt_table *tb, const char *sourc
  * @devno: device number
  * @direction: MNT_ITER_{FORWARD,BACKWARD}
  *
- * Note that zero could be valid device number for root pseudo filesystem (e.g.
+ * Note that zero could be a valid device number for the root pseudo filesystem (e.g.
  * tmpfs).
  *
  * Returns: a tab entry or NULL.
@@ -819,7 +1118,7 @@ struct libmnt_fs *mnt_table_find_devno(struct libmnt_table *tb,
  * tb: /proc/self/mountinfo
  * fs: filesystem
  * mountflags: MS_BIND or 0
- * fsroot: fs-root that will be probably used in the mountinfo file
+ * fsroot: fs-root that will probably be used in the mountinfo file
  *          for @fs after mount(2)
  *
  * For btrfs subvolumes this function returns NULL, but @fsroot properly set.
@@ -841,7 +1140,7 @@ struct libmnt_fs *mnt_table_get_fs_root(struct libmnt_table *tb,
 	assert(fs);
 	assert(fsroot);
 
-	DBG(TAB, mnt_debug("lookup fs-root for %s", mnt_fs_get_source(fs)));
+	DBG(TAB, mnt_debug("lookup fs-root for '%s'", mnt_fs_get_source(fs)));
 
 	fstype = mnt_fs_get_fstype(fs);
 
@@ -945,20 +1244,20 @@ static int is_mountinfo(struct libmnt_table *tb)
 }
 
 /**
- * mnt_table_is_mounted:
+ * mnt_table_is_fs__mounted:
  * @tb: /proc/self/mountinfo file
  * @fstab_fs: /etc/fstab entry
  *
  * Checks if the @fstab_fs entry is already in the @tb table. The "swap" is
- * ignored. This function explicitly compares source, target and root of the
+ * ignored. This function explicitly compares the source, target and root of the
  * filesystems.
  *
  * Note that source and target are canonicalized only if a cache for @tb is
  * defined (see mnt_table_set_cache()). The target canonicalization may
- * triggers automount on autofs mountpoints!
+ * trigger automount on autofs mountpoints!
  *
  * Don't use it if you want to know if a device is mounted, just use
- * mnt_table_find_source() for the device.
+ * mnt_table_find_source() on the device.
  *
  * This function is designed mostly for "mount -a".
  *
@@ -973,6 +1272,7 @@ int mnt_table_is_fs_mounted(struct libmnt_table *tb, struct libmnt_fs *fstab_fs)
 	const char *src = NULL, *tgt = NULL;
 	char *xtgt = NULL;
 	int rc = 0;
+	dev_t devno = 0;
 
 	assert(tb);
 	assert(fstab_fs);
@@ -980,7 +1280,7 @@ int mnt_table_is_fs_mounted(struct libmnt_table *tb, struct libmnt_fs *fstab_fs)
 	DBG(FS, mnt_debug_h(fstab_fs, "is FS mounted? [target=%s]",
 				mnt_fs_get_target(fstab_fs)));
 
-	if (mnt_fs_is_swaparea(fstab_fs) || mnt_table_get_nents(tb) == 0) {
+	if (mnt_fs_is_swaparea(fstab_fs) || mnt_table_is_empty(tb)) {
 		DBG(FS, mnt_debug_h(fstab_fs, "- ignore (swap or no data)"));
 		return 0;
 	}
@@ -1004,6 +1304,14 @@ int mnt_table_is_fs_mounted(struct libmnt_table *tb, struct libmnt_fs *fstab_fs)
 	if (src && tb->cache && !mnt_fs_is_pseudofs(fstab_fs))
 		src = mnt_resolve_spec(src, tb->cache);
 
+	if (src && root) {
+		struct stat st;
+
+		devno = mnt_fs_get_devno(fstab_fs);
+		if (!devno && stat(src, &st) == 0 && S_ISBLK(st.st_mode))
+			devno = st.st_rdev;
+	}
+
 	tgt = mnt_fs_get_target(fstab_fs);
 
 	if (!tgt || !src) {
@@ -1014,7 +1322,12 @@ int mnt_table_is_fs_mounted(struct libmnt_table *tb, struct libmnt_fs *fstab_fs)
 
 	while (mnt_table_next_fs(tb, &itr, &fs) == 0) {
 
-		if (!mnt_fs_streq_srcpath(fs, src)) {
+		int eq = mnt_fs_streq_srcpath(fs, src);
+
+		if (!eq && devno && mnt_fs_get_devno(fs) == devno)
+			eq = 1;
+
+		if (!eq) {
 			/* The source does not match. Maybe the source is a loop
 			 * device backing file.
 			 */
@@ -1046,7 +1359,7 @@ int mnt_table_is_fs_mounted(struct libmnt_table *tb, struct libmnt_fs *fstab_fs)
 		}
 
 		/*
-		 * Compare target, try to minimize number of situations when we
+		 * Compare target, try to minimize the number of situations when we
 		 * need to canonicalize the path to avoid readlink() on
 		 * mountpoints.
 		 */
@@ -1076,10 +1389,10 @@ static int parser_errcb(struct libmnt_table *tb, const char *filename, int line)
 {
 	fprintf(stderr, "%s:%d: parse error\n", filename, line);
 
-	return 1;	/* all errors are recoverable -- this is default */
+	return 1;	/* all errors are recoverable -- this is the default */
 }
 
-struct libmnt_table *create_table(const char *file)
+struct libmnt_table *create_table(const char *file, int comments)
 {
 	struct libmnt_table *tb;
 
@@ -1089,6 +1402,7 @@ struct libmnt_table *create_table(const char *file)
 	if (!tb)
 		goto err;
 
+	mnt_table_enable_comments(tb, comments);
 	mnt_table_set_parser_errcb(tb, parser_errcb);
 
 	if (mnt_table_parse_file(tb, file) != 0)
@@ -1096,7 +1410,7 @@ struct libmnt_table *create_table(const char *file)
 	return tb;
 err:
 	fprintf(stderr, "%s: parsing failed\n", file);
-	mnt_free_table(tb);
+	mnt_unref_table(tb);
 	return NULL;
 }
 
@@ -1106,7 +1420,7 @@ int test_copy_fs(struct libmnt_test *ts, int argc, char *argv[])
 	struct libmnt_fs *fs;
 	int rc = -1;
 
-	tb = create_table(argv[1]);
+	tb = create_table(argv[1], FALSE);
 	if (!tb)
 		return -1;
 
@@ -1123,10 +1437,10 @@ int test_copy_fs(struct libmnt_test *ts, int argc, char *argv[])
 
 	printf("COPY:\n");
 	mnt_fs_print_debug(fs, stdout);
-	mnt_free_fs(fs);
+	mnt_unref_fs(fs);
 	rc = 0;
 done:
-	mnt_free_table(tb);
+	mnt_unref_table(tb);
 	return rc;
 }
 
@@ -1136,8 +1450,12 @@ int test_parse(struct libmnt_test *ts, int argc, char *argv[])
 	struct libmnt_iter *itr = NULL;
 	struct libmnt_fs *fs;
 	int rc = -1;
+	int parse_comments = FALSE;
 
-	tb = create_table(argv[1]);
+	if (argc == 3 && !strcmp(argv[2], "--comments"))
+		parse_comments = TRUE;
+
+	tb = create_table(argv[1], parse_comments);
 	if (!tb)
 		return -1;
 
@@ -1145,12 +1463,20 @@ int test_parse(struct libmnt_test *ts, int argc, char *argv[])
 	if (!itr)
 		goto done;
 
+	if (mnt_table_get_intro_comment(tb))
+		fprintf(stdout, "Initial comment:\n\"%s\"\n",
+				mnt_table_get_intro_comment(tb));
+
 	while(mnt_table_next_fs(tb, itr, &fs) == 0)
 		mnt_fs_print_debug(fs, stdout);
+
+	if (mnt_table_get_trailing_comment(tb))
+		fprintf(stdout, "Trailing comment:\n\"%s\"\n",
+				mnt_table_get_trailing_comment(tb));
 	rc = 0;
 done:
 	mnt_free_iter(itr);
-	mnt_free_table(tb);
+	mnt_unref_table(tb);
 	return rc;
 }
 
@@ -1169,7 +1495,7 @@ int test_find(struct libmnt_test *ts, int argc, char *argv[], int dr)
 
 	file = argv[1], find = argv[2], what = argv[3];
 
-	tb = create_table(file);
+	tb = create_table(file, FALSE);
 	if (!tb)
 		goto done;
 
@@ -1178,6 +1504,7 @@ int test_find(struct libmnt_test *ts, int argc, char *argv[], int dr)
 	if (!mpc)
 		goto done;
 	mnt_table_set_cache(tb, mpc);
+	mnt_unref_cache(mpc);
 
 	if (strcasecmp(find, "source") == 0)
 		fs = mnt_table_find_source(tb, what, dr);
@@ -1191,8 +1518,7 @@ int test_find(struct libmnt_test *ts, int argc, char *argv[], int dr)
 		rc = 0;
 	}
 done:
-	mnt_free_table(tb);
-	mnt_free_cache(mpc);
+	mnt_unref_table(tb);
 	return rc;
 }
 
@@ -1213,13 +1539,14 @@ int test_find_pair(struct libmnt_test *ts, int argc, char *argv[])
 	struct libmnt_cache *mpc = NULL;
 	int rc = -1;
 
-	tb = create_table(argv[1]);
+	tb = create_table(argv[1], FALSE);
 	if (!tb)
 		return -1;
 	mpc = mnt_new_cache();
 	if (!mpc)
 		goto done;
 	mnt_table_set_cache(tb, mpc);
+	mnt_unref_cache(mpc);
 
 	fs = mnt_table_find_pair(tb, argv[2], argv[3], MNT_ITER_FORWARD);
 	if (!fs)
@@ -1228,8 +1555,7 @@ int test_find_pair(struct libmnt_test *ts, int argc, char *argv[])
 	mnt_fs_print_debug(fs, stdout);
 	rc = 0;
 done:
-	mnt_free_table(tb);
-	mnt_free_cache(mpc);
+	mnt_unref_table(tb);
 	return rc;
 }
 
@@ -1247,6 +1573,7 @@ int test_find_mountpoint(struct libmnt_test *ts, int argc, char *argv[])
 	if (!mpc)
 		goto done;
 	mnt_table_set_cache(tb, mpc);
+	mnt_unref_cache(mpc);
 
 	fs = mnt_table_find_mountpoint(tb, argv[1], MNT_ITER_BACKWARD);
 	if (!fs)
@@ -1255,8 +1582,7 @@ int test_find_mountpoint(struct libmnt_test *ts, int argc, char *argv[])
 	mnt_fs_print_debug(fs, stdout);
 	rc = 0;
 done:
-	mnt_free_table(tb);
-	mnt_free_cache(mpc);
+	mnt_unref_table(tb);
 	return rc;
 }
 
@@ -1274,7 +1600,7 @@ static int test_is_mounted(struct libmnt_test *ts, int argc, char *argv[])
 		return -1;
 	}
 
-	fstab = create_table(argv[1]);
+	fstab = create_table(argv[1], FALSE);
 	if (!fstab)
 		goto done;
 
@@ -1286,6 +1612,7 @@ static int test_is_mounted(struct libmnt_test *ts, int argc, char *argv[])
 	if (!mpc)
 		goto done;
 	mnt_table_set_cache(tb, mpc);
+	mnt_unref_cache(mpc);
 
 	while(mnt_table_next_fs(fstab, itr, &fs) == 0) {
 		if (mnt_table_is_fs_mounted(tb, fs))
@@ -1300,9 +1627,8 @@ static int test_is_mounted(struct libmnt_test *ts, int argc, char *argv[])
 
 	rc = 0;
 done:
-	mnt_free_table(tb);
-	mnt_free_table(fstab);
-	mnt_free_cache(mpc);
+	mnt_unref_table(tb);
+	mnt_unref_table(fstab);
 	mnt_free_iter(itr);
 	return rc;
 }
@@ -1310,7 +1636,7 @@ done:
 int main(int argc, char *argv[])
 {
 	struct libmnt_test tss[] = {
-	{ "--parse",    test_parse,        "<file>  parse and print tab" },
+	{ "--parse",    test_parse,        "<file> [--comments] parse and print tab" },
 	{ "--find-forward",  test_find_fw, "<file> <source|target> <string>" },
 	{ "--find-backward", test_find_bw, "<file> <source|target> <string>" },
 	{ "--find-pair",     test_find_pair, "<file> <source> <target>" },
diff --git a/libmount/src/tab_diff.c b/libmount/src/tab_diff.c
index f01f889f8..052278233 100644
--- a/libmount/src/tab_diff.c
+++ b/libmount/src/tab_diff.c
@@ -25,7 +25,7 @@ struct libmnt_tabdiff {
 	int nchanges;			/* number of changes */
 
 	struct list_head changes;	/* list with modified entries */
-	struct list_head unused;	/* list with unuused entries */
+	struct list_head unused;	/* list with unused entries */
 };
 
 /**
@@ -54,6 +54,8 @@ static void free_tabdiff_entry(struct tabdiff_entry *de)
 	if (!de)
 		return;
 	list_del(&de->changes);
+	mnt_unref_fs(de->new_fs);
+	mnt_unref_fs(de->old_fs);
 	free(de);
 }
 
@@ -89,7 +91,7 @@ void mnt_free_tabdiff(struct libmnt_tabdiff *df)
  *
  * The options @old_fs, @new_fs and @oper are optional.
  *
- * Returns: 0 on success, negative number in case of error or 1 at end of list.
+ * Returns: 0 on success, negative number in case of error or 1 at the end of list.
  */
 int mnt_tabdiff_next_change(struct libmnt_tabdiff *df, struct libmnt_iter *itr,
 		struct libmnt_fs **old_fs, struct libmnt_fs **new_fs, int *oper)
@@ -124,9 +126,9 @@ static int tabdiff_reset(struct libmnt_tabdiff *df)
 {
 	assert(df);
 
-	DBG(DIFF, mnt_debug_h(df, "reseting"));
+	DBG(DIFF, mnt_debug_h(df, "resetting"));
 
-	/* zeroize all entries and move them to the list of unuused
+	/* zeroize all entries and move them to the list of unused
 	 */
 	while (!list_empty(&df->changes)) {
 		struct tabdiff_entry *de = list_entry(df->changes.next,
@@ -135,6 +137,9 @@ static int tabdiff_reset(struct libmnt_tabdiff *df)
 		list_del(&de->changes);
 		list_add_tail(&de->changes, &df->unused);
 
+		mnt_unref_fs(de->new_fs);
+		mnt_unref_fs(de->old_fs);
+
 		de->new_fs = de->old_fs = NULL;
 		de->oper = 0;
 	}
@@ -164,6 +169,12 @@ static int tabdiff_add_entry(struct libmnt_tabdiff *df, struct libmnt_fs *old,
 
 	INIT_LIST_HEAD(&de->changes);
 
+	mnt_ref_fs(new);
+	mnt_ref_fs(old);
+
+	mnt_unref_fs(de->new_fs);
+	mnt_unref_fs(de->old_fs);
+
 	de->old_fs = old;
 	de->new_fs = new;
 	de->oper = oper;
@@ -280,6 +291,8 @@ int mnt_diff_tables(struct libmnt_tabdiff *df, struct libmnt_table *old_tab,
 
 			de = tabdiff_get_mount(df, src,	mnt_fs_get_id(fs));
 			if (de) {
+				mnt_ref_fs(fs);
+				mnt_unref_fs(de->old_fs);
 				de->oper = MNT_TABDIFF_MOVE;
 				de->old_fs = fs;
 			} else
@@ -342,8 +355,8 @@ int test_diff(struct libmnt_test *ts, int argc, char *argv[])
 
 	rc = 0;
 done:
-	mnt_free_table(tb_old);
-	mnt_free_table(tb_new);
+	mnt_unref_table(tb_old);
+	mnt_unref_table(tb_new);
 	mnt_free_tabdiff(diff);
 	mnt_free_iter(itr);
 	return rc;
diff --git a/libmount/src/tab_parse.c b/libmount/src/tab_parse.c
index e930fd841..38c48fdfa 100644
--- a/libmount/src/tab_parse.c
+++ b/libmount/src/tab_parse.c
@@ -47,7 +47,7 @@ static int next_number(char **s, int *num)
 
 	*s = end;
 
-	/* valid end of number is space or terminator */
+	/* valid end of number is a space or a terminator */
 	if (*end == ' ' || *end == '\t' || *end == '\0')
 		return 0;
 	return -1;
@@ -82,7 +82,7 @@ static int mnt_parse_table_line(struct libmnt_fs *fs, char *s)
 		if (optstr && *optstr)
 			unmangle_string(optstr);
 
-		/* note that __foo functions does not reallocate the string
+		/* note that __foo functions do not reallocate the string
 		 */
 		rc = __mnt_fs_set_source_ptr(fs, src);
 		if (!rc) {
@@ -128,7 +128,7 @@ static int mnt_parse_table_line(struct libmnt_fs *fs, char *s)
 }
 
 /*
- * Parses one line from mountinfo file
+ * Parses one line from a mountinfo file
  */
 static int mnt_parse_mountinfo_line(struct libmnt_fs *fs, char *s)
 {
@@ -158,7 +158,7 @@ static int mnt_parse_mountinfo_line(struct libmnt_fs *fs, char *s)
 	/* (7) optional fields, terminated by " - " */
 	p = strstr(s, " - ");
 	if (!p) {
-		DBG(TAB, mnt_debug("mountinfo parse error: not found separator"));
+		DBG(TAB, mnt_debug("mountinfo parse error: separator not found"));
 		return -EINVAL;
 	}
 	if (p > s + 1)
@@ -174,9 +174,20 @@ static int mnt_parse_mountinfo_line(struct libmnt_fs *fs, char *s)
 			&fs->fs_optstr);
 
 	if (rc >= 10) {
+		size_t sz;
+
 		fs->flags |= MNT_FS_KERNEL;
 		fs->devno = makedev(maj, min);
 
+		/* remove "(deleted)" suffix */
+		sz = strlen(fs->target);
+		if (sz > PATH_DELETED_SUFFIX_SZ) {
+			char *p = fs->target + (sz - PATH_DELETED_SUFFIX_SZ);
+
+			if (strcmp(p, PATH_DELETED_SUFFIX) == 0)
+				*p = '\0';
+		}
+
 		unmangle_string(fs->root);
 		unmangle_string(fs->target);
 		unmangle_string(fs->vfs_optstr);
@@ -192,7 +203,7 @@ static int mnt_parse_mountinfo_line(struct libmnt_fs *fs, char *s)
 				src = NULL;
 		}
 
-		/* merge VFS and FS options to the one string */
+		/* merge VFS and FS options to one string */
 		fs->optstr = mnt_fs_strdup_options(fs);
 		if (!fs->optstr)
 			rc = -ENOMEM;
@@ -323,8 +334,8 @@ static int mnt_parse_swaps_line(struct libmnt_fs *fs, char *s)
 /*
  * Returns {m,fs}tab or mountinfo file format (MNT_FMT_*)
  *
- * Note that we aren't trying to guess utab file format, because this file has
- * to be always parsed by private libmount routines with explicitly defined
+ * Note that we aren't trying to guess the utab file format, because this file
+ * always has to be parsed by private libmount routines with an explicitly defined
  * format.
  *
  * mountinfo: "<number> <number> ... "
@@ -344,10 +355,82 @@ static int guess_table_format(char *line)
 	return MNT_FMT_FSTAB;		/* fstab, mtab or /proc/mounts */
 }
 
+static int is_comment_line(char *line)
+{
+	char *p	= skip_spaces(line);
+
+	if (p && (*p == '#' || *p == '\n'))
+		return 1;
+	return 0;
+}
+
+/* returns 1 if the last line in the @str is blank */
+static int is_terminated_by_blank(const char *str)
+{
+	size_t sz = str ? strlen(str) : 0;
+	const char *p = sz ? str + (sz - 1) : NULL;
+
+	if (!sz || !p || *p != '\n')
+		return 0;		/* empty or not terminated by '\n' */
+	if (p == str)
+		return 1;		/* only '\n' */
+	p--;
+	while (p >= str && (*p == ' ' || *p == '\t'))
+		p--;
+	return *p == '\n' ? 1 : 0;
+}
+
+/*
+ * Reads the next line from the file.
+ *
+ * Returns 0 if the line is a comment
+ *         1 if the line is not a comment
+ *        <0 on error
+ */
+static int next_comment_line(char *buf, size_t bufsz,
+			     FILE *f, char **last, int *nlines)
+{
+	if (fgets(buf, bufsz, f) == NULL)
+		return feof(f) ? 1 : -EINVAL;
+
+	++*nlines;
+	*last = strchr(buf, '\n');
+
+	return is_comment_line(buf) ? 0 : 1;
+}
+
+static int append_comment(struct libmnt_table *tb,
+			  struct libmnt_fs *fs,
+			  const char *comm,
+			  int eof)
+{
+	int rc, intro = mnt_table_get_nents(tb) == 0;
+
+	if (intro && is_terminated_by_blank(mnt_table_get_intro_comment(tb)))
+		intro = 0;
+
+	DBG(TAB, mnt_debug_h(tb, "appending %s comment",
+			intro ? "intro" :
+			eof ? "trailing" : "fs"));
+	if (intro)
+		rc = mnt_table_append_intro_comment(tb, comm);
+	else if (eof) {
+		rc = mnt_table_set_trailing_comment(tb,
+				mnt_fs_get_comment(fs));
+		if (!rc)
+			rc = mnt_table_append_trailing_comment(tb, comm);
+		if (!rc)
+			rc = mnt_fs_set_comment(fs, NULL);
+	} else
+		rc = mnt_fs_append_comment(fs, comm);
+	return rc;
+}
+
 /*
  * Read and parse the next line from {fs,m}tab or mountinfo
  */
-static int mnt_table_parse_next(struct libmnt_table *tb, FILE *f, struct libmnt_fs *fs,
+static int mnt_table_parse_next(struct libmnt_table *tb, FILE *f,
+				struct libmnt_fs *fs,
 				const char *filename, int *nlines)
 {
 	char buf[BUFSIZ];
@@ -366,7 +449,7 @@ next_line:
 		++*nlines;
 		s = strchr (buf, '\n');
 		if (!s) {
-			/* Missing final newline?  Otherwise extremely */
+			/* Missing final newline?  Otherwise an extremely */
 			/* long line - assume file was corrupted */
 			if (feof(f)) {
 				DBG(TAB, mnt_debug_h(tb,
@@ -379,6 +462,26 @@ next_line:
 				goto err;
 			}
 		}
+
+		/* comments parser */
+		if (tb->comms
+		    && (tb->fmt == MNT_FMT_GUESS || tb->fmt == MNT_FMT_FSTAB)
+		    && is_comment_line(buf)) {
+			do {
+				rc = append_comment(tb, fs, buf, feof(f));
+				if (!rc)
+					rc = next_comment_line(buf,
+							sizeof(buf),
+							f, &s, nlines);
+			} while (rc == 0);
+
+			if (rc == 1 && feof(f))
+				rc = append_comment(tb, fs, NULL, 1);
+			if (rc < 0)
+				return rc;
+
+		}
+
 		*s = '\0';
 		if (--s >= buf && *s == '\r')
 			*s = '\0';
@@ -420,7 +523,7 @@ err:
 				tb->fmt == MNT_FMT_FSTAB ? "tab" : "utab"));
 
 	/* by default all errors are recoverable, otherwise behavior depends on
-	 * errcb() function. See mnt_table_set_parser_errcb().
+	 * the errcb() function. See mnt_table_set_parser_errcb().
 	 */
 	return tb->errcb ? tb->errcb(tb, filename, *nlines) : 1;
 }
@@ -461,7 +564,7 @@ static int kernel_fs_postparse(struct libmnt_table *tb,
 	int rc = 0;
 	const char *src = mnt_fs_get_srcpath(fs);
 
-	/* This is filesystem description from /proc, so we're in some process
+	/* This is a filesystem description from /proc, so we're in some process
 	 * namespace. Let's remember the process PID.
 	 */
 	if (filename && *tid == -1)
@@ -538,8 +641,9 @@ int mnt_table_parse_stream(struct libmnt_table *tb, FILE *f, const char *filenam
 			if (rc == 0 && tb->fmt == MNT_FMT_MOUNTINFO)
 				rc = kernel_fs_postparse(tb, fs, &tid, filename);
 		}
+		mnt_unref_fs(fs);
+
 		if (rc) {
-			mnt_free_fs(fs);
 			if (rc == 1)
 				continue;	/* recoverable error */
 			if (feof(f))
@@ -561,10 +665,10 @@ err:
  * @tb: tab pointer
  * @filename: file
  *
- * Parses whole table (e.g. /etc/mtab) and appends new records to the @tab.
+ * Parses the whole table (e.g. /etc/mtab) and appends new records to the @tab.
  *
  * The libmount parser ignores broken (syntax error) lines, these lines are
- * reported to caller by errcb() function (see mnt_table_set_parser_errcb()).
+ * reported to the caller by the errcb() function (see mnt_table_set_parser_errcb()).
  *
  * Returns: 0 on success, negative number in case of error.
  */
@@ -663,7 +767,7 @@ static int __mnt_table_parse_dir(struct libmnt_table *tb, const char *dirname)
 	if (n <= 0)
 		return 0;
 
-	/* let use "at" functions rather than play crazy games with paths... */
+	/* let's use "at" functions rather than playing crazy games with paths... */
 	dir = opendir(dirname);
 	if (!dir) {
 		r = -errno;
@@ -704,7 +808,7 @@ out:
  *
  * The directory:
  *	- files are sorted by strverscmp(3)
- *	- files that starts with "." are ignored (e.g. ".10foo.fstab")
+ *	- files that start with "." are ignored (e.g. ".10foo.fstab")
  *	- files without the ".fstab" extension are ignored
  *
  * Returns: 0 on success or negative number in case of error.
@@ -728,7 +832,7 @@ struct libmnt_table *__mnt_new_table_from_file(const char *filename, int fmt)
 	if (tb) {
 		tb->fmt = fmt;
 		if (mnt_table_parse_file(tb, filename) != 0) {
-			mnt_free_table(tb);
+			mnt_unref_table(tb);
 			tb = NULL;
 		}
 	}
@@ -740,7 +844,7 @@ struct libmnt_table *__mnt_new_table_from_file(const char *filename, int fmt)
  * @filename: /etc/{m,fs}tab or /proc/self/mountinfo path
  *
  * Same as mnt_new_table() + mnt_table_parse_file(). Use this function for private
- * files only. This function does not allow to use error callback, so you
+ * files only. This function does not allow using the error callback, so you
  * cannot provide any feedback to end-users about broken records in files (e.g.
  * fstab).
  *
@@ -767,7 +871,7 @@ struct libmnt_table *mnt_new_table_from_dir(const char *dirname)
 		return NULL;
 	tb = mnt_new_table();
 	if (tb && mnt_table_parse_dir(tb, dirname) != 0) {
-		mnt_free_table(tb);
+		mnt_unref_table(tb);
 		tb = NULL;
 	}
 	return tb;
@@ -779,13 +883,13 @@ struct libmnt_table *mnt_new_table_from_dir(const char *dirname)
  * @cb: pointer to callback function
  *
  * The error callback function is called by table parser (mnt_table_parse_file())
- * in case of syntax error. The callback function could be used for errors
+ * in case of a syntax error. The callback function could be used for error
  * evaluation, libmount will continue/stop parsing according to callback return
  * codes:
  *
  *   <0  : fatal error (abort parsing)
- *    0	 : success (parsing continue)
- *   >0  : recoverable error (the line is ignored, parsing continue).
+ *    0	 : success (parsing continues)
+ *   >0  : recoverable error (the line is ignored, parsing continues).
  *
  * Returns: 0 on success or negative number in case of error.
  */
@@ -800,7 +904,7 @@ int mnt_table_set_parser_errcb(struct libmnt_table *tb,
 }
 
 /*
- * Filter out entries during tab file parsing. If @cb returns 1 then the entry
+ * Filter out entries during tab file parsing. If @cb returns 1, then the entry
  * is ignored.
  */
 int mnt_table_set_parser_fltrcb(struct libmnt_table *tb,
@@ -851,7 +955,7 @@ int mnt_table_parse_swaps(struct libmnt_table *tb, const char *filename)
  * @filename: overwrites default (/etc/fstab or $LIBMOUNT_FSTAB) or NULL
  *
  * This function parses /etc/fstab and appends new lines to the @tab. If the
- * @filename is a directory then mnt_table_parse_dir() is called.
+ * @filename is a directory, then mnt_table_parse_dir() is called.
  *
  * See also mnt_table_set_parser_errcb().
  *
@@ -884,7 +988,7 @@ int mnt_table_parse_fstab(struct libmnt_table *tb, const char *filename)
 }
 
 /*
- * This function uses @uf to found corresponding record in @tb, then the record
+ * This function uses @uf to find a corresponding record in @tb, then the record
  * from @tb is updated (user specific mount options are added).
  *
  * Note that @uf must contain only user specific mount options instead of
@@ -986,7 +1090,7 @@ int mnt_table_parse_mtab(struct libmnt_table *tb, const char *filename)
 	if (mnt_table_get_nents(tb) == 0)
 		return 0;			/* empty, ignore utab */
 	/*
-	 * try to read user specific information from /run/mount/utabs
+	 * try to read the user specific information from /run/mount/utabs
 	 */
 	utab = mnt_get_utab_path();
 	if (!utab || is_file_empty(utab))
@@ -1005,11 +1109,11 @@ int mnt_table_parse_mtab(struct libmnt_table *tb, const char *filename)
 
 		mnt_reset_iter(&itr, MNT_ITER_BACKWARD);
 
-		/*  merge user options into mountinfo from kernel */
+		/*  merge user options into mountinfo from the kernel */
 		while(mnt_table_next_fs(u_tb, &itr, &u_fs) == 0)
 			mnt_table_merge_user_fs(tb, u_fs);
 	}
 
-	mnt_free_table(u_tb);
+	mnt_unref_table(u_tb);
 	return 0;
 }
diff --git a/libmount/src/tab_update.c b/libmount/src/tab_update.c
index 1e7f32be0..13f6f6ebe 100644
--- a/libmount/src/tab_update.c
+++ b/libmount/src/tab_update.c
@@ -10,10 +10,10 @@
  * @title: Tables update
  * @short_description: userspace mount information management
  *
- * The struct libmnt_update provides abstraction to manage mount options in
- * userspace independently on system configuration. This low-level API works on
- * system with and without /etc/mtab. On systems without the regular /etc/mtab
- * file are userspace mount options (e.g. user=) stored to the /run/mount/utab
+ * The struct libmnt_update provides an abstraction to manage mount options in
+ * userspace independently of system configuration. This low-level API works on
+ * systems both with and without /etc/mtab. On systems without the regular /etc/mtab
+ * file, the userspace mount options (e.g. user=) are stored in the /run/mount/utab
  * file.
  *
  * It's recommended to use high-level struct libmnt_context API.
@@ -70,8 +70,8 @@ void mnt_free_update(struct libmnt_update *upd)
 
 	DBG(UPDATE, mnt_debug_h(upd, "free"));
 
-	mnt_free_fs(upd->fs);
-	mnt_free_table(upd->mountinfo);
+	mnt_unref_fs(upd->fs);
+	mnt_unref_table(upd->mountinfo);
 	free(upd->target);
 	free(upd->filename);
 	free(upd);
@@ -125,7 +125,7 @@ int mnt_update_set_filename(struct libmnt_update *upd, const char *filename,
  * mnt_update_get_filename:
  * @upd: update
  *
- * This function returns file name (e.g. /etc/mtab) for the up-dated file.
+ * This function returns the file name (e.g. /etc/mtab) of the up-dated file.
  *
  * Returns: pointer to filename that will be updated or NULL in case of error.
  */
@@ -140,7 +140,7 @@ const char *mnt_update_get_filename(struct libmnt_update *upd)
  * @upd: update handler
  *
  * Returns: 1 if entry described by @upd is successfully prepared and will be
- * written to mtab/utab file.
+ * written to the mtab/utab file.
  */
 int mnt_update_is_ready(struct libmnt_update *upd)
 {
@@ -180,7 +180,7 @@ int mnt_update_set_fs(struct libmnt_update *upd, unsigned long mountflags,
 		DBG(UPDATE, mnt_fs_print_debug(fs, stderr));
 	}
 
-	mnt_free_fs(upd->fs);
+	mnt_unref_fs(upd->fs);
 	free(upd->target);
 	upd->ready = FALSE;
 	upd->fs = NULL;
@@ -287,10 +287,10 @@ int mnt_update_force_rdonly(struct libmnt_update *upd, int rdonly)
 }
 
 /*
- * Allocates utab entry (upd->fs) for mount/remount. This function should be
+ * Allocates an utab entry (upd->fs) for mount/remount. This function should be
  * called *before* mount(2) syscall. The @fs is used as a read-only template.
  *
- * Returns: 0 on success, negative number on error, 1 if utabs update is
+ * Returns: 0 on success, negative number on error, 1 if utab's update is
  *          unnecessary.
  */
 static int utab_new_entry(struct libmnt_update *upd, struct libmnt_fs *fs,
@@ -350,14 +350,14 @@ static int utab_new_entry(struct libmnt_update *upd, struct libmnt_fs *fs,
 	return 0;
 err:
 	free(u);
-	mnt_free_fs(upd->fs);
+	mnt_unref_fs(upd->fs);
 	upd->fs = NULL;
 	return rc;
 }
 
 /*
  * Sets fs-root and fs-type to @upd->fs according to the @fs template and
- * @mountfalgs. For MS_BIND mountflag it reads information about source
+ * @mountfalgs. For MS_BIND mountflag it reads information about the source
  * filesystem from /proc/self/mountinfo.
  */
 static int set_fs_root(struct libmnt_update *upd, struct libmnt_fs *fs,
@@ -408,13 +408,14 @@ err:
  */
 static int fprintf_mtab_fs(FILE *f, struct libmnt_fs *fs)
 {
-	const char *o, *src, *fstype;
+	const char *o, *src, *fstype, *comm;
 	char *m1, *m2, *m3, *m4;
 	int rc;
 
 	assert(fs);
 	assert(f);
 
+	comm = mnt_fs_get_comment(fs);
 	src = mnt_fs_get_source(fs);
 	fstype = mnt_fs_get_fstype(fs);
 	o = mnt_fs_get_options(fs);
@@ -425,6 +426,8 @@ static int fprintf_mtab_fs(FILE *f, struct libmnt_fs *fs)
 	m4 = o ? mangle(o) : "rw";
 
 	if (m1 && m2 && m3 && m4) {
+		if (comm)
+			fputs(comm, f);
 		rc = fprintf(f, "%s %s %s %s %d %d\n",
 				m1, m2, m3, m4,
 				mnt_fs_get_freq(fs),
@@ -527,6 +530,10 @@ static int update_table(struct libmnt_update *upd, struct libmnt_table *tb)
 		struct libmnt_fs *fs;
 
 		mnt_reset_iter(&itr, MNT_ITER_FORWARD);
+
+		if (tb->comms && mnt_table_get_intro_comment(tb))
+			fputs(mnt_table_get_intro_comment(tb), f);
+
 		while(mnt_table_next_fs(tb, &itr, &fs) == 0) {
 			if (upd->userspace_only)
 				rc = fprintf_utab_fs(f, fs);
@@ -538,6 +545,8 @@ static int update_table(struct libmnt_update *upd, struct libmnt_table *tb)
 				goto leave;
 			}
 		}
+		if (tb->comms && mnt_table_get_trailing_comment(tb))
+			fputs(mnt_table_get_trailing_comment(tb), f);
 
 		if (fflush(f) != 0) {
 			rc = -errno;
@@ -570,6 +579,99 @@ leave:
 	return rc;
 }
 
+/**
+ * mnt_table_write_file
+ * @tb: parsed file (e.g. fstab)
+ * @file: target
+ *
+ * This function writes @tb to @file.
+ *
+ * Returns: 0 on success, negative number on error.
+ */
+int mnt_table_write_file(struct libmnt_table *tb, FILE *file)
+{
+	int rc = 0;
+	struct libmnt_iter itr;
+	struct libmnt_fs *fs;
+
+	if (tb->comms && mnt_table_get_intro_comment(tb))
+		fputs(mnt_table_get_intro_comment(tb), file);
+
+	mnt_reset_iter(&itr, MNT_ITER_FORWARD);
+	while(mnt_table_next_fs(tb, &itr, &fs) == 0) {
+		rc = fprintf_mtab_fs(file, fs);
+		if (rc)
+			return rc;
+	}
+	if (tb->comms && mnt_table_get_trailing_comment(tb))
+		fputs(mnt_table_get_trailing_comment(tb), file);
+
+	if (fflush(file) != 0)
+		rc = -errno;
+
+	DBG(TAB, mnt_debug_h(tb, "write file done [rc=%d]", rc));
+	return rc;
+}
+
+/**
+ * mnt_table_replace_file
+ * @tb: parsed file (e.g. fstab)
+ * @filename: target
+ *
+ * This function replaces @file by the new content from @tb.
+ *
+ * Returns: 0 on success, negative number on error.
+ */
+int mnt_table_replace_file(struct libmnt_table *tb, const char *filename)
+{
+	int fd, rc = 0;
+	FILE *f;
+	char *uq = NULL;
+
+	DBG(TAB, mnt_debug_h(tb, "%s: replacing", filename));
+
+	fd = mnt_open_uniq_filename(filename, &uq);
+	if (fd < 0)
+		return fd;	/* error */
+
+	f = fdopen(fd, "w" UL_CLOEXECSTR);
+	if (f) {
+		struct stat st;
+
+		mnt_table_write_file(tb, f);
+
+		if (fflush(f) != 0) {
+			rc = -errno;
+			DBG(UPDATE, mnt_debug("%s: fflush failed: %m", uq));
+			goto leave;
+		}
+
+		rc = fchmod(fd, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) ? -errno : 0;
+
+		if (!rc && stat(filename, &st) == 0)
+			/* Copy uid/gid from the present file before renaming. */
+			rc = fchown(fd, st.st_uid, st.st_gid) ? -errno : 0;
+
+		fclose(f);
+		f = NULL;
+
+		if (!rc)
+			rc = rename(uq, filename) ? -errno : 0;
+	} else {
+		rc = -errno;
+		close(fd);
+	}
+
+leave:
+	if (f)
+		fclose(f);
+	unlink(uq);
+	free(uq);
+
+	DBG(TAB, mnt_debug_h(tb, "replace done [rc=%d]", rc));
+	return rc;
+}
+
 static int add_file_entry(struct libmnt_table *tb, struct libmnt_update *upd)
 {
 	struct libmnt_fs *fs;
@@ -581,6 +683,8 @@ static int add_file_entry(struct libmnt_table *tb, struct libmnt_update *upd)
 		return -ENOMEM;
 
 	mnt_table_add_fs(tb, fs);
+	mnt_unref_fs(fs);
+
 	return update_table(upd, tb);
 }
 
@@ -606,7 +710,7 @@ static int update_add_entry(struct libmnt_update *upd, struct libmnt_lock *lc)
 	if (lc)
 		mnt_unlock_file(lc);
 
-	mnt_free_table(tb);
+	mnt_unref_table(tb);
 	return rc;
 }
 
@@ -632,13 +736,12 @@ static int update_remove_entry(struct libmnt_update *upd, struct libmnt_lock *lc
 		if (rem) {
 			mnt_table_remove_fs(tb, rem);
 			rc = update_table(upd, tb);
-			mnt_free_fs(rem);
 		}
 	}
 	if (lc)
 		mnt_unlock_file(lc);
 
-	mnt_free_table(tb);
+	mnt_unref_table(tb);
 	return rc;
 }
 
@@ -670,7 +773,7 @@ static int update_modify_target(struct libmnt_update *upd, struct libmnt_lock *l
 	if (lc)
 		mnt_unlock_file(lc);
 
-	mnt_free_table(tb);
+	mnt_unref_table(tb);
 	return rc;
 }
 
@@ -712,7 +815,7 @@ static int update_modify_options(struct libmnt_update *upd, struct libmnt_lock *
 	if (lc)
 		mnt_unlock_file(lc);
 
-	mnt_free_table(tb);
+	mnt_unref_table(tb);
 	return rc;
 }
 
@@ -724,7 +827,7 @@ static int update_modify_options(struct libmnt_update *upd, struct libmnt_lock *
  * High-level API to update /etc/mtab (or private /run/mount/utab file).
  *
  * The @lc lock is optional and will be created if necessary. Note that
- * the automatically created lock blocks all signals.
+ * an automatically created lock blocks all signals.
  *
  * See also mnt_lock_block_signals() and mnt_context_get_lock().
  *
@@ -794,7 +897,7 @@ static int update(const char *target, struct libmnt_fs *fs, unsigned long mountf
 		goto done;
 	}
 
-	/* [... here should be mount(2) call ...]  */
+	/* [... mount(2) call should be here...]  */
 
 	rc = mnt_update_table(upd, NULL);
 done:
@@ -815,7 +918,7 @@ static int test_add(struct libmnt_test *ts, int argc, char *argv[])
 	mnt_fs_set_options(fs, argv[4]);
 
 	rc = update(NULL, fs, 0);
-	mnt_free_fs(fs);
+	mnt_unref_fs(fs);
 	return rc;
 }
 
@@ -838,7 +941,7 @@ static int test_move(struct libmnt_test *ts, int argc, char *argv[])
 
 	rc = update(NULL, fs, MS_MOVE);
 
-	mnt_free_fs(fs);
+	mnt_unref_fs(fs);
 	return rc;
 }
 
@@ -853,17 +956,42 @@ static int test_remount(struct libmnt_test *ts, int argc, char *argv[])
 	mnt_fs_set_options(fs, argv[2]);
 
 	rc = update(NULL, fs, MS_REMOUNT);
-	mnt_free_fs(fs);
+	mnt_unref_fs(fs);
+	return rc;
+}
+
+static int test_replace(struct libmnt_test *ts, int argc, char *argv[])
+{
+	struct libmnt_fs *fs = mnt_new_fs();
+	struct libmnt_table *tb = mnt_new_table();
+	int rc;
+
+	if (argc < 3)
+		return -1;
+
+	mnt_table_enable_comments(tb, TRUE);
+	mnt_table_parse_fstab(tb, NULL);
+
+	mnt_fs_set_source(fs, argv[1]);
+	mnt_fs_set_target(fs, argv[2]);
+	mnt_fs_append_comment(fs, "# this is new filesystem\n");
+
+	mnt_table_add_fs(tb, fs);
+	mnt_unref_fs(fs);
+
+	rc = mnt_table_replace_file(tb, mnt_get_fstab_path());
+	mnt_unref_table(tb);
 	return rc;
 }
 
 int main(int argc, char *argv[])
 {
 	struct libmnt_test tss[] = {
-	{ "--add",    test_add,     "<src> <target> <type> <options>  add line to mtab" },
+	{ "--add",    test_add,     "<src> <target> <type> <options>  add a line to mtab" },
 	{ "--remove", test_remove,  "<target>                      MS_REMOUNT mtab change" },
 	{ "--move",   test_move,    "<old_target>  <target>        MS_MOVE mtab change" },
 	{ "--remount",test_remount, "<target>  <options>           MS_REMOUNT mtab change" },
+	{ "--replace",test_replace, "<src> <target>                Add a line to LIBMOUNT_FSTAB and replace the original file" },
 	{ NULL }
 	};
 
diff --git a/libmount/src/utils.c b/libmount/src/utils.c
index c328414f2..4111b595b 100644
--- a/libmount/src/utils.c
+++ b/libmount/src/utils.c
@@ -14,6 +14,7 @@
 #include <fcntl.h>
 #include <pwd.h>
 #include <grp.h>
+#include <blkid.h>
 
 #include "strutils.h"
 #include "pathnames.h"
@@ -23,39 +24,33 @@
 #include "env.h"
 #include "match.h"
 
-int endswith(const char *s, const char *sx)
+int append_string(char **a, const char *b)
 {
-	ssize_t off;
+	size_t al, bl;
+	char *tmp;
 
-	assert(s);
-	assert(sx);
+	assert(a);
 
-	off = strlen(s);
-	if (!off)
+	if (!b || !*b)
 		return 0;
-	off -= strlen(sx);
-	if (off < 0)
-		return 0;
-
-        return !strcmp(s + off, sx);
-}
-
-int startswith(const char *s, const char *sx)
-{
-	size_t off;
-
-	assert(s);
-	assert(sx);
+	if (!*a) {
+		*a = strdup(b);
+		return !*a ? -ENOMEM : 0;
+	}
 
-	off = strlen(sx);
-	if (!off)
-		return 0;
+	al = strlen(*a);
+	bl = strlen(b);
 
-        return !strncmp(s, sx, off);
+	tmp = realloc(*a, al + bl + 1);
+	if (!tmp)
+		return -ENOMEM;
+	*a = tmp;
+	memcpy((*a) + al, b, bl + 1);
+	return 0;
 }
 
 /*
- * Return 1 if the file does not accessible of empty
+ * Return 1 if the file is not accessible or empty
  */
 int is_file_empty(const char *name)
 {
@@ -65,6 +60,34 @@ int is_file_empty(const char *name)
 	return (stat(name, &st) != 0 || st.st_size == 0);
 }
 
+int mnt_valid_tagname(const char *tagname)
+{
+	if (tagname && *tagname && (
+	    strcmp("UUID", tagname) == 0 ||
+	    strcmp("LABEL", tagname) == 0 ||
+	    strcmp("PARTUUID", tagname) == 0 ||
+	    strcmp("PARTLABEL", tagname) == 0))
+		return 1;
+
+	return 0;
+}
+
+/**
+ * mnt_tag_is_valid:
+ * @tag: NAME=value string
+ *
+ * Returns: 1 if the @tag is parsable and tag NAME= is supported by libmount, or 0.
+ */
+int mnt_tag_is_valid(const char *tag)
+{
+	char *t = NULL;
+	int rc = tag && blkid_parse_tag_string(tag, &t, NULL) == 0
+		     && mnt_valid_tagname(t);
+
+	free(t);
+	return rc;
+}
+
 int mnt_parse_offset(const char *str, size_t len, uintmax_t *res)
 {
 	char *p;
@@ -105,8 +128,8 @@ char *stripoff_last_component(char *path)
 }
 
 /*
- * Note that the @target has to be absolute path (so at least "/").  The
- * @filename returns allocated buffer with last path component, for example:
+ * Note that the @target has to be an absolute path (so at least "/").  The
+ * @filename returns an allocated buffer with the last path component, for example:
  *
  * mnt_chdir_to_parent("/mnt/test", &buf) ==> chdir("/mnt"), buf="test"
  */
@@ -159,8 +182,9 @@ int mnt_chdir_to_parent(const char *target, char **filename)
 		if (!last || !*last)
 			memcpy(*filename, ".", 2);
 		else
-			memcpy(*filename, last, strlen(last) + 1);
-	}
+			memmove(*filename, last, strlen(last) + 1);
+	} else
+		free(buf);
 	return 0;
 err:
 	free(buf);
@@ -168,7 +192,7 @@ err:
 }
 
 /*
- * Check if @path is on read-only filesystem independently on file permissions.
+ * Check if @path is on a read-only filesystem independently of file permissions.
  */
 int mnt_is_readonly(const char *path)
 {
@@ -187,7 +211,7 @@ int mnt_is_readonly(const char *path)
 	 *   accessible for the current rUID. (Note that euidaccess(2) does not
 	 *   check for EROFS at all).
 	 *
-	 * - for read-write filesystem with read-only VFS node (aka -o remount,ro,bind)
+	 * - for a read-write filesystem with a read-only VFS node (aka -o remount,ro,bind)
 	 */
 	{
 		struct timespec times[2];
@@ -208,7 +232,7 @@ int mnt_is_readonly(const char *path)
  *
  * Encode @str to be compatible with fstab/mtab
  *
- * Returns: new allocated string or NULL in case of error.
+ * Returns: newly allocated string or NULL in case of error.
  */
 char *mnt_mangle(const char *str)
 {
@@ -221,7 +245,7 @@ char *mnt_mangle(const char *str)
  *
  * Decode @str from fstab/mtab
  *
- * Returns: new allocated string or NULL in case of error.
+ * Returns: newly allocated string or NULL in case of error.
  */
 char *mnt_unmangle(const char *str)
 {
@@ -250,8 +274,9 @@ int mnt_fstype_is_pseudofs(const char *type)
 		"devpts",
 		"devtmpfs",
 		"dlmfs",
-		"fuse.gvfs-fuse-daemon",
+		"efivarfs",
 		"fusectl",
+		"fuse.gvfs-fuse-daemon",
 		"hugetlbfs",
 		"mqueue",
 		"nfsd",
@@ -300,7 +325,7 @@ int mnt_fstype_is_netfs(const char *type)
  * @type: filesystem type
  * @pattern: filesystem name or comma delimited list of names
  *
- * The @pattern list of filesystem can be prefixed with a global
+ * The @pattern list of filesystems can be prefixed with a global
  * "no" prefix to invert matching of the whole list. The "no" could
  * also be used for individual items in the @pattern list. So,
  * "nofoo,bar" has the same meaning as "nofoo,nobar".
@@ -358,14 +383,14 @@ static int check_option(const char *haystack, size_t len,
  * @optstr: options string
  * @pattern: comma delimited list of options
  *
- * The "no" could used for individual items in the @options list. The "no"
+ * The "no" could be used for individual items in the @options list. The "no"
  * prefix does not have a global meaning.
  *
  * Unlike fs type matching, nonetdev,user and nonetdev,nouser have
  * DIFFERENT meanings; each option is matched explicitly as specified.
  *
- * The "no" prefix interpretation could be disable by "+" prefix, for example
- * "+noauto" matches if @optstr literally contains "noauto" string.
+ * The "no" prefix interpretation could be disabled by the "+" prefix, for example
+ * "+noauto" matches if @optstr literally contains the "noauto" string.
  *
  * "xxx,yyy,zzz" : "nozzz"	-> False
  *
@@ -495,7 +520,7 @@ static int get_filesystems(const char *filename, char ***filesystems, const char
 }
 
 /*
- * Always check @filesystems pointer!
+ * Always check the @filesystems pointer!
  *
  * man mount:
  *
@@ -520,7 +545,7 @@ int mnt_get_filesystems(char ***filesystems, const char *pattern)
 
 	rc = get_filesystems(_PATH_PROC_FILESYSTEMS, filesystems, pattern);
 	if (rc == 1 && *filesystems)
-		rc = 0;			/* not found /proc/filesystems */
+		rc = 0;			/* /proc/filesystems not found */
 
 	return rc;
 }
@@ -536,7 +561,7 @@ static size_t get_pw_record_size(void)
 }
 
 /*
- * Returns allocated string with username or NULL.
+ * Returns an allocated string with username or NULL.
  */
 char *mnt_get_username(const uid_t uid)
 {
@@ -662,8 +687,8 @@ static int try_write(const char *filename)
  * @mtab: returns path to mtab
  * @writable: returns 1 if the file is writable
  *
- * If the file does not exist and @writable argument is not NULL then it will
- * try to create the file
+ * If the file does not exist and @writable argument is not NULL, then it will
+ * try to create the file.
  *
  * Returns: 1 if /etc/mtab is a regular file, and 0 in case of error (check
  *          errno for more details).
@@ -684,7 +709,7 @@ int mnt_has_regular_mtab(const char **mtab, int *writable)
 	rc = lstat(filename, &st);
 
 	if (rc == 0) {
-		/* file exist */
+		/* file exists */
 		if (S_ISREG(st.st_mode)) {
 			if (writable)
 				*writable = !try_write(filename);
@@ -708,7 +733,7 @@ done:
 /*
  * Don't export this to libmount API -- utab is private library stuff.
  *
- * If the file does not exist and @writable argument is not NULL then it will
+ * If the file does not exist and @writable argument is not NULL, then it will
  * try to create the directory (e.g. /run/mount) and the file.
  *
  * Returns: 1 if utab is a regular file, and 0 in case of
@@ -730,13 +755,13 @@ int mnt_has_regular_utab(const char **utab, int *writable)
 	rc = lstat(filename, &st);
 
 	if (rc == 0) {
-		/* file exist */
+		/* file exists */
 		if (S_ISREG(st.st_mode)) {
 			if (writable)
 				*writable = !try_write(filename);
 			return 1;
 		}
-		goto done;	/* it's not regular file */
+		goto done;	/* it's not a regular file */
 	}
 
 	if (writable) {
@@ -788,7 +813,7 @@ const char *mnt_get_fstab_path(void)
 /**
  * mnt_get_mtab_path:
  *
- * This function returns *default* location of the mtab file. The result does
+ * This function returns the *default* location of the mtab file. The result does
  * not have to be writable. See also mnt_has_regular_mtab().
  *
  * Returns: path to /etc/mtab or $LIBMOUNT_MTAB.
@@ -819,7 +844,7 @@ const char *mnt_get_utab_path(void)
 }
 
 
-/* returns file descriptor or -errno, @name returns uniques filename
+/* returns file descriptor or -errno, @name returns a unique filename
  */
 int mnt_open_uniq_filename(const char *filename, char **name)
 {
@@ -836,12 +861,14 @@ int mnt_open_uniq_filename(const char *filename, char **name)
 	if (rc <= 0)
 		return -errno;
 
-	/* This is for very old glibc and for compatibility with Posix where is
+	/* This is for very old glibc and for compatibility with Posix, which says
 	 * nothing about mkstemp() mode. All sane glibc use secure mode (0600).
 	 */
 	oldmode = umask(S_IRGRP|S_IWGRP|S_IXGRP|
 			S_IROTH|S_IWOTH|S_IXOTH);
 	fd = mkostemp(n, O_RDWR|O_CREAT|O_EXCL|O_CLOEXEC);
+	if (fd < 0)
+		fd = -errno;
 	umask(oldmode);
 
 	if (fd >= 0 && name)
@@ -849,7 +876,7 @@ int mnt_open_uniq_filename(const char *filename, char **name)
 	else
 		free(n);
 
-	return fd < 0 ? -errno : fd;
+	return fd;
 }
 
 /**
@@ -859,7 +886,7 @@ int mnt_open_uniq_filename(const char *filename, char **name)
  * This function finds the mountpoint that a given path resides in. @path
  * should be canonicalized. The returned pointer should be freed by the caller.
  *
- * Returns: allocated string with target of the mounted device or NULL on error
+ * Returns: allocated string with the target of the mounted device or NULL on error
  */
 char *mnt_get_mountpoint(const char *path)
 {
@@ -929,7 +956,7 @@ char *mnt_get_fs_root(const char *path, const char *mnt)
 /*
  * Search for @name kernel command parametr.
  *
- * Returns newly allocated string with parameter argument if the @name is
+ * Returns newly allocated string with a parameter argument if the @name is
  * specified as "name=" or returns pointer to @name or returns NULL if not
  * found.
  *
@@ -979,7 +1006,7 @@ char *mnt_get_kernel_cmdline_option(const char *name)
 		if (p != buf && !isblank(*(p - 1)))
 			continue;		/* no space before the option */
 		if (!val && *(p + len) != '\0' && !isblank(*(p + len)))
-			continue;		/* no space behind the option */
+			continue;		/* no space after the option */
 		if (val) {
 			char *v = p + len;
 
@@ -1070,6 +1097,18 @@ int test_endswith(struct libmnt_test *ts, int argc, char *argv[])
 	return 0;
 }
 
+int test_appendstr(struct libmnt_test *ts, int argc, char *argv[])
+{
+	char *str = strdup(argv[1]);
+	const char *ap = argv[2];
+
+	append_string(&str, ap);
+	printf("new string: '%s'\n", str);
+
+	free(str);
+	return 0;
+}
+
 int test_mountpoint(struct libmnt_test *ts, int argc, char *argv[])
 {
 	char *path = canonicalize_path(argv[1]),
@@ -1165,6 +1204,7 @@ int main(int argc, char *argv[])
 	{ "--filesystems",   test_filesystems,	   "[<pattern>] list /{etc,proc}/filesystems" },
 	{ "--starts-with",   test_startswith,      "<string> <prefix>" },
 	{ "--ends-with",     test_endswith,        "<string> <prefix>" },
+	{ "--append-string", test_appendstr,       "<string> <appendix>" },
 	{ "--mountpoint",    test_mountpoint,      "<path>" },
 	{ "--fs-root",       test_fsroot,          "<path>" },
 	{ "--cd-parent",     test_chdir,           "<path>" },
diff --git a/libmount/src/version.c b/libmount/src/version.c
index 00b7c03e7..b72956230 100644
--- a/libmount/src/version.c
+++ b/libmount/src/version.c
@@ -10,7 +10,7 @@
 /**
  * SECTION: version
  * @title: Version functions
- * @short_description: functions to get library version.
+ * @short_description: functions to get the library version.
  */
 
 #include <ctype.h>
@@ -70,11 +70,11 @@ int mnt_get_library_version(const char **ver_string)
 
 /**
  * mnt_get_library_features:
- * @features: returns pointer to the static array of strings, the array is
+ * @features: returns a pointer to the static array of strings, the array is
  *            terminated by NULL.
  *
  * Returns: number of items in the features array not including the last NULL,
- *          or less then zero in case of error
+ *          or less than zero in case of error
  *
  * Example:
  * <informalexample>