fs/xfs/quota/xfs_qm_bhv.c

   1 /*
   2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.  All Rights Reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of version 2 of the GNU General Public License as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it would be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11  *
  12  * Further, this software is distributed without any warranty that it is
  13  * free of the rightful claim of any third person regarding infringement
  14  * or the like.  Any license provided herein, whether implied or
  15  * otherwise, applies only to this software file.  Patent licenses, if
  16  * any, provided herein do not apply to combinations of this program with
  17  * other software, or any other product whatsoever.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with this program; if not, write the Free Software Foundation, Inc., 59
  21  * Temple Place - Suite 330, Boston MA 02111-1307, USA.
  22  *
  23  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
  24  * Mountain View, CA  94043, or:
  25  *
  26  * http://www.sgi.com
  27  *
  28  * For further information regarding this notice, see:
  29  *
  30  * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
  31  */
  32
  33 #include "xfs.h"
  34 #include "xfs_fs.h"
  35 #include "xfs_bit.h"
  36 #include "xfs_log.h"
  37 #include "xfs_inum.h"
  38 #include "xfs_clnt.h"
  39 #include "xfs_trans.h"
  40 #include "xfs_sb.h"
  41 #include "xfs_ag.h"
  42 #include "xfs_dir.h"
  43 #include "xfs_dir2.h"
  44 #include "xfs_alloc.h"
  45 #include "xfs_dmapi.h"
  46 #include "xfs_quota.h"
  47 #include "xfs_mount.h"
  48 #include "xfs_bmap_btree.h"
  49 #include "xfs_alloc_btree.h"
  50 #include "xfs_ialloc_btree.h"
  51 #include "xfs_dir_sf.h"
  52 #include "xfs_dir2_sf.h"
  53 #include "xfs_attr_sf.h"
  54 #include "xfs_dinode.h"
  55 #include "xfs_inode.h"
  56 #include "xfs_ialloc.h"
  57 #include "xfs_itable.h"
  58 #include "xfs_btree.h"
  59 #include "xfs_bmap.h"
  60 #include "xfs_rtalloc.h"
  61 #include "xfs_error.h"
  62 #include "xfs_rw.h"
  63 #include "xfs_acl.h"
  64 #include "xfs_cap.h"
  65 #include "xfs_mac.h"
  66 #include "xfs_attr.h"
  67 #include "xfs_buf_item.h"
  68 #include "xfs_qm.h"
  69
  70 #define MNTOPT_QUOTA    "quota"         /* disk quotas (user) */
  71 #define MNTOPT_NOQUOTA  "noquota"       /* no quotas */
  72 #define MNTOPT_USRQUOTA "usrquota"      /* user quota enabled */
  73 #define MNTOPT_GRPQUOTA "grpquota"      /* group quota enabled */
  74 #define MNTOPT_PRJQUOTA "prjquota"      /* project quota enabled */
  75 #define MNTOPT_UQUOTA   "uquota"        /* user quota (IRIX variant) */
  76 #define MNTOPT_GQUOTA   "gquota"        /* group quota (IRIX variant) */
  77 #define MNTOPT_PQUOTA   "pquota"        /* project quota (IRIX variant) */
  78 #define MNTOPT_UQUOTANOENF "uqnoenforce"/* user quota limit enforcement */
  79 #define MNTOPT_GQUOTANOENF "gqnoenforce"/* group quota limit enforcement */
  80 #define MNTOPT_PQUOTANOENF "pqnoenforce"/* project quota limit enforcement */
  81 #define MNTOPT_QUOTANOENF  "qnoenforce" /* same as uqnoenforce */
  82
  83 STATIC int
  84 xfs_qm_parseargs(
  85         struct bhv_desc         *bhv,
  86         char                    *options,
  87         struct xfs_mount_args   *args,
  88         int                     update)
  89 {
  90         size_t                  length;
  91         char                    *local_options = options;
  92         char                    *this_char;
  93         int                     error;
  94         int                     referenced = update;
  95
  96         while ((this_char = strsep(&local_options, ",")) != NULL) {
  97                 length = strlen(this_char);
  98                 if (local_options)
  99                         length++;
 100
 101                 if (!strcmp(this_char, MNTOPT_NOQUOTA)) {
 102                         args->flags &= ~(XFSMNT_UQUOTAENF|XFSMNT_UQUOTA);
 103                         args->flags &= ~(XFSMNT_GQUOTAENF|XFSMNT_GQUOTA);
 104                         referenced = update;
 105                 } else if (!strcmp(this_char, MNTOPT_QUOTA) ||
 106                            !strcmp(this_char, MNTOPT_UQUOTA) ||
 107                            !strcmp(this_char, MNTOPT_USRQUOTA)) {
 108                         args->flags |= XFSMNT_UQUOTA | XFSMNT_UQUOTAENF;
 109                         referenced = 1;
 110                 } else if (!strcmp(this_char, MNTOPT_QUOTANOENF) ||
 111                            !strcmp(this_char, MNTOPT_UQUOTANOENF)) {
 112                         args->flags |= XFSMNT_UQUOTA;
 113                         args->flags &= ~XFSMNT_UQUOTAENF;
 114                         referenced = 1;
 115                 } else if (!strcmp(this_char, MNTOPT_PQUOTA) ||
 116                            !strcmp(this_char, MNTOPT_PRJQUOTA)) {
 117                         args->flags |= XFSMNT_PQUOTA | XFSMNT_PQUOTAENF;
 118                         referenced = 1;
 119                 } else if (!strcmp(this_char, MNTOPT_PQUOTANOENF)) {
 120                         args->flags |= XFSMNT_PQUOTA;
 121                         args->flags &= ~XFSMNT_PQUOTAENF;
 122                         referenced = 1;
 123                 } else if (!strcmp(this_char, MNTOPT_GQUOTA) ||
 124                            !strcmp(this_char, MNTOPT_GRPQUOTA)) {
 125                         args->flags |= XFSMNT_GQUOTA | XFSMNT_GQUOTAENF;
 126                         referenced = 1;
 127                 } else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) {
 128                         args->flags |= XFSMNT_GQUOTA;
 129                         args->flags &= ~XFSMNT_GQUOTAENF;
 130                         referenced = 1;
 131                 } else {
 132                         if (local_options)
 133                                 *(local_options-1) = ',';
 134                         continue;
 135                 }
 136
 137                 while (length--)
 138                         *this_char++ = ',';
 139         }
 140
 141         if ((args->flags & XFSMNT_GQUOTA) && (args->flags & XFSMNT_PQUOTA)) {
 142                 cmn_err(CE_WARN,
 143                         "XFS: cannot mount with both project and group quota");
 144                 return XFS_ERROR(EINVAL);
 145         }
 146
 147         PVFS_PARSEARGS(BHV_NEXT(bhv), options, args, update, error);
 148         if (!error && !referenced)
 149                 bhv_remove_vfsops(bhvtovfs(bhv), VFS_POSITION_QM);
 150         return error;
 151 }
 152
 153 STATIC int
 154 xfs_qm_showargs(
 155         struct bhv_desc         *bhv,
 156         struct seq_file         *m)
 157 {
 158         struct vfs              *vfsp = bhvtovfs(bhv);
 159         struct xfs_mount        *mp = XFS_VFSTOM(vfsp);
 160         int                     error;
 161
 162         if (mp->m_qflags & XFS_UQUOTA_ACCT) {
 163                 (mp->m_qflags & XFS_UQUOTA_ENFD) ?
 164                         seq_puts(m, "," MNTOPT_USRQUOTA) :
 165                         seq_puts(m, "," MNTOPT_UQUOTANOENF);
 166         }
 167
 168         if (mp->m_qflags & XFS_PQUOTA_ACCT) {
 169                 (mp->m_qflags & XFS_OQUOTA_ENFD) ?
 170                         seq_puts(m, "," MNTOPT_PRJQUOTA) :
 171                         seq_puts(m, "," MNTOPT_PQUOTANOENF);
 172         }
 173
 174         if (mp->m_qflags & XFS_GQUOTA_ACCT) {
 175                 (mp->m_qflags & XFS_OQUOTA_ENFD) ?
 176                         seq_puts(m, "," MNTOPT_GRPQUOTA) :
 177                         seq_puts(m, "," MNTOPT_GQUOTANOENF);
 178         }
 179
 180         if (!(mp->m_qflags & XFS_ALL_QUOTA_ACCT))
 181                 seq_puts(m, "," MNTOPT_NOQUOTA);
 182
 183         PVFS_SHOWARGS(BHV_NEXT(bhv), m, error);
 184         return error;
 185 }
 186
 187 STATIC int
 188 xfs_qm_mount(
 189         struct bhv_desc         *bhv,
 190         struct xfs_mount_args   *args,
 191         struct cred             *cr)
 192 {
 193         struct vfs              *vfsp = bhvtovfs(bhv);
 194         struct xfs_mount        *mp = XFS_VFSTOM(vfsp);
 195         int                     error;
 196
 197         if (args->flags & (XFSMNT_UQUOTA | XFSMNT_GQUOTA | XFSMNT_PQUOTA))
 198                 xfs_qm_mount_quotainit(mp, args->flags);
 199         PVFS_MOUNT(BHV_NEXT(bhv), args, cr, error);
 200         return error;
 201 }
 202
 203 STATIC int
 204 xfs_qm_syncall(
 205         struct bhv_desc         *bhv,
 206         int                     flags,
 207         cred_t                  *credp)
 208 {
 209         struct vfs              *vfsp = bhvtovfs(bhv);
 210         struct xfs_mount        *mp = XFS_VFSTOM(vfsp);
 211         int                     error;
 212
 213         /*
 214          * Get the Quota Manager to flush the dquots.
 215          */
 216         if (XFS_IS_QUOTA_ON(mp)) {
 217                 if ((error = xfs_qm_sync(mp, flags))) {
 218                         /*
 219                          * If we got an IO error, we will be shutting down.
 220                          * So, there's nothing more for us to do here.
 221                          */
 222                         ASSERT(error != EIO || XFS_FORCED_SHUTDOWN(mp));
 223                         if (XFS_FORCED_SHUTDOWN(mp)) {
 224                                 return XFS_ERROR(error);
 225                         }
 226                 }
 227         }
 228         PVFS_SYNC(BHV_NEXT(bhv), flags, credp, error);
 229         return error;
 230 }
 231
 232 STATIC int
 233 xfs_qm_newmount(
 234         xfs_mount_t     *mp,
 235         uint            *needquotamount,
 236         uint            *quotaflags)
 237 {
 238         uint            quotaondisk;
 239         uint            uquotaondisk = 0, gquotaondisk = 0, pquotaondisk = 0;
 240
 241         *quotaflags = 0;
 242         *needquotamount = B_FALSE;
 243
 244         quotaondisk = XFS_SB_VERSION_HASQUOTA(&mp->m_sb) &&
 245                                 (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT);
 246
 247         if (quotaondisk) {
 248                 uquotaondisk = mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT;
 249                 pquotaondisk = mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT;
 250                 gquotaondisk = mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT;
 251         }
 252
 253         /*
 254          * If the device itself is read-only, we can't allow
 255          * the user to change the state of quota on the mount -
 256          * this would generate a transaction on the ro device,
 257          * which would lead to an I/O error and shutdown
 258          */
 259
 260         if (((uquotaondisk && !XFS_IS_UQUOTA_ON(mp)) ||
 261             (!uquotaondisk &&  XFS_IS_UQUOTA_ON(mp)) ||
 262              (pquotaondisk && !XFS_IS_PQUOTA_ON(mp)) ||
 263             (!pquotaondisk &&  XFS_IS_PQUOTA_ON(mp)) ||
 264              (gquotaondisk && !XFS_IS_GQUOTA_ON(mp)) ||
 265             (!gquotaondisk &&  XFS_IS_OQUOTA_ON(mp)))  &&
 266             xfs_dev_is_read_only(mp, "changing quota state")) {
 267                 cmn_err(CE_WARN,
 268                         "XFS: please mount with%s%s%s%s.",
 269                         (!quotaondisk ? "out quota" : ""),
 270                         (uquotaondisk ? " usrquota" : ""),
 271                         (pquotaondisk ? " prjquota" : ""),
 272                         (gquotaondisk ? " grpquota" : ""));
 273                 return XFS_ERROR(EPERM);
 274         }
 275
 276         if (XFS_IS_QUOTA_ON(mp) || quotaondisk) {
 277                 /*
 278                  * Call mount_quotas at this point only if we won't have to do
 279                  * a quotacheck.
 280                  */
 281                 if (quotaondisk && !XFS_QM_NEED_QUOTACHECK(mp)) {
 282                         /*
 283                          * If an error occured, qm_mount_quotas code
 284                          * has already disabled quotas. So, just finish
 285                          * mounting, and get on with the boring life
 286                          * without disk quotas.
 287                          */
 288                         xfs_qm_mount_quotas(mp, 0);
 289                 } else {
 290                         /*
 291                          * Clear the quota flags, but remember them. This
 292                          * is so that the quota code doesn't get invoked
 293                          * before we're ready. This can happen when an
 294                          * inode goes inactive and wants to free blocks,
 295                          * or via xfs_log_mount_finish.
 296                          */
 297                         *needquotamount = B_TRUE;
 298                         *quotaflags = mp->m_qflags;
 299                         mp->m_qflags = 0;
 300                 }
 301         }
 302
 303         return 0;
 304 }
 305
 306 STATIC int
 307 xfs_qm_endmount(
 308         xfs_mount_t     *mp,
 309         uint            needquotamount,
 310         uint            quotaflags,
 311         int             mfsi_flags)
 312 {
 313         if (needquotamount) {
 314                 ASSERT(mp->m_qflags == 0);
 315                 mp->m_qflags = quotaflags;
 316                 xfs_qm_mount_quotas(mp, mfsi_flags);
 317         }
 318
 319 #if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
 320         if (! (XFS_IS_QUOTA_ON(mp)))
 321                 xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas not turned on");
 322         else
 323                 xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas turned on");
 324 #endif
 325
 326 #ifdef QUOTADEBUG
 327         if (XFS_IS_QUOTA_ON(mp) && xfs_qm_internalqcheck(mp))
 328                 cmn_err(CE_WARN, "XFS: mount internalqcheck failed");
 329 #endif
 330
 331         return 0;
 332 }
 333
 334 STATIC void
 335 xfs_qm_dqrele_null(
 336         xfs_dquot_t     *dq)
 337 {
 338         /*
 339          * Called from XFS, where we always check first for a NULL dquot.
 340          */
 341         if (!dq)
 342                 return;
 343         xfs_qm_dqrele(dq);
 344 }
 345
 346
 347 STATIC struct xfs_qmops xfs_qmcore_xfs = {
 348         .xfs_qminit             = xfs_qm_newmount,
 349         .xfs_qmdone             = xfs_qm_unmount_quotadestroy,
 350         .xfs_qmmount            = xfs_qm_endmount,
 351         .xfs_qmunmount          = xfs_qm_unmount_quotas,
 352         .xfs_dqrele             = xfs_qm_dqrele_null,
 353         .xfs_dqattach           = xfs_qm_dqattach,
 354         .xfs_dqdetach           = xfs_qm_dqdetach,
 355         .xfs_dqpurgeall         = xfs_qm_dqpurge_all,
 356         .xfs_dqvopalloc         = xfs_qm_vop_dqalloc,
 357         .xfs_dqvopcreate        = xfs_qm_vop_dqattach_and_dqmod_newinode,
 358         .xfs_dqvoprename        = xfs_qm_vop_rename_dqattach,
 359         .xfs_dqvopchown         = xfs_qm_vop_chown,
 360         .xfs_dqvopchownresv     = xfs_qm_vop_chown_reserve,
 361         .xfs_dqtrxops           = &xfs_trans_dquot_ops,
 362 };
 363
 364 struct bhv_vfsops xfs_qmops = { {
 365         BHV_IDENTITY_INIT(VFS_BHV_QM, VFS_POSITION_QM),
 366         .vfs_parseargs          = xfs_qm_parseargs,
 367         .vfs_showargs           = xfs_qm_showargs,
 368         .vfs_mount              = xfs_qm_mount,
 369         .vfs_sync               = xfs_qm_syncall,
 370         .vfs_quotactl           = xfs_qm_quotactl, },
 371 };
 372
 373
 374 void __init
 375 xfs_qm_init(void)
 376 {
 377         static char     message[] __initdata =
 378                 KERN_INFO "SGI XFS Quota Management subsystem\n";
 379
 380         printk(message);
 381         mutex_init(&xfs_Gqm_lock, MUTEX_DEFAULT, "xfs_qmlock");
 382         vfs_bhv_set_custom(&xfs_qmops, &xfs_qmcore_xfs);
 383         xfs_qm_init_procfs();
 384 }
 385
 386 void __exit
 387 xfs_qm_exit(void)
 388 {
 389         vfs_bhv_clr_custom(&xfs_qmops);
 390         xfs_qm_cleanup_procfs();
 391         if (qm_dqzone)
 392                 kmem_cache_destroy(qm_dqzone);
 393         if (qm_dqtrxzone)
 394                 kmem_cache_destroy(qm_dqtrxzone);
 395 }