LU-6142 ptlrpc: Fix style issues for sec_null.c

This patch fixes issues reported by checkpatch
for file lustre/ptlrpc/sec_null.c

Test-Parameters: trivial
Signed-off-by: Arshad Hussain <arshad.super@gmail.com>
Change-Id: I67631d35ae4461ca92516975ab71f69d01378e19
Reviewed-on: https://review.whamcloud.com/34549
Tested-by: Jenkins
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Reviewed-by: Ben Evans <bevans@cray.com>
Reviewed-by: James Simmons <uja.ornl@yahoo.com>

diff --git a/lustre/ptlrpc/sec_null.c b/lustre/ptlrpc/sec_null.c
index 35aeba8..6ad0c0a 100644 (file)
--- a/lustre/ptlrpc/sec_null.c
+++ b/lustre/ptlrpc/sec_null.c
@@ -57,102 +57,103 @@ static struct ptlrpc_svc_ctx    null_svc_ctx;
 static inline
 void null_encode_sec_part(struct lustre_msg *msg, enum lustre_sec_part sp)
 {
 static inline
 void null_encode_sec_part(struct lustre_msg *msg, enum lustre_sec_part sp)
 {

-        msg->lm_secflvr |= (((__u32) sp) & 0xFF) << 24;
+       msg->lm_secflvr |= (((__u32) sp) & 0xFF) << 24;

 }
 
 static inline
 enum lustre_sec_part null_decode_sec_part(struct lustre_msg *msg)
 {
 }
 
 static inline
 enum lustre_sec_part null_decode_sec_part(struct lustre_msg *msg)
 {

-        return (msg->lm_secflvr >> 24) & 0xFF;
+       return (msg->lm_secflvr >> 24) & 0xFF;

 }
 
 static int null_ctx_refresh(struct ptlrpc_cli_ctx *ctx)
 {
 }
 
 static int null_ctx_refresh(struct ptlrpc_cli_ctx *ctx)
 {

-        /* should never reach here */
-        LBUG();
-        return 0;
+       /* should never reach here */
+       LBUG();
+       return 0;

 }
 
 static
 int null_ctx_sign(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req)
 {
 }
 
 static
 int null_ctx_sign(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req)
 {

-        req->rq_reqbuf->lm_secflvr = SPTLRPC_FLVR_NULL;
-
-        if (!req->rq_import->imp_dlm_fake) {
-                struct obd_device *obd = req->rq_import->imp_obd;
-                null_encode_sec_part(req->rq_reqbuf,
-                                     obd->u.cli.cl_sp_me);
-        }
-        req->rq_reqdata_len = req->rq_reqlen;
-        return 0;
+       req->rq_reqbuf->lm_secflvr = SPTLRPC_FLVR_NULL;
+
+       if (!req->rq_import->imp_dlm_fake) {
+               struct obd_device *obd = req->rq_import->imp_obd;
+
+               null_encode_sec_part(req->rq_reqbuf,
+                                    obd->u.cli.cl_sp_me);
+       }
+       req->rq_reqdata_len = req->rq_reqlen;
+       return 0;

 }
 
 static
 int null_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req)
 {
 }
 
 static
 int null_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req)
 {

-        __u32   cksums, cksumc;
+       __u32   cksums, cksumc;

 
 

-        LASSERT(req->rq_repdata);
+       LASSERT(req->rq_repdata);

 
 

-        req->rq_repmsg = req->rq_repdata;
-        req->rq_replen = req->rq_repdata_len;
+       req->rq_repmsg = req->rq_repdata;
+       req->rq_replen = req->rq_repdata_len;

 
 

-        if (req->rq_early) {
-                cksums = lustre_msg_get_cksum(req->rq_repdata);
+       if (req->rq_early) {
+               cksums = lustre_msg_get_cksum(req->rq_repdata);

                cksumc = lustre_msg_calc_cksum(req->rq_repmsg);
 
                cksumc = lustre_msg_calc_cksum(req->rq_repmsg);
 

-                if (cksumc != cksums) {
-                        CDEBUG(D_SEC,
-                               "early reply checksum mismatch: %08x != %08x\n",
-                               cksumc, cksums);
-                        return -EINVAL;
-                }
-        }
+               if (cksumc != cksums) {
+                       CDEBUG(D_SEC,
+                              "early reply checksum mismatch: %08x != %08x\n",
+                              cksumc, cksums);
+                       return -EINVAL;
+               }
+       }

 
 

-        return 0;
+       return 0;

 }
 
 static
 struct ptlrpc_sec *null_create_sec(struct obd_import *imp,
 }
 
 static
 struct ptlrpc_sec *null_create_sec(struct obd_import *imp,

-                                   struct ptlrpc_svc_ctx *svc_ctx,
-                                   struct sptlrpc_flavor *sf)
+                                  struct ptlrpc_svc_ctx *svc_ctx,
+                                  struct sptlrpc_flavor *sf)

 {
 {

-        LASSERT(SPTLRPC_FLVR_POLICY(sf->sf_rpc) == SPTLRPC_POLICY_NULL);
-
-        /* general layer has take a module reference for us, because we never
-         * really destroy the sec, simply release the reference here.
-         */
-        sptlrpc_policy_put(&null_policy);
-        return &null_sec;
+       LASSERT(SPTLRPC_FLVR_POLICY(sf->sf_rpc) == SPTLRPC_POLICY_NULL);
+
+       /*
+        * general layer has take a module reference for us, because we never
+        * really destroy the sec, simply release the reference here.
+        */
+       sptlrpc_policy_put(&null_policy);
+       return &null_sec;

 }
 
 static
 void null_destroy_sec(struct ptlrpc_sec *sec)
 {
 }
 
 static
 void null_destroy_sec(struct ptlrpc_sec *sec)
 {

-        LASSERT(sec == &null_sec);
+       LASSERT(sec == &null_sec);

 }
 
 static
 struct ptlrpc_cli_ctx *null_lookup_ctx(struct ptlrpc_sec *sec,
 }
 
 static
 struct ptlrpc_cli_ctx *null_lookup_ctx(struct ptlrpc_sec *sec,

-                                       struct vfs_cred *vcred,
-                                       int create, int remove_dead)
+                                      struct vfs_cred *vcred,
+                                      int create, int remove_dead)

 {
        atomic_inc(&null_cli_ctx.cc_refcount);
        return &null_cli_ctx;
 }
 
 static
 {
        atomic_inc(&null_cli_ctx.cc_refcount);
        return &null_cli_ctx;
 }
 
 static

-int null_flush_ctx_cache(struct ptlrpc_sec *sec,
-                         uid_t uid,
-                         int grace, int force)
+int null_flush_ctx_cache(struct ptlrpc_sec *sec, uid_t uid, int grace,
+                        int force)

 {
 {

-        return 0;
+       return 0;

 }
 
 static
 int null_alloc_reqbuf(struct ptlrpc_sec *sec,
 }
 
 static
 int null_alloc_reqbuf(struct ptlrpc_sec *sec,

-                      struct ptlrpc_request *req,
-                      int msgsize)
+                     struct ptlrpc_request *req,
+                     int msgsize)

 {
        if (!req->rq_reqbuf) {
                int alloc_size = size_roundup_power2(msgsize);
 {
        if (!req->rq_reqbuf) {
                int alloc_size = size_roundup_power2(msgsize);


@@ -175,26 +176,26 @@ int null_alloc_reqbuf(struct ptlrpc_sec *sec,
 
 static
 void null_free_reqbuf(struct ptlrpc_sec *sec,
 
 static
 void null_free_reqbuf(struct ptlrpc_sec *sec,

-                      struct ptlrpc_request *req)
+                     struct ptlrpc_request *req)

 {
 {

-        if (!req->rq_pool) {
-                LASSERTF(req->rq_reqmsg == req->rq_reqbuf,
-                         "req %p: reqmsg %p is not reqbuf %p in null sec\n",
-                         req, req->rq_reqmsg, req->rq_reqbuf);
-                LASSERTF(req->rq_reqbuf_len >= req->rq_reqlen,
-                         "req %p: reqlen %d should smaller than buflen %d\n",
-                         req, req->rq_reqlen, req->rq_reqbuf_len);
-
-                OBD_FREE_LARGE(req->rq_reqbuf, req->rq_reqbuf_len);
-                req->rq_reqbuf = NULL;
-                req->rq_reqbuf_len = 0;
-        }
+       if (!req->rq_pool) {
+               LASSERTF(req->rq_reqmsg == req->rq_reqbuf,
+                        "req %p: reqmsg %p is not reqbuf %p in null sec\n",
+                        req, req->rq_reqmsg, req->rq_reqbuf);
+               LASSERTF(req->rq_reqbuf_len >= req->rq_reqlen,
+                        "req %p: reqlen %d should smaller than buflen %d\n",
+                        req, req->rq_reqlen, req->rq_reqbuf_len);
+
+               OBD_FREE_LARGE(req->rq_reqbuf, req->rq_reqbuf_len);
+               req->rq_reqbuf = NULL;
+               req->rq_reqbuf_len = 0;
+       }

 }
 
 static
 int null_alloc_repbuf(struct ptlrpc_sec *sec,
 }
 
 static
 int null_alloc_repbuf(struct ptlrpc_sec *sec,

-                      struct ptlrpc_request *req,
-                      int msgsize)
+                     struct ptlrpc_request *req,
+                     int msgsize)

 {
        /* add space for early replied */
        msgsize += lustre_msg_early_size();
 {
        /* add space for early replied */
        msgsize += lustre_msg_early_size();


@@ -211,37 +212,37 @@ int null_alloc_repbuf(struct ptlrpc_sec *sec,
 
 static
 void null_free_repbuf(struct ptlrpc_sec *sec,
 
 static
 void null_free_repbuf(struct ptlrpc_sec *sec,

-                      struct ptlrpc_request *req)
+                     struct ptlrpc_request *req)

 {
 {

-        LASSERT(req->rq_repbuf);
+       LASSERT(req->rq_repbuf);

 
 

-        OBD_FREE_LARGE(req->rq_repbuf, req->rq_repbuf_len);
-        req->rq_repbuf = NULL;
-        req->rq_repbuf_len = 0;
+       OBD_FREE_LARGE(req->rq_repbuf, req->rq_repbuf_len);
+       req->rq_repbuf = NULL;
+       req->rq_repbuf_len = 0;

 }
 
 static
 int null_enlarge_reqbuf(struct ptlrpc_sec *sec,
 }
 
 static
 int null_enlarge_reqbuf(struct ptlrpc_sec *sec,

-                        struct ptlrpc_request *req,
-                        int segment, int newsize)
+                       struct ptlrpc_request *req,
+                       int segment, int newsize)

 {
 {

-        struct lustre_msg      *newbuf;
-        struct lustre_msg      *oldbuf = req->rq_reqmsg;
-        int                     oldsize, newmsg_size, alloc_size;
+       struct lustre_msg      *newbuf;
+       struct lustre_msg      *oldbuf = req->rq_reqmsg;
+       int                     oldsize, newmsg_size, alloc_size;

 
 

-        LASSERT(req->rq_reqbuf);
-        LASSERT(req->rq_reqbuf == req->rq_reqmsg);
-        LASSERT(req->rq_reqbuf_len >= req->rq_reqlen);
-        LASSERT(req->rq_reqlen == lustre_packed_msg_size(oldbuf));
+       LASSERT(req->rq_reqbuf);
+       LASSERT(req->rq_reqbuf == req->rq_reqmsg);
+       LASSERT(req->rq_reqbuf_len >= req->rq_reqlen);
+       LASSERT(req->rq_reqlen == lustre_packed_msg_size(oldbuf));

 
 

-        /* compute new message size */
-        oldsize = req->rq_reqbuf->lm_buflens[segment];
-        req->rq_reqbuf->lm_buflens[segment] = newsize;
-        newmsg_size = lustre_packed_msg_size(oldbuf);
-        req->rq_reqbuf->lm_buflens[segment] = oldsize;
+       /* compute new message size */
+       oldsize = req->rq_reqbuf->lm_buflens[segment];
+       req->rq_reqbuf->lm_buflens[segment] = newsize;
+       newmsg_size = lustre_packed_msg_size(oldbuf);
+       req->rq_reqbuf->lm_buflens[segment] = oldsize;

 
 

-        /* request from pool should always have enough buffer */
-        LASSERT(!req->rq_pool || req->rq_reqbuf_len >= newmsg_size);
+       /* request from pool should always have enough buffer */
+       LASSERT(!req->rq_pool || req->rq_reqbuf_len >= newmsg_size);

 
        if (req->rq_reqbuf_len < newmsg_size) {
                alloc_size = size_roundup_power2(newmsg_size);
 
        if (req->rq_reqbuf_len < newmsg_size) {
                alloc_size = size_roundup_power2(newmsg_size);


@@ -250,12 +251,14 @@ int null_enlarge_reqbuf(struct ptlrpc_sec *sec,
                if (newbuf == NULL)
                        return -ENOMEM;
 
                if (newbuf == NULL)
                        return -ENOMEM;
 

-               /* Must lock this, so that otherwise unprotected change of
+               /*
+                * Must lock this, so that otherwise unprotected change of

                 * rq_reqmsg is not racing with parallel processing of
                 * imp_replay_list traversing threads. See LU-3333
                 * This is a bandaid at best, we really need to deal with this
                 * in request enlarging code before unpacking that's already
                 * rq_reqmsg is not racing with parallel processing of
                 * imp_replay_list traversing threads. See LU-3333
                 * This is a bandaid at best, we really need to deal with this
                 * in request enlarging code before unpacking that's already

-                * there */
+                * there
+                */

                if (req->rq_import)
                        spin_lock(&req->rq_import->imp_lock);
                memcpy(newbuf, req->rq_reqbuf, req->rq_reqlen);
                if (req->rq_import)
                        spin_lock(&req->rq_import->imp_lock);
                memcpy(newbuf, req->rq_reqbuf, req->rq_reqlen);


@@ -266,17 +269,17 @@ int null_enlarge_reqbuf(struct ptlrpc_sec *sec,
 
                if (req->rq_import)
                        spin_unlock(&req->rq_import->imp_lock);
 
                if (req->rq_import)
                        spin_unlock(&req->rq_import->imp_lock);

-        }
+       }

 
 

-        _sptlrpc_enlarge_msg_inplace(req->rq_reqmsg, segment, newsize);
-        req->rq_reqlen = newmsg_size;
+       _sptlrpc_enlarge_msg_inplace(req->rq_reqmsg, segment, newsize);
+       req->rq_reqlen = newmsg_size;

 
 

-        return 0;
+       return 0;

 }
 
 static struct ptlrpc_svc_ctx null_svc_ctx = {
        .sc_refcount    = ATOMIC_INIT(1),
 }
 
 static struct ptlrpc_svc_ctx null_svc_ctx = {
        .sc_refcount    = ATOMIC_INIT(1),

-        .sc_policy      = &null_policy,
+       .sc_policy      = &null_policy,

 };
 
 static
 };
 
 static


@@ -304,17 +307,17 @@ int null_accept(struct ptlrpc_request *req)
 static
 int null_alloc_rs(struct ptlrpc_request *req, int msgsize)
 {
 static
 int null_alloc_rs(struct ptlrpc_request *req, int msgsize)
 {

-        struct ptlrpc_reply_state *rs;
-        int rs_size = sizeof(*rs) + msgsize;
+       struct ptlrpc_reply_state *rs;
+       int rs_size = sizeof(*rs) + msgsize;

 
 

-        LASSERT(msgsize % 8 == 0);
+       LASSERT(msgsize % 8 == 0);

 
 

-        rs = req->rq_reply_state;
+       rs = req->rq_reply_state;

 
 

-        if (rs) {
-                /* pre-allocated */
-                LASSERT(rs->rs_size >= rs_size);
-        } else {
+       if (rs) {
+               /* pre-allocated */
+               LASSERT(rs->rs_size >= rs_size);
+       } else {

                OBD_ALLOC_LARGE(rs, rs_size);
                if (rs == NULL)
                        return -ENOMEM;
                OBD_ALLOC_LARGE(rs, rs_size);
                if (rs == NULL)
                        return -ENOMEM;


@@ -346,20 +349,20 @@ void null_free_rs(struct ptlrpc_reply_state *rs)
 static
 int null_authorize(struct ptlrpc_request *req)
 {
 static
 int null_authorize(struct ptlrpc_request *req)
 {

-        struct ptlrpc_reply_state *rs = req->rq_reply_state;
+       struct ptlrpc_reply_state *rs = req->rq_reply_state;

 
 

-        LASSERT(rs);
+       LASSERT(rs);

 
 

-        rs->rs_repbuf->lm_secflvr = SPTLRPC_FLVR_NULL;
-        rs->rs_repdata_len = req->rq_replen;
+       rs->rs_repbuf->lm_secflvr = SPTLRPC_FLVR_NULL;
+       rs->rs_repdata_len = req->rq_replen;

 
 

-        if (likely(req->rq_packed_final)) {
-                if (lustre_msghdr_get_flags(req->rq_reqmsg) & MSGHDR_AT_SUPPORT)
-                        req->rq_reply_off = lustre_msg_early_size();
-                else
-                        req->rq_reply_off = 0;
-        } else {
-                __u32 cksum;
+       if (likely(req->rq_packed_final)) {
+               if (lustre_msghdr_get_flags(req->rq_reqmsg) & MSGHDR_AT_SUPPORT)
+                       req->rq_reply_off = lustre_msg_early_size();
+               else
+                       req->rq_reply_off = 0;
+       } else {
+               __u32 cksum;

 
                cksum = lustre_msg_calc_cksum(rs->rs_repbuf);
                lustre_msg_set_cksum(rs->rs_repbuf, cksum);
 
                cksum = lustre_msg_calc_cksum(rs->rs_repbuf);
                lustre_msg_set_cksum(rs->rs_repbuf, cksum);


@@ -370,36 +373,36 @@ int null_authorize(struct ptlrpc_request *req)
 }
 
 static struct ptlrpc_ctx_ops null_ctx_ops = {
 }
 
 static struct ptlrpc_ctx_ops null_ctx_ops = {

-        .refresh                = null_ctx_refresh,
-        .sign                   = null_ctx_sign,
-        .verify                 = null_ctx_verify,
+       .refresh                = null_ctx_refresh,
+       .sign                   = null_ctx_sign,
+       .verify                 = null_ctx_verify,

 };
 
 static struct ptlrpc_sec_cops null_sec_cops = {
 };
 
 static struct ptlrpc_sec_cops null_sec_cops = {

-        .create_sec             = null_create_sec,
-        .destroy_sec            = null_destroy_sec,
-        .lookup_ctx             = null_lookup_ctx,
-        .flush_ctx_cache        = null_flush_ctx_cache,
-        .alloc_reqbuf           = null_alloc_reqbuf,
-        .alloc_repbuf           = null_alloc_repbuf,
-        .free_reqbuf            = null_free_reqbuf,
-        .free_repbuf            = null_free_repbuf,
-        .enlarge_reqbuf         = null_enlarge_reqbuf,
+       .create_sec             = null_create_sec,
+       .destroy_sec            = null_destroy_sec,
+       .lookup_ctx             = null_lookup_ctx,
+       .flush_ctx_cache        = null_flush_ctx_cache,
+       .alloc_reqbuf           = null_alloc_reqbuf,
+       .alloc_repbuf           = null_alloc_repbuf,
+       .free_reqbuf            = null_free_reqbuf,
+       .free_repbuf            = null_free_repbuf,
+       .enlarge_reqbuf         = null_enlarge_reqbuf,

 };
 
 static struct ptlrpc_sec_sops null_sec_sops = {
 };
 
 static struct ptlrpc_sec_sops null_sec_sops = {

-        .accept                 = null_accept,
-        .alloc_rs               = null_alloc_rs,
-        .authorize              = null_authorize,
-        .free_rs                = null_free_rs,
+       .accept                 = null_accept,
+       .alloc_rs               = null_alloc_rs,
+       .authorize              = null_authorize,
+       .free_rs                = null_free_rs,

 };
 
 static struct ptlrpc_sec_policy null_policy = {
 };
 
 static struct ptlrpc_sec_policy null_policy = {

-        .sp_owner               = THIS_MODULE,
-        .sp_name                = "sec.null",
-        .sp_policy              = SPTLRPC_POLICY_NULL,
-        .sp_cops                = &null_sec_cops,
-        .sp_sops                = &null_sec_sops,
+       .sp_owner               = THIS_MODULE,
+       .sp_name                = "sec.null",
+       .sp_policy              = SPTLRPC_POLICY_NULL,
+       .sp_cops                = &null_sec_cops,
+       .sp_sops                = &null_sec_sops,

 };
 
 static void null_init_internal(void)
 };
 
 static void null_init_internal(void)


@@ -435,22 +438,23 @@ static void null_init_internal(void)
 
 int sptlrpc_null_init(void)
 {
 
 int sptlrpc_null_init(void)
 {

-        int rc;
+       int rc;

 
 

-        null_init_internal();
+       null_init_internal();

 
 

-        rc = sptlrpc_register_policy(&null_policy);
-        if (rc)
-                CERROR("failed to register %s: %d\n", null_policy.sp_name, rc);
+       rc = sptlrpc_register_policy(&null_policy);
+       if (rc)
+               CERROR("failed to register %s: %d\n", null_policy.sp_name, rc);

 
 

-        return rc;
+       return rc;

 }
 
 void sptlrpc_null_fini(void)
 {
 }
 
 void sptlrpc_null_fini(void)
 {

-        int rc;
+       int rc;

 
 

-        rc = sptlrpc_unregister_policy(&null_policy);
-        if (rc)
-                CERROR("failed to unregister %s: %d\n", null_policy.sp_name,rc);
+       rc = sptlrpc_unregister_policy(&null_policy);
+       if (rc)
+               CERROR("failed to unregister %s: %d\n", null_policy.sp_name,
+                      rc);

 }
 }