cifs: log mount errors using cifs_errorf()

This makes the errors accessible from userspace via dmesg and
the fs_context fd.

Signed-off-by: Aurelien Aptel <aaptel@suse.com>
Signed-off-by: Steve French <stfrench@microsoft.com>

diff --git a/fs/cifs/fs_context.c b/fs/cifs/fs_context.c
index 8de777e..74758e9 100644 (file)
--- a/fs/cifs/fs_context.c
+++ b/fs/cifs/fs_context.c
@@ -203,7 +203,7 @@ cifs_parse_security_flavors(struct fs_context *fc, char *value, struct smb3_fs_c
 
        switch (match_token(value, cifs_secflavor_tokens, args)) {
        case Opt_sec_krb5p:
-               cifs_dbg(VFS, "sec=krb5p is not supported!\n");
+               cifs_errorf(fc, "sec=krb5p is not supported!\n");
                return 1;
        case Opt_sec_krb5i:
                ctx->sign = true;
@@ -238,7 +238,7 @@ cifs_parse_security_flavors(struct fs_context *fc, char *value, struct smb3_fs_c
                ctx->nullauth = 1;
                break;
        default:
-               cifs_dbg(VFS, "bad security option: %s\n", value);
+               cifs_errorf(fc, "bad security option: %s\n", value);
                return 1;
        }
 
@@ -291,7 +291,7 @@ cifs_parse_cache_flavor(struct fs_context *fc, char *value, struct smb3_fs_conte
                ctx->cache_rw = true;
                break;
        default:
-               cifs_dbg(VFS, "bad cache= option: %s\n", value);
+               cifs_errorf(fc, "bad cache= option: %s\n", value);
                return 1;
        }
        return 0;
@@ -347,24 +347,24 @@ cifs_parse_smb_version(struct fs_context *fc, char *value, struct smb3_fs_contex
 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
        case Smb_1:
                if (disable_legacy_dialects) {
-                       cifs_dbg(VFS, "mount with legacy dialect disabled\n");
+                       cifs_errorf(fc, "mount with legacy dialect disabled\n");
                        return 1;
                }
                if (is_smb3) {
-                       cifs_dbg(VFS, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
+                       cifs_errorf(fc, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
                        return 1;
                }
-               cifs_dbg(VFS, "Use of the less secure dialect vers=1.0 is not recommended unless required for access to very old servers\n");
+               cifs_errorf(fc, "Use of the less secure dialect vers=1.0 is not recommended unless required for access to very old servers\n");
                ctx->ops = &smb1_operations;
                ctx->vals = &smb1_values;
                break;
        case Smb_20:
                if (disable_legacy_dialects) {
-                       cifs_dbg(VFS, "mount with legacy dialect disabled\n");
+                       cifs_errorf(fc, "mount with legacy dialect disabled\n");
                        return 1;
                }
                if (is_smb3) {
-                       cifs_dbg(VFS, "vers=2.0 not permitted when mounting with smb3\n");
+                       cifs_errorf(fc, "vers=2.0 not permitted when mounting with smb3\n");
                        return 1;
                }
                ctx->ops = &smb20_operations;
@@ -372,10 +372,10 @@ cifs_parse_smb_version(struct fs_context *fc, char *value, struct smb3_fs_contex
                break;
 #else
        case Smb_1:
-               cifs_dbg(VFS, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
+               cifs_errorf(fc, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
                return 1;
        case Smb_20:
-               cifs_dbg(VFS, "vers=2.0 mount not permitted when legacy dialects disabled\n");
+               cifs_errorf(fc, "vers=2.0 mount not permitted when legacy dialects disabled\n");
                return 1;
 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
        case Smb_21:
@@ -403,7 +403,7 @@ cifs_parse_smb_version(struct fs_context *fc, char *value, struct smb3_fs_contex
                ctx->vals = &smbdefault_values;
                break;
        default:
-               cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
+               cifs_errorf(fc, "Unknown vers= option specified: %s\n", value);
                return 1;
        }
        return 0;
@@ -588,14 +588,14 @@ static int smb3_fs_context_validate(struct fs_context *fc)
        struct smb3_fs_context *ctx = smb3_fc2context(fc);
 
        if (ctx->rdma && ctx->vals->protocol_id < SMB30_PROT_ID) {
-               cifs_dbg(VFS, "SMB Direct requires Version >=3.0\n");
+               cifs_errorf(fc, "SMB Direct requires Version >=3.0\n");
                return -EOPNOTSUPP;
        }
 
 #ifndef CONFIG_KEYS
        /* Muliuser mounts require CONFIG_KEYS support */
        if (ctx->multiuser) {
-               cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
+               cifs_errorf(fc, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
                return -1;
        }
 #endif
@@ -605,13 +605,13 @@ static int smb3_fs_context_validate(struct fs_context *fc)
 
 
        if (!ctx->UNC) {
-               cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
+               cifs_errorf(fc, "CIFS mount error: No usable UNC path provided in device string!\n");
                return -1;
        }
 
        /* make sure UNC has a share name */
        if (strlen(ctx->UNC) < 3 || !strchr(ctx->UNC + 3, '\\')) {
-               cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
+               cifs_errorf(fc, "Malformed UNC. Unable to find share name.\n");
                return -ENOENT;
        }
 
@@ -689,45 +689,45 @@ static int smb3_verify_reconfigure_ctx(struct fs_context *fc,
                                       struct smb3_fs_context *old_ctx)
 {
        if (new_ctx->posix_paths != old_ctx->posix_paths) {
-               cifs_dbg(VFS, "can not change posixpaths during remount\n");
+               cifs_errorf(fc, "can not change posixpaths during remount\n");
                return -EINVAL;
        }
        if (new_ctx->sectype != old_ctx->sectype) {
-               cifs_dbg(VFS, "can not change sec during remount\n");
+               cifs_errorf(fc, "can not change sec during remount\n");
                return -EINVAL;
        }
        if (new_ctx->multiuser != old_ctx->multiuser) {
-               cifs_dbg(VFS, "can not change multiuser during remount\n");
+               cifs_errorf(fc, "can not change multiuser during remount\n");
                return -EINVAL;
        }
        if (new_ctx->UNC &&
            (!old_ctx->UNC || strcmp(new_ctx->UNC, old_ctx->UNC))) {
-               cifs_dbg(VFS, "can not change UNC during remount\n");
+               cifs_errorf(fc, "can not change UNC during remount\n");
                return -EINVAL;
        }
        if (new_ctx->username &&
            (!old_ctx->username || strcmp(new_ctx->username, old_ctx->username))) {
-               cifs_dbg(VFS, "can not change username during remount\n");
+               cifs_errorf(fc, "can not change username during remount\n");
                return -EINVAL;
        }
        if (new_ctx->password &&
            (!old_ctx->password || strcmp(new_ctx->password, old_ctx->password))) {
-               cifs_dbg(VFS, "can not change password during remount\n");
+               cifs_errorf(fc, "can not change password during remount\n");
                return -EINVAL;
        }
        if (new_ctx->domainname &&
            (!old_ctx->domainname || strcmp(new_ctx->domainname, old_ctx->domainname))) {
-               cifs_dbg(VFS, "can not change domainname during remount\n");
+               cifs_errorf(fc, "can not change domainname during remount\n");
                return -EINVAL;
        }
        if (new_ctx->nodename &&
            (!old_ctx->nodename || strcmp(new_ctx->nodename, old_ctx->nodename))) {
-               cifs_dbg(VFS, "can not change nodename during remount\n");
+               cifs_errorf(fc, "can not change nodename during remount\n");
                return -EINVAL;
        }
        if (new_ctx->iocharset &&
            (!old_ctx->iocharset || strcmp(new_ctx->iocharset, old_ctx->iocharset))) {
-               cifs_dbg(VFS, "can not change iocharset during remount\n");
+               cifs_errorf(fc, "can not change iocharset during remount\n");
                return -EINVAL;
        }
 
@@ -934,7 +934,7 @@ static int smb3_fs_context_parse_param(struct fs_context *fc,
                 */
                if ((result.uint_32 < CIFS_MAX_MSGSIZE) ||
                   (result.uint_32 > (4 * SMB3_DEFAULT_IOSIZE))) {
-                       cifs_dbg(VFS, "%s: Invalid blocksize\n",
+                       cifs_errorf(fc, "%s: Invalid blocksize\n",
                                __func__);
                        goto cifs_parse_mount_err;
                }
@@ -952,25 +952,25 @@ static int smb3_fs_context_parse_param(struct fs_context *fc,
        case Opt_acregmax:
                ctx->acregmax = HZ * result.uint_32;
                if (ctx->acregmax > CIFS_MAX_ACTIMEO) {
-                       cifs_dbg(VFS, "acregmax too large\n");
+                       cifs_errorf(fc, "acregmax too large\n");
                        goto cifs_parse_mount_err;
                }
                break;
        case Opt_acdirmax:
                ctx->acdirmax = HZ * result.uint_32;
                if (ctx->acdirmax > CIFS_MAX_ACTIMEO) {
-                       cifs_dbg(VFS, "acdirmax too large\n");
+                       cifs_errorf(fc, "acdirmax too large\n");
                        goto cifs_parse_mount_err;
                }
                break;
        case Opt_actimeo:
                if (HZ * result.uint_32 > CIFS_MAX_ACTIMEO) {
-                       cifs_dbg(VFS, "timeout too large\n");
+                       cifs_errorf(fc, "timeout too large\n");
                        goto cifs_parse_mount_err;
                }
                if ((ctx->acdirmax != CIFS_DEF_ACTIMEO) ||
                    (ctx->acregmax != CIFS_DEF_ACTIMEO)) {
-                       cifs_dbg(VFS, "actimeo ignored since acregmax or acdirmax specified\n");
+                       cifs_errorf(fc, "actimeo ignored since acregmax or acdirmax specified\n");
                        break;
                }
                ctx->acdirmax = ctx->acregmax = HZ * result.uint_32;
@@ -983,7 +983,7 @@ static int smb3_fs_context_parse_param(struct fs_context *fc,
                break;
        case Opt_max_credits:
                if (result.uint_32 < 20 || result.uint_32 > 60000) {
-                       cifs_dbg(VFS, "%s: Invalid max_credits value\n",
+                       cifs_errorf(fc, "%s: Invalid max_credits value\n",
                                 __func__);
                        goto cifs_parse_mount_err;
                }
@@ -991,7 +991,7 @@ static int smb3_fs_context_parse_param(struct fs_context *fc,
                break;
        case Opt_max_channels:
                if (result.uint_32 < 1 || result.uint_32 > CIFS_MAX_CHANNELS) {
-                       cifs_dbg(VFS, "%s: Invalid max_channels value, needs to be 1-%d\n",
+                       cifs_errorf(fc, "%s: Invalid max_channels value, needs to be 1-%d\n",
                                 __func__, CIFS_MAX_CHANNELS);
                        goto cifs_parse_mount_err;
                }
@@ -1000,7 +1000,7 @@ static int smb3_fs_context_parse_param(struct fs_context *fc,
        case Opt_handletimeout:
                ctx->handle_timeout = result.uint_32;
                if (ctx->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
-                       cifs_dbg(VFS, "Invalid handle cache timeout, longer than 16 minutes\n");
+                       cifs_errorf(fc, "Invalid handle cache timeout, longer than 16 minutes\n");
                        goto cifs_parse_mount_err;
                }
                break;
@@ -1011,23 +1011,23 @@ static int smb3_fs_context_parse_param(struct fs_context *fc,
                case 0:
                        break;
                case -ENOMEM:
-                       cifs_dbg(VFS, "Unable to allocate memory for devname\n");
+                       cifs_errorf(fc, "Unable to allocate memory for devname\n");
                        goto cifs_parse_mount_err;
                case -EINVAL:
-                       cifs_dbg(VFS, "Malformed UNC in devname\n");
+                       cifs_errorf(fc, "Malformed UNC in devname\n");
                        goto cifs_parse_mount_err;
                default:
-                       cifs_dbg(VFS, "Unknown error parsing devname\n");
+                       cifs_errorf(fc, "Unknown error parsing devname\n");
                        goto cifs_parse_mount_err;
                }
                ctx->source = kstrdup(param->string, GFP_KERNEL);
                if (ctx->source == NULL) {
-                       cifs_dbg(VFS, "OOM when copying UNC string\n");
+                       cifs_errorf(fc, "OOM when copying UNC string\n");
                        goto cifs_parse_mount_err;
                }
                fc->source = kstrdup(param->string, GFP_KERNEL);
                if (fc->source == NULL) {
-                       cifs_dbg(VFS, "OOM when copying UNC string\n");
+                       cifs_errorf(fc, "OOM when copying UNC string\n");
                        goto cifs_parse_mount_err;
                }
                break;
@@ -1047,7 +1047,7 @@ static int smb3_fs_context_parse_param(struct fs_context *fc,
                }
                ctx->username = kstrdup(param->string, GFP_KERNEL);
                if (ctx->username == NULL) {
-                       cifs_dbg(VFS, "OOM when copying username string\n");
+                       cifs_errorf(fc, "OOM when copying username string\n");
                        goto cifs_parse_mount_err;
                }
                break;
@@ -1059,7 +1059,7 @@ static int smb3_fs_context_parse_param(struct fs_context *fc,
 
                ctx->password = kstrdup(param->string, GFP_KERNEL);
                if (ctx->password == NULL) {
-                       cifs_dbg(VFS, "OOM when copying password string\n");
+                       cifs_errorf(fc, "OOM when copying password string\n");
                        goto cifs_parse_mount_err;
                }
                break;
@@ -1086,7 +1086,7 @@ static int smb3_fs_context_parse_param(struct fs_context *fc,
                kfree(ctx->domainname);
                ctx->domainname = kstrdup(param->string, GFP_KERNEL);
                if (ctx->domainname == NULL) {
-                       cifs_dbg(VFS, "OOM when copying domainname string\n");
+                       cifs_errorf(fc, "OOM when copying domainname string\n");
                        goto cifs_parse_mount_err;
                }
                cifs_dbg(FYI, "Domain name set\n");
@@ -1110,7 +1110,7 @@ static int smb3_fs_context_parse_param(struct fs_context *fc,
                        kfree(ctx->iocharset);
                        ctx->iocharset = kstrdup(param->string, GFP_KERNEL);
                        if (ctx->iocharset == NULL) {
-                               cifs_dbg(VFS, "OOM when copying iocharset string\n");
+                               cifs_errorf(fc, "OOM when copying iocharset string\n");
                                goto cifs_parse_mount_err;
                        }
                }
@@ -1190,7 +1190,7 @@ static int smb3_fs_context_parse_param(struct fs_context *fc,
                break;
        case Opt_witness:
 #ifndef CONFIG_CIFS_SWN_UPCALL
-               cifs_dbg(VFS, "Witness support needs CONFIG_CIFS_SWN_UPCALL config option\n");
+               cifs_errorf(fc, "Witness support needs CONFIG_CIFS_SWN_UPCALL config option\n");
                        goto cifs_parse_mount_err;
 #endif
                ctx->witness = true;
@@ -1291,7 +1291,7 @@ static int smb3_fs_context_parse_param(struct fs_context *fc,
                break;
        case Opt_fsc:
 #ifndef CONFIG_CIFS_FSCACHE
-               cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
+               cifs_errorf(fc, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
                goto cifs_parse_mount_err;
 #endif
                ctx->fsc = true;
@@ -1312,15 +1312,13 @@ static int smb3_fs_context_parse_param(struct fs_context *fc,
                if (result.negated) {
                        ctx->nopersistent = true;
                        if (ctx->persistent) {
-                               cifs_dbg(VFS,
-                                 "persistenthandles mount options conflict\n");
+                               cifs_errorf(fc, "persistenthandles mount options conflict\n");
                                goto cifs_parse_mount_err;
                        }
                } else {
                        ctx->persistent = true;
                        if ((ctx->nopersistent) || (ctx->resilient)) {
-                               cifs_dbg(VFS,
-                                 "persistenthandles mount options conflict\n");
+                               cifs_errorf(fc, "persistenthandles mount options conflict\n");
                                goto cifs_parse_mount_err;
                        }
                }
@@ -1331,8 +1329,7 @@ static int smb3_fs_context_parse_param(struct fs_context *fc,
                } else {
                        ctx->resilient = true;
                        if (ctx->persistent) {
-                               cifs_dbg(VFS,
-                                 "persistenthandles mount options conflict\n");
+                               cifs_errorf(fc, "persistenthandles mount options conflict\n");
                                goto cifs_parse_mount_err;
                        }
                }