[CIFS] cifs: Rename cERROR and cFYI to cifs_dbg

It's not obvious from reading the macro names that these macros
are for debugging.  Convert the names to a single more typical
kernel style cifs_dbg macro.

	cERROR(1, ...)   -> cifs_dbg(VFS, ...)
	cFYI(1, ...)     -> cifs_dbg(FYI, ...)
	cFYI(DBG2, ...)  -> cifs_dbg(NOISY, ...)

Move the terminating format newline from the macro to the call site.

Add CONFIG_CIFS_DEBUG function cifs_vfs_err to emit the
"CIFS VFS: " prefix for VFS messages.

Size is reduced ~ 1% when CONFIG_CIFS_DEBUG is set (default y)

$ size fs/cifs/cifs.ko*
   text    data     bss     dec     hex filename
 265245	   2525	    132	 267902	  4167e	fs/cifs/cifs.ko.new
 268359    2525     132  271016   422a8 fs/cifs/cifs.ko.old

Other miscellaneous changes around these conversions:

o Miscellaneous typo fixes
o Add terminating \n's to almost all formats and remove them
  from the macros to be more kernel style like.  A few formats
  previously had defective \n's
o Remove unnecessary OOM messages as kmalloc() calls dump_stack
o Coalesce formats to make grep easier,
  added missing spaces when coalescing formats
o Use %s, __func__ instead of embedded function name
o Removed unnecessary "cifs: " prefixes
o Convert kzalloc with multiply to kcalloc
o Remove unused cifswarn macro

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Steve French <smfrench@gmail.com>

1 files changed, 37 insertions, 32 deletions

diff --git a/fs/cifs/sess.c b/fs/cifs/sess.c
index 6f83881ff30b..f230571a7ab3 100644
--- a/fs/cifs/sess.c
+++ b/fs/cifs/sess.c
@@ -283,11 +283,11 @@ decode_unicode_ssetup(char **pbcc_area, int bleft, struct cifs_ses *ses,
         int len;
         char *data = *pbcc_area;
 
-        cFYI(1, "bleft %d", bleft);
+        cifs_dbg(FYI, "bleft %d\n", bleft);
 
         kfree(ses->serverOS);
         ses->serverOS = cifs_strndup_from_utf16(data, bleft, true, nls_cp);
-        cFYI(1, "serverOS=%s", ses->serverOS);
+        cifs_dbg(FYI, "serverOS=%s\n", ses->serverOS);
         len = (UniStrnlen((wchar_t *) data, bleft / 2) * 2) + 2;
         data += len;
         bleft -= len;
@@ -296,7 +296,7 @@ decode_unicode_ssetup(char **pbcc_area, int bleft, struct cifs_ses *ses,
 
         kfree(ses->serverNOS);
         ses->serverNOS = cifs_strndup_from_utf16(data, bleft, true, nls_cp);
-        cFYI(1, "serverNOS=%s", ses->serverNOS);
+        cifs_dbg(FYI, "serverNOS=%s\n", ses->serverNOS);
         len = (UniStrnlen((wchar_t *) data, bleft / 2) * 2) + 2;
         data += len;
         bleft -= len;
@@ -305,7 +305,7 @@ decode_unicode_ssetup(char **pbcc_area, int bleft, struct cifs_ses *ses,
 
         kfree(ses->serverDomain);
         ses->serverDomain = cifs_strndup_from_utf16(data, bleft, true, nls_cp);
-        cFYI(1, "serverDomain=%s", ses->serverDomain);
+        cifs_dbg(FYI, "serverDomain=%s\n", ses->serverDomain);
 
         return;
 }
@@ -318,7 +318,7 @@ static int decode_ascii_ssetup(char **pbcc_area, __u16 bleft,
         int len;
         char *bcc_ptr = *pbcc_area;
 
-        cFYI(1, "decode sessetup ascii. bleft %d", bleft);
+        cifs_dbg(FYI, "decode sessetup ascii. bleft %d\n", bleft);
 
         len = strnlen(bcc_ptr, bleft);
         if (len >= bleft)
@@ -330,7 +330,7 @@ static int decode_ascii_ssetup(char **pbcc_area, __u16 bleft,
         if (ses->serverOS)
                 strncpy(ses->serverOS, bcc_ptr, len);
         if (strncmp(ses->serverOS, "OS/2", 4) == 0) {
-                        cFYI(1, "OS/2 server");
+                cifs_dbg(FYI, "OS/2 server\n");
                         ses->flags |= CIFS_SES_OS2;
         }
 
@@ -359,7 +359,7 @@ static int decode_ascii_ssetup(char **pbcc_area, __u16 bleft,
         /* BB For newer servers which do not support Unicode,
            but thus do return domain here we could add parsing
            for it later, but it is not very important */
-        cFYI(1, "ascii: bytes left %d", bleft);
+        cifs_dbg(FYI, "ascii: bytes left %d\n", bleft);
 
         return rc;
 }
@@ -373,16 +373,18 @@ int decode_ntlmssp_challenge(char *bcc_ptr, int blob_len,
         CHALLENGE_MESSAGE *pblob = (CHALLENGE_MESSAGE *)bcc_ptr;
 
         if (blob_len < sizeof(CHALLENGE_MESSAGE)) {
-                cERROR(1, "challenge blob len %d too small", blob_len);
+                cifs_dbg(VFS, "challenge blob len %d too small\n", blob_len);
                 return -EINVAL;
         }
 
         if (memcmp(pblob->Signature, "NTLMSSP", 8)) {
-                cERROR(1, "blob signature incorrect %s", pblob->Signature);
+                cifs_dbg(VFS, "blob signature incorrect %s\n",
+                         pblob->Signature);
                 return -EINVAL;
         }
         if (pblob->MessageType != NtLmChallenge) {
-                cERROR(1, "Incorrect message type %d", pblob->MessageType);
+                cifs_dbg(VFS, "Incorrect message type %d\n",
+                         pblob->MessageType);
                 return -EINVAL;
         }
 
@@ -395,14 +397,15 @@ int decode_ntlmssp_challenge(char *bcc_ptr, int blob_len,
         tioffset = le32_to_cpu(pblob->TargetInfoArray.BufferOffset);
         tilen = le16_to_cpu(pblob->TargetInfoArray.Length);
         if (tioffset > blob_len || tioffset + tilen > blob_len) {
-                cERROR(1, "tioffset + tilen too high %u + %u", tioffset, tilen);
+                cifs_dbg(VFS, "tioffset + tilen too high %u + %u",
+                        tioffset, tilen);
                 return -EINVAL;
         }
         if (tilen) {
                 ses->auth_key.response = kmemdup(bcc_ptr + tioffset, tilen,
                                                  GFP_KERNEL);
                 if (!ses->auth_key.response) {
-                        cERROR(1, "Challenge target info allocation failure");
+                        cifs_dbg(VFS, "Challenge target info alloc failure");
                         return -ENOMEM;
                 }
                 ses->auth_key.len = tilen;
@@ -486,7 +489,7 @@ int build_ntlmssp_auth_blob(unsigned char *pbuffer,
         sec_blob->NtChallengeResponse.BufferOffset = cpu_to_le32(tmp - pbuffer);
         rc = setup_ntlmv2_rsp(ses, nls_cp);
         if (rc) {
-                cERROR(1, "Error %d during NTLMSSP authentication", rc);
+                cifs_dbg(VFS, "Error %d during NTLMSSP authentication\n", rc);
                 goto setup_ntlmv2_ret;
         }
         memcpy(tmp, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
@@ -580,7 +583,7 @@ CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
                 return -EINVAL;
 
         type = ses->server->secType;
-        cFYI(1, "sess setup type %d", type);
+        cifs_dbg(FYI, "sess setup type %d\n", type);
         if (type == RawNTLMSSP) {
                 /* if memory allocation is successful, caller of this function
                  * frees it.
@@ -674,7 +677,7 @@ ssetup_ntlmssp_authenticate:
                 changed to do higher than lanman dialect and
                 we reconnected would we ever calc signing_key? */
 
-                cFYI(1, "Negotiating LANMAN setting up strings");
+                cifs_dbg(FYI, "Negotiating LANMAN setting up strings\n");
                 /* Unicode not allowed for LANMAN dialects */
                 ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
 #endif
@@ -688,7 +691,8 @@ ssetup_ntlmssp_authenticate:
                 /* calculate ntlm response and session key */
                 rc = setup_ntlm_response(ses, nls_cp);
                 if (rc) {
-                        cERROR(1, "Error %d during NTLM authentication", rc);
+                        cifs_dbg(VFS, "Error %d during NTLM authentication\n",
+                                 rc);
                         goto ssetup_exit;
                 }
 
@@ -718,7 +722,8 @@ ssetup_ntlmssp_authenticate:
                 /* calculate nlmv2 response and session key */
                 rc = setup_ntlmv2_rsp(ses, nls_cp);
                 if (rc) {
-                        cERROR(1, "Error %d during NTLMv2 authentication", rc);
+                        cifs_dbg(VFS, "Error %d during NTLMv2 authentication\n",
+                                 rc);
                         goto ssetup_exit;
                 }
                 memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
@@ -754,8 +759,8 @@ ssetup_ntlmssp_authenticate:
                 /* check version field to make sure that cifs.upcall is
                    sending us a response in an expected form */
                 if (msg->version != CIFS_SPNEGO_UPCALL_VERSION) {
-                        cERROR(1, "incorrect version of cifs.upcall (expected"
-                                   " %d but got %d)",
+                        cifs_dbg(VFS, "incorrect version of cifs.upcall "
+                                   "expected %d but got %d)",
                                    CIFS_SPNEGO_UPCALL_VERSION, msg->version);
                         rc = -EKEYREJECTED;
                         goto ssetup_exit;
@@ -764,7 +769,7 @@ ssetup_ntlmssp_authenticate:
                 ses->auth_key.response = kmemdup(msg->data, msg->sesskey_len,
                                                  GFP_KERNEL);
                 if (!ses->auth_key.response) {
-                        cERROR(1, "Kerberos can't allocate (%u bytes) memory",
+                        cifs_dbg(VFS, "Kerberos can't allocate (%u bytes) memory",
                                         msg->sesskey_len);
                         rc = -ENOMEM;
                         goto ssetup_exit;
@@ -790,18 +795,18 @@ ssetup_ntlmssp_authenticate:
                 /* BB: is this right? */
                         ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
 #else /* ! CONFIG_CIFS_UPCALL */
-                cERROR(1, "Kerberos negotiated but upcall support disabled!");
+                cifs_dbg(VFS, "Kerberos negotiated but upcall support disabled!\n");
                 rc = -ENOSYS;
                 goto ssetup_exit;
 #endif /* CONFIG_CIFS_UPCALL */
         } else if (type == RawNTLMSSP) {
                 if ((pSMB->req.hdr.Flags2 & SMBFLG2_UNICODE) == 0) {
-                        cERROR(1, "NTLMSSP requires Unicode support");
+                        cifs_dbg(VFS, "NTLMSSP requires Unicode support\n");
                         rc = -ENOSYS;
                         goto ssetup_exit;
                 }
 
-                cFYI(1, "ntlmssp session setup phase %d", phase);
+                cifs_dbg(FYI, "ntlmssp session setup phase %d\n", phase);
                 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
                 capabilities |= CAP_EXTENDED_SECURITY;
                 pSMB->req.Capabilities |= cpu_to_le32(capabilities);
@@ -824,7 +829,6 @@ ssetup_ntlmssp_authenticate:
                                 5*sizeof(struct _AUTHENTICATE_MESSAGE),
                                 GFP_KERNEL);
                         if (!ntlmsspblob) {
-                                cERROR(1, "Can't allocate NTLMSSP blob");
                                 rc = -ENOMEM;
                                 goto ssetup_exit;
                         }
@@ -844,7 +848,7 @@ ssetup_ntlmssp_authenticate:
                         smb_buf->Uid = ses->Suid;
                         break;
                 default:
-                        cERROR(1, "invalid phase %d", phase);
+                        cifs_dbg(VFS, "invalid phase %d\n", phase);
                         rc = -ENOSYS;
                         goto ssetup_exit;
                 }
@@ -855,7 +859,7 @@ ssetup_ntlmssp_authenticate:
                 }
                 unicode_oslm_strings(&bcc_ptr, nls_cp);
         } else {
-                cERROR(1, "secType %d not supported!", type);
+                cifs_dbg(VFS, "secType %d not supported!\n", type);
                 rc = -ENOSYS;
                 goto ssetup_exit;
         }
@@ -880,7 +884,7 @@ ssetup_ntlmssp_authenticate:
             (smb_buf->Status.CifsError ==
                         cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))) {
                 if (phase != NtLmNegotiate) {
-                        cERROR(1, "Unexpected more processing error");
+                        cifs_dbg(VFS, "Unexpected more processing error\n");
                         goto ssetup_exit;
                 }
                 /* NTLMSSP Negotiate sent now processing challenge (response) */
@@ -892,14 +896,14 @@ ssetup_ntlmssp_authenticate:
 
         if ((smb_buf->WordCount != 3) && (smb_buf->WordCount != 4)) {
                 rc = -EIO;
-                cERROR(1, "bad word count %d", smb_buf->WordCount);
+                cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
                 goto ssetup_exit;
         }
         action = le16_to_cpu(pSMB->resp.Action);
         if (action & GUEST_LOGIN)
-                cFYI(1, "Guest login"); /* BB mark SesInfo struct? */
+                cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
         ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
-        cFYI(1, "UID = %llu ", ses->Suid);
+        cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
         /* response can have either 3 or 4 word count - Samba sends 3 */
         /* and lanman response is 3 */
         bytes_remaining = get_bcc(smb_buf);
@@ -908,7 +912,8 @@ ssetup_ntlmssp_authenticate:
         if (smb_buf->WordCount == 4) {
                 blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
                 if (blob_len > bytes_remaining) {
-                        cERROR(1, "bad security blob length %d", blob_len);
+                        cifs_dbg(VFS, "bad security blob length %d\n",
+                                 blob_len);
                         rc = -EINVAL;
                         goto ssetup_exit;
                 }
@@ -946,7 +951,7 @@ ssetup_exit:
         kfree(ntlmsspblob);
         ntlmsspblob = NULL;
         if (resp_buf_type == CIFS_SMALL_BUFFER) {
-                cFYI(1, "ssetup freeing small buf %p", iov[0].iov_base);
+                cifs_dbg(FYI, "ssetup freeing small buf %p\n", iov[0].iov_base);
                 cifs_small_buf_release(iov[0].iov_base);
         } else if (resp_buf_type == CIFS_LARGE_BUFFER)
                 cifs_buf_release(iov[0].iov_base);