diff --git a/0001-libmount-fix-mount.nfs-segfault-rely-on-assert-rathe.patch b/0001-libmount-fix-mount.nfs-segfault-rely-on-assert-rathe.patch
new file mode 100644
index 0000000..a2d2223
--- /dev/null
+++ b/0001-libmount-fix-mount.nfs-segfault-rely-on-assert-rathe.patch
@@ -0,0 +1,1340 @@
+From 4569bbeab783632c81ee14793da84b3e29444543 Mon Sep 17 00:00:00 2001
+From: Karel Zak <kzak@redhat.com>
+Date: Fri, 12 Apr 2013 12:35:34 +0200
+Subject: [PATCH] libmount: fix mount.nfs segfault, rely on assert() rather
+ than on nonnull
+
+We use
+   mnt_optstr_append_option(&o, mnt_fs_get_vfs_options(fs), NULL);
+
+in mount.nfs, unfortunately mnt_optstr_append_option() has been marked
+ass nonnull(1, 2). That's wrong because append and prepend should
+robust enough to accept NULL as option name.
+
+The patch also removes almost all __attribute__((nonnull). It seems
+better to rely on assert() to have usable feedback. In many cases
+(nonnull) is premature optimization for the library. This attribute
+makes sense for things like strlen() or so...
+
+Addresses: https://bugzilla.redhat.com/show_bug.cgi?id=948274
+Signed-off-by: Karel Zak <kzak@redhat.com>
+---
+ libmount/src/context.c     |  55 ++++++++++--
+ libmount/src/fs.c          |  34 ++++++--
+ libmount/src/libmount.h.in | 202 ++++++++++++++++-----------------------------
+ libmount/src/lock.c        |   2 +
+ libmount/src/mountP.h      |   4 +-
+ libmount/src/optstr.c      |  26 +++++-
+ libmount/src/tab_parse.c   |   8 +-
+ libmount/src/tab_update.c  |  13 ++-
+ libmount/src/utils.c       |   9 +-
+ libmount/src/version.c     |   5 ++
+ 10 files changed, 202 insertions(+), 156 deletions(-)
+
+diff --git a/libmount/src/context.c b/libmount/src/context.c
+index 614d3f3..38f80de 100644
+--- a/libmount/src/context.c
++++ b/libmount/src/context.c
+@@ -196,6 +196,7 @@ int mnt_reset_context(struct libmnt_context *cxt)
+  */
+ int mnt_context_reset_status(struct libmnt_context *cxt)
+ {
++	assert(cxt);
+ 	if (!cxt)
+ 		return -EINVAL;
+ 
+@@ -207,6 +208,7 @@ int mnt_context_reset_status(struct libmnt_context *cxt)
+ 
+ static int set_flag(struct libmnt_context *cxt, int flag, int enable)
+ {
++	assert(cxt);
+ 	if (!cxt)
+ 		return -EINVAL;
+ 	if (enable) {
+@@ -227,7 +229,6 @@ static int set_flag(struct libmnt_context *cxt, int flag, int enable)
+  */
+ int mnt_context_is_restricted(struct libmnt_context *cxt)
+ {
+-	assert(cxt);
+ 	return cxt->restricted;
+ }
+ 
+@@ -270,6 +271,7 @@ int mnt_context_is_restricted(struct libmnt_context *cxt)
+  */
+ int mnt_context_set_optsmode(struct libmnt_context *cxt, int mode)
+ {
++	assert(cxt);
+ 	if (!cxt)
+ 		return -EINVAL;
+ 	cxt->optsmode = mode;
+@@ -285,6 +287,7 @@ int mnt_context_set_optsmode(struct libmnt_context *cxt, int mode)
+ 
+ int mnt_context_get_optsmode(struct libmnt_context *cxt)
+ {
++	assert(cxt);
+ 	return cxt->optsmode;
+ }
+ 
+@@ -663,6 +666,7 @@ int mnt_context_set_fs(struct libmnt_context *cxt, struct libmnt_fs *fs)
+  */
+ struct libmnt_fs *mnt_context_get_fs(struct libmnt_context *cxt)
+ {
++	assert(cxt);
+ 	if (!cxt)
+ 		return NULL;
+ 	if (!cxt->fs) {
+@@ -681,6 +685,7 @@ struct libmnt_fs *mnt_context_get_fs(struct libmnt_context *cxt)
+  */
+ int mnt_context_set_source(struct libmnt_context *cxt, const char *source)
+ {
++	assert(cxt);
+ 	return mnt_fs_set_source(mnt_context_get_fs(cxt), source);
+ }
+ 
+@@ -692,6 +697,7 @@ int mnt_context_set_source(struct libmnt_context *cxt, const char *source)
+  */
+ const char *mnt_context_get_source(struct libmnt_context *cxt)
+ {
++	assert(cxt);
+ 	return mnt_fs_get_source(mnt_context_get_fs(cxt));
+ }
+ 
+@@ -704,6 +710,7 @@ const char *mnt_context_get_source(struct libmnt_context *cxt)
+  */
+ int mnt_context_set_target(struct libmnt_context *cxt, const char *target)
+ {
++	assert(cxt);
+ 	return mnt_fs_set_target(mnt_context_get_fs(cxt), target);
+ }
+ 
+@@ -715,6 +722,7 @@ int mnt_context_set_target(struct libmnt_context *cxt, const char *target)
+  */
+ const char *mnt_context_get_target(struct libmnt_context *cxt)
+ {
++	assert(cxt);
+ 	return mnt_fs_get_target(mnt_context_get_fs(cxt));
+ }
+ 
+@@ -731,6 +739,7 @@ const char *mnt_context_get_target(struct libmnt_context *cxt)
+  */
+ int mnt_context_set_fstype(struct libmnt_context *cxt, const char *fstype)
+ {
++	assert(cxt);
+ 	return mnt_fs_set_fstype(mnt_context_get_fs(cxt), fstype);
+ }
+ 
+@@ -742,6 +751,7 @@ int mnt_context_set_fstype(struct libmnt_context *cxt, const char *fstype)
+  */
+ const char *mnt_context_get_fstype(struct libmnt_context *cxt)
+ {
++	assert(cxt);
+ 	return mnt_fs_get_fstype(mnt_context_get_fs(cxt));
+ }
+ 
+@@ -754,6 +764,7 @@ const char *mnt_context_get_fstype(struct libmnt_context *cxt)
+  */
+ int mnt_context_set_options(struct libmnt_context *cxt, const char *optstr)
+ {
++	assert(cxt);
+ 	return mnt_fs_set_options(mnt_context_get_fs(cxt), optstr);
+ }
+ 
+@@ -766,6 +777,7 @@ int mnt_context_set_options(struct libmnt_context *cxt, const char *optstr)
+  */
+ int mnt_context_append_options(struct libmnt_context *cxt, const char *optstr)
+ {
++	assert(cxt);
+ 	return mnt_fs_append_options(mnt_context_get_fs(cxt), optstr);
+ }
+ 
+@@ -784,6 +796,7 @@ int mnt_context_append_options(struct libmnt_context *cxt, const char *optstr)
+  */
+ const char *mnt_context_get_options(struct libmnt_context *cxt)
+ {
++	assert(cxt);
+ 	return mnt_fs_get_options(mnt_context_get_fs(cxt));
+ }
+ 
+@@ -800,6 +813,7 @@ int mnt_context_set_fstype_pattern(struct libmnt_context *cxt, const char *patte
+ {
+ 	char *p = NULL;
+ 
++	assert(cxt);
+ 	if (!cxt)
+ 		return -EINVAL;
+ 	if (pattern) {
+@@ -825,6 +839,7 @@ int mnt_context_set_options_pattern(struct libmnt_context *cxt, const char *patt
+ {
+ 	char *p = NULL;
+ 
++	assert(cxt);
+ 	if (!cxt)
+ 		return -EINVAL;
+ 	if (pattern) {
+@@ -856,6 +871,7 @@ int mnt_context_set_options_pattern(struct libmnt_context *cxt, const char *patt
+  */
+ 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))
+@@ -879,9 +895,9 @@ int mnt_context_get_fstab(struct libmnt_context *cxt, struct libmnt_table **tb)
+ {
+ 	struct libmnt_cache *cache;
+ 
++	assert(cxt);
+ 	if (!cxt)
+ 		return -EINVAL;
+-
+ 	if (!cxt->fstab) {
+ 		int rc;
+ 
+@@ -921,9 +937,9 @@ int mnt_context_get_mtab(struct libmnt_context *cxt, struct libmnt_table **tb)
+ {
+ 	struct libmnt_cache *cache;
+ 
++	assert(cxt);
+ 	if (!cxt)
+ 		return -EINVAL;
+-
+ 	if (!cxt->mtab) {
+ 		int rc;
+ 
+@@ -962,6 +978,7 @@ int mnt_context_set_tabfilter(struct libmnt_context *cxt,
+ 			      int (*fltr)(struct libmnt_fs *, void *),
+ 			      void *data)
+ {
++	assert(cxt);
+ 	if (!cxt)
+ 		return -EINVAL;
+ 
+@@ -1002,6 +1019,8 @@ int mnt_context_get_table(struct libmnt_context *cxt,
+ 	struct libmnt_cache *cache;
+ 	int rc;
+ 
++	assert(cxt);
++	assert(tb);
+ 	if (!cxt || !tb)
+ 		return -EINVAL;
+ 
+@@ -1042,6 +1061,7 @@ int mnt_context_get_table(struct libmnt_context *cxt,
+ int mnt_context_set_tables_errcb(struct libmnt_context *cxt,
+ 	int (*cb)(struct libmnt_table *tb, const char *filename, int line))
+ {
++	assert(cxt);
+ 	if (!cxt)
+ 		return -EINVAL;
+ 
+@@ -1085,6 +1105,7 @@ int mnt_context_set_cache(struct libmnt_context *cxt, struct libmnt_cache *cache
+  */
+ struct libmnt_cache *mnt_context_get_cache(struct libmnt_context *cxt)
+ {
++	assert(cxt);
+ 	if (!cxt || mnt_context_is_nocanonicalize(cxt))
+ 		return NULL;
+ 
+@@ -1112,9 +1133,9 @@ int mnt_context_set_passwd_cb(struct libmnt_context *cxt,
+ 			      char *(*get)(struct libmnt_context *),
+ 			      void (*release)(struct libmnt_context *, char *))
+ {
++	assert(cxt);
+ 	if (!cxt)
+ 		return -EINVAL;
+-
+ 	cxt->pwd_get_cb = get;
+ 	cxt->pwd_release_cb = release;
+ 	return 0;
+@@ -1142,6 +1163,7 @@ int mnt_context_set_passwd_cb(struct libmnt_context *cxt,
+  */
+ struct libmnt_lock *mnt_context_get_lock(struct libmnt_context *cxt)
+ {
++	assert(cxt);
+ 	/*
+ 	 * DON'T call this function within libmount, it will always allocate
+ 	 * the lock. The mnt_update_* functions are able to allocate the lock
+@@ -1181,6 +1203,7 @@ struct libmnt_lock *mnt_context_get_lock(struct libmnt_context *cxt)
+  */
+ int mnt_context_set_mflags(struct libmnt_context *cxt, unsigned long flags)
+ {
++	assert(cxt);
+ 	if (!cxt)
+ 		return -EINVAL;
+ 
+@@ -1213,6 +1236,8 @@ int mnt_context_get_mflags(struct libmnt_context *cxt, unsigned long *flags)
+ 	int rc = 0;
+ 	struct list_head *p;
+ 
++	assert(cxt);
++	assert(flags);
+ 	if (!cxt || !flags)
+ 		return -EINVAL;
+ 
+@@ -1249,6 +1274,7 @@ int mnt_context_get_mflags(struct libmnt_context *cxt, unsigned long *flags)
+  */
+ int mnt_context_set_user_mflags(struct libmnt_context *cxt, unsigned long flags)
+ {
++	assert(cxt);
+ 	if (!cxt)
+ 		return -EINVAL;
+ 	cxt->user_mountflags = flags;
+@@ -1268,6 +1294,9 @@ int mnt_context_set_user_mflags(struct libmnt_context *cxt, unsigned long flags)
+ int mnt_context_get_user_mflags(struct libmnt_context *cxt, unsigned long *flags)
+ {
+ 	int rc = 0;
++
++	assert(cxt);
++	assert(flags);
+ 	if (!cxt || !flags)
+ 		return -EINVAL;
+ 
+@@ -1299,6 +1328,7 @@ int mnt_context_get_user_mflags(struct libmnt_context *cxt, unsigned long *flags
+  */
+ int mnt_context_set_mountdata(struct libmnt_context *cxt, void *data)
+ {
++	assert(cxt);
+ 	if (!cxt)
+ 		return -EINVAL;
+ 	cxt->mountdata = data;
+@@ -1908,6 +1938,7 @@ int mnt_context_apply_fstab(struct libmnt_context *cxt)
+  */
+ int mnt_context_tab_applied(struct libmnt_context *cxt)
+ {
++	assert(cxt);
+ 	return cxt->flags & MNT_FL_TAB_APPLIED;
+ }
+ 
+@@ -1949,6 +1980,7 @@ int mnt_context_propagation_only(struct libmnt_context *cxt)
+  */
+ int mnt_context_get_status(struct libmnt_context *cxt)
+ {
++	assert(cxt);
+ 	return !cxt->syscall_status || !cxt->helper_exec_status;
+ }
+ 
+@@ -1960,6 +1992,7 @@ int mnt_context_get_status(struct libmnt_context *cxt)
+  */
+ int mnt_context_helper_executed(struct libmnt_context *cxt)
+ {
++	assert(cxt);
+ 	return cxt->helper_exec_status != 1;
+ }
+ 
+@@ -1972,6 +2005,7 @@ int mnt_context_helper_executed(struct libmnt_context *cxt)
+  */
+ int mnt_context_get_helper_status(struct libmnt_context *cxt)
+ {
++	assert(cxt);
+ 	return cxt->helper_status;
+ }
+ 
+@@ -1983,6 +2017,7 @@ int mnt_context_get_helper_status(struct libmnt_context *cxt)
+  */
+ int mnt_context_syscall_called(struct libmnt_context *cxt)
+ {
++	assert(cxt);
+ 	return cxt->syscall_status != 1;
+ }
+ 
+@@ -1997,9 +2032,9 @@ int mnt_context_syscall_called(struct libmnt_context *cxt)
+  */
+ int mnt_context_get_syscall_errno(struct libmnt_context *cxt)
+ {
++	assert(cxt);
+ 	if (cxt->syscall_status < 0)
+ 		return -cxt->syscall_status;
+-
+ 	return 0;
+ }
+ 
+@@ -2017,6 +2052,7 @@ int mnt_context_get_syscall_errno(struct libmnt_context *cxt)
+  */
+ int mnt_context_set_syscall_status(struct libmnt_context *cxt, int status)
+ {
++	assert(cxt);
+ 	if (!cxt)
+ 		return -EINVAL;
+ 
+@@ -2063,8 +2099,11 @@ int mnt_context_strerror(struct libmnt_context *cxt __attribute__((__unused__)),
+ int mnt_context_init_helper(struct libmnt_context *cxt, int action,
+ 			    int flags __attribute__((__unused__)))
+ {
+-	int rc = mnt_context_disable_helpers(cxt, TRUE);
++	int rc;
+ 
++	assert(cxt);
++
++	rc = mnt_context_disable_helpers(cxt, TRUE);
+ 	if (!rc)
+ 		rc = set_flag(cxt, MNT_FL_HELPER, 1);
+ 	if (!rc)
+@@ -2115,6 +2154,7 @@ int mnt_context_is_fs_mounted(struct libmnt_context *cxt,
+ 	struct libmnt_table *mtab;
+ 	int rc;
+ 
++	assert(cxt);
+ 	if (!cxt || !fs || !mounted)
+ 		return -EINVAL;
+ 
+@@ -2130,6 +2170,7 @@ static int mnt_context_add_child(struct libmnt_context *cxt, pid_t pid)
+ {
+ 	pid_t *pids;
+ 
++	assert(cxt);
+ 	if (!cxt)
+ 		return -EINVAL;
+ 
+@@ -2149,6 +2190,7 @@ int mnt_fork_context(struct libmnt_context *cxt)
+ 	int rc = 0;
+ 	pid_t pid;
+ 
++	assert(cxt);
+ 	if (!mnt_context_is_parent(cxt))
+ 		return -EINVAL;
+ 
+@@ -2182,6 +2224,7 @@ int mnt_context_wait_for_children(struct libmnt_context *cxt,
+ {
+ 	int i;
+ 
++	assert(cxt);
+ 	if (!cxt)
+ 		return -EINVAL;
+ 
+diff --git a/libmount/src/fs.c b/libmount/src/fs.c
+index bb9006d..c95cdc7 100644
+--- a/libmount/src/fs.c
++++ b/libmount/src/fs.c
+@@ -131,7 +131,6 @@ struct libmnt_fs *mnt_copy_fs(struct libmnt_fs *dest,
+ 
+ 	if (!src)
+ 		return NULL;
+-
+ 	if (!dest) {
+ 		dest = mnt_new_fs();
+ 		if (!dest)
+@@ -197,6 +196,7 @@ struct libmnt_fs *mnt_copy_mtab_fs(const struct libmnt_fs *fs)
+ {
+ 	struct libmnt_fs *n = mnt_new_fs();
+ 
++	assert(fs);
+ 	if (!n)
+ 		return NULL;
+ 
+@@ -249,6 +249,7 @@ err:
+  */
+ void *mnt_fs_get_userdata(struct libmnt_fs *fs)
+ {
++	assert(fs);
+ 	return fs ? fs->userdata : NULL;
+ }
+ 
+@@ -263,6 +264,7 @@ void *mnt_fs_get_userdata(struct libmnt_fs *fs)
+  */
+ int mnt_fs_set_userdata(struct libmnt_fs *fs, void *data)
+ {
++	assert(fs);
+ 	if (!fs)
+ 		return -EINVAL;
+ 	fs->userdata = data;
+@@ -303,6 +305,7 @@ const char *mnt_fs_get_srcpath(struct libmnt_fs *fs)
+  */
+ const char *mnt_fs_get_source(struct libmnt_fs *fs)
+ {
++	assert(fs);
+ 	return fs ? fs->source : NULL;
+ }
+ 
+@@ -346,6 +349,7 @@ int mnt_fs_set_source(struct libmnt_fs *fs, const char *source)
+ 	char *p = NULL;
+ 	int rc;
+ 
++	assert(fs);
+ 	if (!fs)
+ 		return -EINVAL;
+ 
+@@ -375,6 +379,7 @@ int mnt_fs_streq_srcpath(struct libmnt_fs *fs, const char *path)
+ {
+ 	const char *p;
+ 
++	assert(fs);
+ 	if (!fs)
+ 		return 0;
+ 
+@@ -401,6 +406,7 @@ int mnt_fs_streq_srcpath(struct libmnt_fs *fs, const char *path)
+  */
+ int mnt_fs_streq_target(struct libmnt_fs *fs, const char *path)
+ {
++	assert(fs);
+ 	return fs && streq_except_trailing_slash(mnt_fs_get_target(fs), path);
+ }
+ 
+@@ -439,6 +445,7 @@ int mnt_fs_streq_target(struct libmnt_fs *fs, const char *path)
+  */
+ int mnt_fs_get_tag(struct libmnt_fs *fs, const char **name, const char **value)
+ {
++	assert(fs);
+ 	if (fs == NULL || !fs->tagname)
+ 		return -EINVAL;
+ 	if (name)
+@@ -474,7 +481,6 @@ int mnt_fs_set_target(struct libmnt_fs *fs, const char *target)
+ 	char *p = NULL;
+ 
+ 	assert(fs);
+-
+ 	if (!fs)
+ 		return -EINVAL;
+ 	if (target) {
+@@ -506,6 +512,7 @@ static int mnt_fs_get_flags(struct libmnt_fs *fs)
+  */
+ int mnt_fs_get_propagation(struct libmnt_fs *fs, unsigned long *flags)
+ {
++	assert(fs);
+ 	if (!fs || !flags)
+ 		return -EINVAL;
+ 
+@@ -547,6 +554,7 @@ int mnt_fs_is_kernel(struct libmnt_fs *fs)
+  */
+ int mnt_fs_is_swaparea(struct libmnt_fs *fs)
+ {
++	assert(fs);
+ 	return mnt_fs_get_flags(fs) & MNT_FS_SWAP;
+ }
+ 
+@@ -558,6 +566,7 @@ int mnt_fs_is_swaparea(struct libmnt_fs *fs)
+  */
+ int mnt_fs_is_pseudofs(struct libmnt_fs *fs)
+ {
++	assert(fs);
+ 	return mnt_fs_get_flags(fs) & MNT_FS_PSEUDO;
+ }
+ 
+@@ -569,6 +578,7 @@ int mnt_fs_is_pseudofs(struct libmnt_fs *fs)
+  */
+ int mnt_fs_is_netfs(struct libmnt_fs *fs)
+ {
++	assert(fs);
+ 	return mnt_fs_get_flags(fs) & MNT_FS_NET;
+ }
+ 
+@@ -622,6 +632,7 @@ int mnt_fs_set_fstype(struct libmnt_fs *fs, const char *fstype)
+ {
+ 	char *p = NULL;
+ 
++	assert(fs);
+ 	if (!fs)
+ 		return -EINVAL;
+ 	if (fstype) {
+@@ -700,9 +711,7 @@ char *mnt_fs_strdup_options(struct libmnt_fs *fs)
+ 	char *res;
+ 
+ 	assert(fs);
+-
+ 	errno = 0;
+-
+ 	if (fs->optstr)
+ 		return strdup(fs->optstr);
+ 
+@@ -758,7 +767,6 @@ int mnt_fs_set_options(struct libmnt_fs *fs, const char *optstr)
+ 	char *v = NULL, *f = NULL, *u = NULL, *n = NULL;
+ 
+ 	assert(fs);
+-
+ 	if (!fs)
+ 		return -EINVAL;
+ 	if (optstr) {
+@@ -801,7 +809,6 @@ int mnt_fs_append_options(struct libmnt_fs *fs, const char *optstr)
+ 	int rc;
+ 
+ 	assert(fs);
+-
+ 	if (!fs)
+ 		return -EINVAL;
+ 	if (!optstr)
+@@ -842,7 +849,6 @@ int mnt_fs_prepend_options(struct libmnt_fs *fs, const char *optstr)
+ 	int rc;
+ 
+ 	assert(fs);
+-
+ 	if (!fs)
+ 		return -EINVAL;
+ 	if (!optstr)
+@@ -932,6 +938,7 @@ int mnt_fs_set_attributes(struct libmnt_fs *fs, const char *optstr)
+ {
+ 	char *p = NULL;
+ 
++	assert(fs);
+ 	if (!fs)
+ 		return -EINVAL;
+ 	if (optstr) {
+@@ -974,6 +981,7 @@ int mnt_fs_append_attributes(struct libmnt_fs *fs, const char *optstr)
+  */
+ int mnt_fs_prepend_attributes(struct libmnt_fs *fs, const char *optstr)
+ {
++	assert(fs);
+ 	if (!fs)
+ 		return -EINVAL;
+ 	if (!optstr)
+@@ -1235,6 +1243,7 @@ int mnt_fs_get_option(struct libmnt_fs *fs, const char *name,
+ {
+ 	char rc = 1;
+ 
++	assert(fs);
+ 	if (!fs)
+ 		return -EINVAL;
+ 	if (fs->fs_optstr)
+@@ -1260,6 +1269,9 @@ int mnt_fs_get_attribute(struct libmnt_fs *fs, const char *name,
+ {
+ 	char rc = 1;
+ 
++	assert(fs);
++	if (!fs)
++		return -EINVAL;
+ 	if (fs->attrs)
+ 		rc = mnt_optstr_get_option(fs->attrs, name, value, valsz);
+ 	return rc;
+@@ -1286,6 +1298,7 @@ int mnt_fs_match_target(struct libmnt_fs *fs, const char *target,
+ {
+ 	int rc = 0;
+ 
++	assert(fs);
+ 	if (!fs || !target || !fs->target)
+ 		return 0;
+ 
+@@ -1330,6 +1343,7 @@ int mnt_fs_match_source(struct libmnt_fs *fs, const char *source,
+ 	char *cn;
+ 	const char *src, *t, *v;
+ 
++	assert(fs);
+ 	if (!fs)
+ 		return 0;
+ 
+@@ -1403,6 +1417,7 @@ int mnt_fs_match_source(struct libmnt_fs *fs, const char *source,
+  */
+ int mnt_fs_match_fstype(struct libmnt_fs *fs, const char *types)
+ {
++	assert(fs);
+ 	return mnt_match_fstype(fs->fstype, types);
+ }
+ 
+@@ -1418,6 +1433,7 @@ int mnt_fs_match_fstype(struct libmnt_fs *fs, const char *types)
+  */
+ int mnt_fs_match_options(struct libmnt_fs *fs, const char *options)
+ {
++	assert(fs);
+ 	return mnt_match_options(mnt_fs_get_options(fs), options);
+ }
+ 
+@@ -1430,7 +1446,7 @@ int mnt_fs_match_options(struct libmnt_fs *fs, const char *options)
+  */
+ int mnt_fs_print_debug(struct libmnt_fs *fs, FILE *file)
+ {
+-	if (!fs)
++	if (!fs || !file)
+ 		return -EINVAL;
+ 	fprintf(file, "------ fs: %p\n", fs);
+ 	fprintf(file, "source: %s\n", mnt_fs_get_source(fs));
+@@ -1514,6 +1530,8 @@ int mnt_fs_to_mntent(struct libmnt_fs *fs, struct mntent **mnt)
+ 	int rc;
+ 	struct mntent *m;
+ 
++	assert(fs);
++	assert(mnt);
+ 	if (!fs || !mnt)
+ 		return -EINVAL;
+ 
+diff --git a/libmount/src/libmount.h.in b/libmount/src/libmount.h.in
+index 1b5df82..db479e1 100644
+--- a/libmount/src/libmount.h.in
++++ b/libmount/src/libmount.h.in
+@@ -187,8 +187,7 @@ enum {
+ extern void mnt_init_debug(int mask);
+ 
+ /* version.c */
+-extern int mnt_parse_version_string(const char *ver_string)
+-			__ul_attribute__((nonnull));
++extern int mnt_parse_version_string(const char *ver_string);
+ extern int mnt_get_library_version(const char **ver_string);
+ extern int mnt_get_library_features(const char ***features);
+ 
+@@ -198,10 +197,8 @@ extern char *mnt_mangle(const char *str)
+ extern char *mnt_unmangle(const char *str)
+ 			__ul_attribute__((warn_unused_result));
+ 
+-extern int mnt_fstype_is_netfs(const char *type)
+-			__ul_attribute__((nonnull));
+-extern int mnt_fstype_is_pseudofs(const char *type)
+-			__ul_attribute__((nonnull));
++extern int mnt_fstype_is_netfs(const char *type);
++extern int mnt_fstype_is_pseudofs(const char *type);
+ 
+ extern int mnt_match_fstype(const char *type, const char *pattern)
+ 			__ul_attribute__((warn_unused_result));
+@@ -212,7 +209,7 @@ extern const char *mnt_get_swaps_path(void);
+ extern const char *mnt_get_mtab_path(void);
+ extern int mnt_has_regular_mtab(const char **mtab, int *writable);
+ extern char *mnt_get_mountpoint(const char *path)
+-			__ul_attribute__((nonnull, warn_unused_result));
++			__ul_attribute__((warn_unused_result));
+ 
+ /* cache.c */
+ extern struct libmnt_cache *mnt_new_cache(void)
+@@ -224,8 +221,7 @@ extern int mnt_cache_read_tags(struct libmnt_cache *cache, const char *devname);
+ extern int mnt_cache_device_has_tag(struct libmnt_cache *cache,
+ 				const char *devname,
+                                 const char *token,
+-				const char *value)
+-			__ul_attribute__((nonnull));
++				const char *value);
+ 
+ extern char *mnt_cache_find_tag_value(struct libmnt_cache *cache,
+ 				const char *devname, const char *token);
+@@ -245,24 +241,18 @@ extern char *mnt_pretty_path(const char *path, struct libmnt_cache *cache)
+ 
+ /* optstr.c */
+ extern int mnt_optstr_next_option(char **optstr, char **name, size_t *namesz,
+-				char **value, size_t *valuesz)
+-			__ul_attribute__((nonnull(1)));
++				char **value, size_t *valuesz);
+ extern int mnt_optstr_append_option(char **optstr, const char *name,
+-				const char *value)
+-			__ul_attribute__((nonnull(1, 2)));
++				const char *value);
+ extern int mnt_optstr_prepend_option(char **optstr, const char *name,
+-				const char *value)
+-			__ul_attribute__((nonnull(1, 2)));
++				const char *value);
+ 
+ extern int mnt_optstr_get_option(const char *optstr, const char *name,
+ 				char **value, size_t *valsz);
+ extern int mnt_optstr_set_option(char **optstr, const char *name,
+-				const char *value)
+-			__ul_attribute__((nonnull(1, 2)));
+-extern int mnt_optstr_remove_option(char **optstr, const char *name)
+-			__ul_attribute__((nonnull));
+-extern int mnt_optstr_deduplicate_option(char **optstr, const char *name)
+-			__ul_attribute__((nonnull));
++				const char *value);
++extern int mnt_optstr_remove_option(char **optstr, const char *name);
++extern int mnt_optstr_deduplicate_option(char **optstr, const char *name);
+ 
+ extern int mnt_split_optstr(const char *optstr,
+ 			    char **user, char **vfs, char **fs,
+@@ -301,11 +291,10 @@ extern const struct libmnt_optmap *mnt_get_builtin_optmap(int id);
+ 
+ /* lock.c */
+ extern struct libmnt_lock *mnt_new_lock(const char *datafile, pid_t id)
+-			__ul_attribute__((nonnull, warn_unused_result));
++			__ul_attribute__((warn_unused_result));
+ extern void mnt_free_lock(struct libmnt_lock *ml);
+ 
+-extern void mnt_unlock_file(struct libmnt_lock *ml)
+-			__ul_attribute__((nonnull));
++extern void mnt_unlock_file(struct libmnt_lock *ml);
+ extern int mnt_lock_file(struct libmnt_lock *ml);
+ extern int mnt_lock_block_signals(struct libmnt_lock *ml, int enable);
+ 
+@@ -314,27 +303,21 @@ 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_reset_fs(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
++extern void mnt_reset_fs(struct libmnt_fs *fs);
+ extern struct libmnt_fs *mnt_copy_fs(struct libmnt_fs *dest,
+ 				     const struct libmnt_fs *src)
+ 			__ul_attribute__((warn_unused_result));
+-extern void *mnt_fs_get_userdata(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
++extern void *mnt_fs_get_userdata(struct libmnt_fs *fs);
+ extern int mnt_fs_set_userdata(struct libmnt_fs *fs, void *data);
+-extern const char *mnt_fs_get_source(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
++extern const char *mnt_fs_get_source(struct libmnt_fs *fs);
+ extern int mnt_fs_set_source(struct libmnt_fs *fs, const char *source);
+ extern const char *mnt_fs_get_srcpath(struct libmnt_fs *fs);
+ 
+ extern int mnt_fs_get_tag(struct libmnt_fs *fs, const char **name,
+-			  const char **value)
+-			__ul_attribute__((nonnull(1)));
+-extern const char *mnt_fs_get_target(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
++			  const char **value);
++extern const char *mnt_fs_get_target(struct libmnt_fs *fs);
+ extern int mnt_fs_set_target(struct libmnt_fs *fs, const char *target);
+-extern const char *mnt_fs_get_fstype(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
++extern const char *mnt_fs_get_fstype(struct libmnt_fs *fs);
+ extern int mnt_fs_set_fstype(struct libmnt_fs *fs, const char *fstype);
+ 
+ extern int mnt_fs_streq_srcpath(struct libmnt_fs *fs, const char *path)
+@@ -343,11 +326,11 @@ extern int mnt_fs_streq_target(struct libmnt_fs *fs, const char *path)
+ 			__ul_attribute__((warn_unused_result));
+ 
+ extern char *mnt_fs_strdup_options(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull, warn_unused_result));
++			__ul_attribute__((warn_unused_result));
+ extern const char *mnt_fs_get_options(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull, warn_unused_result));
++			__ul_attribute__((warn_unused_result));
+ extern const char *mnt_fs_get_optional_fields(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull, warn_unused_result));
++			__ul_attribute__((warn_unused_result));
+ extern int mnt_fs_get_propagation(struct libmnt_fs *fs, unsigned long *flags);
+ 
+ extern int mnt_fs_set_options(struct libmnt_fs *fs, const char *optstr);
+@@ -357,81 +340,56 @@ extern int mnt_fs_prepend_options(struct libmnt_fs *fs, const char *optstr);
+ extern int mnt_fs_get_option(struct libmnt_fs *fs, const char *name,
+ 				char **value, size_t *valsz);
+ 
+-extern const char *mnt_fs_get_fs_options(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
+-extern const char *mnt_fs_get_vfs_options(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
+-extern const char *mnt_fs_get_user_options(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
++extern const char *mnt_fs_get_fs_options(struct libmnt_fs *fs);
++extern const char *mnt_fs_get_vfs_options(struct libmnt_fs *fs);
++extern const char *mnt_fs_get_user_options(struct libmnt_fs *fs);
+ 
+-extern const char *mnt_fs_get_attributes(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
++extern const char *mnt_fs_get_attributes(struct libmnt_fs *fs);
+ extern int mnt_fs_set_attributes(struct libmnt_fs *fs, const char *optstr);
+ extern int mnt_fs_get_attribute(struct libmnt_fs *fs, const char *name,
+ 				char **value, size_t *valsz);
+ extern int mnt_fs_append_attributes(struct libmnt_fs *fs, const char *optstr);
+ extern int mnt_fs_prepend_attributes(struct libmnt_fs *fs, const char *optstr);
+ 
+-extern int mnt_fs_get_freq(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
++extern int mnt_fs_get_freq(struct libmnt_fs *fs);
+ extern int mnt_fs_set_freq(struct libmnt_fs *fs, int freq);
+-extern int mnt_fs_get_passno(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
++extern int mnt_fs_get_passno(struct libmnt_fs *fs);
+ extern int mnt_fs_set_passno(struct libmnt_fs *fs, int passno);
+-extern const char *mnt_fs_get_root(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
++extern const char *mnt_fs_get_root(struct libmnt_fs *fs);
+ extern int mnt_fs_set_root(struct libmnt_fs *fs, const char *root);
+-extern const char *mnt_fs_get_bindsrc(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
++extern const char *mnt_fs_get_bindsrc(struct libmnt_fs *fs);
+ extern int mnt_fs_set_bindsrc(struct libmnt_fs *fs, const char *src);
+-extern int mnt_fs_get_id(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
+-extern int mnt_fs_get_parent_id(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
+-extern dev_t mnt_fs_get_devno(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
+-extern pid_t mnt_fs_get_tid(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
++extern int mnt_fs_get_id(struct libmnt_fs *fs);
++extern int mnt_fs_get_parent_id(struct libmnt_fs *fs);
++extern dev_t mnt_fs_get_devno(struct libmnt_fs *fs);
++extern pid_t mnt_fs_get_tid(struct libmnt_fs *fs);
+ 
+-extern const char *mnt_fs_get_swaptype(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
+-extern off_t mnt_fs_get_size(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
+-extern off_t mnt_fs_get_usedsize(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
+-extern int mnt_fs_get_priority(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
++extern const char *mnt_fs_get_swaptype(struct libmnt_fs *fs);
++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 int mnt_fs_match_target(struct libmnt_fs *fs, const char *target,
+-			       struct libmnt_cache *cache)
+-			__ul_attribute__((nonnull(1)));
++			       struct libmnt_cache *cache);
+ extern int mnt_fs_match_source(struct libmnt_fs *fs, const char *source,
+-			       struct libmnt_cache *cache)
+-			__ul_attribute__((nonnull(1)));
+-extern int mnt_fs_match_fstype(struct libmnt_fs *fs, const char *types)
+-			__ul_attribute__((nonnull(1)));
+-extern int mnt_fs_match_options(struct libmnt_fs *fs, const char *options)
+-			__ul_attribute__((nonnull(1)));
+-extern int mnt_fs_print_debug(struct libmnt_fs *fs, FILE *file)
+-			__ul_attribute__((nonnull));
++			       struct libmnt_cache *cache);
++extern int mnt_fs_match_fstype(struct libmnt_fs *fs, const char *types);
++extern int mnt_fs_match_options(struct libmnt_fs *fs, const char *options);
++extern int mnt_fs_print_debug(struct libmnt_fs *fs, FILE *file);
+ 
+-extern int mnt_fs_is_kernel(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
+-extern int mnt_fs_is_swaparea(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
+-extern int mnt_fs_is_netfs(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
+-extern int mnt_fs_is_pseudofs(struct libmnt_fs *fs)
+-			__ul_attribute__((nonnull));
++extern int mnt_fs_is_kernel(struct libmnt_fs *fs);
++extern int mnt_fs_is_swaparea(struct libmnt_fs *fs);
++extern int mnt_fs_is_netfs(struct libmnt_fs *fs);
++extern int mnt_fs_is_pseudofs(struct libmnt_fs *fs);
+ 
+ extern void mnt_free_mntent(struct mntent *mnt);
+ extern int mnt_fs_to_mntent(struct libmnt_fs *fs, struct mntent **mnt);
+ 
+ /* tab-parse.c */
+ extern struct libmnt_table *mnt_new_table_from_file(const char *filename)
+-			__ul_attribute__((nonnull, warn_unused_result));
++			__ul_attribute__((warn_unused_result));
+ extern struct libmnt_table *mnt_new_table_from_dir(const char *dirname)
+-			__ul_attribute__((nonnull, warn_unused_result));
++			__ul_attribute__((warn_unused_result));
+ extern int mnt_table_parse_stream(struct libmnt_table *tb, FILE *f,
+ 				  const char *filename);
+ extern int mnt_table_parse_file(struct libmnt_table *tb, const char *filename);
+@@ -484,27 +442,21 @@ extern int mnt_table_find_next_fs(struct libmnt_table *tb,
+ 			void *userdata,
+ 		        struct libmnt_fs **fs);
+ 
+-extern int mnt_table_is_fs_mounted(struct libmnt_table *tb, struct libmnt_fs *fstab_fs)
+-			__ul_attribute__((nonnull));
+-
++extern int mnt_table_is_fs_mounted(struct libmnt_table *tb, struct libmnt_fs *fstab_fs);
+ 
+ /* tab_update.c */
+ 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_update_is_ready(struct libmnt_update *upd)
+-			__ul_attribute__((nonnull));
++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);
+ extern int mnt_update_table(struct libmnt_update *upd, struct libmnt_lock *lc);
+-extern unsigned long mnt_update_get_mflags(struct libmnt_update *upd)
+-			__ul_attribute__((nonnull));
++extern unsigned long mnt_update_get_mflags(struct libmnt_update *upd);
+ extern int mnt_update_force_rdonly(struct libmnt_update *upd, int rdonly);
+-extern const char *mnt_update_get_filename(struct libmnt_update *upd)
+-			__ul_attribute__((nonnull));
+-extern struct libmnt_fs *mnt_update_get_fs(struct libmnt_update *upd)
+-			__ul_attribute__((nonnull));
++extern const char *mnt_update_get_filename(struct libmnt_update *upd);
++extern struct libmnt_fs *mnt_update_get_fs(struct libmnt_update *upd);
+ 
+ /* tab_diff.c */
+ enum {
+@@ -578,8 +530,8 @@ extern int mnt_context_enable_loopdel(struct libmnt_context *cxt, int enable);
+ extern int mnt_context_enable_fork(struct libmnt_context *cxt, int enable);
+ extern int mnt_context_disable_swapmatch(struct libmnt_context *cxt, int disable);
+ 
+-extern int mnt_context_get_optsmode(struct libmnt_context *cxt)
+-			__ul_attribute__((nonnull));
++extern int mnt_context_get_optsmode(struct libmnt_context *cxt);
++
+ extern int mnt_context_is_lazy(struct libmnt_context *cxt)
+ 			__ul_attribute__((nonnull));
+ extern int mnt_context_is_rdonly_umount(struct libmnt_context *cxt)
+@@ -614,28 +566,22 @@ extern int mnt_context_wait_for_children(struct libmnt_context *cxt,
+                                   int *nchildren, int *nerrs);
+ 
+ extern int mnt_context_is_fs_mounted(struct libmnt_context *cxt,
+-                              struct libmnt_fs *fs, int *mounted)
+-			__ul_attribute__((nonnull));
++                              struct libmnt_fs *fs, int *mounted);
+ extern int mnt_context_set_fs(struct libmnt_context *cxt, struct libmnt_fs *fs);
+-extern struct libmnt_fs *mnt_context_get_fs(struct libmnt_context *cxt)
+-			__ul_attribute__((nonnull));
++extern struct libmnt_fs *mnt_context_get_fs(struct libmnt_context *cxt);
+ 
+ extern int mnt_context_set_source(struct libmnt_context *cxt, const char *source);
+ extern int mnt_context_set_target(struct libmnt_context *cxt, const char *target);
+ extern int mnt_context_set_fstype(struct libmnt_context *cxt, const char *fstype);
+ 
+-extern const char *mnt_context_get_source(struct libmnt_context *cxt)
+-			__ul_attribute__((nonnull));
+-extern const char *mnt_context_get_target(struct libmnt_context *cxt)
+-			__ul_attribute__((nonnull));
+-extern const char *mnt_context_get_fstype(struct libmnt_context *cxt)
+-			__ul_attribute__((nonnull));
++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 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);
+ 
+-extern const char *mnt_context_get_options(struct libmnt_context *cxt)
+-			__ul_attribute__((nonnull));
++extern const char *mnt_context_get_options(struct libmnt_context *cxt);
+ 
+ extern int mnt_context_set_fstype_pattern(struct libmnt_context *cxt, const char *pattern);
+ extern int mnt_context_set_options_pattern(struct libmnt_context *cxt, const char *pattern);
+@@ -659,10 +605,8 @@ extern int mnt_context_get_table(struct libmnt_context *cxt,
+ 				struct libmnt_table **tb);
+ extern int mnt_context_set_cache(struct libmnt_context *cxt,
+ 				 struct libmnt_cache *cache);
+-extern struct libmnt_cache *mnt_context_get_cache(struct libmnt_context *cxt)
+-			__ul_attribute__((nonnull));
+-extern struct libmnt_lock *mnt_context_get_lock(struct libmnt_context *cxt)
+-			__ul_attribute__((nonnull));
++extern struct libmnt_cache *mnt_context_get_cache(struct libmnt_context *cxt);
++extern struct libmnt_lock *mnt_context_get_lock(struct libmnt_context *cxt);
+ extern int mnt_context_set_mflags(struct libmnt_context *cxt,
+ 				      unsigned long flags);
+ extern int mnt_context_get_mflags(struct libmnt_context *cxt,
+@@ -676,19 +620,14 @@ extern int mnt_context_set_mountdata(struct libmnt_context *cxt, void *data);
+ extern int mnt_context_apply_fstab(struct libmnt_context *cxt);
+ 
+ extern int mnt_context_reset_status(struct libmnt_context *cxt);
+-extern int mnt_context_get_status(struct libmnt_context *cxt)
+-			__ul_attribute__((nonnull));
++extern int mnt_context_get_status(struct libmnt_context *cxt);
+ 
+-extern int mnt_context_helper_executed(struct libmnt_context *cxt)
+-			__ul_attribute__((nonnull));
+-extern int mnt_context_get_helper_status(struct libmnt_context *cxt)
+-			__ul_attribute__((nonnull));
++extern int mnt_context_helper_executed(struct libmnt_context *cxt);
++extern int mnt_context_get_helper_status(struct libmnt_context *cxt);
+ 
+-extern int mnt_context_syscall_called(struct libmnt_context *cxt)
+-			__ul_attribute__((nonnull));
++extern int mnt_context_syscall_called(struct libmnt_context *cxt);
+ 
+-extern int mnt_context_get_syscall_errno(struct libmnt_context *cxt)
+-			__ul_attribute__((nonnull));
++extern int mnt_context_get_syscall_errno(struct libmnt_context *cxt);
+ 
+ extern int mnt_context_strerror(struct libmnt_context *cxt, char *buf,
+ 				size_t bufsiz);
+@@ -720,8 +659,7 @@ extern int mnt_context_prepare_umount(struct libmnt_context *cxt)
+ extern int mnt_context_do_umount(struct libmnt_context *cxt);
+ extern int mnt_context_finalize_umount(struct libmnt_context *cxt);
+ 
+-extern int mnt_context_tab_applied(struct libmnt_context *cxt)
+-			__ul_attribute__((nonnull));
++extern int mnt_context_tab_applied(struct libmnt_context *cxt);
+ extern int mnt_context_set_syscall_status(struct libmnt_context *cxt, int status);
+ 
+ /*
+diff --git a/libmount/src/lock.c b/libmount/src/lock.c
+index 9e583cc..e73edf5 100644
+--- a/libmount/src/lock.c
++++ b/libmount/src/lock.c
+@@ -53,6 +53,8 @@ struct libmnt_lock *mnt_new_lock(const char *datafile, pid_t id)
+ 	char *lo = NULL, *ln = NULL;
+ 	size_t losz;
+ 
++	assert(datafile);
++
+ 	/* for flock we use "foo.lock, for mtab "foo~"
+ 	 */
+ 	losz = strlen(datafile) + sizeof(".lock");
+diff --git a/libmount/src/mountP.h b/libmount/src/mountP.h
+index 065b815..e064a68 100644
+--- a/libmount/src/mountP.h
++++ b/libmount/src/mountP.h
+@@ -26,7 +26,9 @@
+ #define CONFIG_LIBMOUNT_DEBUG
+ 
+ #ifdef CONFIG_LIBMOUNT_ASSERT
+-#include <assert.h>
++# include <assert.h>
++#else
++# define assert(x)
+ #endif
+ 
+ /*
+diff --git a/libmount/src/optstr.c b/libmount/src/optstr.c
+index a3a5d0a..5e9e708 100644
+--- a/libmount/src/optstr.c
++++ b/libmount/src/optstr.c
+@@ -169,8 +169,7 @@ int mnt_optstr_next_option(char **optstr, char **name, size_t *namesz,
+ 	return mnt_optstr_parse_next(optstr, name, namesz, value, valuesz);
+ }
+ 
+-static int __attribute__((nonnull(1, 2)))
+-__mnt_optstr_append_option(char **optstr,
++static int __mnt_optstr_append_option(char **optstr,
+ 			const char *name, size_t nsz,
+ 			const char *value, size_t vsz)
+ {
+@@ -180,6 +179,7 @@ __mnt_optstr_append_option(char **optstr,
+ 	assert(name);
+ 	assert(*name);
+ 	assert(nsz);
++	assert(optstr);
+ 
+ 	osz = *optstr ? strlen(*optstr) : 0;
+ 
+@@ -225,6 +225,8 @@ int mnt_optstr_append_option(char **optstr, const char *name, const char *value)
+ {
+ 	size_t vsz, nsz;
+ 
++	assert(optstr);
++
+ 	if (!name || !*name)
+ 		return 0;
+ 
+@@ -248,6 +250,11 @@ int mnt_optstr_prepend_option(char **optstr, const char *name, const char *value
+ 	int rc = 0;
+ 	char *tmp = *optstr;
+ 
++	assert(optstr);
++
++	if (!name || !*name)
++		return 0;
++
+ 	*optstr = NULL;
+ 
+ 	rc = mnt_optstr_append_option(optstr, name, value);
+@@ -282,6 +289,9 @@ int mnt_optstr_get_option(const char *optstr, const char *name,
+ 	struct libmnt_optloc ol;
+ 	int rc;
+ 
++	assert(optstr);
++	assert(name);
++
+ 	mnt_init_optloc(&ol);
+ 
+ 	rc = mnt_optstr_locate_option((char *) optstr, name, &ol);
+@@ -307,8 +317,12 @@ int mnt_optstr_get_option(const char *optstr, const char *name,
+ int mnt_optstr_deduplicate_option(char **optstr, const char *name)
+ {
+ 	int rc;
+-	char *begin = NULL, *end = NULL, *opt = *optstr;
++	char *begin = NULL, *end = NULL, *opt;
+ 
++	assert(optstr);
++	assert(name);
++
++	opt = *optstr;
+ 	do {
+ 		struct libmnt_optloc ol;
+ 
+@@ -421,6 +435,9 @@ int mnt_optstr_set_option(char **optstr, const char *name, const char *value)
+ 	char *nameend;
+ 	int rc = 1;
+ 
++	assert(optstr);
++	assert(name);
++
+ 	if (!optstr)
+ 		return -EINVAL;
+ 
+@@ -467,6 +484,9 @@ int mnt_optstr_remove_option(char **optstr, const char *name)
+ 	struct libmnt_optloc ol;
+ 	int rc;
+ 
++	assert(optstr);
++	assert(name);
++
+ 	mnt_init_optloc(&ol);
+ 
+ 	rc = mnt_optstr_locate_option(*optstr, name, &ol);
+diff --git a/libmount/src/tab_parse.c b/libmount/src/tab_parse.c
+index 7368d8c..e930fd8 100644
+--- a/libmount/src/tab_parse.c
++++ b/libmount/src/tab_parse.c
+@@ -720,7 +720,6 @@ struct libmnt_table *__mnt_new_table_from_file(const char *filename, int fmt)
+ 	struct stat st;
+ 
+ 	assert(filename);
+-
+ 	if (!filename)
+ 		return NULL;
+ 	if (stat(filename, &st))
+@@ -749,6 +748,7 @@ struct libmnt_table *__mnt_new_table_from_file(const char *filename, int fmt)
+  */
+ struct libmnt_table *mnt_new_table_from_file(const char *filename)
+ {
++	assert(filename);
+ 	return __mnt_new_table_from_file(filename, MNT_FMT_GUESS);
+ }
+ 
+@@ -763,7 +763,6 @@ struct libmnt_table *mnt_new_table_from_dir(const char *dirname)
+ 	struct libmnt_table *tb;
+ 
+ 	assert(dirname);
+-
+ 	if (!dirname)
+ 		return NULL;
+ 	tb = mnt_new_table();
+@@ -793,6 +792,7 @@ struct libmnt_table *mnt_new_table_from_dir(const char *dirname)
+ int mnt_table_set_parser_errcb(struct libmnt_table *tb,
+ 		int (*cb)(struct libmnt_table *tb, const char *filename, int line))
+ {
++	assert(tb);
+ 	if (!tb)
+ 		return -EINVAL;
+ 	tb->errcb = cb;
+@@ -807,6 +807,7 @@ int mnt_table_set_parser_fltrcb(struct libmnt_table *tb,
+ 		int (*cb)(struct libmnt_fs *, void *),
+ 		void *data)
+ {
++	assert(tb);
+ 	if (!tb)
+ 		return -EINVAL;
+ 
+@@ -862,7 +863,6 @@ int mnt_table_parse_fstab(struct libmnt_table *tb, const char *filename)
+ 	int rc = 0;
+ 
+ 	assert(tb);
+-
+ 	if (!tb)
+ 		return -EINVAL;
+ 	if (!filename)
+@@ -959,6 +959,8 @@ int mnt_table_parse_mtab(struct libmnt_table *tb, const char *filename)
+ 	const char *utab = NULL;
+ 	struct libmnt_table *u_tb;
+ 
++	assert(tb);
++
+ 	if (mnt_has_regular_mtab(&filename, NULL)) {
+ 
+ 		DBG(TAB, mnt_debug_h(tb, "force %s usage", filename));
+diff --git a/libmount/src/tab_update.c b/libmount/src/tab_update.c
+index 044a13f..1e7f32b 100644
+--- a/libmount/src/tab_update.c
++++ b/libmount/src/tab_update.c
+@@ -131,6 +131,7 @@ int mnt_update_set_filename(struct libmnt_update *upd, const char *filename,
+  */
+ const char *mnt_update_get_filename(struct libmnt_update *upd)
+ {
++	assert(upd);
+ 	return upd ? upd->filename : NULL;
+ }
+ 
+@@ -143,6 +144,7 @@ const char *mnt_update_get_filename(struct libmnt_update *upd)
+  */
+ int mnt_update_is_ready(struct libmnt_update *upd)
+ {
++	assert(upd);
+ 	return upd ? upd->ready : FALSE;
+ }
+ 
+@@ -227,6 +229,7 @@ int mnt_update_set_fs(struct libmnt_update *upd, unsigned long mountflags,
+  */
+ struct libmnt_fs *mnt_update_get_fs(struct libmnt_update *upd)
+ {
++	assert(upd);
+ 	return upd ? upd->fs : NULL;
+ }
+ 
+@@ -238,6 +241,7 @@ struct libmnt_fs *mnt_update_get_fs(struct libmnt_update *upd)
+  */
+ unsigned long mnt_update_get_mflags(struct libmnt_update *upd)
+ {
++	assert(upd);
+ 	return upd ? upd->mountflags : 0;
+ }
+ 
+@@ -252,6 +256,7 @@ int mnt_update_force_rdonly(struct libmnt_update *upd, int rdonly)
+ {
+ 	int rc = 0;
+ 
++	assert(upd);
+ 	if (!upd || !upd->fs)
+ 		return -EINVAL;
+ 
+@@ -505,6 +510,7 @@ static int update_table(struct libmnt_update *upd, struct libmnt_table *tb)
+ 	int rc, fd;
+ 	char *uq = NULL;
+ 
++	assert(upd);
+ 	if (!tb || !upd->filename)
+ 		return -EINVAL;
+ 
+@@ -566,8 +572,11 @@ leave:
+ 
+ static int add_file_entry(struct libmnt_table *tb, struct libmnt_update *upd)
+ {
+-	struct libmnt_fs *fs = mnt_copy_fs(NULL, upd->fs);
++	struct libmnt_fs *fs;
++
++	assert(upd);
+ 
++	fs = mnt_copy_fs(NULL, upd->fs);
+ 	if (!fs)
+ 		return -ENOMEM;
+ 
+@@ -638,6 +647,7 @@ static int update_modify_target(struct libmnt_update *upd, struct libmnt_lock *l
+ 	struct libmnt_table *tb = NULL;
+ 	int rc = 0;
+ 
++	assert(upd);
+ 	DBG(UPDATE, mnt_debug_h(upd, "%s: modify target", upd->filename));
+ 
+ 	if (lc)
+@@ -726,7 +736,6 @@ int mnt_update_table(struct libmnt_update *upd, struct libmnt_lock *lc)
+ 	int rc = -EINVAL;
+ 
+ 	assert(upd);
+-
+ 	if (!upd || !upd->filename)
+ 		return -EINVAL;
+ 	if (!upd->ready)
+diff --git a/libmount/src/utils.c b/libmount/src/utils.c
+index c910035..c328414 100644
+--- a/libmount/src/utils.c
++++ b/libmount/src/utils.c
+@@ -269,6 +269,8 @@ int mnt_fstype_is_pseudofs(const char *type)
+ 		"tmpfs"
+ 	};
+ 
++	assert(type);
++
+ 	return !(bsearch(&type, pseudofs, ARRAY_SIZE(pseudofs),
+ 				sizeof(char*), fstype_cmp) == NULL);
+ }
+@@ -281,6 +283,8 @@ int mnt_fstype_is_pseudofs(const char *type)
+  */
+ int mnt_fstype_is_netfs(const char *type)
+ {
++	assert(type);
++
+ 	if (strcmp(type, "cifs")   == 0 ||
+ 	    strcmp(type, "smbfs")  == 0 ||
+ 	    strncmp(type,"nfs", 3) == 0 ||
+@@ -859,10 +863,13 @@ int mnt_open_uniq_filename(const char *filename, char **name)
+  */
+ char *mnt_get_mountpoint(const char *path)
+ {
+-	char *mnt = strdup(path);
++	char *mnt;
+ 	struct stat st;
+ 	dev_t dir, base;
+ 
++	assert(path);
++
++	mnt = strdup(path);
+ 	if (!mnt)
+ 		return NULL;
+ 	if (*mnt == '/' && *(mnt + 1) == '\0')
+diff --git a/libmount/src/version.c b/libmount/src/version.c
+index 00e4f99..00b7c03 100644
+--- a/libmount/src/version.c
++++ b/libmount/src/version.c
+@@ -25,6 +25,9 @@ static const char *lib_features[] = {
+ #ifdef CONFIG_LIBMOUNT_DEBUG
+ 	"debug",
+ #endif
++#ifdef CONFIG_LIBMOUNT_ASSERT
++	"assert",
++#endif
+ 	NULL
+ };
+ 
+@@ -39,6 +42,8 @@ int mnt_parse_version_string(const char *ver_string)
+ 	const char *cp;
+ 	int version = 0;
+ 
++	assert(ver_string);
++
+ 	for (cp = ver_string; *cp; cp++) {
+ 		if (*cp == '.')
+ 			continue;
+-- 
+1.8.1.4
+
diff --git a/util-linux.spec b/util-linux.spec
index d832c36..55391c7 100644
--- a/util-linux.spec
+++ b/util-linux.spec
@@ -2,7 +2,7 @@
 Summary: A collection of basic system utilities
 Name: util-linux
 Version: 2.23
-Release: 0.4%{?dist}
+Release: 0.5%{?dist}
 License: GPLv2 and GPLv2+ and LGPLv2+ and BSD with advertising and Public Domain
 Group: System Environment/Base
 URL: http://en.wikipedia.org/wiki/Util-linux
@@ -88,6 +88,10 @@ Patch2: util-linux-2.19-floppy-generic.patch
 # 151635 - makeing /var/log/lastlog
 Patch3: util-linux-ng-2.22-login-lastlog.patch
 
+### upstream pathes (2.23)
+# 948274 - interruption code 0x4003B in libmount.so.1.1.0
+Patch100: 0001-libmount-fix-mount.nfs-segfault-rely-on-assert-rathe.patch
+
 %description
 The util-linux package contains a large variety of low-level system
 utilities that are necessary for a Linux system to function. Among
@@ -822,6 +826,9 @@ fi
 %{_libdir}/pkgconfig/uuid.pc
 
 %changelog
+* Fri Apr 12 2013 Karel Zak <kzak@redhat.com> 2.23-0.5
+- fix #948274 - interruption code 0x4003B in libmount.so.1.1.0
+
 * Wed Apr 10 2013 Karel Zak <kzak@redhat.com> 2.23-0.4
 - upgrade to the release 2.23-rc2