7 files changed, 106 insertions, 66 deletions

diff --git a/fs/xfs/quota/xfs_dquot.c b/fs/xfs/quota/xfs_dquot.c
index 665babcca6a6..631ebb31b295 100644
--- a/fs/xfs/quota/xfs_dquot.c
+++ b/fs/xfs/quota/xfs_dquot.c
@@ -1291,7 +1291,7 @@ xfs_qm_dqflush(
         if (flags & XFS_QMOPT_DELWRI) {
                 xfs_bdwrite(mp, bp);
         } else if (flags & XFS_QMOPT_ASYNC) {
-                xfs_bawrite(mp, bp);
+                error = xfs_bawrite(mp, bp);
         } else {
                 error = xfs_bwrite(mp, bp);
         }
@@ -1439,9 +1439,7 @@ xfs_qm_dqpurge(
         uint            flags)
 {
         xfs_dqhash_t    *thishash;
-        xfs_mount_t     *mp;
-
-        mp = dqp->q_mount;
+        xfs_mount_t     *mp = dqp->q_mount;
 
         ASSERT(XFS_QM_IS_MPLIST_LOCKED(mp));
         ASSERT(XFS_DQ_IS_HASH_LOCKED(dqp->q_hash));
@@ -1485,6 +1483,7 @@ xfs_qm_dqpurge(
          * we're unmounting, we do care, so we flush it and wait.
          */
         if (XFS_DQ_IS_DIRTY(dqp)) {
+                int     error;
                 xfs_dqtrace_entry(dqp, "DQPURGE ->DQFLUSH: DQDIRTY");
                 /* dqflush unlocks dqflock */
                 /*
@@ -1495,7 +1494,10 @@ xfs_qm_dqpurge(
                  * We don't care about getting disk errors here. We need
                  * to purge this dquot anyway, so we go ahead regardless.
                  */
-                (void) xfs_qm_dqflush(dqp, XFS_QMOPT_SYNC);
+                error = xfs_qm_dqflush(dqp, XFS_QMOPT_SYNC);
+                if (error)
+                        xfs_fs_cmn_err(CE_WARN, mp,
+                                "xfs_qm_dqpurge: dquot %p flush failed", dqp);
                 xfs_dqflock(dqp);
         }
         ASSERT(dqp->q_pincount == 0);
@@ -1580,12 +1582,18 @@ xfs_qm_dqflock_pushbuf_wait(
                     XFS_INCORE_TRYLOCK);
         if (bp != NULL) {
                 if (XFS_BUF_ISDELAYWRITE(bp)) {
+                        int     error;
                         if (XFS_BUF_ISPINNED(bp)) {
                                 xfs_log_force(dqp->q_mount,
                                               (xfs_lsn_t)0,
                                               XFS_LOG_FORCE);
                         }
-                        xfs_bawrite(dqp->q_mount, bp);
+                        error = xfs_bawrite(dqp->q_mount, bp);
+                        if (error)
+                                xfs_fs_cmn_err(CE_WARN, dqp->q_mount,
+                                        "xfs_qm_dqflock_pushbuf_wait: "
+                                        "pushbuf error %d on dqp %p, bp %p",
+                                        error, dqp, bp);
                 } else {
                         xfs_buf_relse(bp);
                 }
diff --git a/fs/xfs/quota/xfs_dquot_item.c b/fs/xfs/quota/xfs_dquot_item.c
index 1800e8d1f646..36e05ca78412 100644
--- a/fs/xfs/quota/xfs_dquot_item.c
+++ b/fs/xfs/quota/xfs_dquot_item.c
@@ -146,6 +146,7 @@ xfs_qm_dquot_logitem_push(
         xfs_dq_logitem_t        *logitem)
 {
         xfs_dquot_t     *dqp;
+        int             error;
 
         dqp = logitem->qli_dquot;
 
@@ -161,7 +162,11 @@ xfs_qm_dquot_logitem_push(
          * lock without sleeping, then there must not have been
          * anyone in the process of flushing the dquot.
          */
-        xfs_qm_dqflush(dqp, XFS_B_DELWRI);
+        error = xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
+        if (error)
+                xfs_fs_cmn_err(CE_WARN, dqp->q_mount,
+                        "xfs_qm_dquot_logitem_push: push error %d on dqp %p",
+                        error, dqp);
         xfs_dqunlock(dqp);
 }
 
@@ -262,11 +267,16 @@ xfs_qm_dquot_logitem_pushbuf(
                                               XFS_LOG_FORCE);
                         }
                         if (dopush) {
+                                int     error;
 #ifdef XFSRACEDEBUG
                                 delay_for_intr();
                                 delay(300);
 #endif
-                                xfs_bawrite(mp, bp);
+                                error = xfs_bawrite(mp, bp);
+                                if (error)
+                                        xfs_fs_cmn_err(CE_WARN, mp,
+        "xfs_qm_dquot_logitem_pushbuf: pushbuf error %d on qip %p, bp %p",
+                                                        error, qip, bp);
                         } else {
                                 xfs_buf_relse(bp);
                         }
diff --git a/fs/xfs/quota/xfs_qm.c b/fs/xfs/quota/xfs_qm.c
index 1f3da5b8657b..40ea56409561 100644
--- a/fs/xfs/quota/xfs_qm.c
+++ b/fs/xfs/quota/xfs_qm.c
@@ -304,8 +304,11 @@ xfs_qm_unmount_quotadestroy(
  * necessary data structures like quotainfo.  This is also responsible for
  * running a quotacheck as necessary.  We are guaranteed that the superblock
  * is consistently read in at this point.
+ *
+ * If we fail here, the mount will continue with quota turned off. We don't
+ * need to inidicate success or failure at all.
  */
-int
+void
 xfs_qm_mount_quotas(
         xfs_mount_t     *mp,
         int             mfsi_flags)
@@ -313,7 +316,6 @@ xfs_qm_mount_quotas(
         int             error = 0;
         uint            sbf;
 
-
         /*
          * If quotas on realtime volumes is not supported, we disable
          * quotas immediately.
@@ -332,7 +334,8 @@ xfs_qm_mount_quotas(
          * Allocate the quotainfo structure inside the mount struct, and
          * create quotainode(s), and change/rev superblock if necessary.
          */
-        if ((error = xfs_qm_init_quotainfo(mp))) {
+        error = xfs_qm_init_quotainfo(mp);
+        if (error) {
                 /*
                  * We must turn off quotas.
                  */
@@ -344,12 +347,11 @@ xfs_qm_mount_quotas(
          * If any of the quotas are not consistent, do a quotacheck.
          */
         if (XFS_QM_NEED_QUOTACHECK(mp) &&
-                !(mfsi_flags & XFS_MFSI_NO_QUOTACHECK)) {
-                if ((error = xfs_qm_quotacheck(mp))) {
-                        /* Quotacheck has failed and quotas have
-                         * been disabled.
-                         */
-                        return XFS_ERROR(error);
+            !(mfsi_flags & XFS_MFSI_NO_QUOTACHECK)) {
+                error = xfs_qm_quotacheck(mp);
+                if (error) {
+                        /* Quotacheck failed and disabled quotas. */
+                        return;
                 }
         }
         /* 
@@ -357,12 +359,10 @@ xfs_qm_mount_quotas(
          * quotachecked status, since we won't be doing accounting for
          * that type anymore.
          */
-        if (!XFS_IS_UQUOTA_ON(mp)) {
+        if (!XFS_IS_UQUOTA_ON(mp))
                 mp->m_qflags &= ~XFS_UQUOTA_CHKD;
-        }
-        if (!(XFS_IS_GQUOTA_ON(mp) || XFS_IS_PQUOTA_ON(mp))) {
+        if (!(XFS_IS_GQUOTA_ON(mp) || XFS_IS_PQUOTA_ON(mp)))
                 mp->m_qflags &= ~XFS_OQUOTA_CHKD;
-        }
 
  write_changes:
         /*
@@ -392,7 +392,7 @@ xfs_qm_mount_quotas(
                 xfs_fs_cmn_err(CE_WARN, mp,
                         "Failed to initialize disk quotas.");
         }
-        return XFS_ERROR(error);
+        return;
 }
 
 /*
@@ -1405,13 +1405,13 @@ xfs_qm_qino_alloc(
 #if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
                 unsigned oldv = mp->m_sb.sb_versionnum;
 #endif
-                ASSERT(!XFS_SB_VERSION_HASQUOTA(&mp->m_sb));
+                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_VERSION_ADDQUOTA(&mp->m_sb);
+                xfs_sb_version_addquota(&mp->m_sb);
                 mp->m_sb.sb_uquotino = NULLFSINO;
                 mp->m_sb.sb_gquotino = NULLFSINO;
 
@@ -1438,7 +1438,7 @@ xfs_qm_qino_alloc(
 }
 
 
-STATIC int
+STATIC void
 xfs_qm_reset_dqcounts(
         xfs_mount_t     *mp,
         xfs_buf_t       *bp,
@@ -1478,8 +1478,6 @@ xfs_qm_reset_dqcounts(
                 ddq->d_rtbwarns = 0;
                 ddq = (xfs_disk_dquot_t *) ((xfs_dqblk_t *)ddq + 1);
         }
-
-        return 0;
 }
 
 STATIC int
@@ -1520,7 +1518,7 @@ xfs_qm_dqiter_bufs(
                 if (error)
                         break;
 
-                (void) xfs_qm_reset_dqcounts(mp, bp, firstid, type);
+                xfs_qm_reset_dqcounts(mp, bp, firstid, type);
                 xfs_bdwrite(mp, bp);
                 /*
                  * goto the next block.
@@ -1810,7 +1808,7 @@ xfs_qm_dqusage_adjust(
          * Now release the inode. This will send it to 'inactive', and
          * possibly even free blocks.
          */
-        VN_RELE(XFS_ITOV(ip));
+        IRELE(ip);
 
         /*
          * Goto next inode.
@@ -1880,6 +1878,14 @@ xfs_qm_quotacheck(
         } while (! done);
 
         /*
+         * We've made all the changes that we need to make incore.
+         * Flush them down to disk buffers if everything was updated
+         * successfully.
+         */
+        if (!error)
+                error = xfs_qm_dqflush_all(mp, XFS_QMOPT_DELWRI);
+
+        /*
          * We can get this error if we couldn't do a dquot allocation inside
          * xfs_qm_dqusage_adjust (via bulkstat). We don't care about the
          * dirty dquots that might be cached, we just want to get rid of them
@@ -1890,11 +1896,6 @@ xfs_qm_quotacheck(
                 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL | XFS_QMOPT_QUOTAOFF);
                 goto error_return;
         }
-        /*
-         * We've made all the changes that we need to make incore.
-         * Now flush_them down to disk buffers.
-         */
-        xfs_qm_dqflush_all(mp, XFS_QMOPT_DELWRI);
 
         /*
          * We didn't log anything, because if we crashed, we'll have to
@@ -1926,7 +1927,10 @@ xfs_qm_quotacheck(
                 ASSERT(mp->m_quotainfo != NULL);
                 ASSERT(xfs_Gqm != NULL);
                 xfs_qm_destroy_quotainfo(mp);
-                (void)xfs_mount_reset_sbqflags(mp);
+                if (xfs_mount_reset_sbqflags(mp)) {
+                        cmn_err(CE_WARN, "XFS quotacheck %s: "
+                                "Failed to reset quota flags.", mp->m_fsname);
+                }
         } else {
                 cmn_err(CE_NOTE, "XFS quotacheck %s: Done.", mp->m_fsname);
         }
@@ -1954,7 +1958,7 @@ xfs_qm_init_quotainos(
         /*
          * Get the uquota and gquota inodes
          */
-        if (XFS_SB_VERSION_HASQUOTA(&mp->m_sb)) {
+        if (xfs_sb_version_hasquota(&mp->m_sb)) {
                 if (XFS_IS_UQUOTA_ON(mp) &&
                     mp->m_sb.sb_uquotino != NULLFSINO) {
                         ASSERT(mp->m_sb.sb_uquotino > 0);
@@ -1968,7 +1972,7 @@ xfs_qm_init_quotainos(
                         if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
                                              0, 0, &gip, 0))) {
                                 if (uip)
-                                        VN_RELE(XFS_ITOV(uip));
+                                        IRELE(uip);
                                 return XFS_ERROR(error);
                         }
                 }
@@ -1999,7 +2003,7 @@ xfs_qm_init_quotainos(
                                           sbflags | XFS_SB_GQUOTINO, flags);
                 if (error) {
                         if (uip)
-                                VN_RELE(XFS_ITOV(uip));
+                                IRELE(uip);
 
                         return XFS_ERROR(error);
                 }
@@ -2093,12 +2097,17 @@ xfs_qm_shake_freelist(
                  * dirty dquots.
                  */
                 if (XFS_DQ_IS_DIRTY(dqp)) {
+                        int     error;
                         xfs_dqtrace_entry(dqp, "DQSHAKE: DQDIRTY");
                         /*
                          * We flush it delayed write, so don't bother
                          * releasing the mplock.
                          */
-                        (void) xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
+                        error = xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
+                        if (error) {
+                                xfs_fs_cmn_err(CE_WARN, dqp->q_mount,
+                        "xfs_qm_dqflush_all: dquot %p flush failed", dqp);
+                        }
                         xfs_dqunlock(dqp); /* dqflush unlocks dqflock */
                         dqp = dqp->dq_flnext;
                         continue;
@@ -2265,12 +2274,17 @@ xfs_qm_dqreclaim_one(void)
                  * dirty dquots.
                  */
                 if (XFS_DQ_IS_DIRTY(dqp)) {
+                        int     error;
                         xfs_dqtrace_entry(dqp, "DQRECLAIM: DQDIRTY");
                         /*
                          * We flush it delayed write, so don't bother
                          * releasing the freelist lock.
                          */
-                        (void) xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
+                        error = xfs_qm_dqflush(dqp, XFS_QMOPT_DELWRI);
+                        if (error) {
+                                xfs_fs_cmn_err(CE_WARN, dqp->q_mount,
+                        "xfs_qm_dqreclaim: dquot %p flush failed", dqp);
+                        }
                         xfs_dqunlock(dqp); /* dqflush unlocks dqflock */
                         continue;
                 }
@@ -2378,9 +2392,9 @@ xfs_qm_write_sb_changes(
         }
 
         xfs_mod_sb(tp, flags);
-        (void) xfs_trans_commit(tp, 0);
+        error = xfs_trans_commit(tp, 0);
 
-        return 0;
+        return error;
 }
 
 
diff --git a/fs/xfs/quota/xfs_qm.h b/fs/xfs/quota/xfs_qm.h
index baf537c1c177..cd2300e374af 100644
--- a/fs/xfs/quota/xfs_qm.h
+++ b/fs/xfs/quota/xfs_qm.h
@@ -165,7 +165,7 @@ typedef struct xfs_dquot_acct {
 #define XFS_QM_RELE(xqm)        ((xqm)->qm_nrefs--)
 
 extern void             xfs_qm_destroy_quotainfo(xfs_mount_t *);
-extern int              xfs_qm_mount_quotas(xfs_mount_t *, int);
+extern void             xfs_qm_mount_quotas(xfs_mount_t *, int);
 extern int              xfs_qm_quotacheck(xfs_mount_t *);
 extern void             xfs_qm_unmount_quotadestroy(xfs_mount_t *);
 extern int              xfs_qm_unmount_quotas(xfs_mount_t *);
diff --git a/fs/xfs/quota/xfs_qm_bhv.c b/fs/xfs/quota/xfs_qm_bhv.c
index 97bb32937585..f4f6c4c861d7 100644
--- a/fs/xfs/quota/xfs_qm_bhv.c
+++ b/fs/xfs/quota/xfs_qm_bhv.c
@@ -118,7 +118,7 @@ xfs_qm_newmount(
         *quotaflags = 0;
         *needquotamount = B_FALSE;
 
-        quotaondisk = XFS_SB_VERSION_HASQUOTA(&mp->m_sb) &&
+        quotaondisk = xfs_sb_version_hasquota(&mp->m_sb) &&
                                 (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT);
 
         if (quotaondisk) {
diff --git a/fs/xfs/quota/xfs_qm_stats.h b/fs/xfs/quota/xfs_qm_stats.h
index a50ffabcf554..5b964fc0dc09 100644
--- a/fs/xfs/quota/xfs_qm_stats.h
+++ b/fs/xfs/quota/xfs_qm_stats.h
@@ -45,8 +45,8 @@ extern void xfs_qm_cleanup_procfs(void);
 
 # define XQM_STATS_INC(count)   do { } while (0)
 
-static __inline void xfs_qm_init_procfs(void) { };
-static __inline void xfs_qm_cleanup_procfs(void) { };
+static inline void xfs_qm_init_procfs(void) { };
+static inline void xfs_qm_cleanup_procfs(void) { };
 
 #endif
 
diff --git a/fs/xfs/quota/xfs_qm_syscalls.c b/fs/xfs/quota/xfs_qm_syscalls.c
index 2cc5886cfe85..8342823dbdc3 100644
--- a/fs/xfs/quota/xfs_qm_syscalls.c
+++ b/fs/xfs/quota/xfs_qm_syscalls.c
@@ -279,9 +279,12 @@ xfs_qm_scall_quotaoff(
 
         /*
          * Write the LI_QUOTAOFF log record, and do SB changes atomically,
-         * and synchronously.
+         * and synchronously. If we fail to write, we should abort the
+         * operation as it cannot be recovered safely if we crash.
          */
-        xfs_qm_log_quotaoff(mp, &qoffstart, flags);
+        error = xfs_qm_log_quotaoff(mp, &qoffstart, flags);
+        if (error)
+                goto out_error;
 
         /*
          * Next we clear the XFS_MOUNT_*DQ_ACTIVE bit(s) in the mount struct
@@ -337,7 +340,12 @@ xfs_qm_scall_quotaoff(
          * So, we have QUOTAOFF start and end logitems; the start
          * logitem won't get overwritten until the end logitem appears...
          */
-        xfs_qm_log_quotaoff_end(mp, qoffstart, flags);
+        error = xfs_qm_log_quotaoff_end(mp, qoffstart, flags);
+        if (error) {
+                /* We're screwed now. Shutdown is the only option. */
+                xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
+                goto out_error;
+        }
 
         /*
          * If quotas is completely disabled, close shop.
@@ -361,6 +369,7 @@ xfs_qm_scall_quotaoff(
                 XFS_PURGE_INODE(XFS_QI_GQIP(mp));
                 XFS_QI_GQIP(mp) = NULL;
         }
+out_error:
         mutex_unlock(&(XFS_QI_QOFFLOCK(mp)));
 
         return (error);
@@ -371,35 +380,34 @@ xfs_qm_scall_trunc_qfiles(
         xfs_mount_t     *mp,
         uint            flags)
 {
-        int             error;
+        int             error = 0, error2 = 0;
         xfs_inode_t     *qip;
 
         if (!capable(CAP_SYS_ADMIN))
                 return XFS_ERROR(EPERM);
-        error = 0;
-        if (!XFS_SB_VERSION_HASQUOTA(&mp->m_sb) || flags == 0) {
+        if (!xfs_sb_version_hasquota(&mp->m_sb) || flags == 0) {
                 qdprintk("qtrunc flags=%x m_qflags=%x\n", flags, mp->m_qflags);
                 return XFS_ERROR(EINVAL);
         }
 
         if ((flags & XFS_DQ_USER) && mp->m_sb.sb_uquotino != NULLFSINO) {
                 error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino, 0, 0, &qip, 0);
-                if (! error) {
-                        (void) xfs_truncate_file(mp, qip);
-                        VN_RELE(XFS_ITOV(qip));
+                if (!error) {
+                        error = xfs_truncate_file(mp, qip);
+                        IRELE(qip);
                 }
         }
 
         if ((flags & (XFS_DQ_GROUP|XFS_DQ_PROJ)) &&
             mp->m_sb.sb_gquotino != NULLFSINO) {
-                error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino, 0, 0, &qip, 0);
-                if (! error) {
-                        (void) xfs_truncate_file(mp, qip);
-                        VN_RELE(XFS_ITOV(qip));
+                error2 = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino, 0, 0, &qip, 0);
+                if (!error2) {
+                        error2 = xfs_truncate_file(mp, qip);
+                        IRELE(qip);
                 }
         }
 
-        return (error);
+        return error ? error : error2;
 }
 
 
@@ -522,7 +530,7 @@ xfs_qm_scall_getqstat(
         memset(out, 0, sizeof(fs_quota_stat_t));
 
         out->qs_version = FS_QSTAT_VERSION;
-        if (! XFS_SB_VERSION_HASQUOTA(&mp->m_sb)) {
+        if (!xfs_sb_version_hasquota(&mp->m_sb)) {
                 out->qs_uquota.qfs_ino = NULLFSINO;
                 out->qs_gquota.qfs_ino = NULLFSINO;
                 return (0);
@@ -552,13 +560,13 @@ xfs_qm_scall_getqstat(
                 out->qs_uquota.qfs_nblks = uip->i_d.di_nblocks;
                 out->qs_uquota.qfs_nextents = uip->i_d.di_nextents;
                 if (tempuqip)
-                        VN_RELE(XFS_ITOV(uip));
+                        IRELE(uip);
         }
         if (gip) {
                 out->qs_gquota.qfs_nblks = gip->i_d.di_nblocks;
                 out->qs_gquota.qfs_nextents = gip->i_d.di_nextents;
                 if (tempgqip)
-                        VN_RELE(XFS_ITOV(gip));
+                        IRELE(gip);
         }
         if (mp->m_quotainfo) {
                 out->qs_incoredqs = XFS_QI_MPLNDQUOTS(mp);
@@ -726,12 +734,12 @@ xfs_qm_scall_setqlim(
         xfs_trans_log_dquot(tp, dqp);
 
         xfs_dqtrace_entry(dqp, "Q_SETQLIM: COMMIT");
-        xfs_trans_commit(tp, 0);
+        error = xfs_trans_commit(tp, 0);
         xfs_qm_dqprint(dqp);
         xfs_qm_dqrele(dqp);
         mutex_unlock(&(XFS_QI_QOFFLOCK(mp)));
 
-        return (0);
+        return error;
 }
 
 STATIC int
@@ -1095,7 +1103,7 @@ again:
                  * inactive code in hell.
                  */
                 if (vnode_refd)
-                        VN_RELE(vp);
+                        IRELE(ip);
                 XFS_MOUNT_ILOCK(mp);
                 /*
                  * If an inode was inserted or removed, we gotta