Merge tag 'staging-5.13-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh...
[linux-2.6-microblaze.git] / fs / xfs / xfs_super.c
index e5e0713..a2dab05 100644 (file)
@@ -519,10 +519,10 @@ xfs_init_mount_workqueues(
        if (!mp->m_reclaim_workqueue)
                goto out_destroy_cil;
 
-       mp->m_blockgc_workqueue = alloc_workqueue("xfs-blockgc/%s",
+       mp->m_gc_workqueue = alloc_workqueue("xfs-gc/%s",
                        WQ_SYSFS | WQ_UNBOUND | WQ_FREEZABLE | WQ_MEM_RECLAIM,
                        0, mp->m_super->s_id);
-       if (!mp->m_blockgc_workqueue)
+       if (!mp->m_gc_workqueue)
                goto out_destroy_reclaim;
 
        mp->m_sync_workqueue = alloc_workqueue("xfs-sync/%s",
@@ -533,7 +533,7 @@ xfs_init_mount_workqueues(
        return 0;
 
 out_destroy_eofb:
-       destroy_workqueue(mp->m_blockgc_workqueue);
+       destroy_workqueue(mp->m_gc_workqueue);
 out_destroy_reclaim:
        destroy_workqueue(mp->m_reclaim_workqueue);
 out_destroy_cil:
@@ -551,7 +551,7 @@ xfs_destroy_mount_workqueues(
        struct xfs_mount        *mp)
 {
        destroy_workqueue(mp->m_sync_workqueue);
-       destroy_workqueue(mp->m_blockgc_workqueue);
+       destroy_workqueue(mp->m_gc_workqueue);
        destroy_workqueue(mp->m_reclaim_workqueue);
        destroy_workqueue(mp->m_cil_workqueue);
        destroy_workqueue(mp->m_unwritten_workqueue);
@@ -834,13 +834,13 @@ xfs_fs_statfs(
        statp->f_ffree = max_t(int64_t, ffree, 0);
 
 
-       if ((ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
+       if ((ip->i_diflags & XFS_DIFLAG_PROJINHERIT) &&
            ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))) ==
                              (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))
                xfs_qm_statvfs(ip, statp);
 
        if (XFS_IS_REALTIME_MOUNT(mp) &&
-           (ip->i_d.di_flags & (XFS_DIFLAG_RTINHERIT | XFS_DIFLAG_REALTIME))) {
+           (ip->i_diflags & (XFS_DIFLAG_RTINHERIT | XFS_DIFLAG_REALTIME))) {
                statp->f_blocks = sbp->sb_rblocks;
                statp->f_bavail = statp->f_bfree =
                        sbp->sb_frextents * sbp->sb_rextsize;
@@ -1126,6 +1126,22 @@ suffix_kstrtoint(
        return ret;
 }
 
+static inline void
+xfs_fs_warn_deprecated(
+       struct fs_context       *fc,
+       struct fs_parameter     *param,
+       uint64_t                flag,
+       bool                    value)
+{
+       /* Don't print the warning if reconfiguring and current mount point
+        * already had the flag set
+        */
+       if ((fc->purpose & FS_CONTEXT_FOR_RECONFIGURE) &&
+                       !!(XFS_M(fc->root->d_sb)->m_flags & flag) == value)
+               return;
+       xfs_warn(fc->s_fs_info, "%s mount option is deprecated.", param->key);
+}
+
 /*
  * Set mount state from a mount option.
  *
@@ -1136,7 +1152,7 @@ xfs_fs_parse_param(
        struct fs_context       *fc,
        struct fs_parameter     *param)
 {
-       struct xfs_mount        *mp = fc->s_fs_info;
+       struct xfs_mount        *parsing_mp = fc->s_fs_info;
        struct fs_parse_result  result;
        int                     size = 0;
        int                     opt;
@@ -1147,142 +1163,142 @@ xfs_fs_parse_param(
 
        switch (opt) {
        case Opt_logbufs:
-               mp->m_logbufs = result.uint_32;
+               parsing_mp->m_logbufs = result.uint_32;
                return 0;
        case Opt_logbsize:
-               if (suffix_kstrtoint(param->string, 10, &mp->m_logbsize))
+               if (suffix_kstrtoint(param->string, 10, &parsing_mp->m_logbsize))
                        return -EINVAL;
                return 0;
        case Opt_logdev:
-               kfree(mp->m_logname);
-               mp->m_logname = kstrdup(param->string, GFP_KERNEL);
-               if (!mp->m_logname)
+               kfree(parsing_mp->m_logname);
+               parsing_mp->m_logname = kstrdup(param->string, GFP_KERNEL);
+               if (!parsing_mp->m_logname)
                        return -ENOMEM;
                return 0;
        case Opt_rtdev:
-               kfree(mp->m_rtname);
-               mp->m_rtname = kstrdup(param->string, GFP_KERNEL);
-               if (!mp->m_rtname)
+               kfree(parsing_mp->m_rtname);
+               parsing_mp->m_rtname = kstrdup(param->string, GFP_KERNEL);
+               if (!parsing_mp->m_rtname)
                        return -ENOMEM;
                return 0;
        case Opt_allocsize:
                if (suffix_kstrtoint(param->string, 10, &size))
                        return -EINVAL;
-               mp->m_allocsize_log = ffs(size) - 1;
-               mp->m_flags |= XFS_MOUNT_ALLOCSIZE;
+               parsing_mp->m_allocsize_log = ffs(size) - 1;
+               parsing_mp->m_flags |= XFS_MOUNT_ALLOCSIZE;
                return 0;
        case Opt_grpid:
        case Opt_bsdgroups:
-               mp->m_flags |= XFS_MOUNT_GRPID;
+               parsing_mp->m_flags |= XFS_MOUNT_GRPID;
                return 0;
        case Opt_nogrpid:
        case Opt_sysvgroups:
-               mp->m_flags &= ~XFS_MOUNT_GRPID;
+               parsing_mp->m_flags &= ~XFS_MOUNT_GRPID;
                return 0;
        case Opt_wsync:
-               mp->m_flags |= XFS_MOUNT_WSYNC;
+               parsing_mp->m_flags |= XFS_MOUNT_WSYNC;
                return 0;
        case Opt_norecovery:
-               mp->m_flags |= XFS_MOUNT_NORECOVERY;
+               parsing_mp->m_flags |= XFS_MOUNT_NORECOVERY;
                return 0;
        case Opt_noalign:
-               mp->m_flags |= XFS_MOUNT_NOALIGN;
+               parsing_mp->m_flags |= XFS_MOUNT_NOALIGN;
                return 0;
        case Opt_swalloc:
-               mp->m_flags |= XFS_MOUNT_SWALLOC;
+               parsing_mp->m_flags |= XFS_MOUNT_SWALLOC;
                return 0;
        case Opt_sunit:
-               mp->m_dalign = result.uint_32;
+               parsing_mp->m_dalign = result.uint_32;
                return 0;
        case Opt_swidth:
-               mp->m_swidth = result.uint_32;
+               parsing_mp->m_swidth = result.uint_32;
                return 0;
        case Opt_inode32:
-               mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
+               parsing_mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
                return 0;
        case Opt_inode64:
-               mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
+               parsing_mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
                return 0;
        case Opt_nouuid:
-               mp->m_flags |= XFS_MOUNT_NOUUID;
+               parsing_mp->m_flags |= XFS_MOUNT_NOUUID;
                return 0;
        case Opt_largeio:
-               mp->m_flags |= XFS_MOUNT_LARGEIO;
+               parsing_mp->m_flags |= XFS_MOUNT_LARGEIO;
                return 0;
        case Opt_nolargeio:
-               mp->m_flags &= ~XFS_MOUNT_LARGEIO;
+               parsing_mp->m_flags &= ~XFS_MOUNT_LARGEIO;
                return 0;
        case Opt_filestreams:
-               mp->m_flags |= XFS_MOUNT_FILESTREAMS;
+               parsing_mp->m_flags |= XFS_MOUNT_FILESTREAMS;
                return 0;
        case Opt_noquota:
-               mp->m_qflags &= ~XFS_ALL_QUOTA_ACCT;
-               mp->m_qflags &= ~XFS_ALL_QUOTA_ENFD;
-               mp->m_qflags &= ~XFS_ALL_QUOTA_ACTIVE;
+               parsing_mp->m_qflags &= ~XFS_ALL_QUOTA_ACCT;
+               parsing_mp->m_qflags &= ~XFS_ALL_QUOTA_ENFD;
+               parsing_mp->m_qflags &= ~XFS_ALL_QUOTA_ACTIVE;
                return 0;
        case Opt_quota:
        case Opt_uquota:
        case Opt_usrquota:
-               mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE |
+               parsing_mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE |
                                 XFS_UQUOTA_ENFD);
                return 0;
        case Opt_qnoenforce:
        case Opt_uqnoenforce:
-               mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE);
-               mp->m_qflags &= ~XFS_UQUOTA_ENFD;
+               parsing_mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE);
+               parsing_mp->m_qflags &= ~XFS_UQUOTA_ENFD;
                return 0;
        case Opt_pquota:
        case Opt_prjquota:
-               mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE |
+               parsing_mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE |
                                 XFS_PQUOTA_ENFD);
                return 0;
        case Opt_pqnoenforce:
-               mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE);
-               mp->m_qflags &= ~XFS_PQUOTA_ENFD;
+               parsing_mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE);
+               parsing_mp->m_qflags &= ~XFS_PQUOTA_ENFD;
                return 0;
        case Opt_gquota:
        case Opt_grpquota:
-               mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE |
+               parsing_mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE |
                                 XFS_GQUOTA_ENFD);
                return 0;
        case Opt_gqnoenforce:
-               mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE);
-               mp->m_qflags &= ~XFS_GQUOTA_ENFD;
+               parsing_mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE);
+               parsing_mp->m_qflags &= ~XFS_GQUOTA_ENFD;
                return 0;
        case Opt_discard:
-               mp->m_flags |= XFS_MOUNT_DISCARD;
+               parsing_mp->m_flags |= XFS_MOUNT_DISCARD;
                return 0;
        case Opt_nodiscard:
-               mp->m_flags &= ~XFS_MOUNT_DISCARD;
+               parsing_mp->m_flags &= ~XFS_MOUNT_DISCARD;
                return 0;
 #ifdef CONFIG_FS_DAX
        case Opt_dax:
-               xfs_mount_set_dax_mode(mp, XFS_DAX_ALWAYS);
+               xfs_mount_set_dax_mode(parsing_mp, XFS_DAX_ALWAYS);
                return 0;
        case Opt_dax_enum:
-               xfs_mount_set_dax_mode(mp, result.uint_32);
+               xfs_mount_set_dax_mode(parsing_mp, result.uint_32);
                return 0;
 #endif
        /* Following mount options will be removed in September 2025 */
        case Opt_ikeep:
-               xfs_warn(mp, "%s mount option is deprecated.", param->key);
-               mp->m_flags |= XFS_MOUNT_IKEEP;
+               xfs_fs_warn_deprecated(fc, param, XFS_MOUNT_IKEEP, true);
+               parsing_mp->m_flags |= XFS_MOUNT_IKEEP;
                return 0;
        case Opt_noikeep:
-               xfs_warn(mp, "%s mount option is deprecated.", param->key);
-               mp->m_flags &= ~XFS_MOUNT_IKEEP;
+               xfs_fs_warn_deprecated(fc, param, XFS_MOUNT_IKEEP, false);
+               parsing_mp->m_flags &= ~XFS_MOUNT_IKEEP;
                return 0;
        case Opt_attr2:
-               xfs_warn(mp, "%s mount option is deprecated.", param->key);
-               mp->m_flags |= XFS_MOUNT_ATTR2;
+               xfs_fs_warn_deprecated(fc, param, XFS_MOUNT_ATTR2, true);
+               parsing_mp->m_flags |= XFS_MOUNT_ATTR2;
                return 0;
        case Opt_noattr2:
-               xfs_warn(mp, "%s mount option is deprecated.", param->key);
-               mp->m_flags &= ~XFS_MOUNT_ATTR2;
-               mp->m_flags |= XFS_MOUNT_NOATTR2;
+               xfs_fs_warn_deprecated(fc, param, XFS_MOUNT_NOATTR2, true);
+               parsing_mp->m_flags &= ~XFS_MOUNT_ATTR2;
+               parsing_mp->m_flags |= XFS_MOUNT_NOATTR2;
                return 0;
        default:
-               xfs_warn(mp, "unknown mount option [%s].", param->key);
+               xfs_warn(parsing_mp, "unknown mount option [%s].", param->key);
                return -EINVAL;
        }
 
@@ -1918,7 +1934,7 @@ xfs_init_zones(void)
        if (!xfs_ifork_zone)
                goto out_destroy_da_state_zone;
 
-       xfs_trans_zone = kmem_cache_create("xf_trans",
+       xfs_trans_zone = kmem_cache_create("xfs_trans",
                                           sizeof(struct xfs_trans),
                                           0, 0, NULL);
        if (!xfs_trans_zone)