Btrfs: calc file extent num_bytes correctly in file clone
[linux-2.6.git] / fs / gfs2 / quota.c
index d49ff43..42e8d23 100644 (file)
@@ -1,10 +1,10 @@
 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
- * Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
+ * Copyright (C) 2004-2007 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
- * of the GNU General Public License v.2.
+ * of the GNU General Public License version 2.
  */
 
 /*
@@ -15,7 +15,7 @@
  * fuzziness in the current usage value of IDs that are being used on different
  * nodes in the cluster simultaneously.  So, it is possible for a user on
  * multiple nodes to overrun their quota, but that overrun is controlable.
- * Since quota tags are part of transactions, there is no need to a quota check
+ * Since quota tags are part of transactions, there is no need for a quota check
  * program to be run on node crashes or anything like that.
  *
  * There are couple of knobs that let the administrator manage the quota
 
 #include <linux/sched.h>
 #include <linux/slab.h>
+#include <linux/mm.h>
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
-#include <linux/tty.h>
 #include <linux/sort.h>
 #include <linux/fs.h>
+#include <linux/bio.h>
 #include <linux/gfs2_ondisk.h>
-#include <asm/semaphore.h>
+#include <linux/kthread.h>
+#include <linux/freezer.h>
+#include <linux/quota.h>
+#include <linux/dqblk_xfs.h>
 
 #include "gfs2.h"
-#include "lm_interface.h"
 #include "incore.h"
 #include "bmap.h"
 #include "glock.h"
 #include "glops.h"
 #include "log.h"
-#include "lvb.h"
 #include "meta_io.h"
 #include "quota.h"
 #include "rgrp.h"
 #include "super.h"
 #include "trans.h"
 #include "inode.h"
-#include "ops_file.h"
-#include "ops_address.h"
 #include "util.h"
 
 #define QUOTA_USER 1
 #define QUOTA_GROUP 0
 
-static uint64_t qd2offset(struct gfs2_quota_data *qd)
+struct gfs2_quota_change_host {
+       u64 qc_change;
+       u32 qc_flags; /* GFS2_QCF_... */
+       u32 qc_id;
+};
+
+static LIST_HEAD(qd_lru_list);
+static atomic_t qd_lru_count = ATOMIC_INIT(0);
+static DEFINE_SPINLOCK(qd_lru_lock);
+
+int gfs2_shrink_qd_memory(struct shrinker *shrink, struct shrink_control *sc)
+{
+       struct gfs2_quota_data *qd;
+       struct gfs2_sbd *sdp;
+       int nr_to_scan = sc->nr_to_scan;
+
+       if (nr_to_scan == 0)
+               goto out;
+
+       if (!(sc->gfp_mask & __GFP_FS))
+               return -1;
+
+       spin_lock(&qd_lru_lock);
+       while (nr_to_scan && !list_empty(&qd_lru_list)) {
+               qd = list_entry(qd_lru_list.next,
+                               struct gfs2_quota_data, qd_reclaim);
+               sdp = qd->qd_gl->gl_sbd;
+
+               /* Free from the filesystem-specific list */
+               list_del(&qd->qd_list);
+
+               gfs2_assert_warn(sdp, !qd->qd_change);
+               gfs2_assert_warn(sdp, !qd->qd_slot_count);
+               gfs2_assert_warn(sdp, !qd->qd_bh_count);
+
+               gfs2_glock_put(qd->qd_gl);
+               atomic_dec(&sdp->sd_quota_count);
+
+               /* Delete it from the common reclaim list */
+               list_del_init(&qd->qd_reclaim);
+               atomic_dec(&qd_lru_count);
+               spin_unlock(&qd_lru_lock);
+               kmem_cache_free(gfs2_quotad_cachep, qd);
+               spin_lock(&qd_lru_lock);
+               nr_to_scan--;
+       }
+       spin_unlock(&qd_lru_lock);
+
+out:
+       return (atomic_read(&qd_lru_count) * sysctl_vfs_cache_pressure) / 100;
+}
+
+static u64 qd2offset(struct gfs2_quota_data *qd)
 {
-       uint64_t offset;
+       u64 offset;
 
-       offset = 2 * (uint64_t)qd->qd_id + !test_bit(QDF_USER, &qd->qd_flags);
+       offset = 2 * (u64)qd->qd_id + !test_bit(QDF_USER, &qd->qd_flags);
        offset *= sizeof(struct gfs2_quota);
 
        return offset;
 }
 
-static int qd_alloc(struct gfs2_sbd *sdp, int user, uint32_t id,
+static int qd_alloc(struct gfs2_sbd *sdp, int user, u32 id,
                    struct gfs2_quota_data **qdp)
 {
        struct gfs2_quota_data *qd;
        int error;
 
-       qd = kzalloc(sizeof(struct gfs2_quota_data), GFP_KERNEL);
+       qd = kmem_cache_zalloc(gfs2_quotad_cachep, GFP_NOFS);
        if (!qd)
                return -ENOMEM;
 
-       qd->qd_count = 1;
+       atomic_set(&qd->qd_count, 1);
        qd->qd_id = id;
        if (user)
                set_bit(QDF_USER, &qd->qd_flags);
        qd->qd_slot = -1;
+       INIT_LIST_HEAD(&qd->qd_reclaim);
 
-       error = gfs2_glock_get(sdp, 2 * (uint64_t)id + !user,
+       error = gfs2_glock_get(sdp, 2 * (u64)id + !user,
                              &gfs2_quota_glops, CREATE, &qd->qd_gl);
        if (error)
                goto fail;
 
-       error = gfs2_lvb_hold(qd->qd_gl);
-       gfs2_glock_put(qd->qd_gl);
-       if (error)
-               goto fail;
-
        *qdp = qd;
 
        return 0;
 
- fail:
-       kfree(qd);
+fail:
+       kmem_cache_free(gfs2_quotad_cachep, qd);
        return error;
 }
 
-static int qd_get(struct gfs2_sbd *sdp, int user, uint32_t id, int create,
+static int qd_get(struct gfs2_sbd *sdp, int user, u32 id,
                  struct gfs2_quota_data **qdp)
 {
        struct gfs2_quota_data *qd = NULL, *new_qd = NULL;
@@ -123,11 +171,17 @@ static int qd_get(struct gfs2_sbd *sdp, int user, uint32_t id, int create,
 
        for (;;) {
                found = 0;
-               spin_lock(&sdp->sd_quota_spin);
+               spin_lock(&qd_lru_lock);
                list_for_each_entry(qd, &sdp->sd_quota_list, qd_list) {
                        if (qd->qd_id == id &&
                            !test_bit(QDF_USER, &qd->qd_flags) == !user) {
-                               qd->qd_count++;
+                               if (!atomic_read(&qd->qd_count) &&
+                                   !list_empty(&qd->qd_reclaim)) {
+                                       /* Remove it from reclaim list */
+                                       list_del_init(&qd->qd_reclaim);
+                                       atomic_dec(&qd_lru_count);
+                               }
+                               atomic_inc(&qd->qd_count);
                                found = 1;
                                break;
                        }
@@ -143,12 +197,12 @@ static int qd_get(struct gfs2_sbd *sdp, int user, uint32_t id, int create,
                        new_qd = NULL;
                }
 
-               spin_unlock(&sdp->sd_quota_spin);
+               spin_unlock(&qd_lru_lock);
 
-               if (qd || !create) {
+               if (qd) {
                        if (new_qd) {
-                               gfs2_lvb_unhold(new_qd->qd_gl);
-                               kfree(new_qd);
+                               gfs2_glock_put(new_qd->qd_gl);
+                               kmem_cache_free(gfs2_quotad_cachep, new_qd);
                        }
                        *qdp = qd;
                        return 0;
@@ -163,21 +217,18 @@ static int qd_get(struct gfs2_sbd *sdp, int user, uint32_t id, int create,
 static void qd_hold(struct gfs2_quota_data *qd)
 {
        struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
-
-       spin_lock(&sdp->sd_quota_spin);
-       gfs2_assert(sdp, qd->qd_count);
-       qd->qd_count++;
-       spin_unlock(&sdp->sd_quota_spin);
+       gfs2_assert(sdp, atomic_read(&qd->qd_count));
+       atomic_inc(&qd->qd_count);
 }
 
 static void qd_put(struct gfs2_quota_data *qd)
 {
-       struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
-       spin_lock(&sdp->sd_quota_spin);
-       gfs2_assert(sdp, qd->qd_count);
-       if (!--qd->qd_count)
-               qd->qd_last_touched = jiffies;
-       spin_unlock(&sdp->sd_quota_spin);
+       if (atomic_dec_and_lock(&qd->qd_count, &qd_lru_lock)) {
+               /* Add to the reclaim list */
+               list_add_tail(&qd->qd_reclaim, &qd_lru_list);
+               atomic_inc(&qd_lru_count);
+               spin_unlock(&qd_lru_lock);
+       }
 }
 
 static int slot_get(struct gfs2_quota_data *qd)
@@ -186,10 +237,10 @@ static int slot_get(struct gfs2_quota_data *qd)
        unsigned int c, o = 0, b;
        unsigned char byte = 0;
 
-       spin_lock(&sdp->sd_quota_spin);
+       spin_lock(&qd_lru_lock);
 
        if (qd->qd_slot_count++) {
-               spin_unlock(&sdp->sd_quota_spin);
+               spin_unlock(&qd_lru_lock);
                return 0;
        }
 
@@ -202,7 +253,7 @@ static int slot_get(struct gfs2_quota_data *qd)
 
        goto fail;
 
- found:
+found:
        for (b = 0; b < 8; b++)
                if (!(byte & (1 << b)))
                        break;
@@ -213,13 +264,13 @@ static int slot_get(struct gfs2_quota_data *qd)
 
        sdp->sd_quota_bitmap[c][o] |= 1 << b;
 
-       spin_unlock(&sdp->sd_quota_spin);
+       spin_unlock(&qd_lru_lock);
 
        return 0;
 
- fail:
+fail:
        qd->qd_slot_count--;
-       spin_unlock(&sdp->sd_quota_spin);
+       spin_unlock(&qd_lru_lock);
        return -ENOSPC;
 }
 
@@ -227,35 +278,33 @@ static void slot_hold(struct gfs2_quota_data *qd)
 {
        struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
 
-       spin_lock(&sdp->sd_quota_spin);
+       spin_lock(&qd_lru_lock);
        gfs2_assert(sdp, qd->qd_slot_count);
        qd->qd_slot_count++;
-       spin_unlock(&sdp->sd_quota_spin);
+       spin_unlock(&qd_lru_lock);
 }
 
 static void slot_put(struct gfs2_quota_data *qd)
 {
        struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
 
-       spin_lock(&sdp->sd_quota_spin);
+       spin_lock(&qd_lru_lock);
        gfs2_assert(sdp, qd->qd_slot_count);
        if (!--qd->qd_slot_count) {
                gfs2_icbit_munge(sdp, sdp->sd_quota_bitmap, qd->qd_slot, 0);
                qd->qd_slot = -1;
        }
-       spin_unlock(&sdp->sd_quota_spin);
+       spin_unlock(&qd_lru_lock);
 }
 
 static int bh_get(struct gfs2_quota_data *qd)
 {
        struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
-       struct gfs2_inode *ip = sdp->sd_qc_inode->u.generic_ip;
+       struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
        unsigned int block, offset;
-       uint64_t dblock;
-       int new = 0;
        struct buffer_head *bh;
        int error;
-       int boundary;
+       struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
 
        mutex_lock(&sdp->sd_quota_mutex);
 
@@ -265,12 +314,13 @@ static int bh_get(struct gfs2_quota_data *qd)
        }
 
        block = qd->qd_slot / sdp->sd_qc_per_block;
-       offset = qd->qd_slot % sdp->sd_qc_per_block;;
+       offset = qd->qd_slot % sdp->sd_qc_per_block;
 
-       error = gfs2_block_map(ip->i_vnode, block, &new, &dblock, &boundary);
+       bh_map.b_size = 1 << ip->i_inode.i_blkbits;
+       error = gfs2_block_map(&ip->i_inode, block, &bh_map, 0);
        if (error)
                goto fail;
-       error = gfs2_meta_read(ip->i_gl, dblock, DIO_START | DIO_WAIT, &bh);
+       error = gfs2_meta_read(ip->i_gl, bh_map.b_blocknr, DIO_WAIT, &bh);
        if (error)
                goto fail;
        error = -EIO;
@@ -282,14 +332,13 @@ static int bh_get(struct gfs2_quota_data *qd)
                (bh->b_data + sizeof(struct gfs2_meta_header) +
                 offset * sizeof(struct gfs2_quota_change));
 
-       mutex_lock(&sdp->sd_quota_mutex);
+       mutex_unlock(&sdp->sd_quota_mutex);
 
        return 0;
 
- fail_brelse:
+fail_brelse:
        brelse(bh);
-
- fail:
+fail:
        qd->qd_bh_count--;
        mutex_unlock(&sdp->sd_quota_mutex);
        return error;
@@ -320,7 +369,7 @@ static int qd_fish(struct gfs2_sbd *sdp, struct gfs2_quota_data **qdp)
        if (sdp->sd_vfs->s_flags & MS_RDONLY)
                return 0;
 
-       spin_lock(&sdp->sd_quota_spin);
+       spin_lock(&qd_lru_lock);
 
        list_for_each_entry(qd, &sdp->sd_quota_list, qd_list) {
                if (test_bit(QDF_LOCKED, &qd->qd_flags) ||
@@ -331,8 +380,8 @@ static int qd_fish(struct gfs2_sbd *sdp, struct gfs2_quota_data **qdp)
                list_move_tail(&qd->qd_list, &sdp->sd_quota_list);
 
                set_bit(QDF_LOCKED, &qd->qd_flags);
-               gfs2_assert_warn(sdp, qd->qd_count);
-               qd->qd_count++;
+               gfs2_assert_warn(sdp, atomic_read(&qd->qd_count));
+               atomic_inc(&qd->qd_count);
                qd->qd_change_sync = qd->qd_change;
                gfs2_assert_warn(sdp, qd->qd_slot_count);
                qd->qd_slot_count++;
@@ -344,7 +393,7 @@ static int qd_fish(struct gfs2_sbd *sdp, struct gfs2_quota_data **qdp)
        if (!found)
                qd = NULL;
 
-       spin_unlock(&sdp->sd_quota_spin);
+       spin_unlock(&qd_lru_lock);
 
        if (qd) {
                gfs2_assert_warn(sdp, qd->qd_change_sync);
@@ -369,24 +418,24 @@ static int qd_trylock(struct gfs2_quota_data *qd)
        if (sdp->sd_vfs->s_flags & MS_RDONLY)
                return 0;
 
-       spin_lock(&sdp->sd_quota_spin);
+       spin_lock(&qd_lru_lock);
 
        if (test_bit(QDF_LOCKED, &qd->qd_flags) ||
            !test_bit(QDF_CHANGE, &qd->qd_flags)) {
-               spin_unlock(&sdp->sd_quota_spin);
+               spin_unlock(&qd_lru_lock);
                return 0;
        }
 
        list_move_tail(&qd->qd_list, &sdp->sd_quota_list);
 
        set_bit(QDF_LOCKED, &qd->qd_flags);
-       gfs2_assert_warn(sdp, qd->qd_count);
-       qd->qd_count++;
+       gfs2_assert_warn(sdp, atomic_read(&qd->qd_count));
+       atomic_inc(&qd->qd_count);
        qd->qd_change_sync = qd->qd_change;
        gfs2_assert_warn(sdp, qd->qd_slot_count);
        qd->qd_slot_count++;
 
-       spin_unlock(&sdp->sd_quota_spin);
+       spin_unlock(&qd_lru_lock);
 
        gfs2_assert_warn(sdp, qd->qd_change_sync);
        if (bh_get(qd)) {
@@ -409,12 +458,12 @@ static void qd_unlock(struct gfs2_quota_data *qd)
        qd_put(qd);
 }
 
-static int qdsb_get(struct gfs2_sbd *sdp, int user, uint32_t id, int create,
+static int qdsb_get(struct gfs2_sbd *sdp, int user, u32 id,
                    struct gfs2_quota_data **qdp)
 {
        int error;
 
-       error = qd_get(sdp, user, id, create, qdp);
+       error = qd_get(sdp, user, id, qdp);
        if (error)
                return error;
 
@@ -428,10 +477,9 @@ static int qdsb_get(struct gfs2_sbd *sdp, int user, uint32_t id, int create,
 
        return 0;
 
- fail_slot:
+fail_slot:
        slot_put(*qdp);
-
- fail:
+fail:
        qd_put(*qdp);
        return error;
 }
@@ -443,10 +491,10 @@ static void qdsb_put(struct gfs2_quota_data *qd)
        qd_put(qd);
 }
 
-int gfs2_quota_hold(struct gfs2_inode *ip, uint32_t uid, uint32_t gid)
+int gfs2_quota_hold(struct gfs2_inode *ip, u32 uid, u32 gid)
 {
-       struct gfs2_sbd *sdp = ip->i_sbd;
-       struct gfs2_alloc *al = &ip->i_alloc;
+       struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
+       struct gfs2_alloc *al = ip->i_alloc;
        struct gfs2_quota_data **qd = al->al_qd;
        int error;
 
@@ -457,45 +505,44 @@ int gfs2_quota_hold(struct gfs2_inode *ip, uint32_t uid, uint32_t gid)
        if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
                return 0;
 
-       error = qdsb_get(sdp, QUOTA_USER, ip->i_di.di_uid, CREATE, qd);
+       error = qdsb_get(sdp, QUOTA_USER, ip->i_inode.i_uid, qd);
        if (error)
                goto out;
        al->al_qd_num++;
        qd++;
 
-       error = qdsb_get(sdp, QUOTA_GROUP, ip->i_di.di_gid, CREATE, qd);
+       error = qdsb_get(sdp, QUOTA_GROUP, ip->i_inode.i_gid, qd);
        if (error)
                goto out;
        al->al_qd_num++;
        qd++;
 
-       if (uid != NO_QUOTA_CHANGE && uid != ip->i_di.di_uid) {
-               error = qdsb_get(sdp, QUOTA_USER, uid, CREATE, qd);
+       if (uid != NO_QUOTA_CHANGE && uid != ip->i_inode.i_uid) {
+               error = qdsb_get(sdp, QUOTA_USER, uid, qd);
                if (error)
                        goto out;
                al->al_qd_num++;
                qd++;
        }
 
-       if (gid != NO_QUOTA_CHANGE && gid != ip->i_di.di_gid) {
-               error = qdsb_get(sdp, QUOTA_GROUP, gid, CREATE, qd);
+       if (gid != NO_QUOTA_CHANGE && gid != ip->i_inode.i_gid) {
+               error = qdsb_get(sdp, QUOTA_GROUP, gid, qd);
                if (error)
                        goto out;
                al->al_qd_num++;
                qd++;
        }
 
- out:
+out:
        if (error)
                gfs2_quota_unhold(ip);
-
        return error;
 }
 
 void gfs2_quota_unhold(struct gfs2_inode *ip)
 {
-       struct gfs2_sbd *sdp = ip->i_sbd;
-       struct gfs2_alloc *al = &ip->i_alloc;
+       struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
+       struct gfs2_alloc *al = ip->i_alloc;
        unsigned int x;
 
        gfs2_assert_warn(sdp, !test_bit(GIF_QD_LOCKED, &ip->i_flags));
@@ -509,32 +556,30 @@ void gfs2_quota_unhold(struct gfs2_inode *ip)
 
 static int sort_qd(const void *a, const void *b)
 {
-       struct gfs2_quota_data *qd_a = *(struct gfs2_quota_data **)a;
-       struct gfs2_quota_data *qd_b = *(struct gfs2_quota_data **)b;
-       int ret = 0;
+       const struct gfs2_quota_data *qd_a = *(const struct gfs2_quota_data **)a;
+       const struct gfs2_quota_data *qd_b = *(const struct gfs2_quota_data **)b;
 
        if (!test_bit(QDF_USER, &qd_a->qd_flags) !=
            !test_bit(QDF_USER, &qd_b->qd_flags)) {
                if (test_bit(QDF_USER, &qd_a->qd_flags))
-                       ret = -1;
+                       return -1;
                else
-                       ret = 1;
-       } else {
-               if (qd_a->qd_id < qd_b->qd_id)
-                       ret = -1;
-               else if (qd_a->qd_id > qd_b->qd_id)
-                       ret = 1;
+                       return 1;
        }
+       if (qd_a->qd_id < qd_b->qd_id)
+               return -1;
+       if (qd_a->qd_id > qd_b->qd_id)
+               return 1;
 
-       return ret;
+       return 0;
 }
 
-static void do_qc(struct gfs2_quota_data *qd, int64_t change)
+static void do_qc(struct gfs2_quota_data *qd, s64 change)
 {
        struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
-       struct gfs2_inode *ip = sdp->sd_qc_inode->u.generic_ip;
+       struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
        struct gfs2_quota_change *qc = qd->qd_bh_qc;
-       int64_t x;
+       s64 x;
 
        mutex_lock(&sdp->sd_quota_mutex);
        gfs2_trans_add_bh(ip->i_gl, qd->qd_bh, 1);
@@ -547,13 +592,12 @@ static void do_qc(struct gfs2_quota_data *qd, int64_t change)
                qc->qc_id = cpu_to_be32(qd->qd_id);
        }
 
-       x = qc->qc_change;
-       x = be64_to_cpu(x) + change;
+       x = be64_to_cpu(qc->qc_change) + change;
        qc->qc_change = cpu_to_be64(x);
 
-       spin_lock(&sdp->sd_quota_spin);
+       spin_lock(&qd_lru_lock);
        qd->qd_change = x;
-       spin_unlock(&sdp->sd_quota_spin);
+       spin_unlock(&qd_lru_lock);
 
        if (!x) {
                gfs2_assert_warn(sdp, test_bit(QDF_CHANGE, &qd->qd_flags));
@@ -566,31 +610,74 @@ static void do_qc(struct gfs2_quota_data *qd, int64_t change)
                qd_hold(qd);
                slot_hold(qd);
        }
-                       
+
        mutex_unlock(&sdp->sd_quota_mutex);
 }
 
 /**
- * gfs2_adjust_quota
+ * gfs2_adjust_quota - adjust record of current block usage
+ * @ip: The quota inode
+ * @loc: Offset of the entry in the quota file
+ * @change: The amount of usage change to record
+ * @qd: The quota data
+ * @fdq: The updated limits to record
  *
  * This function was mostly borrowed from gfs2_block_truncate_page which was
  * in turn mostly borrowed from ext3
+ *
+ * Returns: 0 or -ve on error
  */
+
 static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc,
-                            int64_t change, struct gfs2_quota_data *qd)
+                            s64 change, struct gfs2_quota_data *qd,
+                            struct fs_disk_quota *fdq)
 {
-       struct inode *inode = ip->i_vnode;
+       struct inode *inode = &ip->i_inode;
+       struct gfs2_sbd *sdp = GFS2_SB(inode);
        struct address_space *mapping = inode->i_mapping;
        unsigned long index = loc >> PAGE_CACHE_SHIFT;
-       unsigned offset = loc & (PAGE_CACHE_SHIFT - 1);
+       unsigned offset = loc & (PAGE_CACHE_SIZE - 1);
        unsigned blocksize, iblock, pos;
-       struct buffer_head *bh;
+       struct buffer_head *bh, *dibh;
        struct page *page;
-       void *kaddr;
-       __be64 *ptr;
-       u64 value;
-       int err = -EIO;
+       void *kaddr, *ptr;
+       struct gfs2_quota q, *qp;
+       int err, nbytes;
+       u64 size;
+
+       if (gfs2_is_stuffed(ip))
+               gfs2_unstuff_dinode(ip, NULL);
+
+       memset(&q, 0, sizeof(struct gfs2_quota));
+       err = gfs2_internal_read(ip, NULL, (char *)&q, &loc, sizeof(q));
+       if (err < 0)
+               return err;
+
+       err = -EIO;
+       qp = &q;
+       qp->qu_value = be64_to_cpu(qp->qu_value);
+       qp->qu_value += change;
+       qp->qu_value = cpu_to_be64(qp->qu_value);
+       qd->qd_qb.qb_value = qp->qu_value;
+       if (fdq) {
+               if (fdq->d_fieldmask & FS_DQ_BSOFT) {
+                       qp->qu_warn = cpu_to_be64(fdq->d_blk_softlimit >> sdp->sd_fsb2bb_shift);
+                       qd->qd_qb.qb_warn = qp->qu_warn;
+               }
+               if (fdq->d_fieldmask & FS_DQ_BHARD) {
+                       qp->qu_limit = cpu_to_be64(fdq->d_blk_hardlimit >> sdp->sd_fsb2bb_shift);
+                       qd->qd_qb.qb_limit = qp->qu_limit;
+               }
+               if (fdq->d_fieldmask & FS_DQ_BCOUNT) {
+                       qp->qu_value = cpu_to_be64(fdq->d_bcount >> sdp->sd_fsb2bb_shift);
+                       qd->qd_qb.qb_value = qp->qu_value;
+               }
+       }
 
+       /* Write the quota into the quota file on disk */
+       ptr = qp;
+       nbytes = sizeof(struct gfs2_quota);
+get_a_page:
        page = grab_cache_page(mapping, index);
        if (!page)
                return -ENOMEM;
@@ -610,36 +697,62 @@ static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc,
        }
 
        if (!buffer_mapped(bh)) {
-               gfs2_get_block(inode, iblock, bh, 1);
+               gfs2_block_map(inode, iblock, bh, 1);
                if (!buffer_mapped(bh))
-                       goto unlock;
+                       goto unlock_out;
+               /* If it's a newly allocated disk block for quota, zero it */
+               if (buffer_new(bh))
+                       zero_user(page, pos - blocksize, bh->b_size);
        }
 
        if (PageUptodate(page))
                set_buffer_uptodate(bh);
 
        if (!buffer_uptodate(bh)) {
-               ll_rw_block(READ, 1, &bh);
+               ll_rw_block(READ_META, 1, &bh);
                wait_on_buffer(bh);
                if (!buffer_uptodate(bh))
-                       goto unlock;
+                       goto unlock_out;
        }
 
        gfs2_trans_add_bh(ip->i_gl, bh, 0);
 
        kaddr = kmap_atomic(page, KM_USER0);
-       ptr = (__be64 *)(kaddr + offset);
-       value = *ptr = cpu_to_be64(be64_to_cpu(*ptr) + change);
+       if (offset + sizeof(struct gfs2_quota) > PAGE_CACHE_SIZE)
+               nbytes = PAGE_CACHE_SIZE - offset;
+       memcpy(kaddr + offset, ptr, nbytes);
        flush_dcache_page(page);
        kunmap_atomic(kaddr, KM_USER0);
-       err = 0;
-       qd->qd_qb.qb_magic = cpu_to_be32(GFS2_MAGIC);
-#if 0
-       qd->qd_qb.qb_limit = cpu_to_be64(q.qu_limit);
-       qd->qd_qb.qb_warn = cpu_to_be64(q.qu_warn);
-#endif
-       qd->qd_qb.qb_value = cpu_to_be64(value);
-unlock:
+       unlock_page(page);
+       page_cache_release(page);
+
+       /* If quota straddles page boundary, we need to update the rest of the
+        * quota at the beginning of the next page */
+       if ((offset + sizeof(struct gfs2_quota)) > PAGE_CACHE_SIZE) {
+               ptr = ptr + nbytes;
+               nbytes = sizeof(struct gfs2_quota) - nbytes;
+               offset = 0;
+               index++;
+               goto get_a_page;
+       }
+
+       /* Update the disk inode timestamp and size (if extended) */
+       err = gfs2_meta_inode_buffer(ip, &dibh);
+       if (err)
+               goto out;
+
+       size = loc + sizeof(struct gfs2_quota);
+       if (size > inode->i_size)
+               i_size_write(inode, size);
+       inode->i_mtime = inode->i_atime = CURRENT_TIME;
+       gfs2_trans_add_bh(ip->i_gl, dibh, 1);
+       gfs2_dinode_out(ip, dibh->b_data);
+       brelse(dibh);
+       mark_inode_dirty(inode);
+
+out:
+       return err;
+unlock_out:
        unlock_page(page);
        page_cache_release(page);
        return err;
@@ -648,28 +761,27 @@ unlock:
 static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)
 {
        struct gfs2_sbd *sdp = (*qda)->qd_gl->gl_sbd;
-       struct gfs2_inode *ip = sdp->sd_quota_inode->u.generic_ip;
+       struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
        unsigned int data_blocks, ind_blocks;
-       struct file_ra_state ra_state;
        struct gfs2_holder *ghs, i_gh;
        unsigned int qx, x;
        struct gfs2_quota_data *qd;
        loff_t offset;
-       unsigned int nalloc = 0;
+       unsigned int nalloc = 0, blocks;
        struct gfs2_alloc *al = NULL;
        int error;
 
        gfs2_write_calc_reserv(ip, sizeof(struct gfs2_quota),
                              &data_blocks, &ind_blocks);
 
-       ghs = kcalloc(num_qd, sizeof(struct gfs2_holder), GFP_KERNEL);
+       ghs = kcalloc(num_qd, sizeof(struct gfs2_holder), GFP_NOFS);
        if (!ghs)
                return -ENOMEM;
 
        sort(qda, num_qd, sizeof(struct gfs2_quota_data *), sort_qd, NULL);
+       mutex_lock_nested(&ip->i_inode.i_mutex, I_MUTEX_QUOTA);
        for (qx = 0; qx < num_qd; qx++) {
-               error = gfs2_glock_nq_init(qda[qx]->qd_gl,
-                                          LM_ST_EXCLUSIVE,
+               error = gfs2_glock_nq_init(qda[qx]->qd_gl, LM_ST_EXCLUSIVE,
                                           GL_NOCACHE, &ghs[qx]);
                if (error)
                        goto out;
@@ -680,158 +792,147 @@ static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)
                goto out;
 
        for (x = 0; x < num_qd; x++) {
-               int alloc_required;
-
                offset = qd2offset(qda[x]);
-               error = gfs2_write_alloc_required(ip, offset,
-                                                 sizeof(struct gfs2_quota),
-                                                 &alloc_required);
-               if (error)
-                       goto out_gunlock;
-               if (alloc_required)
+               if (gfs2_write_alloc_required(ip, offset,
+                                             sizeof(struct gfs2_quota)))
                        nalloc++;
        }
 
-       if (nalloc) {
-               al = gfs2_alloc_get(ip);
+       al = gfs2_alloc_get(ip);
+       if (!al) {
+               error = -ENOMEM;
+               goto out_gunlock;
+       }
+       /* 
+        * 1 blk for unstuffing inode if stuffed. We add this extra
+        * block to the reservation unconditionally. If the inode
+        * doesn't need unstuffing, the block will be released to the 
+        * rgrp since it won't be allocated during the transaction
+        */
+       al->al_requested = 1;
+       /* +3 in the end for unstuffing block, inode size update block
+        * and another block in case quota straddles page boundary and 
+        * two blocks need to be updated instead of 1 */
+       blocks = num_qd * data_blocks + RES_DINODE + num_qd + 3;
 
-               al->al_requested = nalloc * (data_blocks + ind_blocks);
+       if (nalloc)
+               al->al_requested += nalloc * (data_blocks + ind_blocks);                
+       error = gfs2_inplace_reserve(ip);
+       if (error)
+               goto out_alloc;
 
-               error = gfs2_inplace_reserve(ip);
-               if (error)
-                       goto out_alloc;
+       if (nalloc)
+               blocks += gfs2_rg_blocks(al) + nalloc * ind_blocks + RES_STATFS;
 
-               error = gfs2_trans_begin(sdp,
-                                        al->al_rgd->rd_ri.ri_length +
-                                        num_qd * data_blocks +
-                                        nalloc * ind_blocks +
-                                        RES_DINODE + num_qd +
-                                        RES_STATFS, 0);
-               if (error)
-                       goto out_ipres;
-       } else {
-               error = gfs2_trans_begin(sdp,
-                                        num_qd * data_blocks +
-                                        RES_DINODE + num_qd, 0);
-               if (error)
-                       goto out_gunlock;
-       }
+       error = gfs2_trans_begin(sdp, blocks, 0);
+       if (error)
+               goto out_ipres;
 
-       file_ra_state_init(&ra_state, ip->i_vnode->i_mapping);
        for (x = 0; x < num_qd; x++) {
                qd = qda[x];
                offset = qd2offset(qd);
-               error = gfs2_adjust_quota(ip, offset, qd->qd_change_sync,
-                                         (struct gfs2_quota_data *)
-                                         qd->qd_gl->gl_lvb);
+               error = gfs2_adjust_quota(ip, offset, qd->qd_change_sync, qd, NULL);
                if (error)
                        goto out_end_trans;
 
                do_qc(qd, -qd->qd_change_sync);
+               set_bit(QDF_REFRESH, &qd->qd_flags);
        }
 
        error = 0;
 
- out_end_trans:
+out_end_trans:
        gfs2_trans_end(sdp);
-
- out_ipres:
-       if (nalloc)
-               gfs2_inplace_release(ip);
-
- out_alloc:
-       if (nalloc)
-               gfs2_alloc_put(ip);
-
- out_gunlock:
+out_ipres:
+       gfs2_inplace_release(ip);
+out_alloc:
+       gfs2_alloc_put(ip);
+out_gunlock:
        gfs2_glock_dq_uninit(&i_gh);
-
- out:
+out:
        while (qx--)
                gfs2_glock_dq_uninit(&ghs[qx]);
+       mutex_unlock(&ip->i_inode.i_mutex);
        kfree(ghs);
        gfs2_log_flush(ip->i_gl->gl_sbd, ip->i_gl);
-
        return error;
 }
 
+static int update_qd(struct gfs2_sbd *sdp, struct gfs2_quota_data *qd)
+{
+       struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
+       struct gfs2_quota q;
+       struct gfs2_quota_lvb *qlvb;
+       loff_t pos;
+       int error;
+
+       memset(&q, 0, sizeof(struct gfs2_quota));
+       pos = qd2offset(qd);
+       error = gfs2_internal_read(ip, NULL, (char *)&q, &pos, sizeof(q));
+       if (error < 0)
+               return error;
+
+       qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb;
+       qlvb->qb_magic = cpu_to_be32(GFS2_MAGIC);
+       qlvb->__pad = 0;
+       qlvb->qb_limit = q.qu_limit;
+       qlvb->qb_warn = q.qu_warn;
+       qlvb->qb_value = q.qu_value;
+       qd->qd_qb = *qlvb;
+
+       return 0;
+}
+
 static int do_glock(struct gfs2_quota_data *qd, int force_refresh,
                    struct gfs2_holder *q_gh)
 {
        struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
-       struct gfs2_inode *ip = sdp->sd_quota_inode->u.generic_ip;
+       struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
        struct gfs2_holder i_gh;
-       struct gfs2_quota q;
-       char buf[sizeof(struct gfs2_quota)];
-       struct file_ra_state ra_state;
        int error;
 
-       file_ra_state_init(&ra_state, sdp->sd_quota_inode->i_mapping);
- restart:
+restart:
        error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_SHARED, 0, q_gh);
        if (error)
                return error;
 
-       gfs2_quota_lvb_in(&qd->qd_qb, qd->qd_gl->gl_lvb);
+       qd->qd_qb = *(struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb;
 
-       if (force_refresh || qd->qd_qb.qb_magic != GFS2_MAGIC) {
-               loff_t pos;
+       if (force_refresh || qd->qd_qb.qb_magic != cpu_to_be32(GFS2_MAGIC)) {
                gfs2_glock_dq_uninit(q_gh);
-               error = gfs2_glock_nq_init(qd->qd_gl,
-                                         LM_ST_EXCLUSIVE, GL_NOCACHE,
-                                         q_gh);
+               error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE,
+                                          GL_NOCACHE, q_gh);
                if (error)
                        return error;
 
-               error = gfs2_glock_nq_init(ip->i_gl,
-                                         LM_ST_SHARED, 0,
-                                         &i_gh);
+               error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
                if (error)
                        goto fail;
 
-               memset(buf, 0, sizeof(struct gfs2_quota));
-               pos = qd2offset(qd);
-               error = gfs2_internal_read(ip,
-                                           &ra_state, buf,
-                                           &pos,
-                                           sizeof(struct gfs2_quota));
-               if (error < 0)
+               error = update_qd(sdp, qd);
+               if (error)
                        goto fail_gunlock;
 
                gfs2_glock_dq_uninit(&i_gh);
-
-               gfs2_quota_in(&q, buf);
-
-               memset(&qd->qd_qb, 0, sizeof(struct gfs2_quota_lvb));
-               qd->qd_qb.qb_magic = GFS2_MAGIC;
-               qd->qd_qb.qb_limit = q.qu_limit;
-               qd->qd_qb.qb_warn = q.qu_warn;
-               qd->qd_qb.qb_value = q.qu_value;
-
-               gfs2_quota_lvb_out(&qd->qd_qb, qd->qd_gl->gl_lvb);
-
-               if (gfs2_glock_is_blocking(qd->qd_gl)) {
-                       gfs2_glock_dq_uninit(q_gh);
-                       force_refresh = 0;
-                       goto restart;
-               }
+               gfs2_glock_dq_uninit(q_gh);
+               force_refresh = 0;
+               goto restart;
        }
 
        return 0;
 
- fail_gunlock:
+fail_gunlock:
        gfs2_glock_dq_uninit(&i_gh);
-
- fail:
+fail:
        gfs2_glock_dq_uninit(q_gh);
-
        return error;
 }
 
-int gfs2_quota_lock(struct gfs2_inode *ip, uint32_t uid, uint32_t gid)
+int gfs2_quota_lock(struct gfs2_inode *ip, u32 uid, u32 gid)
 {
-       struct gfs2_sbd *sdp = ip->i_sbd;
-       struct gfs2_alloc *al = &ip->i_alloc;
+       struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
+       struct gfs2_alloc *al = ip->i_alloc;
+       struct gfs2_quota_data *qd;
        unsigned int x;
        int error = 0;
 
@@ -845,7 +946,11 @@ int gfs2_quota_lock(struct gfs2_inode *ip, uint32_t uid, uint32_t gid)
             sort_qd, NULL);
 
        for (x = 0; x < al->al_qd_num; x++) {
-               error = do_glock(al->al_qd[x], NO_FORCE, &al->al_qd_ghs[x]);
+               int force = NO_FORCE;
+               qd = al->al_qd[x];
+               if (test_and_clear_bit(QDF_REFRESH, &qd->qd_flags))
+                       force = FORCE;
+               error = do_glock(qd, force, &al->al_qd_ghs[x]);
                if (error)
                        break;
        }
@@ -865,16 +970,16 @@ static int need_sync(struct gfs2_quota_data *qd)
 {
        struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
        struct gfs2_tune *gt = &sdp->sd_tune;
-       int64_t value;
+       s64 value;
        unsigned int num, den;
        int do_sync = 1;
 
        if (!qd->qd_qb.qb_limit)
                return 0;
 
-       spin_lock(&sdp->sd_quota_spin);
+       spin_lock(&qd_lru_lock);
        value = qd->qd_change;
-       spin_unlock(&sdp->sd_quota_spin);
+       spin_unlock(&qd_lru_lock);
 
        spin_lock(&gt->gt_spin);
        num = gt->gt_quota_scale_num;
@@ -883,13 +988,14 @@ static int need_sync(struct gfs2_quota_data *qd)
 
        if (value < 0)
                do_sync = 0;
-       else if (qd->qd_qb.qb_value >= (int64_t)qd->qd_qb.qb_limit)
+       else if ((s64)be64_to_cpu(qd->qd_qb.qb_value) >=
+                (s64)be64_to_cpu(qd->qd_qb.qb_limit))
                do_sync = 0;
        else {
                value *= gfs2_jindex_size(sdp) * num;
-               do_div(value, den);
-               value += qd->qd_qb.qb_value;
-               if (value < (int64_t)qd->qd_qb.qb_limit)
+               value = div_s64(value, den);
+               value += (s64)be64_to_cpu(qd->qd_qb.qb_value);
+               if (value < (s64)be64_to_cpu(qd->qd_qb.qb_limit))
                        do_sync = 0;
        }
 
@@ -898,7 +1004,7 @@ static int need_sync(struct gfs2_quota_data *qd)
 
 void gfs2_quota_unlock(struct gfs2_inode *ip)
 {
-       struct gfs2_alloc *al = &ip->i_alloc;
+       struct gfs2_alloc *al = ip->i_alloc;
        struct gfs2_quota_data *qda[4];
        unsigned int count = 0;
        unsigned int x;
@@ -925,7 +1031,7 @@ void gfs2_quota_unlock(struct gfs2_inode *ip)
                        qd_unlock(qda[x]);
        }
 
- out:
+out:
        gfs2_quota_unhold(ip);
 }
 
@@ -934,35 +1040,21 @@ void gfs2_quota_unlock(struct gfs2_inode *ip)
 static int print_message(struct gfs2_quota_data *qd, char *type)
 {
        struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
-       char *line;
-       int len;
-
-       line = kmalloc(MAX_LINE, GFP_KERNEL);
-       if (!line)
-               return -ENOMEM;
-
-       len = snprintf(line, MAX_LINE-1,
-                      "GFS2: fsid=%s: quota %s for %s %u\r\n",
-                      sdp->sd_fsname, type,
-                      (test_bit(QDF_USER, &qd->qd_flags)) ? "user" : "group",
-                      qd->qd_id);
-       line[MAX_LINE-1] = 0;
 
-       if (current->signal) { /* Is this test still required? */
-               tty_write_message(current->signal->tty, line);
-       }
-
-       kfree(line);
+       printk(KERN_INFO "GFS2: fsid=%s: quota %s for %s %u\n",
+              sdp->sd_fsname, type,
+              (test_bit(QDF_USER, &qd->qd_flags)) ? "user" : "group",
+              qd->qd_id);
 
        return 0;
 }
 
-int gfs2_quota_check(struct gfs2_inode *ip, uint32_t uid, uint32_t gid)
+int gfs2_quota_check(struct gfs2_inode *ip, u32 uid, u32 gid)
 {
-       struct gfs2_sbd *sdp = ip->i_sbd;
-       struct gfs2_alloc *al = &ip->i_alloc;
+       struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
+       struct gfs2_alloc *al = ip->i_alloc;
        struct gfs2_quota_data *qd;
-       int64_t value;
+       s64 value;
        unsigned int x;
        int error = 0;
 
@@ -979,20 +1071,27 @@ int gfs2_quota_check(struct gfs2_inode *ip, uint32_t uid, uint32_t gid)
                      (qd->qd_id == gid && !test_bit(QDF_USER, &qd->qd_flags))))
                        continue;
 
-               value = qd->qd_qb.qb_value;
-               spin_lock(&sdp->sd_quota_spin);
+               value = (s64)be64_to_cpu(qd->qd_qb.qb_value);
+               spin_lock(&qd_lru_lock);
                value += qd->qd_change;
-               spin_unlock(&sdp->sd_quota_spin);
+               spin_unlock(&qd_lru_lock);
 
-               if (qd->qd_qb.qb_limit && (int64_t)qd->qd_qb.qb_limit < value) {
+               if (be64_to_cpu(qd->qd_qb.qb_limit) && (s64)be64_to_cpu(qd->qd_qb.qb_limit) < value) {
                        print_message(qd, "exceeded");
+                       quota_send_warning(test_bit(QDF_USER, &qd->qd_flags) ?
+                                          USRQUOTA : GRPQUOTA, qd->qd_id,
+                                          sdp->sd_vfs->s_dev, QUOTA_NL_BHARDWARN);
+
                        error = -EDQUOT;
                        break;
-               } else if (qd->qd_qb.qb_warn &&
-                          (int64_t)qd->qd_qb.qb_warn < value &&
+               } else if (be64_to_cpu(qd->qd_qb.qb_warn) &&
+                          (s64)be64_to_cpu(qd->qd_qb.qb_warn) < value &&
                           time_after_eq(jiffies, qd->qd_last_warn +
                                         gfs2_tune_get(sdp,
                                                gt_quota_warn_period) * HZ)) {
+                       quota_send_warning(test_bit(QDF_USER, &qd->qd_flags) ?
+                                          USRQUOTA : GRPQUOTA, qd->qd_id,
+                                          sdp->sd_vfs->s_dev, QUOTA_NL_BSOFTWARN);
                        error = print_message(qd, "warning");
                        qd->qd_last_warn = jiffies;
                }
@@ -1001,17 +1100,16 @@ int gfs2_quota_check(struct gfs2_inode *ip, uint32_t uid, uint32_t gid)
        return error;
 }
 
-void gfs2_quota_change(struct gfs2_inode *ip, int64_t change,
-                      uint32_t uid, uint32_t gid)
+void gfs2_quota_change(struct gfs2_inode *ip, s64 change,
+                      u32 uid, u32 gid)
 {
-       struct gfs2_alloc *al = &ip->i_alloc;
+       struct gfs2_alloc *al = ip->i_alloc;
        struct gfs2_quota_data *qd;
        unsigned int x;
-       unsigned int found = 0;
 
-       if (gfs2_assert_warn(ip->i_sbd, change))
+       if (gfs2_assert_warn(GFS2_SB(&ip->i_inode), change))
                return;
-       if (ip->i_di.di_flags & GFS2_DIF_SYSTEM)
+       if (ip->i_diskflags & GFS2_DIF_SYSTEM)
                return;
 
        for (x = 0; x < al->al_qd_num; x++) {
@@ -1020,13 +1118,13 @@ void gfs2_quota_change(struct gfs2_inode *ip, int64_t change,
                if ((qd->qd_id == uid && test_bit(QDF_USER, &qd->qd_flags)) ||
                    (qd->qd_id == gid && !test_bit(QDF_USER, &qd->qd_flags))) {
                        do_qc(qd, change);
-                       found++;
                }
        }
 }
 
-int gfs2_quota_sync(struct gfs2_sbd *sdp)
+int gfs2_quota_sync(struct super_block *sb, int type, int wait)
 {
+       struct gfs2_sbd *sdp = sb->s_fs_info;
        struct gfs2_quota_data **qda;
        unsigned int max_qd = gfs2_tune_get(sdp, gt_quota_simul_sync);
        unsigned int num_qd;
@@ -1068,13 +1166,18 @@ int gfs2_quota_sync(struct gfs2_sbd *sdp)
        return error;
 }
 
-int gfs2_quota_refresh(struct gfs2_sbd *sdp, int user, uint32_t id)
+static int gfs2_quota_sync_timeo(struct super_block *sb, int type)
+{
+       return gfs2_quota_sync(sb, type, 0);
+}
+
+int gfs2_quota_refresh(struct gfs2_sbd *sdp, int user, u32 id)
 {
        struct gfs2_quota_data *qd;
        struct gfs2_holder q_gh;
        int error;
 
-       error = qd_get(sdp, user, id, CREATE, &qd);
+       error = qd_get(sdp, user, id, &qd);
        if (error)
                return error;
 
@@ -1083,76 +1186,44 @@ int gfs2_quota_refresh(struct gfs2_sbd *sdp, int user, uint32_t id)
                gfs2_glock_dq_uninit(&q_gh);
 
        qd_put(qd);
-
        return error;
 }
 
-#if 0
-int gfs2_quota_read(struct gfs2_sbd *sdp, int user, uint32_t id,
-                   struct gfs2_quota *q)
+static void gfs2_quota_change_in(struct gfs2_quota_change_host *qc, const void *buf)
 {
-       struct gfs2_quota_data *qd;
-       struct gfs2_holder q_gh;
-       int error;
+       const struct gfs2_quota_change *str = buf;
 
-       if (((user) ? (id != current->fsuid) : (!in_group_p(id))) &&
-           !capable(CAP_SYS_ADMIN))
-               return -EACCES;
-
-       error = qd_get(sdp, user, id, CREATE, &qd);
-       if (error)
-               return error;
-
-       error = do_glock(qd, NO_FORCE, &q_gh);
-       if (error)
-               goto out;
-
-       memset(q, 0, sizeof(struct gfs2_quota));
-       q->qu_limit = qd->qd_qb.qb_limit;
-       q->qu_warn = qd->qd_qb.qb_warn;
-       q->qu_value = qd->qd_qb.qb_value;
-
-       spin_lock(&sdp->sd_quota_spin);
-       q->qu_value += qd->qd_change;
-       spin_unlock(&sdp->sd_quota_spin);
-
-       gfs2_glock_dq_uninit(&q_gh);
-
- out:
-       qd_put(qd);
-
-       return error;
+       qc->qc_change = be64_to_cpu(str->qc_change);
+       qc->qc_flags = be32_to_cpu(str->qc_flags);
+       qc->qc_id = be32_to_cpu(str->qc_id);
 }
-#endif  /*  0  */
 
 int gfs2_quota_init(struct gfs2_sbd *sdp)
 {
-       struct gfs2_inode *ip = sdp->sd_qc_inode->u.generic_ip;
-       unsigned int blocks = ip->i_di.di_size >> sdp->sd_sb.sb_bsize_shift;
+       struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
+       u64 size = i_size_read(sdp->sd_qc_inode);
+       unsigned int blocks = size >> sdp->sd_sb.sb_bsize_shift;
        unsigned int x, slot = 0;
        unsigned int found = 0;
-       uint64_t dblock;
-       uint32_t extlen = 0;
+       u64 dblock;
+       u32 extlen = 0;
        int error;
 
-       if (!ip->i_di.di_size ||
-           ip->i_di.di_size > (64 << 20) ||
-           ip->i_di.di_size & (sdp->sd_sb.sb_bsize - 1)) {
-               gfs2_consist_inode(ip);
-               return -EIO;            
-       }
+       if (gfs2_check_internal_file_size(sdp->sd_qc_inode, 1, 64 << 20))
+               return -EIO;
+
        sdp->sd_quota_slots = blocks * sdp->sd_qc_per_block;
        sdp->sd_quota_chunks = DIV_ROUND_UP(sdp->sd_quota_slots, 8 * PAGE_SIZE);
 
        error = -ENOMEM;
 
        sdp->sd_quota_bitmap = kcalloc(sdp->sd_quota_chunks,
-                                      sizeof(unsigned char *), GFP_KERNEL);
+                                      sizeof(unsigned char *), GFP_NOFS);
        if (!sdp->sd_quota_bitmap)
                return error;
 
        for (x = 0; x < sdp->sd_quota_chunks; x++) {
-               sdp->sd_quota_bitmap[x] = kzalloc(PAGE_SIZE, GFP_KERNEL);
+               sdp->sd_quota_bitmap[x] = kzalloc(PAGE_SIZE, GFP_NOFS);
                if (!sdp->sd_quota_bitmap[x])
                        goto fail;
        }
@@ -1163,25 +1234,22 @@ int gfs2_quota_init(struct gfs2_sbd *sdp)
 
                if (!extlen) {
                        int new = 0;
-                       error = gfs2_extent_map(ip->i_vnode, x, &new, &dblock, &extlen);
+                       error = gfs2_extent_map(&ip->i_inode, x, &new, &dblock, &extlen);
                        if (error)
                                goto fail;
                }
-               gfs2_meta_ra(ip->i_gl,  dblock, extlen);
-               error = gfs2_meta_read(ip->i_gl, dblock, DIO_START | DIO_WAIT,
-                                      &bh);
-               if (error)
-                       goto fail;
                error = -EIO;
+               bh = gfs2_meta_ra(ip->i_gl, dblock, extlen);
+               if (!bh)
+                       goto fail;
                if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_QC)) {
                        brelse(bh);
                        goto fail;
                }
 
-               for (y = 0;
-                    y < sdp->sd_qc_per_block && slot < sdp->sd_quota_slots;
+               for (y = 0; y < sdp->sd_qc_per_block && slot < sdp->sd_quota_slots;
                     y++, slot++) {
-                       struct gfs2_quota_change qc;
+                       struct gfs2_quota_change_host qc;
                        struct gfs2_quota_data *qd;
 
                        gfs2_quota_change_in(&qc, bh->b_data +
@@ -1201,13 +1269,12 @@ int gfs2_quota_init(struct gfs2_sbd *sdp)
                        qd->qd_change = qc.qc_change;
                        qd->qd_slot = slot;
                        qd->qd_slot_count = 1;
-                       qd->qd_last_touched = jiffies;
 
-                       spin_lock(&sdp->sd_quota_spin);
+                       spin_lock(&qd_lru_lock);
                        gfs2_icbit_munge(sdp, sdp->sd_quota_bitmap, slot, 1);
                        list_add(&qd->qd_list, &sdp->sd_quota_list);
                        atomic_inc(&sdp->sd_quota_count);
-                       spin_unlock(&sdp->sd_quota_spin);
+                       spin_unlock(&qd_lru_lock);
 
                        found++;
                }
@@ -1222,78 +1289,53 @@ int gfs2_quota_init(struct gfs2_sbd *sdp)
 
        return 0;
 
- fail:
+fail:
        gfs2_quota_cleanup(sdp);
        return error;
 }
 
-void gfs2_quota_scan(struct gfs2_sbd *sdp)
-{
-       struct gfs2_quota_data *qd, *safe;
-       LIST_HEAD(dead);
-
-       spin_lock(&sdp->sd_quota_spin);
-       list_for_each_entry_safe(qd, safe, &sdp->sd_quota_list, qd_list) {
-               if (!qd->qd_count &&
-                   time_after_eq(jiffies, qd->qd_last_touched +
-                               gfs2_tune_get(sdp, gt_quota_cache_secs) * HZ)) {
-                       list_move(&qd->qd_list, &dead);
-                       gfs2_assert_warn(sdp,
-                                        atomic_read(&sdp->sd_quota_count) > 0);
-                       atomic_dec(&sdp->sd_quota_count);
-               }
-       }
-       spin_unlock(&sdp->sd_quota_spin);
-
-       while (!list_empty(&dead)) {
-               qd = list_entry(dead.next, struct gfs2_quota_data, qd_list);
-               list_del(&qd->qd_list);
-
-               gfs2_assert_warn(sdp, !qd->qd_change);
-               gfs2_assert_warn(sdp, !qd->qd_slot_count);
-               gfs2_assert_warn(sdp, !qd->qd_bh_count);
-
-               gfs2_lvb_unhold(qd->qd_gl);
-               kfree(qd);
-       }
-}
-
 void gfs2_quota_cleanup(struct gfs2_sbd *sdp)
 {
        struct list_head *head = &sdp->sd_quota_list;
        struct gfs2_quota_data *qd;
        unsigned int x;
 
-       spin_lock(&sdp->sd_quota_spin);
+       spin_lock(&qd_lru_lock);
        while (!list_empty(head)) {
                qd = list_entry(head->prev, struct gfs2_quota_data, qd_list);
 
-               if (qd->qd_count > 1 ||
-                   (qd->qd_count && !test_bit(QDF_CHANGE, &qd->qd_flags))) {
+               if (atomic_read(&qd->qd_count) > 1 ||
+                   (atomic_read(&qd->qd_count) &&
+                    !test_bit(QDF_CHANGE, &qd->qd_flags))) {
                        list_move(&qd->qd_list, head);
-                       spin_unlock(&sdp->sd_quota_spin);
+                       spin_unlock(&qd_lru_lock);
                        schedule();
-                       spin_lock(&sdp->sd_quota_spin);
+                       spin_lock(&qd_lru_lock);
                        continue;
                }
 
                list_del(&qd->qd_list);
+               /* Also remove if this qd exists in the reclaim list */
+               if (!list_empty(&qd->qd_reclaim)) {
+                       list_del_init(&qd->qd_reclaim);
+                       atomic_dec(&qd_lru_count);
+               }
                atomic_dec(&sdp->sd_quota_count);
-               spin_unlock(&sdp->sd_quota_spin);
+               spin_unlock(&qd_lru_lock);
 
-               if (!qd->qd_count) {
+               if (!atomic_read(&qd->qd_count)) {
                        gfs2_assert_warn(sdp, !qd->qd_change);
                        gfs2_assert_warn(sdp, !qd->qd_slot_count);
                } else
                        gfs2_assert_warn(sdp, qd->qd_slot_count == 1);
                gfs2_assert_warn(sdp, !qd->qd_bh_count);
 
-               gfs2_lvb_unhold(qd->qd_gl);
-               kfree(qd);
+               gfs2_glock_put(qd->qd_gl);
+               kmem_cache_free(gfs2_quotad_cachep, qd);
 
-               spin_lock(&sdp->sd_quota_spin);
+               spin_lock(&qd_lru_lock);
        }
-       spin_unlock(&sdp->sd_quota_spin);
+       spin_unlock(&qd_lru_lock);
 
        gfs2_assert_warn(sdp, !atomic_read(&sdp->sd_quota_count));
 
@@ -1304,3 +1346,299 @@ void gfs2_quota_cleanup(struct gfs2_sbd *sdp)
        }
 }
 
+static void quotad_error(struct gfs2_sbd *sdp, const char *msg, int error)
+{
+       if (error == 0 || error == -EROFS)
+               return;
+       if (!test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
+               fs_err(sdp, "gfs2_quotad: %s error %d\n", msg, error);
+}
+
+static void quotad_check_timeo(struct gfs2_sbd *sdp, const char *msg,
+                              int (*fxn)(struct super_block *sb, int type),
+                              unsigned long t, unsigned long *timeo,
+                              unsigned int *new_timeo)
+{
+       if (t >= *timeo) {
+               int error = fxn(sdp->sd_vfs, 0);
+               quotad_error(sdp, msg, error);
+               *timeo = gfs2_tune_get_i(&sdp->sd_tune, new_timeo) * HZ;
+       } else {
+               *timeo -= t;
+       }
+}
+
+static void quotad_check_trunc_list(struct gfs2_sbd *sdp)
+{
+       struct gfs2_inode *ip;
+
+       while(1) {
+               ip = NULL;
+               spin_lock(&sdp->sd_trunc_lock);
+               if (!list_empty(&sdp->sd_trunc_list)) {
+                       ip = list_entry(sdp->sd_trunc_list.next,
+                                       struct gfs2_inode, i_trunc_list);
+                       list_del_init(&ip->i_trunc_list);
+               }
+               spin_unlock(&sdp->sd_trunc_lock);
+               if (ip == NULL)
+                       return;
+               gfs2_glock_finish_truncate(ip);
+       }
+}
+
+void gfs2_wake_up_statfs(struct gfs2_sbd *sdp) {
+       if (!sdp->sd_statfs_force_sync) {
+               sdp->sd_statfs_force_sync = 1;
+               wake_up(&sdp->sd_quota_wait);
+       }
+}
+
+
+/**
+ * gfs2_quotad - Write cached quota changes into the quota file
+ * @sdp: Pointer to GFS2 superblock
+ *
+ */
+
+int gfs2_quotad(void *data)
+{
+       struct gfs2_sbd *sdp = data;
+       struct gfs2_tune *tune = &sdp->sd_tune;
+       unsigned long statfs_timeo = 0;
+       unsigned long quotad_timeo = 0;
+       unsigned long t = 0;
+       DEFINE_WAIT(wait);
+       int empty;
+
+       while (!kthread_should_stop()) {
+
+               /* Update the master statfs file */
+               if (sdp->sd_statfs_force_sync) {
+                       int error = gfs2_statfs_sync(sdp->sd_vfs, 0);
+                       quotad_error(sdp, "statfs", error);
+                       statfs_timeo = gfs2_tune_get(sdp, gt_statfs_quantum) * HZ;
+               }
+               else
+                       quotad_check_timeo(sdp, "statfs", gfs2_statfs_sync, t,
+                                          &statfs_timeo,
+                                          &tune->gt_statfs_quantum);
+
+               /* Update quota file */
+               quotad_check_timeo(sdp, "sync", gfs2_quota_sync_timeo, t,
+                                  &quotad_timeo, &tune->gt_quota_quantum);
+
+               /* Check for & recover partially truncated inodes */
+               quotad_check_trunc_list(sdp);
+
+               if (freezing(current))
+                       refrigerator();
+               t = min(quotad_timeo, statfs_timeo);
+
+               prepare_to_wait(&sdp->sd_quota_wait, &wait, TASK_INTERRUPTIBLE);
+               spin_lock(&sdp->sd_trunc_lock);
+               empty = list_empty(&sdp->sd_trunc_list);
+               spin_unlock(&sdp->sd_trunc_lock);
+               if (empty && !sdp->sd_statfs_force_sync)
+                       t -= schedule_timeout(t);
+               else
+                       t = 0;
+               finish_wait(&sdp->sd_quota_wait, &wait);
+       }
+
+       return 0;
+}
+
+static int gfs2_quota_get_xstate(struct super_block *sb,
+                                struct fs_quota_stat *fqs)
+{
+       struct gfs2_sbd *sdp = sb->s_fs_info;
+
+       memset(fqs, 0, sizeof(struct fs_quota_stat));
+       fqs->qs_version = FS_QSTAT_VERSION;
+
+       switch (sdp->sd_args.ar_quota) {
+       case GFS2_QUOTA_ON:
+               fqs->qs_flags |= (FS_QUOTA_UDQ_ENFD | FS_QUOTA_GDQ_ENFD);
+               /*FALLTHRU*/
+       case GFS2_QUOTA_ACCOUNT:
+               fqs->qs_flags |= (FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT);
+               break;
+       case GFS2_QUOTA_OFF:
+               break;
+       }
+
+       if (sdp->sd_quota_inode) {
+               fqs->qs_uquota.qfs_ino = GFS2_I(sdp->sd_quota_inode)->i_no_addr;
+               fqs->qs_uquota.qfs_nblks = sdp->sd_quota_inode->i_blocks;
+       }
+       fqs->qs_uquota.qfs_nextents = 1; /* unsupported */
+       fqs->qs_gquota = fqs->qs_uquota; /* its the same inode in both cases */
+       fqs->qs_incoredqs = atomic_read(&qd_lru_count);
+       return 0;
+}
+
+static int gfs2_get_dqblk(struct super_block *sb, int type, qid_t id,
+                         struct fs_disk_quota *fdq)
+{
+       struct gfs2_sbd *sdp = sb->s_fs_info;
+       struct gfs2_quota_lvb *qlvb;
+       struct gfs2_quota_data *qd;
+       struct gfs2_holder q_gh;
+       int error;
+
+       memset(fdq, 0, sizeof(struct fs_disk_quota));
+
+       if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
+               return -ESRCH; /* Crazy XFS error code */
+
+       if (type == USRQUOTA)
+               type = QUOTA_USER;
+       else if (type == GRPQUOTA)
+               type = QUOTA_GROUP;
+       else
+               return -EINVAL;
+
+       error = qd_get(sdp, type, id, &qd);
+       if (error)
+               return error;
+       error = do_glock(qd, FORCE, &q_gh);
+       if (error)
+               goto out;
+
+       qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb;
+       fdq->d_version = FS_DQUOT_VERSION;
+       fdq->d_flags = (type == QUOTA_USER) ? FS_USER_QUOTA : FS_GROUP_QUOTA;
+       fdq->d_id = id;
+       fdq->d_blk_hardlimit = be64_to_cpu(qlvb->qb_limit) << sdp->sd_fsb2bb_shift;
+       fdq->d_blk_softlimit = be64_to_cpu(qlvb->qb_warn) << sdp->sd_fsb2bb_shift;
+       fdq->d_bcount = be64_to_cpu(qlvb->qb_value) << sdp->sd_fsb2bb_shift;
+
+       gfs2_glock_dq_uninit(&q_gh);
+out:
+       qd_put(qd);
+       return error;
+}
+
+/* GFS2 only supports a subset of the XFS fields */
+#define GFS2_FIELDMASK (FS_DQ_BSOFT|FS_DQ_BHARD|FS_DQ_BCOUNT)
+
+static int gfs2_set_dqblk(struct super_block *sb, int type, qid_t id,
+                         struct fs_disk_quota *fdq)
+{
+       struct gfs2_sbd *sdp = sb->s_fs_info;
+       struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
+       struct gfs2_quota_data *qd;
+       struct gfs2_holder q_gh, i_gh;
+       unsigned int data_blocks, ind_blocks;
+       unsigned int blocks = 0;
+       int alloc_required;
+       struct gfs2_alloc *al;
+       loff_t offset;
+       int error;
+
+       if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
+               return -ESRCH; /* Crazy XFS error code */
+
+       switch(type) {
+       case USRQUOTA:
+               type = QUOTA_USER;
+               if (fdq->d_flags != FS_USER_QUOTA)
+                       return -EINVAL;
+               break;
+       case GRPQUOTA:
+               type = QUOTA_GROUP;
+               if (fdq->d_flags != FS_GROUP_QUOTA)
+                       return -EINVAL;
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       if (fdq->d_fieldmask & ~GFS2_FIELDMASK)
+               return -EINVAL;
+       if (fdq->d_id != id)
+               return -EINVAL;
+
+       error = qd_get(sdp, type, id, &qd);
+       if (error)
+               return error;
+
+       mutex_lock(&ip->i_inode.i_mutex);
+       error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE, 0, &q_gh);
+       if (error)
+               goto out_put;
+       error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
+       if (error)
+               goto out_q;
+
+       /* Check for existing entry, if none then alloc new blocks */
+       error = update_qd(sdp, qd);
+       if (error)
+               goto out_i;
+
+       /* If nothing has changed, this is a no-op */
+       if ((fdq->d_fieldmask & FS_DQ_BSOFT) &&
+           ((fdq->d_blk_softlimit >> sdp->sd_fsb2bb_shift) == be64_to_cpu(qd->qd_qb.qb_warn)))
+               fdq->d_fieldmask ^= FS_DQ_BSOFT;
+
+       if ((fdq->d_fieldmask & FS_DQ_BHARD) &&
+           ((fdq->d_blk_hardlimit >> sdp->sd_fsb2bb_shift) == be64_to_cpu(qd->qd_qb.qb_limit)))
+               fdq->d_fieldmask ^= FS_DQ_BHARD;
+
+       if ((fdq->d_fieldmask & FS_DQ_BCOUNT) &&
+           ((fdq->d_bcount >> sdp->sd_fsb2bb_shift) == be64_to_cpu(qd->qd_qb.qb_value)))
+               fdq->d_fieldmask ^= FS_DQ_BCOUNT;
+
+       if (fdq->d_fieldmask == 0)
+               goto out_i;
+
+       offset = qd2offset(qd);
+       alloc_required = gfs2_write_alloc_required(ip, offset, sizeof(struct gfs2_quota));
+       if (gfs2_is_stuffed(ip))
+               alloc_required = 1;
+       if (alloc_required) {
+               al = gfs2_alloc_get(ip);
+               if (al == NULL)
+                       goto out_i;
+               gfs2_write_calc_reserv(ip, sizeof(struct gfs2_quota),
+                                      &data_blocks, &ind_blocks);
+               blocks = al->al_requested = 1 + data_blocks + ind_blocks;
+               error = gfs2_inplace_reserve(ip);
+               if (error)
+                       goto out_alloc;
+               blocks += gfs2_rg_blocks(al);
+       }
+
+       /* Some quotas span block boundaries and can update two blocks,
+          adding an extra block to the transaction to handle such quotas */
+       error = gfs2_trans_begin(sdp, blocks + RES_DINODE + 2, 0);
+       if (error)
+               goto out_release;
+
+       /* Apply changes */
+       error = gfs2_adjust_quota(ip, offset, 0, qd, fdq);
+
+       gfs2_trans_end(sdp);
+out_release:
+       if (alloc_required) {
+               gfs2_inplace_release(ip);
+out_alloc:
+               gfs2_alloc_put(ip);
+       }
+out_i:
+       gfs2_glock_dq_uninit(&i_gh);
+out_q:
+       gfs2_glock_dq_uninit(&q_gh);
+out_put:
+       mutex_unlock(&ip->i_inode.i_mutex);
+       qd_put(qd);
+       return error;
+}
+
+const struct quotactl_ops gfs2_quotactl_ops = {
+       .quota_sync     = gfs2_quota_sync,
+       .get_xstate     = gfs2_quota_get_xstate,
+       .get_dqblk      = gfs2_get_dqblk,
+       .set_dqblk      = gfs2_set_dqblk,
+};