tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

quota: Clean up the namespace in dqblk_xfs.h

Almost all identifiers use the FS_* namespace, so rename the missing few
XFS_* ones to FS_* as well. Without this some people might get upset
about having too many XFS names in generic code.

Acked-by: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jan Kara <jack@suse.cz>

authored by

Christoph Hellwig and committed by
Jan Kara ade7ce31 7af9cce8

+39 -39
+5 -5
fs/gfs2/quota.c
··· 1455 1455 1456 1456 switch (sdp->sd_args.ar_quota) { 1457 1457 case GFS2_QUOTA_ON: 1458 - fqs->qs_flags |= (XFS_QUOTA_UDQ_ENFD | XFS_QUOTA_GDQ_ENFD); 1458 + fqs->qs_flags |= (FS_QUOTA_UDQ_ENFD | FS_QUOTA_GDQ_ENFD); 1459 1459 /*FALLTHRU*/ 1460 1460 case GFS2_QUOTA_ACCOUNT: 1461 - fqs->qs_flags |= (XFS_QUOTA_UDQ_ACCT | XFS_QUOTA_GDQ_ACCT); 1461 + fqs->qs_flags |= (FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT); 1462 1462 break; 1463 1463 case GFS2_QUOTA_OFF: 1464 1464 break; ··· 1504 1504 1505 1505 qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb; 1506 1506 fdq->d_version = FS_DQUOT_VERSION; 1507 - fdq->d_flags = (type == QUOTA_USER) ? XFS_USER_QUOTA : XFS_GROUP_QUOTA; 1507 + fdq->d_flags = (type == QUOTA_USER) ? FS_USER_QUOTA : FS_GROUP_QUOTA; 1508 1508 fdq->d_id = id; 1509 1509 fdq->d_blk_hardlimit = be64_to_cpu(qlvb->qb_limit); 1510 1510 fdq->d_blk_softlimit = be64_to_cpu(qlvb->qb_warn); ··· 1539 1539 switch(type) { 1540 1540 case USRQUOTA: 1541 1541 type = QUOTA_USER; 1542 - if (fdq->d_flags != XFS_USER_QUOTA) 1542 + if (fdq->d_flags != FS_USER_QUOTA) 1543 1543 return -EINVAL; 1544 1544 break; 1545 1545 case GRPQUOTA: 1546 1546 type = QUOTA_GROUP; 1547 - if (fdq->d_flags != XFS_GROUP_QUOTA) 1547 + if (fdq->d_flags != FS_GROUP_QUOTA) 1548 1548 return -EINVAL; 1549 1549 break; 1550 1550 default:
+1 -1
fs/quota/dquot.c
··· 2281 2281 memset(di, 0, sizeof(*di)); 2282 2282 di->d_version = FS_DQUOT_VERSION; 2283 2283 di->d_flags = dquot->dq_type == USRQUOTA ? 2284 - XFS_USER_QUOTA : XFS_GROUP_QUOTA; 2284 + FS_USER_QUOTA : FS_GROUP_QUOTA; 2285 2285 di->d_id = dquot->dq_id; 2286 2286 2287 2287 spin_lock(&dq_data_lock);
+5 -5
fs/xfs/linux-2.6/xfs_quotaops.c
··· 69 69 if (op != Q_XQUOTARM && !XFS_IS_QUOTA_RUNNING(mp)) 70 70 return -ENOSYS; 71 71 72 - if (uflags & XFS_QUOTA_UDQ_ACCT) 72 + if (uflags & FS_QUOTA_UDQ_ACCT) 73 73 flags |= XFS_UQUOTA_ACCT; 74 - if (uflags & XFS_QUOTA_PDQ_ACCT) 74 + if (uflags & FS_QUOTA_PDQ_ACCT) 75 75 flags |= XFS_PQUOTA_ACCT; 76 - if (uflags & XFS_QUOTA_GDQ_ACCT) 76 + if (uflags & FS_QUOTA_GDQ_ACCT) 77 77 flags |= XFS_GQUOTA_ACCT; 78 - if (uflags & XFS_QUOTA_UDQ_ENFD) 78 + if (uflags & FS_QUOTA_UDQ_ENFD) 79 79 flags |= XFS_UQUOTA_ENFD; 80 - if (uflags & (XFS_QUOTA_PDQ_ENFD|XFS_QUOTA_GDQ_ENFD)) 80 + if (uflags & (FS_QUOTA_PDQ_ENFD|FS_QUOTA_GDQ_ENFD)) 81 81 flags |= XFS_OQUOTA_ENFD; 82 82 83 83 switch (op) {
+16 -16
fs/xfs/quota/xfs_qm_syscalls.c
··· 786 786 } 787 787 788 788 #ifdef DEBUG 789 - if (((XFS_IS_UQUOTA_ENFORCED(mp) && dst->d_flags == XFS_USER_QUOTA) || 789 + if (((XFS_IS_UQUOTA_ENFORCED(mp) && dst->d_flags == FS_USER_QUOTA) || 790 790 (XFS_IS_OQUOTA_ENFORCED(mp) && 791 - (dst->d_flags & (XFS_PROJ_QUOTA | XFS_GROUP_QUOTA)))) && 791 + (dst->d_flags & (FS_PROJ_QUOTA | FS_GROUP_QUOTA)))) && 792 792 dst->d_id != 0) { 793 793 if (((int) dst->d_bcount >= (int) dst->d_blk_softlimit) && 794 794 (dst->d_blk_softlimit > 0)) { ··· 809 809 /* 810 810 * Can't be more than one, or none. 811 811 */ 812 - ASSERT((flags & (XFS_PROJ_QUOTA | XFS_USER_QUOTA)) != 813 - (XFS_PROJ_QUOTA | XFS_USER_QUOTA)); 814 - ASSERT((flags & (XFS_PROJ_QUOTA | XFS_GROUP_QUOTA)) != 815 - (XFS_PROJ_QUOTA | XFS_GROUP_QUOTA)); 816 - ASSERT((flags & (XFS_USER_QUOTA | XFS_GROUP_QUOTA)) != 817 - (XFS_USER_QUOTA | XFS_GROUP_QUOTA)); 818 - ASSERT((flags & (XFS_PROJ_QUOTA|XFS_USER_QUOTA|XFS_GROUP_QUOTA)) != 0); 812 + ASSERT((flags & (FS_PROJ_QUOTA | FS_USER_QUOTA)) != 813 + (FS_PROJ_QUOTA | FS_USER_QUOTA)); 814 + ASSERT((flags & (FS_PROJ_QUOTA | FS_GROUP_QUOTA)) != 815 + (FS_PROJ_QUOTA | FS_GROUP_QUOTA)); 816 + ASSERT((flags & (FS_USER_QUOTA | FS_GROUP_QUOTA)) != 817 + (FS_USER_QUOTA | FS_GROUP_QUOTA)); 818 + ASSERT((flags & (FS_PROJ_QUOTA|FS_USER_QUOTA|FS_GROUP_QUOTA)) != 0); 819 819 820 820 return (flags & XFS_DQ_USER) ? 821 - XFS_USER_QUOTA : (flags & XFS_DQ_PROJ) ? 822 - XFS_PROJ_QUOTA : XFS_GROUP_QUOTA; 821 + FS_USER_QUOTA : (flags & XFS_DQ_PROJ) ? 822 + FS_PROJ_QUOTA : FS_GROUP_QUOTA; 823 823 } 824 824 825 825 STATIC uint ··· 830 830 831 831 uflags = 0; 832 832 if (flags & XFS_UQUOTA_ACCT) 833 - uflags |= XFS_QUOTA_UDQ_ACCT; 833 + uflags |= FS_QUOTA_UDQ_ACCT; 834 834 if (flags & XFS_PQUOTA_ACCT) 835 - uflags |= XFS_QUOTA_PDQ_ACCT; 835 + uflags |= FS_QUOTA_PDQ_ACCT; 836 836 if (flags & XFS_GQUOTA_ACCT) 837 - uflags |= XFS_QUOTA_GDQ_ACCT; 837 + uflags |= FS_QUOTA_GDQ_ACCT; 838 838 if (flags & XFS_UQUOTA_ENFD) 839 - uflags |= XFS_QUOTA_UDQ_ENFD; 839 + uflags |= FS_QUOTA_UDQ_ENFD; 840 840 if (flags & (XFS_OQUOTA_ENFD)) { 841 841 uflags |= (flags & XFS_GQUOTA_ACCT) ? 842 - XFS_QUOTA_GDQ_ENFD : XFS_QUOTA_PDQ_ENFD; 842 + FS_QUOTA_GDQ_ENFD : FS_QUOTA_PDQ_ENFD; 843 843 } 844 844 return (uflags); 845 845 }
+12 -12
include/linux/dqblk_xfs.h
··· 49 49 #define FS_DQUOT_VERSION 1 /* fs_disk_quota.d_version */ 50 50 typedef struct fs_disk_quota { 51 51 __s8 d_version; /* version of this structure */ 52 - __s8 d_flags; /* XFS_{USER,PROJ,GROUP}_QUOTA */ 52 + __s8 d_flags; /* FS_{USER,PROJ,GROUP}_QUOTA */ 53 53 __u16 d_fieldmask; /* field specifier */ 54 54 __u32 d_id; /* user, project, or group ID */ 55 55 __u64 d_blk_hardlimit;/* absolute limit on disk blks */ ··· 119 119 #define FS_DQ_ACCT_MASK (FS_DQ_BCOUNT | FS_DQ_ICOUNT | FS_DQ_RTBCOUNT) 120 120 121 121 /* 122 - * Various flags related to quotactl(2). Only relevant to XFS filesystems. 122 + * Various flags related to quotactl(2). 123 123 */ 124 - #define XFS_QUOTA_UDQ_ACCT (1<<0) /* user quota accounting */ 125 - #define XFS_QUOTA_UDQ_ENFD (1<<1) /* user quota limits enforcement */ 126 - #define XFS_QUOTA_GDQ_ACCT (1<<2) /* group quota accounting */ 127 - #define XFS_QUOTA_GDQ_ENFD (1<<3) /* group quota limits enforcement */ 128 - #define XFS_QUOTA_PDQ_ACCT (1<<4) /* project quota accounting */ 129 - #define XFS_QUOTA_PDQ_ENFD (1<<5) /* project quota limits enforcement */ 124 + #define FS_QUOTA_UDQ_ACCT (1<<0) /* user quota accounting */ 125 + #define FS_QUOTA_UDQ_ENFD (1<<1) /* user quota limits enforcement */ 126 + #define FS_QUOTA_GDQ_ACCT (1<<2) /* group quota accounting */ 127 + #define FS_QUOTA_GDQ_ENFD (1<<3) /* group quota limits enforcement */ 128 + #define FS_QUOTA_PDQ_ACCT (1<<4) /* project quota accounting */ 129 + #define FS_QUOTA_PDQ_ENFD (1<<5) /* project quota limits enforcement */ 130 130 131 - #define XFS_USER_QUOTA (1<<0) /* user quota type */ 132 - #define XFS_PROJ_QUOTA (1<<1) /* project quota type */ 133 - #define XFS_GROUP_QUOTA (1<<2) /* group quota type */ 131 + #define FS_USER_QUOTA (1<<0) /* user quota type */ 132 + #define FS_PROJ_QUOTA (1<<1) /* project quota type */ 133 + #define FS_GROUP_QUOTA (1<<2) /* group quota type */ 134 134 135 135 /* 136 136 * fs_quota_stat is the struct returned in Q_XGETQSTAT for a given file system. ··· 151 151 152 152 typedef struct fs_quota_stat { 153 153 __s8 qs_version; /* version number for future changes */ 154 - __u16 qs_flags; /* XFS_QUOTA_{U,P,G}DQ_{ACCT,ENFD} */ 154 + __u16 qs_flags; /* FS_QUOTA_{U,P,G}DQ_{ACCT,ENFD} */ 155 155 __s8 qs_pad; /* unused */ 156 156 fs_qfilestat_t qs_uquota; /* user quota storage information */ 157 157 fs_qfilestat_t qs_gquota; /* group quota storage information */