1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2008, Christoph Hellwig 4 * All Rights Reserved. 5 */ 6 #include "xfs.h" 7 #include "xfs_format.h" 8 #include "xfs_log_format.h" 9 #include "xfs_trans_resv.h" 10 #include "xfs_mount.h" 11 #include "xfs_inode.h" 12 #include "xfs_quota.h" 13 #include "xfs_trans.h" 14 #include "xfs_trace.h" 15 #include "xfs_icache.h" 16 #include "xfs_qm.h" 17 #include <linux/quota.h> 18 19 20 static void 21 xfs_qm_fill_state( 22 struct qc_type_state *tstate, 23 struct xfs_mount *mp, 24 struct xfs_inode *ip, 25 xfs_ino_t ino) 26 { 27 struct xfs_quotainfo *q = mp->m_quotainfo; 28 bool tempqip = false; 29 30 tstate->ino = ino; 31 if (!ip && ino == NULLFSINO) 32 return; 33 if (!ip) { 34 if (xfs_iget(mp, NULL, ino, 0, 0, &ip)) 35 return; 36 tempqip = true; 37 } 38 tstate->flags |= QCI_SYSFILE; 39 tstate->blocks = ip->i_d.di_nblocks; 40 tstate->nextents = ip->i_d.di_nextents; 41 tstate->spc_timelimit = q->qi_btimelimit; 42 tstate->ino_timelimit = q->qi_itimelimit; 43 tstate->rt_spc_timelimit = q->qi_rtbtimelimit; 44 tstate->spc_warnlimit = q->qi_bwarnlimit; 45 tstate->ino_warnlimit = q->qi_iwarnlimit; 46 tstate->rt_spc_warnlimit = q->qi_rtbwarnlimit; 47 if (tempqip) 48 xfs_irele(ip); 49 } 50 51 /* 52 * Return quota status information, such as enforcements, quota file inode 53 * numbers etc. 54 */ 55 static int 56 xfs_fs_get_quota_state( 57 struct super_block *sb, 58 struct qc_state *state) 59 { 60 struct xfs_mount *mp = XFS_M(sb); 61 struct xfs_quotainfo *q = mp->m_quotainfo; 62 63 memset(state, 0, sizeof(*state)); 64 if (!XFS_IS_QUOTA_RUNNING(mp)) 65 return 0; 66 state->s_incoredqs = q->qi_dquots; 67 if (XFS_IS_UQUOTA_RUNNING(mp)) 68 state->s_state[USRQUOTA].flags |= QCI_ACCT_ENABLED; 69 if (XFS_IS_UQUOTA_ENFORCED(mp)) 70 state->s_state[USRQUOTA].flags |= QCI_LIMITS_ENFORCED; 71 if (XFS_IS_GQUOTA_RUNNING(mp)) 72 state->s_state[GRPQUOTA].flags |= QCI_ACCT_ENABLED; 73 if (XFS_IS_GQUOTA_ENFORCED(mp)) 74 state->s_state[GRPQUOTA].flags |= QCI_LIMITS_ENFORCED; 75 if (XFS_IS_PQUOTA_RUNNING(mp)) 76 state->s_state[PRJQUOTA].flags |= QCI_ACCT_ENABLED; 77 if (XFS_IS_PQUOTA_ENFORCED(mp)) 78 state->s_state[PRJQUOTA].flags |= QCI_LIMITS_ENFORCED; 79 80 xfs_qm_fill_state(&state->s_state[USRQUOTA], mp, q->qi_uquotaip, 81 mp->m_sb.sb_uquotino); 82 xfs_qm_fill_state(&state->s_state[GRPQUOTA], mp, q->qi_gquotaip, 83 mp->m_sb.sb_gquotino); 84 xfs_qm_fill_state(&state->s_state[PRJQUOTA], mp, q->qi_pquotaip, 85 mp->m_sb.sb_pquotino); 86 return 0; 87 } 88 89 STATIC int 90 xfs_quota_type(int type) 91 { 92 switch (type) { 93 case USRQUOTA: 94 return XFS_DQ_USER; 95 case GRPQUOTA: 96 return XFS_DQ_GROUP; 97 default: 98 return XFS_DQ_PROJ; 99 } 100 } 101 102 #define XFS_QC_SETINFO_MASK (QC_TIMER_MASK | QC_WARNS_MASK) 103 104 /* 105 * Adjust quota timers & warnings 106 */ 107 static int 108 xfs_fs_set_info( 109 struct super_block *sb, 110 int type, 111 struct qc_info *info) 112 { 113 struct xfs_mount *mp = XFS_M(sb); 114 struct qc_dqblk newlim; 115 116 if (sb_rdonly(sb)) 117 return -EROFS; 118 if (!XFS_IS_QUOTA_RUNNING(mp)) 119 return -ENOSYS; 120 if (!XFS_IS_QUOTA_ON(mp)) 121 return -ESRCH; 122 if (info->i_fieldmask & ~XFS_QC_SETINFO_MASK) 123 return -EINVAL; 124 if ((info->i_fieldmask & XFS_QC_SETINFO_MASK) == 0) 125 return 0; 126 127 newlim.d_fieldmask = info->i_fieldmask; 128 newlim.d_spc_timer = info->i_spc_timelimit; 129 newlim.d_ino_timer = info->i_ino_timelimit; 130 newlim.d_rt_spc_timer = info->i_rt_spc_timelimit; 131 newlim.d_ino_warns = info->i_ino_warnlimit; 132 newlim.d_spc_warns = info->i_spc_warnlimit; 133 newlim.d_rt_spc_warns = info->i_rt_spc_warnlimit; 134 135 return xfs_qm_scall_setqlim(mp, 0, xfs_quota_type(type), &newlim); 136 } 137 138 static unsigned int 139 xfs_quota_flags(unsigned int uflags) 140 { 141 unsigned int flags = 0; 142 143 if (uflags & FS_QUOTA_UDQ_ACCT) 144 flags |= XFS_UQUOTA_ACCT; 145 if (uflags & FS_QUOTA_PDQ_ACCT) 146 flags |= XFS_PQUOTA_ACCT; 147 if (uflags & FS_QUOTA_GDQ_ACCT) 148 flags |= XFS_GQUOTA_ACCT; 149 if (uflags & FS_QUOTA_UDQ_ENFD) 150 flags |= XFS_UQUOTA_ENFD; 151 if (uflags & FS_QUOTA_GDQ_ENFD) 152 flags |= XFS_GQUOTA_ENFD; 153 if (uflags & FS_QUOTA_PDQ_ENFD) 154 flags |= XFS_PQUOTA_ENFD; 155 156 return flags; 157 } 158 159 STATIC int 160 xfs_quota_enable( 161 struct super_block *sb, 162 unsigned int uflags) 163 { 164 struct xfs_mount *mp = XFS_M(sb); 165 166 if (sb_rdonly(sb)) 167 return -EROFS; 168 if (!XFS_IS_QUOTA_RUNNING(mp)) 169 return -ENOSYS; 170 171 return xfs_qm_scall_quotaon(mp, xfs_quota_flags(uflags)); 172 } 173 174 STATIC int 175 xfs_quota_disable( 176 struct super_block *sb, 177 unsigned int uflags) 178 { 179 struct xfs_mount *mp = XFS_M(sb); 180 181 if (sb_rdonly(sb)) 182 return -EROFS; 183 if (!XFS_IS_QUOTA_RUNNING(mp)) 184 return -ENOSYS; 185 if (!XFS_IS_QUOTA_ON(mp)) 186 return -EINVAL; 187 188 return xfs_qm_scall_quotaoff(mp, xfs_quota_flags(uflags)); 189 } 190 191 STATIC int 192 xfs_fs_rm_xquota( 193 struct super_block *sb, 194 unsigned int uflags) 195 { 196 struct xfs_mount *mp = XFS_M(sb); 197 unsigned int flags = 0; 198 199 if (sb_rdonly(sb)) 200 return -EROFS; 201 202 if (XFS_IS_QUOTA_ON(mp)) 203 return -EINVAL; 204 205 if (uflags & FS_USER_QUOTA) 206 flags |= XFS_DQ_USER; 207 if (uflags & FS_GROUP_QUOTA) 208 flags |= XFS_DQ_GROUP; 209 if (uflags & FS_PROJ_QUOTA) 210 flags |= XFS_DQ_PROJ; 211 212 return xfs_qm_scall_trunc_qfiles(mp, flags); 213 } 214 215 STATIC int 216 xfs_fs_get_dqblk( 217 struct super_block *sb, 218 struct kqid qid, 219 struct qc_dqblk *qdq) 220 { 221 struct xfs_mount *mp = XFS_M(sb); 222 xfs_dqid_t id; 223 224 if (!XFS_IS_QUOTA_RUNNING(mp)) 225 return -ENOSYS; 226 if (!XFS_IS_QUOTA_ON(mp)) 227 return -ESRCH; 228 229 id = from_kqid(&init_user_ns, qid); 230 return xfs_qm_scall_getquota(mp, id, xfs_quota_type(qid.type), qdq); 231 } 232 233 /* Return quota info for active quota >= this qid */ 234 STATIC int 235 xfs_fs_get_nextdqblk( 236 struct super_block *sb, 237 struct kqid *qid, 238 struct qc_dqblk *qdq) 239 { 240 int ret; 241 struct xfs_mount *mp = XFS_M(sb); 242 xfs_dqid_t id; 243 244 if (!XFS_IS_QUOTA_RUNNING(mp)) 245 return -ENOSYS; 246 if (!XFS_IS_QUOTA_ON(mp)) 247 return -ESRCH; 248 249 id = from_kqid(&init_user_ns, *qid); 250 ret = xfs_qm_scall_getquota_next(mp, &id, xfs_quota_type(qid->type), 251 qdq); 252 if (ret) 253 return ret; 254 255 /* ID may be different, so convert back what we got */ 256 *qid = make_kqid(current_user_ns(), qid->type, id); 257 return 0; 258 } 259 260 STATIC int 261 xfs_fs_set_dqblk( 262 struct super_block *sb, 263 struct kqid qid, 264 struct qc_dqblk *qdq) 265 { 266 struct xfs_mount *mp = XFS_M(sb); 267 268 if (sb_rdonly(sb)) 269 return -EROFS; 270 if (!XFS_IS_QUOTA_RUNNING(mp)) 271 return -ENOSYS; 272 if (!XFS_IS_QUOTA_ON(mp)) 273 return -ESRCH; 274 275 return xfs_qm_scall_setqlim(mp, from_kqid(&init_user_ns, qid), 276 xfs_quota_type(qid.type), qdq); 277 } 278 279 const struct quotactl_ops xfs_quotactl_operations = { 280 .get_state = xfs_fs_get_quota_state, 281 .set_info = xfs_fs_set_info, 282 .quota_enable = xfs_quota_enable, 283 .quota_disable = xfs_quota_disable, 284 .rm_xquota = xfs_fs_rm_xquota, 285 .get_dqblk = xfs_fs_get_dqblk, 286 .get_nextdqblk = xfs_fs_get_nextdqblk, 287 .set_dqblk = xfs_fs_set_dqblk, 288 }; 289