[CIFS] cifs: Rename cERROR and cFYI to cifs_dbg

[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / cifs / cifsencrypt.c

diff --git a/fs/cifs/cifsencrypt.c b/fs/cifs/cifsencrypt.c
index 652f5051be093c5080878ddcabd30879fcd695ee..2cbbec6ce9cbca293d61a8691ce33e16019ce1bf 100644 (file)
--- a/fs/cifs/cifsencrypt.c
+++ b/fs/cifs/cifsencrypt.c
@@ -50,20 +50,20 @@ static int cifs_calc_signature(struct smb_rqst *rqst,
                return -EINVAL;
 
        if (!server->secmech.sdescmd5) {
-               cERROR(1, "%s: Can't generate signature", __func__);
+               cifs_dbg(VFS, "%s: Can't generate signature\n", __func__);
                return -1;
        }
 
        rc = crypto_shash_init(&server->secmech.sdescmd5->shash);
        if (rc) {
-               cERROR(1, "%s: Could not init md5", __func__);
+               cifs_dbg(VFS, "%s: Could not init md5\n", __func__);
                return rc;
        }
 
        rc = crypto_shash_update(&server->secmech.sdescmd5->shash,
                server->session_key.response, server->session_key.len);
        if (rc) {
-               cERROR(1, "%s: Could not update with response", __func__);
+               cifs_dbg(VFS, "%s: Could not update with response\n", __func__);
                return rc;
        }
 
@@ -71,7 +71,7 @@ static int cifs_calc_signature(struct smb_rqst *rqst,
                if (iov[i].iov_len == 0)
                        continue;
                if (iov[i].iov_base == NULL) {
-                       cERROR(1, "null iovec entry");
+                       cifs_dbg(VFS, "null iovec entry\n");
                        return -EIO;
                }
                /* The first entry includes a length field (which does not get
@@ -88,8 +88,8 @@ static int cifs_calc_signature(struct smb_rqst *rqst,
                                iov[i].iov_base, iov[i].iov_len);
                }
                if (rc) {
-                       cERROR(1, "%s: Could not update with payload",
-                                                       __func__);
+                       cifs_dbg(VFS, "%s: Could not update with payload\n",
+                                __func__);
                        return rc;
                }
        }
@@ -106,7 +106,7 @@ static int cifs_calc_signature(struct smb_rqst *rqst,
 
        rc = crypto_shash_final(&server->secmech.sdescmd5->shash, signature);
        if (rc)
-               cERROR(1, "%s: Could not generate md5 hash", __func__);
+               cifs_dbg(VFS, "%s: Could not generate md5 hash\n", __func__);
 
        return rc;
 }
@@ -196,8 +196,8 @@ int cifs_verify_signature(struct smb_rqst *rqst,
 
        /* Do not need to verify session setups with signature "BSRSPYL "  */
        if (memcmp(cifs_pdu->Signature.SecuritySignature, "BSRSPYL ", 8) == 0)
-               cFYI(1, "dummy signature received for smb command 0x%x",
-                       cifs_pdu->Command);
+               cifs_dbg(FYI, "dummy signature received for smb command 0x%x\n",
+                        cifs_pdu->Command);
 
        /* save off the origiginal signature so we can modify the smb and check
                its signature against what the server sent */
@@ -235,30 +235,30 @@ int setup_ntlm_response(struct cifs_ses *ses, const struct nls_table *nls_cp)
                return -EINVAL;
 
        ses->auth_key.response = kmalloc(temp_len, GFP_KERNEL);
-       if (!ses->auth_key.response) {
-               cERROR(1, "NTLM can't allocate (%u bytes) memory", temp_len);
+       if (!ses->auth_key.response)
                return -ENOMEM;
-       }
+
        ses->auth_key.len = temp_len;
 
        rc = SMBNTencrypt(ses->password, ses->server->cryptkey,
                        ses->auth_key.response + CIFS_SESS_KEY_SIZE, nls_cp);
        if (rc) {
-               cFYI(1, "%s Can't generate NTLM response, error: %d",
-                       __func__, rc);
+               cifs_dbg(FYI, "%s Can't generate NTLM response, error: %d\n",
+                        __func__, rc);
                return rc;
        }
 
        rc = E_md4hash(ses->password, temp_key, nls_cp);
        if (rc) {
-               cFYI(1, "%s Can't generate NT hash, error: %d", __func__, rc);
+               cifs_dbg(FYI, "%s Can't generate NT hash, error: %d\n",
+                        __func__, rc);
                return rc;
        }
 
        rc = mdfour(ses->auth_key.response, temp_key, CIFS_SESS_KEY_SIZE);
        if (rc)
-               cFYI(1, "%s Can't generate NTLM session key, error: %d",
-                       __func__, rc);
+               cifs_dbg(FYI, "%s Can't generate NTLM session key, error: %d\n",
+                        __func__, rc);
 
        return rc;
 }
@@ -334,7 +334,6 @@ build_avpair_blob(struct cifs_ses *ses, const struct nls_table *nls_cp)
        ses->auth_key.response = kzalloc(ses->auth_key.len, GFP_KERNEL);
        if (!ses->auth_key.response) {
                ses->auth_key.len = 0;
-               cERROR(1, "Challenge target info allocation failure");
                return -ENOMEM;
        }
 
@@ -420,7 +419,7 @@ static int calc_ntlmv2_hash(struct cifs_ses *ses, char *ntlmv2_hash,
        wchar_t *server;
 
        if (!ses->server->secmech.sdeschmacmd5) {
-               cERROR(1, "calc_ntlmv2_hash: can't generate ntlmv2 hash");
+               cifs_dbg(VFS, "%s: can't generate ntlmv2 hash\n", __func__);
                return -1;
        }
 
@@ -430,13 +429,13 @@ static int calc_ntlmv2_hash(struct cifs_ses *ses, char *ntlmv2_hash,
        rc = crypto_shash_setkey(ses->server->secmech.hmacmd5, nt_hash,
                                CIFS_NTHASH_SIZE);
        if (rc) {
-               cERROR(1, "%s: Could not set NT Hash as a key", __func__);
+               cifs_dbg(VFS, "%s: Could not set NT Hash as a key\n", __func__);
                return rc;
        }
 
        rc = crypto_shash_init(&ses->server->secmech.sdeschmacmd5->shash);
        if (rc) {
-               cERROR(1, "calc_ntlmv2_hash: could not init hmacmd5");
+               cifs_dbg(VFS, "%s: could not init hmacmd5\n", __func__);
                return rc;
        }
 
@@ -444,7 +443,6 @@ static int calc_ntlmv2_hash(struct cifs_ses *ses, char *ntlmv2_hash,
        len = ses->user_name ? strlen(ses->user_name) : 0;
        user = kmalloc(2 + (len * 2), GFP_KERNEL);
        if (user == NULL) {
-               cERROR(1, "calc_ntlmv2_hash: user mem alloc failure");
                rc = -ENOMEM;
                return rc;
        }
@@ -460,7 +458,7 @@ static int calc_ntlmv2_hash(struct cifs_ses *ses, char *ntlmv2_hash,
                                (char *)user, 2 * len);
        kfree(user);
        if (rc) {
-               cERROR(1, "%s: Could not update with user", __func__);
+               cifs_dbg(VFS, "%s: Could not update with user\n", __func__);
                return rc;
        }
 
@@ -470,7 +468,6 @@ static int calc_ntlmv2_hash(struct cifs_ses *ses, char *ntlmv2_hash,
 
                domain = kmalloc(2 + (len * 2), GFP_KERNEL);
                if (domain == NULL) {
-                       cERROR(1, "calc_ntlmv2_hash: domain mem alloc failure");
                        rc = -ENOMEM;
                        return rc;
                }
@@ -481,8 +478,8 @@ static int calc_ntlmv2_hash(struct cifs_ses *ses, char *ntlmv2_hash,
                                        (char *)domain, 2 * len);
                kfree(domain);
                if (rc) {
-                       cERROR(1, "%s: Could not update with domain",
-                                                               __func__);
+                       cifs_dbg(VFS, "%s: Could not update with domain\n",
+                                __func__);
                        return rc;
                }
        } else if (ses->serverName) {
@@ -490,7 +487,6 @@ static int calc_ntlmv2_hash(struct cifs_ses *ses, char *ntlmv2_hash,
 
                server = kmalloc(2 + (len * 2), GFP_KERNEL);
                if (server == NULL) {
-                       cERROR(1, "calc_ntlmv2_hash: server mem alloc failure");
                        rc = -ENOMEM;
                        return rc;
                }
@@ -501,8 +497,8 @@ static int calc_ntlmv2_hash(struct cifs_ses *ses, char *ntlmv2_hash,
                                        (char *)server, 2 * len);
                kfree(server);
                if (rc) {
-                       cERROR(1, "%s: Could not update with server",
-                                                               __func__);
+                       cifs_dbg(VFS, "%s: Could not update with server\n",
+                                __func__);
                        return rc;
                }
        }
@@ -510,7 +506,7 @@ static int calc_ntlmv2_hash(struct cifs_ses *ses, char *ntlmv2_hash,
        rc = crypto_shash_final(&ses->server->secmech.sdeschmacmd5->shash,
                                        ntlmv2_hash);
        if (rc)
-               cERROR(1, "%s: Could not generate md5 hash", __func__);
+               cifs_dbg(VFS, "%s: Could not generate md5 hash\n", __func__);
 
        return rc;
 }
@@ -522,20 +518,21 @@ CalcNTLMv2_response(const struct cifs_ses *ses, char *ntlmv2_hash)
        unsigned int offset = CIFS_SESS_KEY_SIZE + 8;
 
        if (!ses->server->secmech.sdeschmacmd5) {
-               cERROR(1, "calc_ntlmv2_hash: can't generate ntlmv2 hash");
+               cifs_dbg(VFS, "%s: can't generate ntlmv2 hash\n", __func__);
                return -1;
        }
 
        rc = crypto_shash_setkey(ses->server->secmech.hmacmd5,
                                ntlmv2_hash, CIFS_HMAC_MD5_HASH_SIZE);
        if (rc) {
-               cERROR(1, "%s: Could not set NTLMV2 Hash as a key", __func__);
+               cifs_dbg(VFS, "%s: Could not set NTLMV2 Hash as a key\n",
+                        __func__);
                return rc;
        }
 
        rc = crypto_shash_init(&ses->server->secmech.sdeschmacmd5->shash);
        if (rc) {
-               cERROR(1, "CalcNTLMv2_response: could not init hmacmd5");
+               cifs_dbg(VFS, "%s: could not init hmacmd5\n", __func__);
                return rc;
        }
 
@@ -548,14 +545,14 @@ CalcNTLMv2_response(const struct cifs_ses *ses, char *ntlmv2_hash)
        rc = crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,
                ses->auth_key.response + offset, ses->auth_key.len - offset);
        if (rc) {
-               cERROR(1, "%s: Could not update with response", __func__);
+               cifs_dbg(VFS, "%s: Could not update with response\n", __func__);
                return rc;
        }
 
        rc = crypto_shash_final(&ses->server->secmech.sdeschmacmd5->shash,
                ses->auth_key.response + CIFS_SESS_KEY_SIZE);
        if (rc)
-               cERROR(1, "%s: Could not generate md5 hash", __func__);
+               cifs_dbg(VFS, "%s: Could not generate md5 hash\n", __func__);
 
        return rc;
 }
@@ -575,14 +572,15 @@ setup_ntlmv2_rsp(struct cifs_ses *ses, const struct nls_table *nls_cp)
                if (!ses->domainName) {
                        rc = find_domain_name(ses, nls_cp);
                        if (rc) {
-                               cERROR(1, "error %d finding domain name", rc);
+                               cifs_dbg(VFS, "error %d finding domain name\n",
+                                        rc);
                                goto setup_ntlmv2_rsp_ret;
                        }
                }
        } else {
                rc = build_avpair_blob(ses, nls_cp);
                if (rc) {
-                       cERROR(1, "error %d building av pair blob", rc);
+                       cifs_dbg(VFS, "error %d building av pair blob\n", rc);
                        goto setup_ntlmv2_rsp_ret;
                }
        }
@@ -595,7 +593,6 @@ setup_ntlmv2_rsp(struct cifs_ses *ses, const struct nls_table *nls_cp)
        if (!ses->auth_key.response) {
                rc = ENOMEM;
                ses->auth_key.len = 0;
-               cERROR(1, "%s: Can't allocate auth blob", __func__);
                goto setup_ntlmv2_rsp_ret;
        }
        ses->auth_key.len += baselen;
@@ -613,14 +610,14 @@ setup_ntlmv2_rsp(struct cifs_ses *ses, const struct nls_table *nls_cp)
        /* calculate ntlmv2_hash */
        rc = calc_ntlmv2_hash(ses, ntlmv2_hash, nls_cp);
        if (rc) {
-               cERROR(1, "could not get v2 hash rc %d", rc);
+               cifs_dbg(VFS, "could not get v2 hash rc %d\n", rc);
                goto setup_ntlmv2_rsp_ret;
        }
 
        /* calculate first part of the client response (CR1) */
        rc = CalcNTLMv2_response(ses, ntlmv2_hash);
        if (rc) {
-               cERROR(1, "Could not calculate CR1  rc: %d", rc);
+               cifs_dbg(VFS, "Could not calculate CR1 rc: %d\n", rc);
                goto setup_ntlmv2_rsp_ret;
        }
 
@@ -628,13 +625,14 @@ setup_ntlmv2_rsp(struct cifs_ses *ses, const struct nls_table *nls_cp)
        rc = crypto_shash_setkey(ses->server->secmech.hmacmd5,
                ntlmv2_hash, CIFS_HMAC_MD5_HASH_SIZE);
        if (rc) {
-               cERROR(1, "%s: Could not set NTLMV2 Hash as a key", __func__);
+               cifs_dbg(VFS, "%s: Could not set NTLMV2 Hash as a key\n",
+                        __func__);
                goto setup_ntlmv2_rsp_ret;
        }
 
        rc = crypto_shash_init(&ses->server->secmech.sdeschmacmd5->shash);
        if (rc) {
-               cERROR(1, "%s: Could not init hmacmd5", __func__);
+               cifs_dbg(VFS, "%s: Could not init hmacmd5\n", __func__);
                goto setup_ntlmv2_rsp_ret;
        }
 
@@ -642,14 +640,14 @@ setup_ntlmv2_rsp(struct cifs_ses *ses, const struct nls_table *nls_cp)
                ses->auth_key.response + CIFS_SESS_KEY_SIZE,
                CIFS_HMAC_MD5_HASH_SIZE);
        if (rc) {
-               cERROR(1, "%s: Could not update with response", __func__);
+               cifs_dbg(VFS, "%s: Could not update with response\n", __func__);
                goto setup_ntlmv2_rsp_ret;
        }
 
        rc = crypto_shash_final(&ses->server->secmech.sdeschmacmd5->shash,
                ses->auth_key.response);
        if (rc)
-               cERROR(1, "%s: Could not generate md5 hash", __func__);
+               cifs_dbg(VFS, "%s: Could not generate md5 hash\n", __func__);
 
 setup_ntlmv2_rsp_ret:
        kfree(tiblob);
@@ -671,7 +669,7 @@ calc_seckey(struct cifs_ses *ses)
        tfm_arc4 = crypto_alloc_blkcipher("ecb(arc4)", 0, CRYPTO_ALG_ASYNC);
        if (IS_ERR(tfm_arc4)) {
                rc = PTR_ERR(tfm_arc4);
-               cERROR(1, "could not allocate crypto API arc4");
+               cifs_dbg(VFS, "could not allocate crypto API arc4\n");
                return rc;
        }
 
@@ -680,7 +678,8 @@ calc_seckey(struct cifs_ses *ses)
        rc = crypto_blkcipher_setkey(tfm_arc4, ses->auth_key.response,
                                        CIFS_SESS_KEY_SIZE);
        if (rc) {
-               cERROR(1, "%s: Could not set response as a key", __func__);
+               cifs_dbg(VFS, "%s: Could not set response as a key\n",
+                        __func__);
                return rc;
        }
 
@@ -689,7 +688,7 @@ calc_seckey(struct cifs_ses *ses)
 
        rc = crypto_blkcipher_encrypt(&desc, &sgout, &sgin, CIFS_CPHTXT_SIZE);
        if (rc) {
-               cERROR(1, "could not encrypt session key rc: %d", rc);
+               cifs_dbg(VFS, "could not encrypt session key rc: %d\n", rc);
                crypto_free_blkcipher(tfm_arc4);
                return rc;
        }
@@ -731,20 +730,20 @@ cifs_crypto_shash_allocate(struct TCP_Server_Info *server)
 
        server->secmech.hmacmd5 = crypto_alloc_shash("hmac(md5)", 0, 0);
        if (IS_ERR(server->secmech.hmacmd5)) {
-               cERROR(1, "could not allocate crypto hmacmd5");
+               cifs_dbg(VFS, "could not allocate crypto hmacmd5\n");
                return PTR_ERR(server->secmech.hmacmd5);
        }
 
        server->secmech.md5 = crypto_alloc_shash("md5", 0, 0);
        if (IS_ERR(server->secmech.md5)) {
-               cERROR(1, "could not allocate crypto md5");
+               cifs_dbg(VFS, "could not allocate crypto md5\n");
                rc = PTR_ERR(server->secmech.md5);
                goto crypto_allocate_md5_fail;
        }
 
        server->secmech.hmacsha256 = crypto_alloc_shash("hmac(sha256)", 0, 0);
        if (IS_ERR(server->secmech.hmacsha256)) {
-               cERROR(1, "could not allocate crypto hmacsha256\n");
+               cifs_dbg(VFS, "could not allocate crypto hmacsha256\n");
                rc = PTR_ERR(server->secmech.hmacsha256);
                goto crypto_allocate_hmacsha256_fail;
        }
@@ -753,7 +752,6 @@ cifs_crypto_shash_allocate(struct TCP_Server_Info *server)
                        crypto_shash_descsize(server->secmech.hmacmd5);
        server->secmech.sdeschmacmd5 = kmalloc(size, GFP_KERNEL);
        if (!server->secmech.sdeschmacmd5) {
-               cERROR(1, "cifs_crypto_shash_allocate: can't alloc hmacmd5");
                rc = -ENOMEM;
                goto crypto_allocate_hmacmd5_sdesc_fail;
        }
@@ -764,7 +762,6 @@ cifs_crypto_shash_allocate(struct TCP_Server_Info *server)
                        crypto_shash_descsize(server->secmech.md5);
        server->secmech.sdescmd5 = kmalloc(size, GFP_KERNEL);
        if (!server->secmech.sdescmd5) {
-               cERROR(1, "cifs_crypto_shash_allocate: can't alloc md5");
                rc = -ENOMEM;
                goto crypto_allocate_md5_sdesc_fail;
        }
@@ -775,7 +772,6 @@ cifs_crypto_shash_allocate(struct TCP_Server_Info *server)
                        crypto_shash_descsize(server->secmech.hmacsha256);
        server->secmech.sdeschmacsha256 = kmalloc(size, GFP_KERNEL);
        if (!server->secmech.sdeschmacsha256) {
-               cERROR(1, "%s: Can't alloc hmacsha256\n", __func__);
                rc = -ENOMEM;
                goto crypto_allocate_hmacsha256_sdesc_fail;
        }