Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mfasheh/ocfs2

* 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mfasheh/ocfs2: (138 commits)
  ocfs2: Access the right buffer_head in ocfs2_merge_rec_left.
  ocfs2: use min_t in ocfs2_quota_read()
  ocfs2: remove unneeded lvb casts
  ocfs2: Add xattr support checking in init_security
  ocfs2: alloc xattr bucket in ocfs2_xattr_set_handle
  ocfs2: calculate and reserve credits for xattr value in mknod
  ocfs2/xattr: fix credits calculation during index create
  ocfs2/xattr: Always updating ctime during xattr set.
  ocfs2/xattr: Remove extend_trans call and add its credits from the beginning
  ocfs2/dlm: Fix race during lockres mastery
  ocfs2/dlm: Fix race in adding/removing lockres' to/from the tracking list
  ocfs2/dlm: Hold off sending lockres drop ref message while lockres is migrating
  ocfs2/dlm: Clean up errors in dlm_proxy_ast_handler()
  ocfs2/dlm: Fix a race between migrate request and exit domain
  ocfs2: One more hamming code optimization.
  ocfs2: Another hamming code optimization.
  ocfs2: Don't hand-code xor in ocfs2_hamming_encode().
  ocfs2: Enable metadata checksums.
  ocfs2: Validate superblock with checksum and ecc.
  ocfs2: Checksum and ECC for directory blocks.
  ...

10 files changed, 253 insertions, 192 deletions

diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index 95ac82340c3b..39da666067b9 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -56,8 +56,6 @@ header-y += dlm_device.h
 header-y += dlm_netlink.h
 header-y += dm-ioctl.h
 header-y += dn.h
-header-y += dqblk_v1.h
-header-y += dqblk_v2.h
 header-y += dqblk_xfs.h
 header-y += efs_fs_sb.h
 header-y += elf-fdpic.h
@@ -134,8 +132,6 @@ header-y += posix_types.h
 header-y += ppdev.h
 header-y += prctl.h
 header-y += qnxtypes.h
-header-y += quotaio_v1.h
-header-y += quotaio_v2.h
 header-y += radeonfb.h
 header-y += raw.h
 header-y += resource.h
diff --git a/include/linux/dqblk_qtree.h b/include/linux/dqblk_qtree.h
new file mode 100644
index 000000000000..82a16527b367
--- /dev/null
+++ b/include/linux/dqblk_qtree.h
@@ -0,0 +1,56 @@
+/*
+ *      Definitions of structures and functions for quota formats using trie
+ */
+
+#ifndef _LINUX_DQBLK_QTREE_H
+#define _LINUX_DQBLK_QTREE_H
+
+#include <linux/types.h>
+
+/* Numbers of blocks needed for updates - we count with the smallest
+ * possible block size (1024) */
+#define QTREE_INIT_ALLOC 4
+#define QTREE_INIT_REWRITE 2
+#define QTREE_DEL_ALLOC 0
+#define QTREE_DEL_REWRITE 6
+
+struct dquot;
+
+/* Operations */
+struct qtree_fmt_operations {
+        void (*mem2disk_dqblk)(void *disk, struct dquot *dquot);        /* Convert given entry from in memory format to disk one */
+        void (*disk2mem_dqblk)(struct dquot *dquot, void *disk);        /* Convert given entry from disk format to in memory one */
+        int (*is_id)(void *disk, struct dquot *dquot);  /* Is this structure for given id? */
+};
+
+/* Inmemory copy of version specific information */
+struct qtree_mem_dqinfo {
+        struct super_block *dqi_sb;     /* Sb quota is on */
+        int dqi_type;                   /* Quota type */
+        unsigned int dqi_blocks;        /* # of blocks in quota file */
+        unsigned int dqi_free_blk;      /* First block in list of free blocks */
+        unsigned int dqi_free_entry;    /* First block with free entry */
+        unsigned int dqi_blocksize_bits;        /* Block size of quota file */
+        unsigned int dqi_entry_size;    /* Size of quota entry in quota file */
+        unsigned int dqi_usable_bs;     /* Space usable in block for quota data */
+        unsigned int dqi_qtree_depth;   /* Precomputed depth of quota tree */
+        struct qtree_fmt_operations *dqi_ops;   /* Operations for entry manipulation */
+};
+
+int qtree_write_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot);
+int qtree_read_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot);
+int qtree_delete_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot);
+int qtree_release_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot);
+int qtree_entry_unused(struct qtree_mem_dqinfo *info, char *disk);
+static inline int qtree_depth(struct qtree_mem_dqinfo *info)
+{
+        unsigned int epb = info->dqi_usable_bs >> 2;
+        unsigned long long entries = epb;
+        int i;
+
+        for (i = 1; entries < (1ULL << 32); i++)
+                entries *= epb;
+        return i;
+}
+
+#endif /* _LINUX_DQBLK_QTREE_H */
diff --git a/include/linux/dqblk_v1.h b/include/linux/dqblk_v1.h
index 57f1250d5a52..3713a7232dd8 100644
--- a/include/linux/dqblk_v1.h
+++ b/include/linux/dqblk_v1.h
@@ -5,9 +5,6 @@
 #ifndef _LINUX_DQBLK_V1_H
 #define _LINUX_DQBLK_V1_H
 
-/* Id of quota format */
-#define QFMT_VFS_OLD 1
-
 /* Root squash turned on */
 #define V1_DQF_RSQUASH 1
 
@@ -17,8 +14,4 @@
 #define V1_DEL_ALLOC 0
 #define V1_DEL_REWRITE 2
 
-/* Special information about quotafile */
-struct v1_mem_dqinfo {
-};
-
 #endif  /* _LINUX_DQBLK_V1_H */
diff --git a/include/linux/dqblk_v2.h b/include/linux/dqblk_v2.h
index 4f853322cb7f..18000a542677 100644
--- a/include/linux/dqblk_v2.h
+++ b/include/linux/dqblk_v2.h
@@ -1,26 +1,16 @@
 /*
- *      Definitions of structures for vfsv0 quota format
+ *  Definitions for vfsv0 quota format
  */
 
 #ifndef _LINUX_DQBLK_V2_H
 #define _LINUX_DQBLK_V2_H
 
-#include <linux/types.h>
-
-/* id numbers of quota format */
-#define QFMT_VFS_V0 2
+#include <linux/dqblk_qtree.h>
 
 /* Numbers of blocks needed for updates */
-#define V2_INIT_ALLOC 4
-#define V2_INIT_REWRITE 2
-#define V2_DEL_ALLOC 0
-#define V2_DEL_REWRITE 6
-
-/* Inmemory copy of version specific information */
-struct v2_mem_dqinfo {
-        unsigned int dqi_blocks;
-        unsigned int dqi_free_blk;
-        unsigned int dqi_free_entry;
-};
+#define V2_INIT_ALLOC QTREE_INIT_ALLOC
+#define V2_INIT_REWRITE QTREE_INIT_REWRITE
+#define V2_DEL_ALLOC QTREE_DEL_ALLOC
+#define V2_DEL_REWRITE QTREE_DEL_REWRITE
 
 #endif /* _LINUX_DQBLK_V2_H */
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index c7d106ef22e2..34456476e761 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -329,6 +329,7 @@ enum jbd_state_bits {
         BH_State,               /* Pins most journal_head state */
         BH_JournalHead,         /* Pins bh->b_private and jh->b_bh */
         BH_Unshadow,            /* Dummy bit, for BJ_Shadow wakeup filtering */
+        BH_JBDPrivateStart,     /* First bit available for private use by FS */
 };
 
 BUFFER_FNS(JBD, jbd)
@@ -1007,6 +1008,35 @@ int __jbd2_journal_clean_checkpoint_list(journal_t *journal);
 int __jbd2_journal_remove_checkpoint(struct journal_head *);
 void __jbd2_journal_insert_checkpoint(struct journal_head *, transaction_t *);
 
+
+/*
+ * Triggers
+ */
+
+struct jbd2_buffer_trigger_type {
+        /*
+         * Fired just before a buffer is written to the journal.
+         * mapped_data is a mapped buffer that is the frozen data for
+         * commit.
+         */
+        void (*t_commit)(struct jbd2_buffer_trigger_type *type,
+                         struct buffer_head *bh, void *mapped_data,
+                         size_t size);
+
+        /*
+         * Fired during journal abort for dirty buffers that will not be
+         * committed.
+         */
+        void (*t_abort)(struct jbd2_buffer_trigger_type *type,
+                        struct buffer_head *bh);
+};
+
+extern void jbd2_buffer_commit_trigger(struct journal_head *jh,
+                                       void *mapped_data,
+                                       struct jbd2_buffer_trigger_type *triggers);
+extern void jbd2_buffer_abort_trigger(struct journal_head *jh,
+                                      struct jbd2_buffer_trigger_type *triggers);
+
 /* Buffer IO */
 extern int
 jbd2_journal_write_metadata_buffer(transaction_t          *transaction,
@@ -1045,6 +1075,8 @@ extern int	 jbd2_journal_extend (handle_t *, int nblocks);
 extern int       jbd2_journal_get_write_access(handle_t *, struct buffer_head *);
 extern int       jbd2_journal_get_create_access (handle_t *, struct buffer_head *);
 extern int       jbd2_journal_get_undo_access(handle_t *, struct buffer_head *);
+void             jbd2_journal_set_triggers(struct buffer_head *,
+                                           struct jbd2_buffer_trigger_type *type);
 extern int       jbd2_journal_dirty_metadata (handle_t *, struct buffer_head *);
 extern void      jbd2_journal_release_buffer (handle_t *, struct buffer_head *);
 extern int       jbd2_journal_forget (handle_t *, struct buffer_head *);
diff --git a/include/linux/journal-head.h b/include/linux/journal-head.h
index bb70ebb6a2d5..525aac3c97df 100644
--- a/include/linux/journal-head.h
+++ b/include/linux/journal-head.h
@@ -12,6 +12,8 @@
 
 typedef unsigned int            tid_t;          /* Unique transaction ID */
 typedef struct transaction_s    transaction_t;  /* Compound transaction type */
+
+
 struct buffer_head;
 
 struct journal_head {
@@ -87,6 +89,12 @@ struct journal_head {
          * [j_list_lock]
          */
         struct journal_head *b_cpnext, *b_cpprev;
+
+        /* Trigger type */
+        struct jbd2_buffer_trigger_type *b_triggers;
+
+        /* Trigger type for the committing transaction's frozen data */
+        struct jbd2_buffer_trigger_type *b_frozen_triggers;
 };
 
 #endif          /* JOURNAL_HEAD_H_INCLUDED */
diff --git a/include/linux/quota.h b/include/linux/quota.h
index 40401b554484..d72d5d84fde5 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -36,17 +36,7 @@
 #include <linux/errno.h>
 #include <linux/types.h>
 
-#define __DQUOT_VERSION__       "dquot_6.5.1"
-#define __DQUOT_NUM_VERSION__   6*10000+5*100+1
-
-/* Size of blocks in which are counted size limits */
-#define QUOTABLOCK_BITS 10
-#define QUOTABLOCK_SIZE (1 << QUOTABLOCK_BITS)
-
-/* Conversion routines from and to quota blocks */
-#define qb2kb(x) ((x) << (QUOTABLOCK_BITS-10))
-#define kb2qb(x) ((x) >> (QUOTABLOCK_BITS-10))
-#define toqb(x) (((x) + QUOTABLOCK_SIZE - 1) >> QUOTABLOCK_BITS)
+#define __DQUOT_VERSION__       "dquot_6.5.2"
 
 #define MAXQUOTAS 2
 #define USRQUOTA  0             /* element used for user quotas */
@@ -80,16 +70,34 @@
 #define Q_GETQUOTA 0x800007     /* get user quota structure */
 #define Q_SETQUOTA 0x800008     /* set user quota structure */
 
+/* Quota format type IDs */
+#define QFMT_VFS_OLD 1
+#define QFMT_VFS_V0 2
+
+/* Size of block in which space limits are passed through the quota
+ * interface */
+#define QIF_DQBLKSIZE_BITS 10
+#define QIF_DQBLKSIZE (1 << QIF_DQBLKSIZE_BITS)
+
 /*
  * Quota structure used for communication with userspace via quotactl
  * Following flags are used to specify which fields are valid
  */
-#define QIF_BLIMITS     1
-#define QIF_SPACE       2
-#define QIF_ILIMITS     4
-#define QIF_INODES      8
-#define QIF_BTIME       16
-#define QIF_ITIME       32
+enum {
+        QIF_BLIMITS_B = 0,
+        QIF_SPACE_B,
+        QIF_ILIMITS_B,
+        QIF_INODES_B,
+        QIF_BTIME_B,
+        QIF_ITIME_B,
+};
+
+#define QIF_BLIMITS     (1 << QIF_BLIMITS_B)
+#define QIF_SPACE       (1 << QIF_SPACE_B)
+#define QIF_ILIMITS     (1 << QIF_ILIMITS_B)
+#define QIF_INODES      (1 << QIF_INODES_B)
+#define QIF_BTIME       (1 << QIF_BTIME_B)
+#define QIF_ITIME       (1 << QIF_ITIME_B)
 #define QIF_LIMITS      (QIF_BLIMITS | QIF_ILIMITS)
 #define QIF_USAGE       (QIF_SPACE | QIF_INODES)
 #define QIF_TIMES       (QIF_BTIME | QIF_ITIME)
@@ -172,7 +180,7 @@ enum {
 #include <asm/atomic.h>
 
 typedef __kernel_uid32_t qid_t; /* Type in which we store ids in memory */
-typedef __u64 qsize_t;          /* Type in which we store sizes */
+typedef long long qsize_t;      /* Type in which we store sizes */
 
 extern spinlock_t dq_data_lock;
 
@@ -187,12 +195,12 @@ extern spinlock_t dq_data_lock;
  * Data for one user/group kept in memory
  */
 struct mem_dqblk {
-        __u32 dqb_bhardlimit;   /* absolute limit on disk blks alloc */
-        __u32 dqb_bsoftlimit;   /* preferred limit on disk blks */
+        qsize_t dqb_bhardlimit; /* absolute limit on disk blks alloc */
+        qsize_t dqb_bsoftlimit; /* preferred limit on disk blks */
         qsize_t dqb_curspace;   /* current used space */
-        __u32 dqb_ihardlimit;   /* absolute limit on allocated inodes */
-        __u32 dqb_isoftlimit;   /* preferred inode limit */
-        __u32 dqb_curinodes;    /* current # allocated inodes */
+        qsize_t dqb_ihardlimit; /* absolute limit on allocated inodes */
+        qsize_t dqb_isoftlimit; /* preferred inode limit */
+        qsize_t dqb_curinodes;  /* current # allocated inodes */
         time_t dqb_btime;       /* time limit for excessive disk use */
         time_t dqb_itime;       /* time limit for excessive inode use */
 };
@@ -212,10 +220,7 @@ struct mem_dqinfo {
         unsigned int dqi_igrace;
         qsize_t dqi_maxblimit;
         qsize_t dqi_maxilimit;
-        union {
-                struct v1_mem_dqinfo v1_i;
-                struct v2_mem_dqinfo v2_i;
-        } u;
+        void *dqi_priv;
 };
 
 struct super_block;
@@ -249,6 +254,11 @@ extern struct dqstats dqstats;
 #define DQ_FAKE_B       3       /* no limits only usage */
 #define DQ_READ_B       4       /* dquot was read into memory */
 #define DQ_ACTIVE_B     5       /* dquot is active (dquot_release not called) */
+#define DQ_LASTSET_B    6       /* Following 6 bits (see QIF_) are reserved\
+                                 * for the mask of entries set via SETQUOTA\
+                                 * quotactl. They are set under dq_data_lock\
+                                 * and the quota format handling dquot can\
+                                 * clear them when it sees fit. */
 
 struct dquot {
         struct hlist_node dq_hash;      /* Hash list in memory */
@@ -287,11 +297,13 @@ struct dquot_operations {
         int (*initialize) (struct inode *, int);
         int (*drop) (struct inode *);
         int (*alloc_space) (struct inode *, qsize_t, int);
-        int (*alloc_inode) (const struct inode *, unsigned long);
+        int (*alloc_inode) (const struct inode *, qsize_t);
         int (*free_space) (struct inode *, qsize_t);
-        int (*free_inode) (const struct inode *, unsigned long);
+        int (*free_inode) (const struct inode *, qsize_t);
         int (*transfer) (struct inode *, struct iattr *);
         int (*write_dquot) (struct dquot *);            /* Ordinary dquot write */
+        struct dquot *(*alloc_dquot)(struct super_block *, int);        /* Allocate memory for new dquot */
+        void (*destroy_dquot)(struct dquot *);          /* Free memory for dquot */
         int (*acquire_dquot) (struct dquot *);          /* Quota is going to be created on disk */
         int (*release_dquot) (struct dquot *);          /* Quota is going to be deleted from disk */
         int (*mark_dirty) (struct dquot *);             /* Dquot is marked dirty */
@@ -320,12 +332,42 @@ struct quota_format_type {
         struct quota_format_type *qf_next;
 };
 
-#define DQUOT_USR_ENABLED       0x01            /* User diskquotas enabled */
-#define DQUOT_GRP_ENABLED       0x02            /* Group diskquotas enabled */
-#define DQUOT_USR_SUSPENDED     0x04            /* User diskquotas are off, but
+/* Quota state flags - they actually come in two flavors - for users and groups */
+enum {
+        _DQUOT_USAGE_ENABLED = 0,               /* Track disk usage for users */
+        _DQUOT_LIMITS_ENABLED,                  /* Enforce quota limits for users */
+        _DQUOT_SUSPENDED,                       /* User diskquotas are off, but
                                                  * we have necessary info in
                                                  * memory to turn them on */
-#define DQUOT_GRP_SUSPENDED     0x08            /* The same for group quotas */
+        _DQUOT_STATE_FLAGS
+};
+#define DQUOT_USAGE_ENABLED     (1 << _DQUOT_USAGE_ENABLED)
+#define DQUOT_LIMITS_ENABLED    (1 << _DQUOT_LIMITS_ENABLED)
+#define DQUOT_SUSPENDED         (1 << _DQUOT_SUSPENDED)
+#define DQUOT_STATE_FLAGS       (DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED | \
+                                 DQUOT_SUSPENDED)
+/* Other quota flags */
+#define DQUOT_QUOTA_SYS_FILE    (1 << 6)        /* Quota file is a special
+                                                 * system file and user cannot
+                                                 * touch it. Filesystem is
+                                                 * responsible for setting
+                                                 * S_NOQUOTA, S_NOATIME flags
+                                                 */
+#define DQUOT_NEGATIVE_USAGE    (1 << 7)        /* Allow negative quota usage */
+
+static inline unsigned int dquot_state_flag(unsigned int flags, int type)
+{
+        if (type == USRQUOTA)
+                return flags;
+        return flags << _DQUOT_STATE_FLAGS;
+}
+
+static inline unsigned int dquot_generic_flag(unsigned int flags, int type)
+{
+        if (type == USRQUOTA)
+                return flags;
+        return flags >> _DQUOT_STATE_FLAGS;
+}
 
 struct quota_info {
         unsigned int flags;                     /* Flags for diskquotas on this device */
diff --git a/include/linux/quotaio_v1.h b/include/linux/quotaio_v1.h
deleted file mode 100644
index 746654b5de70..000000000000
--- a/include/linux/quotaio_v1.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef _LINUX_QUOTAIO_V1_H
-#define _LINUX_QUOTAIO_V1_H
-
-#include <linux/types.h>
-
-/*
- * The following constants define the amount of time given a user
- * before the soft limits are treated as hard limits (usually resulting
- * in an allocation failure). The timer is started when the user crosses
- * their soft limit, it is reset when they go below their soft limit.
- */
-#define MAX_IQ_TIME  604800     /* (7*24*60*60) 1 week */
-#define MAX_DQ_TIME  604800     /* (7*24*60*60) 1 week */
-
-/*
- * The following structure defines the format of the disk quota file
- * (as it appears on disk) - the file is an array of these structures
- * indexed by user or group number.
- */
-struct v1_disk_dqblk {
-        __u32 dqb_bhardlimit;   /* absolute limit on disk blks alloc */
-        __u32 dqb_bsoftlimit;   /* preferred limit on disk blks */
-        __u32 dqb_curblocks;    /* current block count */
-        __u32 dqb_ihardlimit;   /* absolute limit on allocated inodes */
-        __u32 dqb_isoftlimit;   /* preferred inode limit */
-        __u32 dqb_curinodes;    /* current # allocated inodes */
-        time_t dqb_btime;       /* time limit for excessive disk use */
-        time_t dqb_itime;       /* time limit for excessive inode use */
-};
-
-#define v1_dqoff(UID)      ((loff_t)((UID) * sizeof (struct v1_disk_dqblk)))
-
-#endif  /* _LINUX_QUOTAIO_V1_H */
diff --git a/include/linux/quotaio_v2.h b/include/linux/quotaio_v2.h
deleted file mode 100644
index 303d7cbe30d4..000000000000
--- a/include/linux/quotaio_v2.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- *      Definitions of structures for vfsv0 quota format
- */
-
-#ifndef _LINUX_QUOTAIO_V2_H
-#define _LINUX_QUOTAIO_V2_H
-
-#include <linux/types.h>
-#include <linux/quota.h>
-
-/*
- * Definitions of magics and versions of current quota files
- */
-#define V2_INITQMAGICS {\
-        0xd9c01f11,     /* USRQUOTA */\
-        0xd9c01927      /* GRPQUOTA */\
-}
-
-#define V2_INITQVERSIONS {\
-        0,              /* USRQUOTA */\
-        0               /* GRPQUOTA */\
-}
-
-/*
- * The following structure defines the format of the disk quota file
- * (as it appears on disk) - the file is a radix tree whose leaves point
- * to blocks of these structures.
- */
-struct v2_disk_dqblk {
-        __le32 dqb_id;          /* id this quota applies to */
-        __le32 dqb_ihardlimit;  /* absolute limit on allocated inodes */
-        __le32 dqb_isoftlimit;  /* preferred inode limit */
-        __le32 dqb_curinodes;   /* current # allocated inodes */
-        __le32 dqb_bhardlimit;  /* absolute limit on disk space (in QUOTABLOCK_SIZE) */
-        __le32 dqb_bsoftlimit;  /* preferred limit on disk space (in QUOTABLOCK_SIZE) */
-        __le64 dqb_curspace;    /* current space occupied (in bytes) */
-        __le64 dqb_btime;       /* time limit for excessive disk use */
-        __le64 dqb_itime;       /* time limit for excessive inode use */
-};
-
-/*
- * Here are header structures as written on disk and their in-memory copies
- */
-/* First generic header */
-struct v2_disk_dqheader {
-        __le32 dqh_magic;       /* Magic number identifying file */
-        __le32 dqh_version;     /* File version */
-};
-
-/* Header with type and version specific information */
-struct v2_disk_dqinfo {
-        __le32 dqi_bgrace;      /* Time before block soft limit becomes hard limit */
-        __le32 dqi_igrace;      /* Time before inode soft limit becomes hard limit */
-        __le32 dqi_flags;       /* Flags for quotafile (DQF_*) */
-        __le32 dqi_blocks;      /* Number of blocks in file */
-        __le32 dqi_free_blk;    /* Number of first free block in the list */
-        __le32 dqi_free_entry;  /* Number of block with at least one free entry */
-};
-
-/*
- *  Structure of header of block with quota structures. It is padded to 16 bytes so
- *  there will be space for exactly 21 quota-entries in a block
- */
-struct v2_disk_dqdbheader {
-        __le32 dqdh_next_free;  /* Number of next block with free entry */
-        __le32 dqdh_prev_free;  /* Number of previous block with free entry */
-        __le16 dqdh_entries;    /* Number of valid entries in block */
-        __le16 dqdh_pad1;
-        __le32 dqdh_pad2;
-};
-
-#define V2_DQINFOOFF    sizeof(struct v2_disk_dqheader) /* Offset of info header in file */
-#define V2_DQBLKSIZE_BITS       10
-#define V2_DQBLKSIZE    (1 << V2_DQBLKSIZE_BITS)        /* Size of block with quota structures */
-#define V2_DQTREEOFF    1               /* Offset of tree in file in blocks */
-#define V2_DQTREEDEPTH  4               /* Depth of quota tree */
-#define V2_DQSTRINBLK   ((V2_DQBLKSIZE - sizeof(struct v2_disk_dqdbheader)) / sizeof(struct v2_disk_dqblk))     /* Number of entries in one blocks */
-
-#endif /* _LINUX_QUOTAIO_V2_H */
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index a558a4c1d35a..21b781a3350f 100644
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -24,12 +24,21 @@ void sync_dquots(struct super_block *sb, int type);
 
 int dquot_initialize(struct inode *inode, int type);
 int dquot_drop(struct inode *inode);
+int dquot_drop_locked(struct inode *inode);
+struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
+void dqput(struct dquot *dquot);
+int dquot_is_cached(struct super_block *sb, unsigned int id, int type);
+int dquot_scan_active(struct super_block *sb,
+                      int (*fn)(struct dquot *dquot, unsigned long priv),
+                      unsigned long priv);
+struct dquot *dquot_alloc(struct super_block *sb, int type);
+void dquot_destroy(struct dquot *dquot);
 
 int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
-int dquot_alloc_inode(const struct inode *inode, unsigned long number);
+int dquot_alloc_inode(const struct inode *inode, qsize_t number);
 
 int dquot_free_space(struct inode *inode, qsize_t number);
-int dquot_free_inode(const struct inode *inode, unsigned long number);
+int dquot_free_inode(const struct inode *inode, qsize_t number);
 
 int dquot_transfer(struct inode *inode, struct iattr *iattr);
 int dquot_commit(struct dquot *dquot);
@@ -40,11 +49,14 @@ int dquot_mark_dquot_dirty(struct dquot *dquot);
 
 int vfs_quota_on(struct super_block *sb, int type, int format_id,
         char *path, int remount);
+int vfs_quota_enable(struct inode *inode, int type, int format_id,
+        unsigned int flags);
 int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
         struct path *path);
 int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
         int format_id, int type);
 int vfs_quota_off(struct super_block *sb, int type, int remount);
+int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags);
 int vfs_quota_sync(struct super_block *sb, int type);
 int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
 int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
@@ -64,24 +76,22 @@ static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
  * Functions for checking status of quota
  */
 
-static inline int sb_has_quota_enabled(struct super_block *sb, int type)
+static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
 {
-        if (type == USRQUOTA)
-                return sb_dqopt(sb)->flags & DQUOT_USR_ENABLED;
-        return sb_dqopt(sb)->flags & DQUOT_GRP_ENABLED;
+        return sb_dqopt(sb)->flags &
+                                dquot_state_flag(DQUOT_USAGE_ENABLED, type);
 }
 
-static inline int sb_any_quota_enabled(struct super_block *sb)
+static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
 {
-        return sb_has_quota_enabled(sb, USRQUOTA) ||
-                sb_has_quota_enabled(sb, GRPQUOTA);
+        return sb_dqopt(sb)->flags &
+                                dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
 }
 
 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
 {
-        if (type == USRQUOTA)
-                return sb_dqopt(sb)->flags & DQUOT_USR_SUSPENDED;
-        return sb_dqopt(sb)->flags & DQUOT_GRP_SUSPENDED;
+        return sb_dqopt(sb)->flags &
+                                dquot_state_flag(DQUOT_SUSPENDED, type);
 }
 
 static inline int sb_any_quota_suspended(struct super_block *sb)
@@ -90,6 +100,31 @@ static inline int sb_any_quota_suspended(struct super_block *sb)
                 sb_has_quota_suspended(sb, GRPQUOTA);
 }
 
+/* Does kernel know about any quota information for given sb + type? */
+static inline int sb_has_quota_loaded(struct super_block *sb, int type)
+{
+        /* Currently if anything is on, then quota usage is on as well */
+        return sb_has_quota_usage_enabled(sb, type);
+}
+
+static inline int sb_any_quota_loaded(struct super_block *sb)
+{
+        return sb_has_quota_loaded(sb, USRQUOTA) ||
+                sb_has_quota_loaded(sb, GRPQUOTA);
+}
+
+static inline int sb_has_quota_active(struct super_block *sb, int type)
+{
+        return sb_has_quota_loaded(sb, type) &&
+               !sb_has_quota_suspended(sb, type);
+}
+
+static inline int sb_any_quota_active(struct super_block *sb)
+{
+        return sb_has_quota_active(sb, USRQUOTA) ||
+               sb_has_quota_active(sb, GRPQUOTA);
+}
+
 /*
  * Operations supported for diskquotas.
  */
@@ -104,7 +139,7 @@ extern struct quotactl_ops vfs_quotactl_ops;
 static inline void vfs_dq_init(struct inode *inode)
 {
         BUG_ON(!inode->i_sb);
-        if (sb_any_quota_enabled(inode->i_sb) && !IS_NOQUOTA(inode))
+        if (sb_any_quota_active(inode->i_sb) && !IS_NOQUOTA(inode))
                 inode->i_sb->dq_op->initialize(inode, -1);
 }
 
@@ -112,7 +147,7 @@ static inline void vfs_dq_init(struct inode *inode)
  * a transaction (deadlocks possible otherwise) */
 static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
 {
-        if (sb_any_quota_enabled(inode->i_sb)) {
+        if (sb_any_quota_active(inode->i_sb)) {
                 /* Used space is updated in alloc_space() */
                 if (inode->i_sb->dq_op->alloc_space(inode, nr, 1) == NO_QUOTA)
                         return 1;
@@ -132,7 +167,7 @@ static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
 
 static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
 {
-        if (sb_any_quota_enabled(inode->i_sb)) {
+        if (sb_any_quota_active(inode->i_sb)) {
                 /* Used space is updated in alloc_space() */
                 if (inode->i_sb->dq_op->alloc_space(inode, nr, 0) == NO_QUOTA)
                         return 1;
@@ -152,7 +187,7 @@ static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
 
 static inline int vfs_dq_alloc_inode(struct inode *inode)
 {
-        if (sb_any_quota_enabled(inode->i_sb)) {
+        if (sb_any_quota_active(inode->i_sb)) {
                 vfs_dq_init(inode);
                 if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
                         return 1;
@@ -162,7 +197,7 @@ static inline int vfs_dq_alloc_inode(struct inode *inode)
 
 static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
 {
-        if (sb_any_quota_enabled(inode->i_sb))
+        if (sb_any_quota_active(inode->i_sb))
                 inode->i_sb->dq_op->free_space(inode, nr);
         else
                 inode_sub_bytes(inode, nr);
@@ -176,7 +211,7 @@ static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
 
 static inline void vfs_dq_free_inode(struct inode *inode)
 {
-        if (sb_any_quota_enabled(inode->i_sb))
+        if (sb_any_quota_active(inode->i_sb))
                 inode->i_sb->dq_op->free_inode(inode, 1);
 }
 
@@ -197,12 +232,12 @@ static inline int vfs_dq_off(struct super_block *sb, int remount)
 
 #else
 
-static inline int sb_has_quota_enabled(struct super_block *sb, int type)
+static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
 {
         return 0;
 }
 
-static inline int sb_any_quota_enabled(struct super_block *sb)
+static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
 {
         return 0;
 }
@@ -217,6 +252,27 @@ static inline int sb_any_quota_suspended(struct super_block *sb)
         return 0;
 }
 
+/* Does kernel know about any quota information for given sb + type? */
+static inline int sb_has_quota_loaded(struct super_block *sb, int type)
+{
+        return 0;
+}
+
+static inline int sb_any_quota_loaded(struct super_block *sb)
+{
+        return 0;
+}
+
+static inline int sb_has_quota_active(struct super_block *sb, int type)
+{
+        return 0;
+}
+
+static inline int sb_any_quota_active(struct super_block *sb)
+{
+        return 0;
+}
+
 /*
  * NO-OP when quota not configured.
  */