fs/xfs/xfs_quotaops.c

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