cifs: remove some camelCase and also some static build warnings

Remove warnings for five global variables. For example:
  fs/cifs/cifsglob.h:1984:24: warning: symbol 'midCount' was not declared. Should it be static?

Also change them from camelCase (e.g. "midCount" to "mid_count")

Reviewed-by: Paulo Alcantara (SUSE) <pc@cjr.nz>
Signed-off-by: Steve French <stfrench@microsoft.com>

diff --git a/fs/cifs/cifs_debug.c b/fs/cifs/cifs_debug.c
index 97116c1710e2c32261725133b0d981b7885bb41d..f5e63dfac2b1fbc7bcfb8aa98a0e2fa12b5bd823 100644 (file)
--- a/fs/cifs/cifs_debug.c
+++ b/fs/cifs/cifs_debug.c
@@ -514,8 +514,8 @@ static ssize_t cifs_stats_proc_write(struct file *file,
 #ifdef CONFIG_CIFS_STATS2
                int i;
 
-               atomic_set(&totBufAllocCount, 0);
-               atomic_set(&totSmBufAllocCount, 0);
+               atomic_set(&total_buf_alloc_count, 0);
+               atomic_set(&total_small_buf_alloc_count, 0);
 #endif /* CONFIG_CIFS_STATS2 */
                atomic_set(&tcpSesReconnectCount, 0);
                atomic_set(&tconInfoReconnectCount, 0);
@@ -579,17 +579,17 @@ static int cifs_stats_proc_show(struct seq_file *m, void *v)
        seq_printf(m, "Share (unique mount targets): %d\n",
                        tconInfoAllocCount.counter);
        seq_printf(m, "SMB Request/Response Buffer: %d Pool size: %d\n",
-                       bufAllocCount.counter,
+                       buf_alloc_count.counter,
                        cifs_min_rcv + tcpSesAllocCount.counter);
        seq_printf(m, "SMB Small Req/Resp Buffer: %d Pool size: %d\n",
-                       smBufAllocCount.counter, cifs_min_small);
+                       small_buf_alloc_count.counter, cifs_min_small);
 #ifdef CONFIG_CIFS_STATS2
        seq_printf(m, "Total Large %d Small %d Allocations\n",
-                               atomic_read(&totBufAllocCount),
-                               atomic_read(&totSmBufAllocCount));
+                               atomic_read(&total_buf_alloc_count),
+                               atomic_read(&total_small_buf_alloc_count));
 #endif /* CONFIG_CIFS_STATS2 */
 
-       seq_printf(m, "Operations (MIDs): %d\n", atomic_read(&midCount));
+       seq_printf(m, "Operations (MIDs): %d\n", atomic_read(&mid_count));
        seq_printf(m,
                "\n%d session %d share reconnects\n",
                tcpSesReconnectCount.counter, tconInfoReconnectCount.counter);

diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 8f2e003e059075fe2c715728e5477d9d2d712028..2732953f49e49f1c124f83418b643946adb8b277 100644 (file)
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -68,6 +68,13 @@ bool enable_negotiate_signing; /* false by default */
 unsigned int global_secflags = CIFSSEC_DEF;
 /* unsigned int ntlmv2_support = 0; */
 unsigned int sign_CIFS_PDUs = 1;
+atomic_t mid_count;
+atomic_t buf_alloc_count;
+atomic_t small_buf_alloc_count;
+#ifdef CONFIG_CIFS_STATS2
+atomic_t total_buf_alloc_count;
+atomic_t total_small_buf_alloc_count;
+#endif/* STATS2 */
 static const struct super_operations cifs_super_ops;
 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
 module_param(CIFSMaxBufSize, uint, 0444);
@@ -1579,11 +1586,11 @@ init_cifs(void)
        atomic_set(&tcpSesReconnectCount, 0);
        atomic_set(&tconInfoReconnectCount, 0);
 
-       atomic_set(&bufAllocCount, 0);
-       atomic_set(&smBufAllocCount, 0);
+       atomic_set(&buf_alloc_count, 0);
+       atomic_set(&small_buf_alloc_count, 0);
 #ifdef CONFIG_CIFS_STATS2
-       atomic_set(&totBufAllocCount, 0);
-       atomic_set(&totSmBufAllocCount, 0);
+       atomic_set(&total_buf_alloc_count, 0);
+       atomic_set(&total_small_buf_alloc_count, 0);
        if (slow_rsp_threshold < 1)
                cifs_dbg(FYI, "slow_response_threshold msgs disabled\n");
        else if (slow_rsp_threshold > 32767)
@@ -1591,7 +1598,7 @@ init_cifs(void)
                       "slow response threshold set higher than recommended (0 to 32767)\n");
 #endif /* CONFIG_CIFS_STATS2 */
 
-       atomic_set(&midCount, 0);
+       atomic_set(&mid_count, 0);
        GlobalCurrentXid = 0;
        GlobalTotalActiveXid = 0;
        GlobalMaxActiveXid = 0;

diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index a643c84ff1e93077e7b3d53989b4147a34cb7c2f..c5eecc9522b32898baa0cf24dea125327e54ca63 100644 (file)
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -1974,14 +1974,13 @@ GLOBAL_EXTERN atomic_t tcpSesReconnectCount;
 GLOBAL_EXTERN atomic_t tconInfoReconnectCount;
 
 /* Various Debug counters */
-GLOBAL_EXTERN atomic_t bufAllocCount;    /* current number allocated  */
+extern atomic_t buf_alloc_count;       /* current number allocated  */
+extern atomic_t small_buf_alloc_count;
 #ifdef CONFIG_CIFS_STATS2
-GLOBAL_EXTERN atomic_t totBufAllocCount; /* total allocated over all time */
-GLOBAL_EXTERN atomic_t totSmBufAllocCount;
+extern atomic_t total_buf_alloc_count; /* total allocated over all time */
+extern atomic_t total_small_buf_alloc_count;
 extern unsigned int slow_rsp_threshold; /* number of secs before logging */
 #endif
-GLOBAL_EXTERN atomic_t smBufAllocCount;
-GLOBAL_EXTERN atomic_t midCount;
 
 /* Misc globals */
 extern bool enable_oplocks; /* enable or disable oplocks */
@@ -1998,6 +1997,7 @@ extern unsigned int cifs_min_rcv;    /* min size of big ntwrk buf pool */
 extern unsigned int cifs_min_small;  /* min size of small buf pool */
 extern unsigned int cifs_max_pending; /* MAX requests at once to server*/
 extern bool disable_legacy_dialects;  /* forbid vers=1.0 and vers=2.0 mounts */
+extern atomic_t mid_count;
 
 void cifs_oplock_break(struct work_struct *work);
 void cifs_queue_oplock_break(struct cifsFileInfo *cfile);

diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 47a161f86662ecff3b407631098edc3145ddea4e..fdd8452b8450d4374d78fdf9cab7ae4568929061 100644 (file)
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -1240,7 +1240,7 @@ next_pdu:
                                cifs_dbg(FYI, "Received oplock break\n");
                        } else {
                                cifs_server_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
-                                               atomic_read(&midCount));
+                                               atomic_read(&mid_count));
                                cifs_dump_mem("Received Data is: ", bufs[i],
                                              HEADER_SIZE(server));
                                smb2_add_credits_from_hdr(bufs[i], server);

diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c
index 0e84e6fcf8ab4fdb0fad67b58586218050afbf2f..16168ebd1a62f75a58b2526ec55d57a26544ecca 100644 (file)
--- a/fs/cifs/misc.c
+++ b/fs/cifs/misc.c
@@ -172,9 +172,9 @@ cifs_buf_get(void)
        /* clear the first few header bytes */
        /* for most paths, more is cleared in header_assemble */
        memset(ret_buf, 0, buf_size + 3);
-       atomic_inc(&bufAllocCount);
+       atomic_inc(&buf_alloc_count);
 #ifdef CONFIG_CIFS_STATS2
-       atomic_inc(&totBufAllocCount);
+       atomic_inc(&total_buf_alloc_count);
 #endif /* CONFIG_CIFS_STATS2 */
 
        return ret_buf;
@@ -189,7 +189,7 @@ cifs_buf_release(void *buf_to_free)
        }
        mempool_free(buf_to_free, cifs_req_poolp);
 
-       atomic_dec(&bufAllocCount);
+       atomic_dec(&buf_alloc_count);
        return;
 }
 
@@ -205,9 +205,9 @@ cifs_small_buf_get(void)
        ret_buf = mempool_alloc(cifs_sm_req_poolp, GFP_NOFS);
        /* No need to clear memory here, cleared in header assemble */
        /*      memset(ret_buf, 0, sizeof(struct smb_hdr) + 27);*/
-       atomic_inc(&smBufAllocCount);
+       atomic_inc(&small_buf_alloc_count);
 #ifdef CONFIG_CIFS_STATS2
-       atomic_inc(&totSmBufAllocCount);
+       atomic_inc(&total_small_buf_alloc_count);
 #endif /* CONFIG_CIFS_STATS2 */
 
        return ret_buf;
@@ -223,7 +223,7 @@ cifs_small_buf_release(void *buf_to_free)
        }
        mempool_free(buf_to_free, cifs_sm_req_poolp);
 
-       atomic_dec(&smBufAllocCount);
+       atomic_dec(&small_buf_alloc_count);
        return;
 }
 

diff --git a/fs/cifs/smb2transport.c b/fs/cifs/smb2transport.c
index 55e79f6ee78d1751af8c09fb5360b74008828880..53ff6bc11939f8e12c22b2a6c9690eebe1b60ba6 100644 (file)
--- a/fs/cifs/smb2transport.c
+++ b/fs/cifs/smb2transport.c
@@ -750,7 +750,7 @@ smb2_mid_entry_alloc(const struct smb2_hdr *shdr,
        temp->callback = cifs_wake_up_task;
        temp->callback_data = current;
 
-       atomic_inc(&midCount);
+       atomic_inc(&mid_count);
        temp->mid_state = MID_REQUEST_ALLOCATED;
        trace_smb3_cmd_enter(le32_to_cpu(shdr->Id.SyncId.TreeId),
                             le64_to_cpu(shdr->SessionId),

diff --git a/fs/cifs/transport.c b/fs/cifs/transport.c
index bfc9bd55870a0626005cf4adc7c10be58201cc95..dac8d6f9b309fc17e643858201705cce3346030a 100644 (file)
--- a/fs/cifs/transport.c
+++ b/fs/cifs/transport.c
@@ -68,7 +68,7 @@ AllocMidQEntry(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server)
        temp->callback = cifs_wake_up_task;
        temp->callback_data = current;
 
-       atomic_inc(&midCount);
+       atomic_inc(&mid_count);
        temp->mid_state = MID_REQUEST_ALLOCATED;
        return temp;
 }
@@ -91,7 +91,7 @@ static void _cifs_mid_q_entry_release(struct kref *refcount)
                server->ops->handle_cancelled_mid(midEntry, server);
 
        midEntry->mid_state = MID_FREE;
-       atomic_dec(&midCount);
+       atomic_dec(&mid_count);
        if (midEntry->large_buf)
                cifs_buf_release(midEntry->resp_buf);
        else