util-linux/0001-libmount-fix-mount.nfs-segfault-rely-on-assert-rathe.patch

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