Merge tag 'xfs-for-linus-v3.12-rc1' of git://oss.sgi.com/xfs/xfs

Pull xfs updates from Ben Myers:
 "For 3.12-rc1 there are a number of bugfixes in addition to work to
  ease usage of shared code between libxfs and the kernel, the rest of
  the work to enable project and group quotas to be used simultaneously,
  performance optimisations in the log and the CIL, directory entry file
  type support, fixes for log space reservations, some spelling/grammar
  cleanups, and the addition of user namespace support.

   - introduce readahead to log recovery
   - add directory entry file type support
   - fix a number of spelling errors in comments
   - introduce new Q_XGETQSTATV quotactl for project quotas
   - add USER_NS support
   - log space reservation rework
   - CIL optimisations
  - kernel/userspace libxfs rework"

* tag 'xfs-for-linus-v3.12-rc1' of git://oss.sgi.com/xfs/xfs: (112 commits)
  xfs: XFS_MOUNT_QUOTA_ALL needed by userspace
  xfs: dtype changed xfs_dir2_sfe_put_ino to xfs_dir3_sfe_put_ino
  Fix wrong flag ASSERT in xfs_attr_shortform_getvalue
  xfs: finish removing IOP_* macros.
  xfs: inode log reservations are too small
  xfs: check correct status variable for xfs_inobt_get_rec() call
  xfs: inode buffers may not be valid during recovery readahead
  xfs: check LSN ordering for v5 superblocks during recovery
  xfs: btree block LSN escaping to disk uninitialised
  XFS: Assertion failed: first <= last && last < BBTOB(bp->b_length), file: fs/xfs/xfs_trans_buf.c, line: 568
  xfs: fix bad dquot buffer size in log recovery readahead
  xfs: don't account buffer cancellation during log recovery readahead
  xfs: check for underflow in xfs_iformat_fork()
  xfs: xfs_dir3_sfe_put_ino can be static
  xfs: introduce object readahead to log recovery
  xfs: Simplify xfs_ail_min() with list_first_entry_or_null()
  xfs: Register hotcpu notifier after initialization
  xfs: add xfs sb v4 support for dirent filetype field
  xfs: Add write support for dirent filetype field
  xfs: Add read-only support for dirent filetype field
  ...

1 files changed, 64 insertions, 31 deletions

diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index d320794d03ce..6218a0aeeeea 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -17,6 +17,7 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_format.h"
 #include "xfs_bit.h"
 #include "xfs_log.h"
 #include "xfs_trans.h"
@@ -37,7 +38,6 @@
 #include "xfs_attr.h"
 #include "xfs_buf_item.h"
 #include "xfs_trans_space.h"
-#include "xfs_utils.h"
 #include "xfs_qm.h"
 #include "xfs_trace.h"
 #include "xfs_icache.h"
@@ -834,21 +834,52 @@ xfs_qm_qino_alloc(
         int             error;
         int             committed;
 
+        *ip = NULL;
+        /*
+         * With superblock that doesn't have separate pquotino, we
+         * share an inode between gquota and pquota. If the on-disk
+         * superblock has GQUOTA and the filesystem is now mounted
+         * with PQUOTA, just use sb_gquotino for sb_pquotino and
+         * vice-versa.
+         */
+        if (!xfs_sb_version_has_pquotino(&mp->m_sb) &&
+                        (flags & (XFS_QMOPT_PQUOTA|XFS_QMOPT_GQUOTA))) {
+                xfs_ino_t ino = NULLFSINO;
+
+                if ((flags & XFS_QMOPT_PQUOTA) &&
+                             (mp->m_sb.sb_gquotino != NULLFSINO)) {
+                        ino = mp->m_sb.sb_gquotino;
+                        ASSERT(mp->m_sb.sb_pquotino == NULLFSINO);
+                } else if ((flags & XFS_QMOPT_GQUOTA) &&
+                             (mp->m_sb.sb_pquotino != NULLFSINO)) {
+                        ino = mp->m_sb.sb_pquotino;
+                        ASSERT(mp->m_sb.sb_gquotino == NULLFSINO);
+                }
+                if (ino != NULLFSINO) {
+                        error = xfs_iget(mp, NULL, ino, 0, 0, ip);
+                        if (error)
+                                return error;
+                        mp->m_sb.sb_gquotino = NULLFSINO;
+                        mp->m_sb.sb_pquotino = NULLFSINO;
+                }
+        }
+
         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE);
-        if ((error = xfs_trans_reserve(tp,
-                                      XFS_QM_QINOCREATE_SPACE_RES(mp),
-                                      XFS_CREATE_LOG_RES(mp), 0,
-                                      XFS_TRANS_PERM_LOG_RES,
-                                      XFS_CREATE_LOG_COUNT))) {
+        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_create,
+                                  XFS_QM_QINOCREATE_SPACE_RES(mp), 0);
+        if (error) {
                 xfs_trans_cancel(tp, 0);
                 return error;
         }
 
-        error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0, 0, 1, ip, &committed);
-        if (error) {
-                xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
-                                 XFS_TRANS_ABORT);
-                return error;
+        if (!*ip) {
+                error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0, 0, 1, ip,
+                                                                &committed);
+                if (error) {
+                        xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
+                                         XFS_TRANS_ABORT);
+                        return error;
+                }
         }
 
         /*
@@ -860,21 +891,25 @@ xfs_qm_qino_alloc(
         if (flags & XFS_QMOPT_SBVERSION) {
                 ASSERT(!xfs_sb_version_hasquota(&mp->m_sb));
                 ASSERT((sbfields & (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
-                                   XFS_SB_GQUOTINO | XFS_SB_QFLAGS)) ==
-                       (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
-                        XFS_SB_GQUOTINO | XFS_SB_QFLAGS));
+                        XFS_SB_GQUOTINO | XFS_SB_PQUOTINO | XFS_SB_QFLAGS)) ==
+                                (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
+                                 XFS_SB_GQUOTINO | XFS_SB_PQUOTINO |
+                                 XFS_SB_QFLAGS));
 
                 xfs_sb_version_addquota(&mp->m_sb);
                 mp->m_sb.sb_uquotino = NULLFSINO;
                 mp->m_sb.sb_gquotino = NULLFSINO;
+                mp->m_sb.sb_pquotino = NULLFSINO;
 
-                /* qflags will get updated _after_ quotacheck */
-                mp->m_sb.sb_qflags = 0;
+                /* qflags will get updated fully _after_ quotacheck */
+                mp->m_sb.sb_qflags = mp->m_qflags & XFS_ALL_QUOTA_ACCT;
         }
         if (flags & XFS_QMOPT_UQUOTA)
                 mp->m_sb.sb_uquotino = (*ip)->i_ino;
-        else
+        else if (flags & XFS_QMOPT_GQUOTA)
                 mp->m_sb.sb_gquotino = (*ip)->i_ino;
+        else
+                mp->m_sb.sb_pquotino = (*ip)->i_ino;
         spin_unlock(&mp->m_sb_lock);
         xfs_mod_sb(tp, sbfields);
 
@@ -1484,11 +1519,10 @@ xfs_qm_init_quotainos(
                         if (error)
                                 goto error_rele;
                 }
-                /* XXX: Use gquotino for now */
                 if (XFS_IS_PQUOTA_ON(mp) &&
-                    mp->m_sb.sb_gquotino != NULLFSINO) {
-                        ASSERT(mp->m_sb.sb_gquotino > 0);
-                        error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
+                    mp->m_sb.sb_pquotino != NULLFSINO) {
+                        ASSERT(mp->m_sb.sb_pquotino > 0);
+                        error = xfs_iget(mp, NULL, mp->m_sb.sb_pquotino,
                                              0, 0, &pip);
                         if (error)
                                 goto error_rele;
@@ -1496,7 +1530,8 @@ xfs_qm_init_quotainos(
         } else {
                 flags |= XFS_QMOPT_SBVERSION;
                 sbflags |= (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
-                            XFS_SB_GQUOTINO | XFS_SB_QFLAGS);
+                            XFS_SB_GQUOTINO | XFS_SB_PQUOTINO |
+                            XFS_SB_QFLAGS);
         }
 
         /*
@@ -1524,9 +1559,8 @@ xfs_qm_init_quotainos(
                 flags &= ~XFS_QMOPT_SBVERSION;
         }
         if (XFS_IS_PQUOTA_ON(mp) && pip == NULL) {
-                /* XXX: Use XFS_SB_GQUOTINO for now */
                 error = xfs_qm_qino_alloc(mp, &pip,
-                                          sbflags | XFS_SB_GQUOTINO,
+                                          sbflags | XFS_SB_PQUOTINO,
                                           flags | XFS_QMOPT_PQUOTA);
                 if (error)
                         goto error_rele;
@@ -1704,8 +1738,7 @@ xfs_qm_write_sb_changes(
         int             error;
 
         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
-        error = xfs_trans_reserve(tp, 0, XFS_QM_SBCHANGE_LOG_RES(mp),
-                                  0, 0, XFS_DEFAULT_LOG_COUNT);
+        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_qm_sbchange, 0, 0);
         if (error) {
                 xfs_trans_cancel(tp, 0);
                 return error;
@@ -1734,8 +1767,8 @@ xfs_qm_write_sb_changes(
 int
 xfs_qm_vop_dqalloc(
         struct xfs_inode        *ip,
-        uid_t                   uid,
-        gid_t                   gid,
+        xfs_dqid_t              uid,
+        xfs_dqid_t              gid,
         prid_t                  prid,
         uint                    flags,
         struct xfs_dquot        **O_udqpp,
@@ -1782,7 +1815,7 @@ xfs_qm_vop_dqalloc(
                          * holding ilock.
                          */
                         xfs_iunlock(ip, lockflags);
-                        error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
+                        error = xfs_qm_dqget(mp, NULL, uid,
                                                  XFS_DQ_USER,
                                                  XFS_QMOPT_DQALLOC |
                                                  XFS_QMOPT_DOWARN,
@@ -1809,7 +1842,7 @@ xfs_qm_vop_dqalloc(
         if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
                 if (ip->i_d.di_gid != gid) {
                         xfs_iunlock(ip, lockflags);
-                        error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
+                        error = xfs_qm_dqget(mp, NULL, gid,
                                                  XFS_DQ_GROUP,
                                                  XFS_QMOPT_DQALLOC |
                                                  XFS_QMOPT_DOWARN,
@@ -1943,7 +1976,7 @@ xfs_qm_vop_chown_reserve(
                         XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
 
         if (XFS_IS_UQUOTA_ON(mp) && udqp &&
-            ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) {
+            ip->i_d.di_uid != be32_to_cpu(udqp->q_core.d_id)) {
                 udq_delblks = udqp;
                 /*
                  * If there are delayed allocation blocks, then we have to