selinux: fix style issues in security/selinux/ss/sidtab.c

As part of on ongoing effort to perform more automated testing and
provide more tools for individual developers to validate their
patches before submitting, we are trying to make our code
"clang-format clean".  My hope is that once we have fixed all of our
style "quirks", developers will be able to run clang-format on their
patches to help avoid silly formatting problems and ensure their
changes fit in well with the rest of the SELinux kernel code.

Signed-off-by: Paul Moore <paul@paul-moore.com>

diff --git a/security/selinux/ss/sidtab.c b/security/selinux/ss/sidtab.c
index 732fd8e22a120396b34063ea831ad392b054427f..c8848cbba81f24abbb2e0d07697ece10d2cc6637 100644 (file)
--- a/security/selinux/ss/sidtab.c
+++ b/security/selinux/ss/sidtab.c
@@ -7,6 +7,7 @@
  *
  * Copyright (C) 2018 Red Hat, Inc.
  */
+
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
@@ -29,7 +30,7 @@ struct sidtab_str_cache {
 };
 
 #define index_to_sid(index) ((index) + SECINITSID_NUM + 1)
-#define sid_to_index(sid) ((sid) - (SECINITSID_NUM + 1))
+#define sid_to_index(sid)   ((sid) - (SECINITSID_NUM + 1))
 
 int sidtab_init(struct sidtab *s)
 {
@@ -140,9 +141,11 @@ int sidtab_hash_stats(struct sidtab *sidtab, char *page)
        if (chain_len > max_chain_len)
                max_chain_len = chain_len;
 
-       return scnprintf(page, PAGE_SIZE, "entries: %d\nbuckets used: %d/%d\n"
-                        "longest chain: %d\n", entries,
-                        slots_used, SIDTAB_HASH_BUCKETS, max_chain_len);
+       return scnprintf(page, PAGE_SIZE,
+                        "entries: %d\nbuckets used: %d/%d\n"
+                        "longest chain: %d\n",
+                        entries, slots_used, SIDTAB_HASH_BUCKETS,
+                        max_chain_len);
 }
 
 static u32 sidtab_level_from_count(u32 count)
@@ -162,15 +165,15 @@ static int sidtab_alloc_roots(struct sidtab *s, u32 level)
        u32 l;
 
        if (!s->roots[0].ptr_leaf) {
-               s->roots[0].ptr_leaf = kzalloc(SIDTAB_NODE_ALLOC_SIZE,
-                                              GFP_ATOMIC);
+               s->roots[0].ptr_leaf =
+                       kzalloc(SIDTAB_NODE_ALLOC_SIZE, GFP_ATOMIC);
                if (!s->roots[0].ptr_leaf)
                        return -ENOMEM;
        }
        for (l = 1; l <= level; ++l)
                if (!s->roots[l].ptr_inner) {
-                       s->roots[l].ptr_inner = kzalloc(SIDTAB_NODE_ALLOC_SIZE,
-                                                       GFP_ATOMIC);
+                       s->roots[l].ptr_inner =
+                               kzalloc(SIDTAB_NODE_ALLOC_SIZE, GFP_ATOMIC);
                        if (!s->roots[l].ptr_inner)
                                return -ENOMEM;
                        s->roots[l].ptr_inner->entries[0] = s->roots[l - 1];
@@ -203,16 +206,16 @@ static struct sidtab_entry *sidtab_do_lookup(struct sidtab *s, u32 index,
 
                if (!entry->ptr_inner) {
                        if (alloc)
-                               entry->ptr_inner = kzalloc(SIDTAB_NODE_ALLOC_SIZE,
-                                                          GFP_ATOMIC);
+                               entry->ptr_inner = kzalloc(
+                                       SIDTAB_NODE_ALLOC_SIZE, GFP_ATOMIC);
                        if (!entry->ptr_inner)
                                return NULL;
                }
        }
        if (!entry->ptr_leaf) {
                if (alloc)
-                       entry->ptr_leaf = kzalloc(SIDTAB_NODE_ALLOC_SIZE,
-                                                 GFP_ATOMIC);
+                       entry->ptr_leaf =
+                               kzalloc(SIDTAB_NODE_ALLOC_SIZE, GFP_ATOMIC);
                if (!entry->ptr_leaf)
                        return NULL;
        }
@@ -262,8 +265,7 @@ struct sidtab_entry *sidtab_search_entry_force(struct sidtab *s, u32 sid)
        return sidtab_search_core(s, sid, 1);
 }
 
-int sidtab_context_to_sid(struct sidtab *s, struct context *context,
-                         u32 *sid)
+int sidtab_context_to_sid(struct sidtab *s, struct context *context, u32 *sid)
 {
        unsigned long flags;
        u32 count, hash = context_compute_hash(context);
@@ -327,8 +329,8 @@ int sidtab_context_to_sid(struct sidtab *s, struct context *context,
                        goto out_unlock;
                }
 
-               rc = services_convert_context(convert->args,
-                                             context, &dst_convert->context,
+               rc = services_convert_context(convert->args, context,
+                                             &dst_convert->context,
                                              GFP_ATOMIC);
                if (rc) {
                        context_destroy(&dst->context);
@@ -338,8 +340,8 @@ int sidtab_context_to_sid(struct sidtab *s, struct context *context,
                dst_convert->hash = context_compute_hash(&dst_convert->context);
                target->count = count + 1;
 
-               hash_add_rcu(target->context_to_sid,
-                            &dst_convert->list, dst_convert->hash);
+               hash_add_rcu(target->context_to_sid, &dst_convert->list,
+                            dst_convert->hash);
        }
 
        if (context->len)
@@ -373,8 +375,8 @@ static void sidtab_convert_hashtable(struct sidtab *s, u32 count)
 }
 
 static int sidtab_convert_tree(union sidtab_entry_inner *edst,
-                              union sidtab_entry_inner *esrc,
-                              u32 *pos, u32 count, u32 level,
+                              union sidtab_entry_inner *esrc, u32 *pos,
+                              u32 count, u32 level,
                               struct sidtab_convert_params *convert)
 {
        int rc;
@@ -382,8 +384,8 @@ static int sidtab_convert_tree(union sidtab_entry_inner *edst,
 
        if (level != 0) {
                if (!edst->ptr_inner) {
-                       edst->ptr_inner = kzalloc(SIDTAB_NODE_ALLOC_SIZE,
-                                                 GFP_KERNEL);
+                       edst->ptr_inner =
+                               kzalloc(SIDTAB_NODE_ALLOC_SIZE, GFP_KERNEL);
                        if (!edst->ptr_inner)
                                return -ENOMEM;
                }
@@ -399,17 +401,18 @@ static int sidtab_convert_tree(union sidtab_entry_inner *edst,
                }
        } else {
                if (!edst->ptr_leaf) {
-                       edst->ptr_leaf = kzalloc(SIDTAB_NODE_ALLOC_SIZE,
-                                                GFP_KERNEL);
+                       edst->ptr_leaf =
+                               kzalloc(SIDTAB_NODE_ALLOC_SIZE, GFP_KERNEL);
                        if (!edst->ptr_leaf)
                                return -ENOMEM;
                }
                i = 0;
                while (i < SIDTAB_LEAF_ENTRIES && *pos < count) {
-                       rc = services_convert_context(convert->args,
-                                       &esrc->ptr_leaf->entries[i].context,
-                                       &edst->ptr_leaf->entries[i].context,
-                                       GFP_KERNEL);
+                       rc = services_convert_context(
+                               convert->args,
+                               &esrc->ptr_leaf->entries[i].context,
+                               &edst->ptr_leaf->entries[i].context,
+                               GFP_KERNEL);
                        if (rc)
                                return rc;
                        (*pos)++;
@@ -489,13 +492,15 @@ void sidtab_cancel_convert(struct sidtab *s)
        spin_unlock_irqrestore(&s->lock, flags);
 }
 
-void sidtab_freeze_begin(struct sidtab *s, unsigned long *flags) __acquires(&s->lock)
+void sidtab_freeze_begin(struct sidtab *s, unsigned long *flags)
+       __acquires(&s->lock)
 {
        spin_lock_irqsave(&s->lock, *flags);
        s->frozen = true;
        s->convert = NULL;
 }
-void sidtab_freeze_end(struct sidtab *s, unsigned long *flags) __releases(&s->lock)
+void sidtab_freeze_end(struct sidtab *s, unsigned long *flags)
+       __releases(&s->lock)
 {
        spin_unlock_irqrestore(&s->lock, *flags);
 }
@@ -600,8 +605,8 @@ out_unlock:
        kfree_rcu(victim, rcu_member);
 }
 
-int sidtab_sid2str_get(struct sidtab *s, struct sidtab_entry *entry,
-                      char **out, u32 *out_len)
+int sidtab_sid2str_get(struct sidtab *s, struct sidtab_entry *entry, char **out,
+                      u32 *out_len)
 {
        struct sidtab_str_cache *cache;
        int rc = 0;