Merge remote-tracking branch 'audit/next'

diff --git a/include/linux/audit.h b/include/linux/audit.h
index b2abc996c25dabee1c9b55a97667e06ad436ec1e..20eba1eb0a3cc2e1eb1e982f1f330f259fa03cab 100644 (file)
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -143,7 +143,7 @@ extern void __audit_inode_child(const struct inode *parent,
 extern void __audit_seccomp(unsigned long syscall, long signr, int code);
 extern void __audit_ptrace(struct task_struct *t);
 
-static inline int audit_dummy_context(void)
+static inline bool audit_dummy_context(void)
 {
        void *p = current->audit_context;
        return !p || *(int *)p;
@@ -345,9 +345,9 @@ static inline void audit_syscall_entry(int major, unsigned long a0,
 { }
 static inline void audit_syscall_exit(void *pt_regs)
 { }
-static inline int audit_dummy_context(void)
+static inline bool audit_dummy_context(void)
 {
-       return 1;
+       return true;
 }
 static inline struct filename *audit_reusename(const __user char *name)
 {
@@ -457,7 +457,7 @@ extern struct audit_buffer *audit_log_start(struct audit_context *ctx, gfp_t gfp
 extern __printf(2, 3)
 void audit_log_format(struct audit_buffer *ab, const char *fmt, ...);
 extern void                audit_log_end(struct audit_buffer *ab);
-extern int                 audit_string_contains_control(const char *string,
+extern bool                audit_string_contains_control(const char *string,
                                                          size_t len);
 extern void                audit_log_n_hex(struct audit_buffer *ab,
                                          const unsigned char *buf,

diff --git a/kernel/audit.c b/kernel/audit.c
index 662c007635fb778bef2bca5cc213f8cb23ed364e..8a056a32ded7d2b4560612af7d84ac317f7a17b3 100644 (file)
--- a/kernel/audit.c
+++ b/kernel/audit.c
@@ -407,16 +407,33 @@ static void audit_printk_skb(struct sk_buff *skb)
 static void kauditd_send_skb(struct sk_buff *skb)
 {
        int err;
+       int attempts = 0;
+#define AUDITD_RETRIES 5
+
+restart:
        /* take a reference in case we can't send it and we want to hold it */
        skb_get(skb);
        err = netlink_unicast(audit_sock, skb, audit_nlk_portid, 0);
        if (err < 0) {
-               BUG_ON(err != -ECONNREFUSED); /* Shouldn't happen */
+               pr_err("netlink_unicast sending to audit_pid=%d returned error: %d\n",
+                      audit_pid, err);
                if (audit_pid) {
-                       pr_err("*NO* daemon at audit_pid=%d\n", audit_pid);
-                       audit_log_lost("auditd disappeared");
-                       audit_pid = 0;
-                       audit_sock = NULL;
+                       if (err == -ECONNREFUSED || err == -EPERM
+                           || ++attempts >= AUDITD_RETRIES) {
+                               char s[32];
+
+                               snprintf(s, sizeof(s), "audit_pid=%d reset", audit_pid);
+                               audit_log_lost(s);
+                               audit_pid = 0;
+                               audit_sock = NULL;
+                       } else {
+                               pr_warn("re-scheduling(#%d) write to audit_pid=%d\n",
+                                       attempts, audit_pid);
+                               set_current_state(TASK_INTERRUPTIBLE);
+                               schedule();
+                               __set_current_state(TASK_RUNNING);
+                               goto restart;
+                       }
                }
                /* we might get lucky and get this in the next auditd */
                audit_hold_skb(skb);
@@ -684,25 +701,22 @@ static int audit_netlink_ok(struct sk_buff *skb, u16 msg_type)
        return err;
 }
 
-static int audit_log_common_recv_msg(struct audit_buffer **ab, u16 msg_type)
+static void audit_log_common_recv_msg(struct audit_buffer **ab, u16 msg_type)
 {
-       int rc = 0;
        uid_t uid = from_kuid(&init_user_ns, current_uid());
        pid_t pid = task_tgid_nr(current);
 
        if (!audit_enabled && msg_type != AUDIT_USER_AVC) {
                *ab = NULL;
-               return rc;
+               return;
        }
 
        *ab = audit_log_start(NULL, GFP_KERNEL, msg_type);
        if (unlikely(!*ab))
-               return rc;
+               return;
        audit_log_format(*ab, "pid=%d uid=%u", pid, uid);
        audit_log_session_info(*ab);
        audit_log_task_context(*ab);
-
-       return rc;
 }
 
 int is_audit_feature_set(int i)
@@ -1566,14 +1580,14 @@ void audit_log_n_string(struct audit_buffer *ab, const char *string,
  * @string: string to be checked
  * @len: max length of the string to check
  */
-int audit_string_contains_control(const char *string, size_t len)
+bool audit_string_contains_control(const char *string, size_t len)
 {
        const unsigned char *p;
        for (p = string; p < (const unsigned char *)string + len; p++) {
                if (*p == '"' || *p < 0x21 || *p > 0x7e)
-                       return 1;
+                       return true;
        }
-       return 0;
+       return false;
 }
 
 /**

diff --git a/kernel/audit.h b/kernel/audit.h
index dadf86a0e59e5956d16ef741086c56c1fbf77a6c..de6cbb7cf547037d91fd891a403dfd666045c4eb 100644 (file)
--- a/kernel/audit.h
+++ b/kernel/audit.h
@@ -301,7 +301,7 @@ extern int audit_exe_compare(struct task_struct *tsk, struct audit_fsnotify_mark
 #ifdef CONFIG_AUDIT_TREE
 extern struct audit_chunk *audit_tree_lookup(const struct inode *);
 extern void audit_put_chunk(struct audit_chunk *);
-extern int audit_tree_match(struct audit_chunk *, struct audit_tree *);
+extern bool audit_tree_match(struct audit_chunk *, struct audit_tree *);
 extern int audit_make_tree(struct audit_krule *, char *, u32);
 extern int audit_add_tree_rule(struct audit_krule *);
 extern int audit_remove_tree_rule(struct audit_krule *);

diff --git a/kernel/audit_tree.c b/kernel/audit_tree.c
index 94ecdabda8e6b31f8f2ba25fc66b992e320d9fcb..5efe9b299a12876242648d41acc1950291b7a166 100644 (file)
--- a/kernel/audit_tree.c
+++ b/kernel/audit_tree.c
@@ -197,13 +197,13 @@ struct audit_chunk *audit_tree_lookup(const struct inode *inode)
        return NULL;
 }
 
-int audit_tree_match(struct audit_chunk *chunk, struct audit_tree *tree)
+bool audit_tree_match(struct audit_chunk *chunk, struct audit_tree *tree)
 {
        int n;
        for (n = 0; n < chunk->count; n++)
                if (chunk->owners[n].owner == tree)
-                       return 1;
-       return 0;
+                       return true;
+       return false;
 }
 
 /* tagging and untagging inodes with trees */

diff --git a/kernel/auditfilter.c b/kernel/auditfilter.c
index 7714d93edb8505fc6bbd212ad3dbcec9d05b4cdb..b8ff9e193753614072d55b98b0bb46e2a8534880 100644 (file)
--- a/kernel/auditfilter.c
+++ b/kernel/auditfilter.c
@@ -39,13 +39,13 @@
  * Locking model:
  *
  * audit_filter_mutex:
- *             Synchronizes writes and blocking reads of audit's filterlist
- *             data.  Rcu is used to traverse the filterlist and access
- *             contents of structs audit_entry, audit_watch and opaque
- *             LSM rules during filtering.  If modified, these structures
- *             must be copied and replace their counterparts in the filterlist.
- *             An audit_parent struct is not accessed during filtering, so may
- *             be written directly provided audit_filter_mutex is held.
+ *             Synchronizes writes and blocking reads of audit's filterlist
+ *             data.  Rcu is used to traverse the filterlist and access
+ *             contents of structs audit_entry, audit_watch and opaque
+ *             LSM rules during filtering.  If modified, these structures
+ *             must be copied and replace their counterparts in the filterlist.
+ *             An audit_parent struct is not accessed during filtering, so may
+ *             be written directly provided audit_filter_mutex is held.
  */
 
 /* Audit filter lists, defined in <linux/audit.h> */