fs/xfs/quota/xfs_qm_bhv.c

   1 /*
   2  * Copyright (c) 2000-2004 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_inum.h"
  36 #include "xfs_log.h"
  37 #include "xfs_clnt.h"
  38 #include "xfs_trans.h"
  39 #include "xfs_sb.h"
  40 #include "xfs_dir.h"
  41 #include "xfs_dir2.h"
  42 #include "xfs_alloc.h"
  43 #include "xfs_dmapi.h"
  44 #include "xfs_quota.h"
  45 #include "xfs_mount.h"
  46 #include "xfs_alloc_btree.h"
  47 #include "xfs_bmap_btree.h"
  48 #include "xfs_ialloc_btree.h"
  49 #include "xfs_btree.h"
  50 #include "xfs_ialloc.h"
  51 #include "xfs_attr_sf.h"
  52 #include "xfs_dir_sf.h"
  53 #include "xfs_dir2_sf.h"
  54 #include "xfs_dinode.h"
  55 #include "xfs_inode.h"
  56 #include "xfs_bmap.h"
  57 #include "xfs_bit.h"
  58 #include "xfs_rtalloc.h"
  59 #include "xfs_error.h"
  60 #include "xfs_itable.h"
  61 #include "xfs_rw.h"
  62 #include "xfs_acl.h"
  63 #include "xfs_cap.h"
  64 #include "xfs_mac.h"
  65 #include "xfs_attr.h"
  66 #include "xfs_buf_item.h"
  67
  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_UQUOTA   "uquota"        /* user quota (IRIX variant) */
  75 #define MNTOPT_GQUOTA   "gquota"        /* group quota (IRIX variant) */
  76 #define MNTOPT_UQUOTANOENF "uqnoenforce"/* user quota limit enforcement */
  77 #define MNTOPT_GQUOTANOENF "gqnoenforce"/* group quota limit enforcement */
  78 #define MNTOPT_QUOTANOENF  "qnoenforce" /* same as uqnoenforce */
  79
  80 STATIC int
  81 xfs_qm_parseargs(
  82         struct bhv_desc         *bhv,
  83         char                    *options,
  84         struct xfs_mount_args   *args,
  85         int                     update)
  86 {
  87         size_t                  length;
  88         char                    *local_options = options;
  89         char                    *this_char;
  90         int                     error;
  91         int                     referenced = update;
  92
  93         while ((this_char = strsep(&local_options, ",")) != NULL) {
  94                 length = strlen(this_char);
  95                 if (local_options)
  96                         length++;
  97
  98                 if (!strcmp(this_char, MNTOPT_NOQUOTA)) {
  99                         args->flags &= ~(XFSMNT_UQUOTAENF|XFSMNT_UQUOTA);
 100                         args->flags &= ~(XFSMNT_GQUOTAENF|XFSMNT_GQUOTA);
 101                         referenced = update;
 102                 } else if (!strcmp(this_char, MNTOPT_QUOTA) ||
 103                            !strcmp(this_char, MNTOPT_UQUOTA) ||
 104                            !strcmp(this_char, MNTOPT_USRQUOTA)) {
 105                         args->flags |= XFSMNT_UQUOTA | XFSMNT_UQUOTAENF;
 106                         referenced = 1;
 107                 } else if (!strcmp(this_char, MNTOPT_QUOTANOENF) ||
 108                            !strcmp(this_char, MNTOPT_UQUOTANOENF)) {
 109                         args->flags |= XFSMNT_UQUOTA;
 110                         args->flags &= ~XFSMNT_UQUOTAENF;
 111                         referenced = 1;
 112                 } else if (!strcmp(this_char, MNTOPT_GQUOTA) ||
 113                            !strcmp(this_char, MNTOPT_GRPQUOTA)) {
 114                         args->flags |= XFSMNT_GQUOTA | XFSMNT_GQUOTAENF;
 115                         referenced = 1;
 116                 } else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) {
 117                         args->flags |= XFSMNT_GQUOTA;
 118                         args->flags &= ~XFSMNT_GQUOTAENF;
 119                         referenced = 1;
 120                 } else {
 121                         if (local_options)
 122                                 *(local_options-1) = ',';
 123                         continue;
 124                 }
 125
 126                 while (length--)
 127                         *this_char++ = ',';
 128         }
 129
 130         PVFS_PARSEARGS(BHV_NEXT(bhv), options, args, update, error);
 131         if (!error && !referenced)
 132                 bhv_remove_vfsops(bhvtovfs(bhv), VFS_POSITION_QM);
 133         return error;
 134 }
 135
 136 STATIC int
 137 xfs_qm_showargs(
 138         struct bhv_desc         *bhv,
 139         struct seq_file         *m)
 140 {
 141         struct vfs              *vfsp = bhvtovfs(bhv);
 142         struct xfs_mount        *mp = XFS_VFSTOM(vfsp);
 143         int                     error;
 144
 145         if (mp->m_qflags & XFS_UQUOTA_ACCT) {
 146                 (mp->m_qflags & XFS_UQUOTA_ENFD) ?
 147                         seq_puts(m, "," MNTOPT_USRQUOTA) :
 148                         seq_puts(m, "," MNTOPT_UQUOTANOENF);
 149         }
 150
 151         if (mp->m_qflags & XFS_GQUOTA_ACCT) {
 152                 (mp->m_qflags & XFS_GQUOTA_ENFD) ?
 153                         seq_puts(m, "," MNTOPT_GRPQUOTA) :
 154                         seq_puts(m, "," MNTOPT_GQUOTANOENF);
 155         }
 156
 157         if (!(mp->m_qflags & (XFS_UQUOTA_ACCT|XFS_GQUOTA_ACCT)))
 158                 seq_puts(m, "," MNTOPT_NOQUOTA);
 159
 160         PVFS_SHOWARGS(BHV_NEXT(bhv), m, error);
 161         return error;
 162 }
 163
 164 STATIC int
 165 xfs_qm_mount(
 166         struct bhv_desc         *bhv,
 167         struct xfs_mount_args   *args,
 168         struct cred             *cr)
 169 {
 170         struct vfs              *vfsp = bhvtovfs(bhv);
 171         struct xfs_mount        *mp = XFS_VFSTOM(vfsp);
 172         int                     error;
 173
 174         if (args->flags & (XFSMNT_UQUOTA | XFSMNT_GQUOTA))
 175                 xfs_qm_mount_quotainit(mp, args->flags);
 176         PVFS_MOUNT(BHV_NEXT(bhv), args, cr, error);
 177         return error;
 178 }
 179
 180 STATIC int
 181 xfs_qm_syncall(
 182         struct bhv_desc         *bhv,
 183         int                     flags,
 184         cred_t                  *credp)
 185 {
 186         struct vfs              *vfsp = bhvtovfs(bhv);
 187         struct xfs_mount        *mp = XFS_VFSTOM(vfsp);
 188         int                     error;
 189
 190         /*
 191          * Get the Quota Manager to flush the dquots.
 192          */
 193         if (XFS_IS_QUOTA_ON(mp)) {
 194                 if ((error = xfs_qm_sync(mp, flags))) {
 195                         /*
 196                          * If we got an IO error, we will be shutting down.
 197                          * So, there's nothing more for us to do here.
 198                          */
 199                         ASSERT(error != EIO || XFS_FORCED_SHUTDOWN(mp));
 200                         if (XFS_FORCED_SHUTDOWN(mp)) {
 201                                 return XFS_ERROR(error);
 202                         }
 203                 }
 204         }
 205         PVFS_SYNC(BHV_NEXT(bhv), flags, credp, error);
 206         return error;
 207 }
 208
 209 /*
 210  * Clear the quotaflags in memory and in the superblock.
 211  */
 212 void
 213 xfs_mount_reset_sbqflags(
 214         xfs_mount_t             *mp)
 215 {
 216         xfs_trans_t             *tp;
 217         unsigned long           s;
 218
 219         mp->m_qflags = 0;
 220         /*
 221          * It is OK to look at sb_qflags here in mount path,
 222          * without SB_LOCK.
 223          */
 224         if (mp->m_sb.sb_qflags == 0)
 225                 return;
 226         s = XFS_SB_LOCK(mp);
 227         mp->m_sb.sb_qflags = 0;
 228         XFS_SB_UNLOCK(mp, s);
 229
 230         /*
 231          * if the fs is readonly, let the incore superblock run
 232          * with quotas off but don't flush the update out to disk
 233          */
 234         if (XFS_MTOVFS(mp)->vfs_flag & VFS_RDONLY)
 235                 return;
 236 #ifdef QUOTADEBUG
 237         xfs_fs_cmn_err(CE_NOTE, mp, "Writing superblock quota changes");
 238 #endif
 239         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
 240         if (xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
 241                                       XFS_DEFAULT_LOG_COUNT)) {
 242                 xfs_trans_cancel(tp, 0);
 243                 xfs_fs_cmn_err(CE_ALERT, mp,
 244                         "xfs_mount_reset_sbqflags: Superblock update failed!");
 245                 return;
 246         }
 247         xfs_mod_sb(tp, XFS_SB_QFLAGS);
 248         xfs_trans_commit(tp, 0, NULL);
 249 }
 250
 251 STATIC int
 252 xfs_qm_newmount(
 253         xfs_mount_t     *mp,
 254         uint            *needquotamount,
 255         uint            *quotaflags)
 256 {
 257         uint            quotaondisk;
 258         uint            uquotaondisk = 0, gquotaondisk = 0;
 259
 260         *quotaflags = 0;
 261         *needquotamount = B_FALSE;
 262
 263         quotaondisk = XFS_SB_VERSION_HASQUOTA(&mp->m_sb) &&
 264                 mp->m_sb.sb_qflags & (XFS_UQUOTA_ACCT|XFS_GQUOTA_ACCT);
 265
 266         if (quotaondisk) {
 267                 uquotaondisk = mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT;
 268                 gquotaondisk = mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT;
 269         }
 270
 271         /*
 272          * If the device itself is read-only, we can't allow
 273          * the user to change the state of quota on the mount -
 274          * this would generate a transaction on the ro device,
 275          * which would lead to an I/O error and shutdown
 276          */
 277
 278         if (((uquotaondisk && !XFS_IS_UQUOTA_ON(mp)) ||
 279             (!uquotaondisk &&  XFS_IS_UQUOTA_ON(mp)) ||
 280              (gquotaondisk && !XFS_IS_GQUOTA_ON(mp)) ||
 281             (!gquotaondisk &&  XFS_IS_GQUOTA_ON(mp)))  &&
 282             xfs_dev_is_read_only(mp, "changing quota state")) {
 283                 cmn_err(CE_WARN,
 284                         "XFS: please mount with%s%s%s.",
 285                         (!quotaondisk ? "out quota" : ""),
 286                         (uquotaondisk ? " usrquota" : ""),
 287                         (gquotaondisk ? " grpquota" : ""));
 288                 return XFS_ERROR(EPERM);
 289         }
 290
 291         if (XFS_IS_QUOTA_ON(mp) || quotaondisk) {
 292                 /*
 293                  * Call mount_quotas at this point only if we won't have to do
 294                  * a quotacheck.
 295                  */
 296                 if (quotaondisk && !XFS_QM_NEED_QUOTACHECK(mp)) {
 297                         /*
 298                          * If an error occured, qm_mount_quotas code
 299                          * has already disabled quotas. So, just finish
 300                          * mounting, and get on with the boring life
 301                          * without disk quotas.
 302                          */
 303                         xfs_qm_mount_quotas(mp, 0);
 304                 } else {
 305                         /*
 306                          * Clear the quota flags, but remember them. This
 307                          * is so that the quota code doesn't get invoked
 308                          * before we're ready. This can happen when an
 309                          * inode goes inactive and wants to free blocks,
 310                          * or via xfs_log_mount_finish.
 311                          */
 312                         *needquotamount = B_TRUE;
 313                         *quotaflags = mp->m_qflags;
 314                         mp->m_qflags = 0;
 315                 }
 316         }
 317
 318         return 0;
 319 }
 320
 321 STATIC int
 322 xfs_qm_endmount(
 323         xfs_mount_t     *mp,
 324         uint            needquotamount,
 325         uint            quotaflags,
 326         int             mfsi_flags)
 327 {
 328         if (needquotamount) {
 329                 ASSERT(mp->m_qflags == 0);
 330                 mp->m_qflags = quotaflags;
 331                 xfs_qm_mount_quotas(mp, mfsi_flags);
 332         }
 333
 334 #if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
 335         if (! (XFS_IS_QUOTA_ON(mp)))
 336                 xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas not turned on");
 337         else
 338                 xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas turned on");
 339 #endif
 340
 341 #ifdef QUOTADEBUG
 342         if (XFS_IS_QUOTA_ON(mp) && xfs_qm_internalqcheck(mp))
 343                 cmn_err(CE_WARN, "XFS: mount internalqcheck failed");
 344 #endif
 345
 346         return 0;
 347 }
 348
 349 STATIC void
 350 xfs_qm_dqrele_null(
 351         xfs_dquot_t     *dq)
 352 {
 353         /*
 354          * Called from XFS, where we always check first for a NULL dquot.
 355          */
 356         if (!dq)
 357                 return;
 358         xfs_qm_dqrele(dq);
 359 }
 360
 361
 362 struct xfs_qmops xfs_qmcore_xfs = {
 363         .xfs_qminit             = xfs_qm_newmount,
 364         .xfs_qmdone             = xfs_qm_unmount_quotadestroy,
 365         .xfs_qmmount            = xfs_qm_endmount,
 366         .xfs_qmunmount          = xfs_qm_unmount_quotas,
 367         .xfs_dqrele             = xfs_qm_dqrele_null,
 368         .xfs_dqattach           = xfs_qm_dqattach,
 369         .xfs_dqdetach           = xfs_qm_dqdetach,
 370         .xfs_dqpurgeall         = xfs_qm_dqpurge_all,
 371         .xfs_dqvopalloc         = xfs_qm_vop_dqalloc,
 372         .xfs_dqvopcreate        = xfs_qm_vop_dqattach_and_dqmod_newinode,
 373         .xfs_dqvoprename        = xfs_qm_vop_rename_dqattach,
 374         .xfs_dqvopchown         = xfs_qm_vop_chown,
 375         .xfs_dqvopchownresv     = xfs_qm_vop_chown_reserve,
 376         .xfs_dqtrxops           = &xfs_trans_dquot_ops,
 377 };
 378
 379 struct bhv_vfsops xfs_qmops = { {
 380         BHV_IDENTITY_INIT(VFS_BHV_QM, VFS_POSITION_QM),
 381         .vfs_parseargs          = xfs_qm_parseargs,
 382         .vfs_showargs           = xfs_qm_showargs,
 383         .vfs_mount              = xfs_qm_mount,
 384         .vfs_sync               = xfs_qm_syncall,
 385         .vfs_quotactl           = xfs_qm_quotactl, },
 386 };
 387
 388
 389 void __init
 390 xfs_qm_init(void)
 391 {
 392         static char     message[] __initdata =
 393                 KERN_INFO "SGI XFS Quota Management subsystem\n";
 394
 395         printk(message);
 396         mutex_init(&xfs_Gqm_lock, MUTEX_DEFAULT, "xfs_qmlock");
 397         vfs_bhv_set_custom(&xfs_qmops, &xfs_qmcore_xfs);
 398         xfs_qm_init_procfs();
 399 }
 400
 401 void __exit
 402 xfs_qm_exit(void)
 403 {
 404         vfs_bhv_clr_custom(&xfs_qmops);
 405         xfs_qm_cleanup_procfs();
 406         if (qm_dqzone)
 407                 kmem_cache_destroy(qm_dqzone);
 408         if (qm_dqtrxzone)
 409                 kmem_cache_destroy(qm_dqtrxzone);
 410 }