audit: purge unnecessary list_empty calls

The original conditions that led to the use of list_empty() to optimize
list_for_each_entry_rcu() in auditfilter.c and auditsc.c code have been
removed without removing the list_empty() call, but this code example
has been copied several times.  Remove the unnecessary list_empty()
calls.

Please see upstream github issue
https://github.com/linux-audit/audit-kernel/issues/112

Signed-off-by: Richard Guy Briggs <rgb@redhat.com>
Signed-off-by: Paul Moore <paul@paul-moore.com>

diff --git a/kernel/auditfilter.c b/kernel/auditfilter.c
index 63f8b3f26fab452b171fd5ba662d3e1b801999c3..2c3c2f349b23ea5b072e93faffc23f81a0395ff0 100644 (file)
--- a/kernel/auditfilter.c
+++ b/kernel/auditfilter.c
@@ -1315,8 +1315,6 @@ int audit_filter(int msgtype, unsigned int listtype)
        int ret = 1; /* Audit by default */
 
        rcu_read_lock();
-       if (list_empty(&audit_filter_list[listtype]))
-               goto unlock_and_return;
        list_for_each_entry_rcu(e, &audit_filter_list[listtype], list) {
                int i, result = 0;
 

diff --git a/kernel/auditsc.c b/kernel/auditsc.c
index 98a98e6dca0508382815f24dca0771199aac46ed..51a2ceb3a1cabf3943ea621cdebfc20e81a90d67 100644 (file)
--- a/kernel/auditsc.c
+++ b/kernel/auditsc.c
@@ -771,15 +771,13 @@ static enum audit_state audit_filter_syscall(struct task_struct *tsk,
                return AUDIT_DISABLED;
 
        rcu_read_lock();
-       if (!list_empty(list)) {
-               list_for_each_entry_rcu(e, list, list) {
-                       if (audit_in_mask(&e->rule, ctx->major) &&
-                           audit_filter_rules(tsk, &e->rule, ctx, NULL,
-                                              &state, false)) {
-                               rcu_read_unlock();
-                               ctx->current_state = state;
-                               return state;
-                       }
+       list_for_each_entry_rcu(e, list, list) {
+               if (audit_in_mask(&e->rule, ctx->major) &&
+                   audit_filter_rules(tsk, &e->rule, ctx, NULL,
+                                      &state, false)) {
+                       rcu_read_unlock();
+                       ctx->current_state = state;
+                       return state;
                }
        }
        rcu_read_unlock();
@@ -798,9 +796,6 @@ static int audit_filter_inode_name(struct task_struct *tsk,
        struct audit_entry *e;
        enum audit_state state;
 
-       if (list_empty(list))
-               return 0;
-
        list_for_each_entry_rcu(e, list, list) {
                if (audit_in_mask(&e->rule, ctx->major) &&
                    audit_filter_rules(tsk, &e->rule, ctx, n, &state, false)) {
@@ -808,7 +803,6 @@ static int audit_filter_inode_name(struct task_struct *tsk,
                        return 1;
                }
        }
-
        return 0;
 }
 
@@ -1945,18 +1939,16 @@ void __audit_inode(struct filename *name, const struct dentry *dentry,
                return;
 
        rcu_read_lock();
-       if (!list_empty(list)) {
-               list_for_each_entry_rcu(e, list, list) {
-                       for (i = 0; i < e->rule.field_count; i++) {
-                               struct audit_field *f = &e->rule.fields[i];
-
-                               if (f->type == AUDIT_FSTYPE
-                                   && audit_comparator(inode->i_sb->s_magic,
-                                                       f->op, f->val)
-                                   && e->rule.action == AUDIT_NEVER) {
-                                       rcu_read_unlock();
-                                       return;
-                               }
+       list_for_each_entry_rcu(e, list, list) {
+               for (i = 0; i < e->rule.field_count; i++) {
+                       struct audit_field *f = &e->rule.fields[i];
+
+                       if (f->type == AUDIT_FSTYPE
+                           && audit_comparator(inode->i_sb->s_magic,
+                                               f->op, f->val)
+                           && e->rule.action == AUDIT_NEVER) {
+                               rcu_read_unlock();
+                               return;
                        }
                }
        }
@@ -2065,18 +2057,16 @@ void __audit_inode_child(struct inode *parent,
                return;
 
        rcu_read_lock();
-       if (!list_empty(list)) {
-               list_for_each_entry_rcu(e, list, list) {
-                       for (i = 0; i < e->rule.field_count; i++) {
-                               struct audit_field *f = &e->rule.fields[i];
-
-                               if (f->type == AUDIT_FSTYPE
-                                   && audit_comparator(parent->i_sb->s_magic,
-                                                       f->op, f->val)
-                                   && e->rule.action == AUDIT_NEVER) {
-                                       rcu_read_unlock();
-                                       return;
-                               }
+       list_for_each_entry_rcu(e, list, list) {
+               for (i = 0; i < e->rule.field_count; i++) {
+                       struct audit_field *f = &e->rule.fields[i];
+
+                       if (f->type == AUDIT_FSTYPE
+                           && audit_comparator(parent->i_sb->s_magic,
+                                               f->op, f->val)
+                           && e->rule.action == AUDIT_NEVER) {
+                               rcu_read_unlock();
+                               return;
                        }
                }
        }