[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, 149 insertions, 161 deletions

diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 06394f5478a2..9535abe3d24c 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -316,11 +316,12 @@ cifs_reconnect(struct TCP_Server_Info *server)
         server->max_read = 0;
 #endif
 
-        cFYI(1, "Reconnecting tcp session");
+        cifs_dbg(FYI, "Reconnecting tcp session\n");
 
         /* before reconnecting the tcp session, mark the smb session (uid)
                 and the tid bad so they are not used until reconnected */
-        cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
+        cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
+                 __func__);
         spin_lock(&cifs_tcp_ses_lock);
         list_for_each(tmp, &server->smb_ses_list) {
                 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
@@ -334,15 +335,14 @@ cifs_reconnect(struct TCP_Server_Info *server)
         spin_unlock(&cifs_tcp_ses_lock);
 
         /* do not want to be sending data on a socket we are freeing */
-        cFYI(1, "%s: tearing down socket", __func__);
+        cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
         mutex_lock(&server->srv_mutex);
         if (server->ssocket) {
-                cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
-                        server->ssocket->flags);
+                cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
+                         server->ssocket->state, server->ssocket->flags);
                 kernel_sock_shutdown(server->ssocket, SHUT_WR);
-                cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
-                        server->ssocket->state,
-                        server->ssocket->flags);
+                cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
+                         server->ssocket->state, server->ssocket->flags);
                 sock_release(server->ssocket);
                 server->ssocket = NULL;
         }
@@ -356,7 +356,7 @@ cifs_reconnect(struct TCP_Server_Info *server)
 
         /* mark submitted MIDs for retry and issue callback */
         INIT_LIST_HEAD(&retry_list);
-        cFYI(1, "%s: moving mids to private list", __func__);
+        cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
         spin_lock(&GlobalMid_Lock);
         list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
@@ -366,7 +366,7 @@ cifs_reconnect(struct TCP_Server_Info *server)
         }
         spin_unlock(&GlobalMid_Lock);
 
-        cFYI(1, "%s: issuing mid callbacks", __func__);
+        cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
         list_for_each_safe(tmp, tmp2, &retry_list) {
                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
                 list_del_init(&mid_entry->qhead);
@@ -379,7 +379,7 @@ cifs_reconnect(struct TCP_Server_Info *server)
                 /* we should try only the port we connected to before */
                 rc = generic_ip_connect(server);
                 if (rc) {
-                        cFYI(1, "reconnect error %d", rc);
+                        cifs_dbg(FYI, "reconnect error %d\n", rc);
                         msleep(3000);
                 } else {
                         atomic_inc(&tcpSesReconnectCount);
@@ -413,8 +413,8 @@ cifs_echo_request(struct work_struct *work)
 
         rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
         if (rc)
-                cFYI(1, "Unable to send echo request to server: %s",
-                        server->hostname);
+                cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
+                         server->hostname);
 
 requeue_echo:
         queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
@@ -426,7 +426,7 @@ allocate_buffers(struct TCP_Server_Info *server)
         if (!server->bigbuf) {
                 server->bigbuf = (char *)cifs_buf_get();
                 if (!server->bigbuf) {
-                        cERROR(1, "No memory for large SMB response");
+                        cifs_dbg(VFS, "No memory for large SMB response\n");
                         msleep(3000);
                         /* retry will check if exiting */
                         return false;
@@ -439,7 +439,7 @@ allocate_buffers(struct TCP_Server_Info *server)
         if (!server->smallbuf) {
                 server->smallbuf = (char *)cifs_small_buf_get();
                 if (!server->smallbuf) {
-                        cERROR(1, "No memory for SMB response");
+                        cifs_dbg(VFS, "No memory for SMB response\n");
                         msleep(1000);
                         /* retry will check if exiting */
                         return false;
@@ -469,9 +469,8 @@ server_unresponsive(struct TCP_Server_Info *server)
          */
         if (server->tcpStatus == CifsGood &&
             time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
-                cERROR(1, "Server %s has not responded in %d seconds. "
-                          "Reconnecting...", server->hostname,
-                          (2 * SMB_ECHO_INTERVAL) / HZ);
+                cifs_dbg(VFS, "Server %s has not responded in %d seconds. Reconnecting...\n",
+                         server->hostname, (2 * SMB_ECHO_INTERVAL) / HZ);
                 cifs_reconnect(server);
                 wake_up(&server->response_q);
                 return true;
@@ -582,8 +581,8 @@ cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
                         length = 0;
                         continue;
                 } else if (length <= 0) {
-                        cFYI(1, "Received no data or error: expecting %d "
-                                "got %d", to_read, length);
+                        cifs_dbg(FYI, "Received no data or error: expecting %d\n"
+                                 "got %d", to_read, length);
                         cifs_reconnect(server);
                         total_read = -EAGAIN;
                         break;
@@ -617,17 +616,17 @@ is_smb_response(struct TCP_Server_Info *server, unsigned char type)
                 /* Regular SMB response */
                 return true;
         case RFC1002_SESSION_KEEP_ALIVE:
-                cFYI(1, "RFC 1002 session keep alive");
+                cifs_dbg(FYI, "RFC 1002 session keep alive\n");
                 break;
         case RFC1002_POSITIVE_SESSION_RESPONSE:
-                cFYI(1, "RFC 1002 positive session response");
+                cifs_dbg(FYI, "RFC 1002 positive session response\n");
                 break;
         case RFC1002_NEGATIVE_SESSION_RESPONSE:
                 /*
                  * We get this from Windows 98 instead of an error on
                  * SMB negprot response.
                  */
-                cFYI(1, "RFC 1002 negative session response");
+                cifs_dbg(FYI, "RFC 1002 negative session response\n");
                 /* give server a second to clean up */
                 msleep(1000);
                 /*
@@ -641,7 +640,7 @@ is_smb_response(struct TCP_Server_Info *server, unsigned char type)
                 wake_up(&server->response_q);
                 break;
         default:
-                cERROR(1, "RFC 1002 unknown response type 0x%x", type);
+                cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
                 cifs_reconnect(server);
         }
 
@@ -727,7 +726,7 @@ static void clean_demultiplex_info(struct TCP_Server_Info *server)
                 spin_lock(&GlobalMid_Lock);
                 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
-                        cFYI(1, "Clearing mid 0x%llx", mid_entry->mid);
+                        cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
                         mid_entry->mid_state = MID_SHUTDOWN;
                         list_move(&mid_entry->qhead, &dispose_list);
                 }
@@ -736,7 +735,7 @@ static void clean_demultiplex_info(struct TCP_Server_Info *server)
                 /* now walk dispose list and issue callbacks */
                 list_for_each_safe(tmp, tmp2, &dispose_list) {
                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
-                        cFYI(1, "Callback mid 0x%llx", mid_entry->mid);
+                        cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
                         list_del_init(&mid_entry->qhead);
                         mid_entry->callback(mid_entry);
                 }
@@ -753,7 +752,7 @@ static void clean_demultiplex_info(struct TCP_Server_Info *server)
                  * least 45 seconds before giving up on a request getting a
                  * response and going ahead and killing cifsd.
                  */
-                cFYI(1, "Wait for exit from demultiplex thread");
+                cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
                 msleep(46000);
                 /*
                  * If threads still have not exited they are probably never
@@ -780,8 +779,7 @@ standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
 
         /* make sure this will fit in a large buffer */
         if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
-                cERROR(1, "SMB response too long (%u bytes)",
-                        pdu_length);
+                cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
                 cifs_reconnect(server);
                 wake_up(&server->response_q);
                 return -EAGAIN;
@@ -839,7 +837,7 @@ cifs_demultiplex_thread(void *p)
         struct mid_q_entry *mid_entry;
 
         current->flags |= PF_MEMALLOC;
-        cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
+        cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
 
         length = atomic_inc_return(&tcpSesAllocCount);
         if (length > 1)
@@ -869,14 +867,14 @@ cifs_demultiplex_thread(void *p)
                  */
                 pdu_length = get_rfc1002_length(buf);
 
-                cFYI(1, "RFC1002 header 0x%x", pdu_length);
+                cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
                 if (!is_smb_response(server, buf[0]))
                         continue;
 
                 /* make sure we have enough to get to the MID */
                 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
-                        cERROR(1, "SMB response too short (%u bytes)",
-                                pdu_length);
+                        cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
+                                 pdu_length);
                         cifs_reconnect(server);
                         wake_up(&server->response_q);
                         continue;
@@ -908,8 +906,8 @@ cifs_demultiplex_thread(void *p)
                                 mid_entry->callback(mid_entry);
                 } else if (!server->ops->is_oplock_break ||
                            !server->ops->is_oplock_break(buf, server)) {
-                        cERROR(1, "No task to wake, unknown frame received! "
-                                   "NumMids %d", atomic_read(&midCount));
+                        cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
+                                 atomic_read(&midCount));
                         cifs_dump_mem("Received Data is: ", buf,
                                       HEADER_SIZE(server));
 #ifdef CONFIG_CIFS_DEBUG2
@@ -1035,7 +1033,7 @@ static int cifs_parse_security_flavors(char *value,
                 break;
         case Opt_sec_krb5p:
                 /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
-                cERROR(1, "Krb5 cifs privacy not supported");
+                cifs_dbg(VFS, "Krb5 cifs privacy not supported\n");
                 break;
         case Opt_sec_ntlmssp:
                 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
@@ -1065,7 +1063,7 @@ static int cifs_parse_security_flavors(char *value,
                 vol->nullauth = 1;
                 break;
         default:
-                cERROR(1, "bad security option: %s", value);
+                cifs_dbg(VFS, "bad security option: %s\n", value);
                 return 1;
         }
 
@@ -1091,7 +1089,7 @@ cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
                 vol->strict_io = false;
                 break;
         default:
-                cERROR(1, "bad cache= option: %s", value);
+                cifs_dbg(VFS, "bad cache= option: %s\n", value);
                 return 1;
         }
         return 0;
@@ -1122,7 +1120,7 @@ cifs_parse_smb_version(char *value, struct smb_vol *vol)
                 break;
 #endif
         default:
-                cERROR(1, "Unknown vers= option specified: %s", value);
+                cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
                 return 1;
         }
         return 0;
@@ -1253,7 +1251,7 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
                         separator[0] = options[4];
                         options += 5;
                 } else {
-                        cFYI(1, "Null separator not allowed");
+                        cifs_dbg(FYI, "Null separator not allowed\n");
                 }
         }
         vol->backupuid_specified = false; /* no backup intent for a user */
@@ -1438,8 +1436,7 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
                         break;
                 case Opt_fsc:
 #ifndef CONFIG_CIFS_FSCACHE
-                        cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
-                                  "kernel config option set");
+                        cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
                         goto cifs_parse_mount_err;
 #endif
                         vol->fsc = true;
@@ -1457,55 +1454,55 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
                 /* Numeric Values */
                 case Opt_backupuid:
                         if (get_option_uid(args, &vol->backupuid)) {
-                                cERROR(1, "%s: Invalid backupuid value",
-                                        __func__);
+                                cifs_dbg(VFS, "%s: Invalid backupuid value\n",
+                                         __func__);
                                 goto cifs_parse_mount_err;
                         }
                         vol->backupuid_specified = true;
                         break;
                 case Opt_backupgid:
                         if (get_option_gid(args, &vol->backupgid)) {
-                                cERROR(1, "%s: Invalid backupgid value",
-                                        __func__);
+                                cifs_dbg(VFS, "%s: Invalid backupgid value\n",
+                                         __func__);
                                 goto cifs_parse_mount_err;
                         }
                         vol->backupgid_specified = true;
                         break;
                 case Opt_uid:
                         if (get_option_uid(args, &vol->linux_uid)) {
-                                cERROR(1, "%s: Invalid uid value",
-                                        __func__);
+                                cifs_dbg(VFS, "%s: Invalid uid value\n",
+                                         __func__);
                                 goto cifs_parse_mount_err;
                         }
                         uid_specified = true;
                         break;
                 case Opt_cruid:
                         if (get_option_uid(args, &vol->cred_uid)) {
-                                cERROR(1, "%s: Invalid cruid value",
-                                        __func__);
+                                cifs_dbg(VFS, "%s: Invalid cruid value\n",
+                                         __func__);
                                 goto cifs_parse_mount_err;
                         }
                         break;
                 case Opt_gid:
                         if (get_option_gid(args, &vol->linux_gid)) {
-                                cERROR(1, "%s: Invalid gid value",
-                                                __func__);
+                                cifs_dbg(VFS, "%s: Invalid gid value\n",
+                                         __func__);
                                 goto cifs_parse_mount_err;
                         }
                         gid_specified = true;
                         break;
                 case Opt_file_mode:
                         if (get_option_ul(args, &option)) {
-                                cERROR(1, "%s: Invalid file_mode value",
-                                        __func__);
+                                cifs_dbg(VFS, "%s: Invalid file_mode value\n",
+                                         __func__);
                                 goto cifs_parse_mount_err;
                         }
                         vol->file_mode = option;
                         break;
                 case Opt_dirmode:
                         if (get_option_ul(args, &option)) {
-                                cERROR(1, "%s: Invalid dir_mode value",
-                                        __func__);
+                                cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
+                                         __func__);
                                 goto cifs_parse_mount_err;
                         }
                         vol->dir_mode = option;
@@ -1513,37 +1510,37 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
                 case Opt_port:
                         if (get_option_ul(args, &option) ||
                             option > USHRT_MAX) {
-                                cERROR(1, "%s: Invalid port value", __func__);
+                                cifs_dbg(VFS, "%s: Invalid port value\n",
+                                         __func__);
                                 goto cifs_parse_mount_err;
                         }
                         port = (unsigned short)option;
                         break;
                 case Opt_rsize:
                         if (get_option_ul(args, &option)) {
-                                cERROR(1, "%s: Invalid rsize value",
-                                        __func__);
+                                cifs_dbg(VFS, "%s: Invalid rsize value\n",
+                                         __func__);
                                 goto cifs_parse_mount_err;
                         }
                         vol->rsize = option;
                         break;
                 case Opt_wsize:
                         if (get_option_ul(args, &option)) {
-                                cERROR(1, "%s: Invalid wsize value",
-                                        __func__);
+                                cifs_dbg(VFS, "%s: Invalid wsize value\n",
+                                         __func__);
                                 goto cifs_parse_mount_err;
                         }
                         vol->wsize = option;
                         break;
                 case Opt_actimeo:
                         if (get_option_ul(args, &option)) {
-                                cERROR(1, "%s: Invalid actimeo value",
-                                        __func__);
+                                cifs_dbg(VFS, "%s: Invalid actimeo value\n",
+                                         __func__);
                                 goto cifs_parse_mount_err;
                         }
                         vol->actimeo = HZ * option;
                         if (vol->actimeo > CIFS_MAX_ACTIMEO) {
-                                cERROR(1, "CIFS: attribute cache"
-                                          "timeout too large");
+                                cifs_dbg(VFS, "attribute cache timeout too large\n");
                                 goto cifs_parse_mount_err;
                         }
                         break;
@@ -1566,11 +1563,8 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
                                 goto cifs_parse_mount_err;
                         }
                         vol->username = kstrdup(string, GFP_KERNEL);
-                        if (!vol->username) {
-                                printk(KERN_WARNING "CIFS: no memory "
-                                                    "for username\n");
+                        if (!vol->username)
                                 goto cifs_parse_mount_err;
-                        }
                         break;
                 case Opt_blank_pass:
                         /* passwords have to be handled differently
@@ -1675,7 +1669,7 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
                                                     "for domainname\n");
                                 goto cifs_parse_mount_err;
                         }
-                        cFYI(1, "Domain name set");
+                        cifs_dbg(FYI, "Domain name set\n");
                         break;
                 case Opt_srcaddr:
                         string = match_strdup(args);
@@ -1713,7 +1707,7 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
                         /* if iocharset not set then load_nls_default
                          * is used by caller
                          */
-                        cFYI(1, "iocharset set to %s", string);
+                         cifs_dbg(FYI, "iocharset set to %s\n", string);
                         break;
                 case Opt_netbiosname:
                         string = match_strdup(args);
@@ -1827,20 +1821,18 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
 #ifndef CONFIG_KEYS
         /* Muliuser mounts require CONFIG_KEYS support */
         if (vol->multiuser) {
-                cERROR(1, "Multiuser mounts require kernels with "
-                          "CONFIG_KEYS enabled.");
+                cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
                 goto cifs_parse_mount_err;
         }
 #endif
         if (!vol->UNC) {
-                cERROR(1, "CIFS mount error: No usable UNC path provided in "
-                          "device string or in unc= option!");
+                cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string or in unc= option!\n");
                 goto cifs_parse_mount_err;
         }
 
         /* make sure UNC has a share name */
         if (!strchr(vol->UNC + 3, '\\')) {
-                cERROR(1, "Malformed UNC. Unable to find share name.");
+                cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
                 goto cifs_parse_mount_err;
         }
 
@@ -2061,7 +2053,7 @@ cifs_find_tcp_session(struct smb_vol *vol)
 
                 ++server->srv_count;
                 spin_unlock(&cifs_tcp_ses_lock);
-                cFYI(1, "Existing tcp session with server found");
+                cifs_dbg(FYI, "Existing tcp session with server found\n");
                 return server;
         }
         spin_unlock(&cifs_tcp_ses_lock);
@@ -2108,7 +2100,7 @@ cifs_get_tcp_session(struct smb_vol *volume_info)
         struct TCP_Server_Info *tcp_ses = NULL;
         int rc;
 
-        cFYI(1, "UNC: %s", volume_info->UNC);
+        cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
 
         /* see if we already have a matching tcp_ses */
         tcp_ses = cifs_find_tcp_session(volume_info);
@@ -2123,7 +2115,7 @@ cifs_get_tcp_session(struct smb_vol *volume_info)
 
         rc = cifs_crypto_shash_allocate(tcp_ses);
         if (rc) {
-                cERROR(1, "could not setup hash structures rc %d", rc);
+                cifs_dbg(VFS, "could not setup hash structures rc %d\n", rc);
                 goto out_err;
         }
 
@@ -2170,7 +2162,7 @@ cifs_get_tcp_session(struct smb_vol *volume_info)
 
         rc = ip_connect(tcp_ses);
         if (rc < 0) {
-                cERROR(1, "Error connecting to socket. Aborting operation");
+                cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
                 goto out_err_crypto_release;
         }
 
@@ -2183,7 +2175,7 @@ cifs_get_tcp_session(struct smb_vol *volume_info)
                                   tcp_ses, "cifsd");
         if (IS_ERR(tcp_ses->tsk)) {
                 rc = PTR_ERR(tcp_ses->tsk);
-                cERROR(1, "error %d create cifsd thread", rc);
+                cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
                 module_put(THIS_MODULE);
                 goto out_err_crypto_release;
         }
@@ -2270,7 +2262,7 @@ cifs_put_smb_ses(struct cifs_ses *ses)
         unsigned int xid;
         struct TCP_Server_Info *server = ses->server;
 
-        cFYI(1, "%s: ses_count=%d", __func__, ses->ses_count);
+        cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
         spin_lock(&cifs_tcp_ses_lock);
         if (--ses->ses_count > 0) {
                 spin_unlock(&cifs_tcp_ses_lock);
@@ -2322,23 +2314,24 @@ cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
                 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
                 break;
         default:
-                cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
+                cifs_dbg(FYI, "Bad ss_family (%hu)\n",
+                         server->dstaddr.ss_family);
                 rc = -EINVAL;
                 goto out_err;
         }
 
-        cFYI(1, "%s: desc=%s", __func__, desc);
+        cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
         key = request_key(&key_type_logon, desc, "");
         if (IS_ERR(key)) {
                 if (!ses->domainName) {
-                        cFYI(1, "domainName is NULL");
+                        cifs_dbg(FYI, "domainName is NULL\n");
                         rc = PTR_ERR(key);
                         goto out_err;
                 }
 
                 /* didn't work, try to find a domain key */
                 sprintf(desc, "cifs:d:%s", ses->domainName);
-                cFYI(1, "%s: desc=%s", __func__, desc);
+                cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
                 key = request_key(&key_type_logon, desc, "");
                 if (IS_ERR(key)) {
                         rc = PTR_ERR(key);
@@ -2356,32 +2349,34 @@ cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
         /* find first : in payload */
         payload = (char *)upayload->data;
         delim = strnchr(payload, upayload->datalen, ':');
-        cFYI(1, "payload=%s", payload);
+        cifs_dbg(FYI, "payload=%s\n", payload);
         if (!delim) {
-                cFYI(1, "Unable to find ':' in payload (datalen=%d)",
-                                upayload->datalen);
+                cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
+                         upayload->datalen);
                 rc = -EINVAL;
                 goto out_key_put;
         }
 
         len = delim - payload;
         if (len > MAX_USERNAME_SIZE || len <= 0) {
-                cFYI(1, "Bad value from username search (len=%zd)", len);
+                cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
+                         len);
                 rc = -EINVAL;
                 goto out_key_put;
         }
 
         vol->username = kstrndup(payload, len, GFP_KERNEL);
         if (!vol->username) {
-                cFYI(1, "Unable to allocate %zd bytes for username", len);
+                cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
+                         len);
                 rc = -ENOMEM;
                 goto out_key_put;
         }
-        cFYI(1, "%s: username=%s", __func__, vol->username);
+        cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
 
         len = key->datalen - (len + 1);
         if (len > MAX_PASSWORD_SIZE || len <= 0) {
-                cFYI(1, "Bad len for password search (len=%zd)", len);
+                cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
                 rc = -EINVAL;
                 kfree(vol->username);
                 vol->username = NULL;
@@ -2391,7 +2386,8 @@ cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
         ++delim;
         vol->password = kstrndup(delim, len, GFP_KERNEL);
         if (!vol->password) {
-                cFYI(1, "Unable to allocate %zd bytes for password", len);
+                cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
+                         len);
                 rc = -ENOMEM;
                 kfree(vol->username);
                 vol->username = NULL;
@@ -2403,7 +2399,7 @@ out_key_put:
         key_put(key);
 out_err:
         kfree(desc);
-        cFYI(1, "%s: returning %d", __func__, rc);
+        cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
         return rc;
 }
 #else /* ! CONFIG_KEYS */
@@ -2428,7 +2424,8 @@ cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
 
         ses = cifs_find_smb_ses(server, volume_info);
         if (ses) {
-                cFYI(1, "Existing smb sess found (status=%d)", ses->status);
+                cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
+                         ses->status);
 
                 mutex_lock(&ses->session_mutex);
                 rc = cifs_negotiate_protocol(xid, ses);
@@ -2440,7 +2437,7 @@ cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
                         return ERR_PTR(rc);
                 }
                 if (ses->need_reconnect) {
-                        cFYI(1, "Session needs reconnect");
+                        cifs_dbg(FYI, "Session needs reconnect\n");
                         rc = cifs_setup_session(xid, ses,
                                                 volume_info->local_nls);
                         if (rc) {
@@ -2459,7 +2456,7 @@ cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
                 return ses;
         }
 
-        cFYI(1, "Existing smb sess not found");
+        cifs_dbg(FYI, "Existing smb sess not found\n");
         ses = sesInfoAlloc();
         if (ses == NULL)
                 goto get_ses_fail;
@@ -2549,7 +2546,7 @@ cifs_put_tcon(struct cifs_tcon *tcon)
         unsigned int xid;
         struct cifs_ses *ses = tcon->ses;
 
-        cFYI(1, "%s: tc_count=%d", __func__, tcon->tc_count);
+        cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
         spin_lock(&cifs_tcp_ses_lock);
         if (--tcon->tc_count > 0) {
                 spin_unlock(&cifs_tcp_ses_lock);
@@ -2577,12 +2574,11 @@ cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
 
         tcon = cifs_find_tcon(ses, volume_info->UNC);
         if (tcon) {
-                cFYI(1, "Found match on UNC path");
+                cifs_dbg(FYI, "Found match on UNC path\n");
                 /* existing tcon already has a reference */
                 cifs_put_smb_ses(ses);
                 if (tcon->seal != volume_info->seal)
-                        cERROR(1, "transport encryption setting "
-                                   "conflicts with existing tid");
+                        cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
                 return tcon;
         }
 
@@ -2614,13 +2610,13 @@ cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
         rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
                                             volume_info->local_nls);
         free_xid(xid);
-        cFYI(1, "Tcon rc = %d", rc);
+        cifs_dbg(FYI, "Tcon rc = %d\n", rc);
         if (rc)
                 goto out_fail;
 
         if (volume_info->nodfs) {
                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
-                cFYI(1, "DFS disabled (%d)", tcon->Flags);
+                cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
         }
         tcon->seal = volume_info->seal;
         /*
@@ -2774,7 +2770,7 @@ get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
                 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
                 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
                                                     nls_codepage);
-                cFYI(1, "Tcon rc = %d ipc_tid = %d", rc, ses->ipc_tid);
+                cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
                 kfree(temp_unc);
         }
         if (rc == 0)
@@ -2852,13 +2848,11 @@ bind_socket(struct TCP_Server_Info *server)
                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
                         if (saddr6->sin6_family == AF_INET6)
-                                cERROR(1, "cifs: "
-                                       "Failed to bind to: %pI6c, error: %d",
-                                       &saddr6->sin6_addr, rc);
+                                cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
+                                         &saddr6->sin6_addr, rc);
                         else
-                                cERROR(1, "cifs: "
-                                       "Failed to bind to: %pI4, error: %d",
-                                       &saddr4->sin_addr.s_addr, rc);
+                                cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
+                                         &saddr4->sin_addr.s_addr, rc);
                 }
         }
         return rc;
@@ -2963,13 +2957,13 @@ generic_ip_connect(struct TCP_Server_Info *server)
                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
                                    IPPROTO_TCP, &socket, 1);
                 if (rc < 0) {
-                        cERROR(1, "Error %d creating socket", rc);
+                        cifs_dbg(VFS, "Error %d creating socket\n", rc);
                         server->ssocket = NULL;
                         return rc;
                 }
 
                 /* BB other socket options to set KEEPALIVE, NODELAY? */
-                cFYI(1, "Socket created");
+                cifs_dbg(FYI, "Socket created\n");
                 server->ssocket = socket;
                 socket->sk->sk_allocation = GFP_NOFS;
                 if (sfamily == AF_INET6)
@@ -3003,16 +2997,17 @@ generic_ip_connect(struct TCP_Server_Info *server)
                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
                                 (char *)&val, sizeof(val));
                 if (rc)
-                        cFYI(1, "set TCP_NODELAY socket option error %d", rc);
+                        cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
+                                 rc);
         }
 
-         cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
+        cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
                  socket->sk->sk_sndbuf,
                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
 
         rc = socket->ops->connect(socket, saddr, slen, 0);
         if (rc < 0) {
-                cFYI(1, "Error %d connecting to server", rc);
+                cifs_dbg(FYI, "Error %d connecting to server\n", rc);
                 sock_release(socket);
                 server->ssocket = NULL;
                 return rc;
@@ -3070,19 +3065,19 @@ void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
         if (vol_info && vol_info->no_linux_ext) {
                 tcon->fsUnixInfo.Capability = 0;
                 tcon->unix_ext = 0; /* Unix Extensions disabled */
-                cFYI(1, "Linux protocol extensions disabled");
+                cifs_dbg(FYI, "Linux protocol extensions disabled\n");
                 return;
         } else if (vol_info)
                 tcon->unix_ext = 1; /* Unix Extensions supported */
 
         if (tcon->unix_ext == 0) {
-                cFYI(1, "Unix extensions disabled so not set on reconnect");
+                cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
                 return;
         }
 
         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
-                cFYI(1, "unix caps which server supports %lld", cap);
+                cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
                 /* check for reconnect case in which we do not
                    want to change the mount behavior if we can avoid it */
                 if (vol_info == NULL) {
@@ -3092,22 +3087,22 @@ void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
-                                        cERROR(1, "POSIXPATH support change");
+                                        cifs_dbg(VFS, "POSIXPATH support change\n");
                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
-                                cERROR(1, "possible reconnect error");
-                                cERROR(1, "server disabled POSIX path support");
+                                cifs_dbg(VFS, "possible reconnect error\n");
+                                cifs_dbg(VFS, "server disabled POSIX path support\n");
                         }
                 }
 
                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
-                        cERROR(1, "per-share encryption not supported yet");
+                        cifs_dbg(VFS, "per-share encryption not supported yet\n");
 
                 cap &= CIFS_UNIX_CAP_MASK;
                 if (vol_info && vol_info->no_psx_acl)
                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
-                        cFYI(1, "negotiated posix acl support");
+                        cifs_dbg(FYI, "negotiated posix acl support\n");
                         if (cifs_sb)
                                 cifs_sb->mnt_cifs_flags |=
                                         CIFS_MOUNT_POSIXACL;
@@ -3116,43 +3111,38 @@ void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
                 if (vol_info && vol_info->posix_paths == 0)
                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
-                        cFYI(1, "negotiate posix pathnames");
+                        cifs_dbg(FYI, "negotiate posix pathnames\n");
                         if (cifs_sb)
                                 cifs_sb->mnt_cifs_flags |=
                                         CIFS_MOUNT_POSIX_PATHS;
                 }
 
-                cFYI(1, "Negotiate caps 0x%x", (int)cap);
+                cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
 #ifdef CONFIG_CIFS_DEBUG2
                 if (cap & CIFS_UNIX_FCNTL_CAP)
-                        cFYI(1, "FCNTL cap");
+                        cifs_dbg(FYI, "FCNTL cap\n");
                 if (cap & CIFS_UNIX_EXTATTR_CAP)
-                        cFYI(1, "EXTATTR cap");
+                        cifs_dbg(FYI, "EXTATTR cap\n");
                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
-                        cFYI(1, "POSIX path cap");
+                        cifs_dbg(FYI, "POSIX path cap\n");
                 if (cap & CIFS_UNIX_XATTR_CAP)
-                        cFYI(1, "XATTR cap");
+                        cifs_dbg(FYI, "XATTR cap\n");
                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
-                        cFYI(1, "POSIX ACL cap");
+                        cifs_dbg(FYI, "POSIX ACL cap\n");
                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
-                        cFYI(1, "very large read cap");
+                        cifs_dbg(FYI, "very large read cap\n");
                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
-                        cFYI(1, "very large write cap");
+                        cifs_dbg(FYI, "very large write cap\n");
                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
-                        cFYI(1, "transport encryption cap");
+                        cifs_dbg(FYI, "transport encryption cap\n");
                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
-                        cFYI(1, "mandatory transport encryption cap");
+                        cifs_dbg(FYI, "mandatory transport encryption cap\n");
 #endif /* CIFS_DEBUG2 */
                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
                         if (vol_info == NULL) {
-                                cFYI(1, "resetting capabilities failed");
+                                cifs_dbg(FYI, "resetting capabilities failed\n");
                         } else
-                                cERROR(1, "Negotiating Unix capabilities "
-                                           "with the server failed. Consider "
-                                           "mounting with the Unix Extensions "
-                                           "disabled if problems are found "
-                                           "by specifying the nounix mount "
-                                           "option.");
+                                cifs_dbg(VFS, "Negotiating Unix capabilities with the server failed. Consider mounting with the Unix Extensions disabled if problems are found by specifying the nounix mount option.\n");
 
                 }
         }
@@ -3177,8 +3167,8 @@ void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
         cifs_sb->mnt_gid = pvolume_info->linux_gid;
         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
-        cFYI(1, "file mode: 0x%hx  dir mode: 0x%hx",
-                cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
+        cifs_dbg(FYI, "file mode: 0x%hx  dir mode: 0x%hx\n",
+                 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
 
         cifs_sb->actimeo = pvolume_info->actimeo;
         cifs_sb->local_nls = pvolume_info->local_nls;
@@ -3227,21 +3217,19 @@ void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
         if (pvolume_info->strict_io)
                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
         if (pvolume_info->direct_io) {
-                cFYI(1, "mounting share using direct i/o");
+                cifs_dbg(FYI, "mounting share using direct i/o\n");
                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
         }
         if (pvolume_info->mfsymlinks) {
                 if (pvolume_info->sfu_emul) {
-                        cERROR(1,  "mount option mfsymlinks ignored if sfu "
-                                   "mount option is used");
+                        cifs_dbg(VFS, "mount option mfsymlinks ignored if sfu mount option is used\n");
                 } else {
                         cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
                 }
         }
 
         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
-                cERROR(1, "mount option dynperm ignored if cifsacl "
-                           "mount option supported");
+                cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
 }
 
 static void
@@ -3293,7 +3281,7 @@ build_unc_path_to_root(const struct smb_vol *vol,
 
         *pos = '\0'; /* add trailing null */
         convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
-        cFYI(1, "%s: full_path=%s", __func__, full_path);
+        cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
         return full_path;
 }
 
@@ -3364,14 +3352,14 @@ cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
                 return -EINVAL;
 
         if (volume_info->nullauth) {
-                cFYI(1, "Anonymous login");
+                cifs_dbg(FYI, "Anonymous login\n");
                 kfree(volume_info->username);
                 volume_info->username = NULL;
         } else if (volume_info->username) {
                 /* BB fixme parse for domain name here */
-                cFYI(1, "Username: %s", volume_info->username);
+                cifs_dbg(FYI, "Username: %s\n", volume_info->username);
         } else {
-                cifserror("No username specified");
+                cifs_dbg(VFS, "No username specified\n");
         /* In userspace mount helper we can get user name from alternate
            locations such as env variables and files on disk */
                 return -EINVAL;
@@ -3384,7 +3372,7 @@ cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
         } else {
                 volume_info->local_nls = load_nls(volume_info->iocharset);
                 if (volume_info->local_nls == NULL) {
-                        cERROR(1, "CIFS mount error: iocharset %s not found",
+                        cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
                                  volume_info->iocharset);
                         return -ELIBACC;
                 }
@@ -3734,13 +3722,13 @@ CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
                 if (length == 3) {
                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
                             (bcc_ptr[2] == 'C')) {
-                                cFYI(1, "IPC connection");
+                                cifs_dbg(FYI, "IPC connection\n");
                                 tcon->ipc = 1;
                         }
                 } else if (length == 2) {
                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
                                 /* the most common case */
-                                cFYI(1, "disk share connection");
+                                cifs_dbg(FYI, "disk share connection\n");
                         }
                 }
                 bcc_ptr += length + 1;
@@ -3753,7 +3741,7 @@ CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
                                                       bytes_left, is_unicode,
                                                       nls_codepage);
 
-                cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
+                cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
 
                 if ((smb_buffer_response->WordCount == 3) ||
                          (smb_buffer_response->WordCount == 7))
@@ -3761,7 +3749,7 @@ CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
                 else
                         tcon->Flags = 0;
-                cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
+                cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
         } else if ((rc == 0) && tcon == NULL) {
                 /* all we need to save for IPC$ connection */
                 ses->ipc_tid = smb_buffer_response->Tid;
@@ -3839,14 +3827,14 @@ cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
         if (linuxExtEnabled == 0)
                 ses->capabilities &= (~server->vals->cap_unix);
 
-        cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
+        cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
                  server->sec_mode, server->capabilities, server->timeAdj);
 
         if (server->ops->sess_setup)
                 rc = server->ops->sess_setup(xid, ses, nls_info);
 
         if (rc) {
-                cERROR(1, "Send error in SessSetup = %d", rc);
+                cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
         } else {
                 mutex_lock(&ses->server->srv_mutex);
                 if (!server->session_estab) {
@@ -3858,7 +3846,7 @@ cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
                 }
                 mutex_unlock(&server->srv_mutex);
 
-                cFYI(1, "CIFS Session Established successfully");
+                cifs_dbg(FYI, "CIFS Session Established successfully\n");
                 spin_lock(&GlobalMid_Lock);
                 ses->status = CifsGood;
                 ses->need_reconnect = false;