[PATCH] ext2: fsid for statvfs
[linux-2.6.git] / fs / dquot.c
index 11048e0..f9cd5e2 100644 (file)
@@ -77,6 +77,8 @@
 #include <linux/kmod.h>
 #include <linux/namei.h>
 #include <linux/buffer_head.h>
+#include <linux/capability.h>
+#include <linux/quotaops.h>
 
 #include <asm/uaccess.h>
 
  * operation is just reading pointers from inode (or not using them at all) the
  * read lock is enough. If pointers are altered function must hold write lock
  * (these locking rules also apply for S_NOQUOTA flag in the inode - note that
- * for altering the flag i_sem is also needed).  If operation is holding
+ * for altering the flag i_mutex is also needed).  If operation is holding
  * reference to dquot in other way (e.g. quotactl ops) it must be guarded by
- * dqonoff_sem.
+ * dqonoff_mutex.
  * This locking assures that:
  *   a) update/access to dquot pointers in inode is serialized
  *   b) everyone is guarded against invalidate_dquots()
  *
- * Each dquot has its dq_lock semaphore. Locked dquots might not be referenced
+ * Each dquot has its dq_lock mutex. Locked dquots might not be referenced
  * from inodes (dquot_alloc_space() and such don't check the dq_lock).
  * Currently dquot is locked only when it is being read to memory (or space for
  * it is being allocated) on the first dqget() and when it is being released on
  * spinlock to internal buffers before writing.
  *
  * Lock ordering (including related VFS locks) is the following:
- *   i_sem > dqonoff_sem > iprune_sem > journal_lock > dqptr_sem >
- *   > dquot->dq_lock > dqio_sem
- * i_sem on quota files is special (it's below dqio_sem)
+ *   i_mutex > dqonoff_sem > journal_lock > dqptr_sem > dquot->dq_lock >
+ *   dqio_mutex
+ * i_mutex on quota files is special (it's below dqio_mutex)
  */
 
 static DEFINE_SPINLOCK(dq_list_lock);
@@ -129,7 +131,7 @@ static struct quota_format_type *quota_formats;     /* List of registered formats */
 static struct quota_module_name module_names[] = INIT_QUOTA_MODULE_NAMES;
 
 /* SLAB cache for dquot structures */
-static kmem_cache_t *dquot_cachep;
+static struct kmem_cache *dquot_cachep;
 
 int register_quota_format(struct quota_format_type *fmt)
 {
@@ -248,7 +250,7 @@ static inline struct dquot *find_dquot(unsigned int hashent, struct super_block
 /* Add a dquot to the tail of the free list */
 static inline void put_dquot_last(struct dquot *dquot)
 {
-       list_add(&dquot->dq_free, free_dquots.prev);
+       list_add_tail(&dquot->dq_free, &free_dquots);
        dqstats.free_dquots++;
 }
 
@@ -264,7 +266,7 @@ static inline void put_inuse(struct dquot *dquot)
 {
        /* We add to the back of inuse list so we don't have to restart
         * when traversing this list and we block */
-       list_add(&dquot->dq_inuse, inuse_list.prev);
+       list_add_tail(&dquot->dq_inuse, &inuse_list);
        dqstats.allocated_dquots++;
 }
 
@@ -279,8 +281,8 @@ static inline void remove_inuse(struct dquot *dquot)
 
 static void wait_on_dquot(struct dquot *dquot)
 {
-       down(&dquot->dq_lock);
-       up(&dquot->dq_lock);
+       mutex_lock(&dquot->dq_lock);
+       mutex_unlock(&dquot->dq_lock);
 }
 
 #define mark_dquot_dirty(dquot) ((dquot)->dq_sb->dq_op->mark_dirty(dquot))
@@ -319,8 +321,8 @@ int dquot_acquire(struct dquot *dquot)
        int ret = 0, ret2 = 0;
        struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
 
-       down(&dquot->dq_lock);
-       down(&dqopt->dqio_sem);
+       mutex_lock(&dquot->dq_lock);
+       mutex_lock(&dqopt->dqio_mutex);
        if (!test_bit(DQ_READ_B, &dquot->dq_flags))
                ret = dqopt->ops[dquot->dq_type]->read_dqblk(dquot);
        if (ret < 0)
@@ -341,8 +343,8 @@ int dquot_acquire(struct dquot *dquot)
        }
        set_bit(DQ_ACTIVE_B, &dquot->dq_flags);
 out_iolock:
-       up(&dqopt->dqio_sem);
-       up(&dquot->dq_lock);
+       mutex_unlock(&dqopt->dqio_mutex);
+       mutex_unlock(&dquot->dq_lock);
        return ret;
 }
 
@@ -354,7 +356,7 @@ int dquot_commit(struct dquot *dquot)
        int ret = 0, ret2 = 0;
        struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
 
-       down(&dqopt->dqio_sem);
+       mutex_lock(&dqopt->dqio_mutex);
        spin_lock(&dq_list_lock);
        if (!clear_dquot_dirty(dquot)) {
                spin_unlock(&dq_list_lock);
@@ -371,7 +373,7 @@ int dquot_commit(struct dquot *dquot)
                        ret = ret2;
        }
 out_sem:
-       up(&dqopt->dqio_sem);
+       mutex_unlock(&dqopt->dqio_mutex);
        return ret;
 }
 
@@ -383,11 +385,11 @@ int dquot_release(struct dquot *dquot)
        int ret = 0, ret2 = 0;
        struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
 
-       down(&dquot->dq_lock);
+       mutex_lock(&dquot->dq_lock);
        /* Check whether we are not racing with some other dqget() */
        if (atomic_read(&dquot->dq_count) > 1)
                goto out_dqlock;
-       down(&dqopt->dqio_sem);
+       mutex_lock(&dqopt->dqio_mutex);
        if (dqopt->ops[dquot->dq_type]->release_dqblk) {
                ret = dqopt->ops[dquot->dq_type]->release_dqblk(dquot);
                /* Write the info */
@@ -397,34 +399,57 @@ int dquot_release(struct dquot *dquot)
                        ret = ret2;
        }
        clear_bit(DQ_ACTIVE_B, &dquot->dq_flags);
-       up(&dqopt->dqio_sem);
+       mutex_unlock(&dqopt->dqio_mutex);
 out_dqlock:
-       up(&dquot->dq_lock);
+       mutex_unlock(&dquot->dq_lock);
        return ret;
 }
 
 /* Invalidate all dquots on the list. Note that this function is called after
  * quota is disabled and pointers from inodes removed so there cannot be new
- * quota users. Also because we hold dqonoff_sem there can be no quota users
- * for this sb+type at all. */
+ * quota users. There can still be some users of quotas due to inodes being
+ * just deleted or pruned by prune_icache() (those are not attached to any
+ * list). We have to wait for such users.
+ */
 static void invalidate_dquots(struct super_block *sb, int type)
 {
-       struct dquot *dquot;
-       struct list_head *head;
+       struct dquot *dquot, *tmp;
 
+restart:
        spin_lock(&dq_list_lock);
-       for (head = inuse_list.next; head != &inuse_list;) {
-               dquot = list_entry(head, struct dquot, dq_inuse);
-               head = head->next;
+       list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) {
                if (dquot->dq_sb != sb)
                        continue;
                if (dquot->dq_type != type)
                        continue;
-#ifdef __DQUOT_PARANOIA
-               if (atomic_read(&dquot->dq_count))
-                       BUG();
-#endif
-               /* Quota now has no users and it has been written on last dqput() */
+               /* Wait for dquot users */
+               if (atomic_read(&dquot->dq_count)) {
+                       DEFINE_WAIT(wait);
+
+                       atomic_inc(&dquot->dq_count);
+                       prepare_to_wait(&dquot->dq_wait_unused, &wait,
+                                       TASK_UNINTERRUPTIBLE);
+                       spin_unlock(&dq_list_lock);
+                       /* Once dqput() wakes us up, we know it's time to free
+                        * the dquot.
+                        * IMPORTANT: we rely on the fact that there is always
+                        * at most one process waiting for dquot to free.
+                        * Otherwise dq_count would be > 1 and we would never
+                        * wake up.
+                        */
+                       if (atomic_read(&dquot->dq_count) > 1)
+                               schedule();
+                       finish_wait(&dquot->dq_wait_unused, &wait);
+                       dqput(dquot);
+                       /* At this moment dquot() need not exist (it could be
+                        * reclaimed by prune_dqcache(). Hence we must
+                        * restart. */
+                       goto restart;
+               }
+               /*
+                * Quota now has no users and it has been written on last
+                * dqput()
+                */
                remove_dquot_hash(dquot);
                remove_free_dquot(dquot);
                remove_inuse(dquot);
@@ -440,7 +465,7 @@ int vfs_quota_sync(struct super_block *sb, int type)
        struct quota_info *dqopt = sb_dqopt(sb);
        int cnt;
 
-       down(&dqopt->dqonoff_sem);
+       mutex_lock(&dqopt->dqonoff_mutex);
        for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
                if (type != -1 && cnt != type)
                        continue;
@@ -475,7 +500,7 @@ int vfs_quota_sync(struct super_block *sb, int type)
        spin_lock(&dq_list_lock);
        dqstats.syncs++;
        spin_unlock(&dq_list_lock);
-       up(&dqopt->dqonoff_sem);
+       mutex_unlock(&dqopt->dqonoff_mutex);
 
        return 0;
 }
@@ -503,7 +528,7 @@ static void prune_dqcache(int count)
  * more memory
  */
 
-static int shrink_dqcache_memory(int nr, unsigned int gfp_mask)
+static int shrink_dqcache_memory(int nr, gfp_t gfp_mask)
 {
        if (nr) {
                spin_lock(&dq_list_lock);
@@ -516,7 +541,7 @@ static int shrink_dqcache_memory(int nr, unsigned int gfp_mask)
 /*
  * Put reference to dquot
  * NOTE: If you change this function please check whether dqput_blocks() works right...
- * MUST be called with either dqptr_sem or dqonoff_sem held
+ * MUST be called with either dqptr_sem or dqonoff_mutex held
  */
 static void dqput(struct dquot *dquot)
 {
@@ -541,6 +566,10 @@ we_slept:
        if (atomic_read(&dquot->dq_count) > 1) {
                /* We have more than one user... nothing to do */
                atomic_dec(&dquot->dq_count);
+               /* Releasing dquot during quotaoff phase? */
+               if (!sb_has_quota_enabled(dquot->dq_sb, dquot->dq_type) &&
+                   atomic_read(&dquot->dq_count) == 1)
+                       wake_up(&dquot->dq_wait_unused);
                spin_unlock(&dq_list_lock);
                return;
        }
@@ -561,8 +590,7 @@ we_slept:
        atomic_dec(&dquot->dq_count);
 #ifdef __DQUOT_PARANOIA
        /* sanity check */
-       if (!list_empty(&dquot->dq_free))
-               BUG();
+       BUG_ON(!list_empty(&dquot->dq_free));
 #endif
        put_dquot_last(dquot);
        spin_unlock(&dq_list_lock);
@@ -572,16 +600,17 @@ static struct dquot *get_empty_dquot(struct super_block *sb, int type)
 {
        struct dquot *dquot;
 
-       dquot = kmem_cache_alloc(dquot_cachep, SLAB_NOFS);
+       dquot = kmem_cache_alloc(dquot_cachep, GFP_NOFS);
        if(!dquot)
                return NODQUOT;
 
        memset((caddr_t)dquot, 0, sizeof(struct dquot));
-       sema_init(&dquot->dq_lock, 1);
+       mutex_init(&dquot->dq_lock);
        INIT_LIST_HEAD(&dquot->dq_free);
        INIT_LIST_HEAD(&dquot->dq_inuse);
        INIT_HLIST_NODE(&dquot->dq_hash);
        INIT_LIST_HEAD(&dquot->dq_dirty);
+       init_waitqueue_head(&dquot->dq_wait_unused);
        dquot->dq_sb = sb;
        dquot->dq_type = type;
        atomic_set(&dquot->dq_count, 1);
@@ -591,7 +620,7 @@ static struct dquot *get_empty_dquot(struct super_block *sb, int type)
 
 /*
  * Get reference to dquot
- * MUST be called with either dqptr_sem or dqonoff_sem held
+ * MUST be called with either dqptr_sem or dqonoff_mutex held
  */
 static struct dquot *dqget(struct super_block *sb, unsigned int id, int type)
 {
@@ -636,8 +665,7 @@ we_slept:
                return NODQUOT;
        }
 #ifdef __DQUOT_PARANOIA
-       if (!dquot->dq_sb)      /* Has somebody invalidated entry under us? */
-               BUG();
+       BUG_ON(!dquot->dq_sb);  /* Has somebody invalidated entry under us? */
 #endif
 
        return dquot;
@@ -657,7 +685,7 @@ static int dqinit_needed(struct inode *inode, int type)
        return 0;
 }
 
-/* This routine is guarded by dqonoff_sem semaphore */
+/* This routine is guarded by dqonoff_mutex mutex */
 static void add_dquot_ref(struct super_block *sb, int type)
 {
        struct list_head *p;
@@ -665,7 +693,7 @@ static void add_dquot_ref(struct super_block *sb, int type)
 restart:
        file_list_lock();
        list_for_each(p, &sb->s_files) {
-               struct file *filp = list_entry(p, struct file, f_list);
+               struct file *filp = list_entry(p, struct file, f_u.fu_list);
                struct inode *inode = filp->f_dentry->d_inode;
                if (filp->f_mode & FMODE_WRITE && dqinit_needed(inode, type)) {
                        struct dentry *dentry = dget(filp->f_dentry);
@@ -733,13 +761,9 @@ static void drop_dquot_ref(struct super_block *sb, int type)
 {
        LIST_HEAD(tofree_head);
 
-       /* We need to be guarded against prune_icache to reach all the
-        * inodes - otherwise some can be on the local list of prune_icache */
-       down(&iprune_sem);
        down_write(&sb_dqopt(sb)->dqptr_sem);
        remove_dquot_ref(sb, type, &tofree_head);
        up_write(&sb_dqopt(sb)->dqptr_sem);
-       up(&iprune_sem);
        put_dquot_list(&tofree_head);
 }
 
@@ -810,6 +834,9 @@ static void print_warning(struct dquot *dquot, const char warntype)
        if (!need_print_warning(dquot) || (flag && test_and_set_bit(flag, &dquot->dq_flags)))
                return;
 
+       mutex_lock(&tty_mutex);
+       if (!current->signal->tty)
+               goto out_lock;
        tty_write_message(current->signal->tty, dquot->dq_sb->s_id);
        if (warntype == ISOFTWARN || warntype == BSOFTWARN)
                tty_write_message(current->signal->tty, ": warning, ");
@@ -837,6 +864,8 @@ static void print_warning(struct dquot *dquot, const char warntype)
                        break;
        }
        tty_write_message(current->signal->tty, msg);
+out_lock:
+       mutex_unlock(&tty_mutex);
 }
 
 static inline void flush_warnings(struct dquot **dquots, char *warntype)
@@ -939,8 +968,8 @@ int dquot_initialize(struct inode *inode, int type)
        unsigned int id = 0;
        int cnt, ret = 0;
 
-       /* First test before acquiring semaphore - solves deadlocks when we
-         * re-enter the quota code and are already holding the semaphore */
+       /* First test before acquiring mutex - solves deadlocks when we
+         * re-enter the quota code and are already holding the mutex */
        if (IS_NOQUOTA(inode))
                return 0;
        down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
@@ -1003,8 +1032,8 @@ int dquot_alloc_space(struct inode *inode, qsize_t number, int warn)
        int cnt, ret = NO_QUOTA;
        char warntype[MAXQUOTAS];
 
-       /* First test before acquiring semaphore - solves deadlocks when we
-         * re-enter the quota code and are already holding the semaphore */
+       /* First test before acquiring mutex - solves deadlocks when we
+         * re-enter the quota code and are already holding the mutex */
        if (IS_NOQUOTA(inode)) {
 out_add:
                inode_add_bytes(inode, number);
@@ -1052,8 +1081,8 @@ int dquot_alloc_inode(const struct inode *inode, unsigned long number)
        int cnt, ret = NO_QUOTA;
        char warntype[MAXQUOTAS];
 
-       /* First test before acquiring semaphore - solves deadlocks when we
-         * re-enter the quota code and are already holding the semaphore */
+       /* First test before acquiring mutex - solves deadlocks when we
+         * re-enter the quota code and are already holding the mutex */
        if (IS_NOQUOTA(inode))
                return QUOTA_OK;
        for (cnt = 0; cnt < MAXQUOTAS; cnt++)
@@ -1096,8 +1125,8 @@ int dquot_free_space(struct inode *inode, qsize_t number)
 {
        unsigned int cnt;
 
-       /* First test before acquiring semaphore - solves deadlocks when we
-         * re-enter the quota code and are already holding the semaphore */
+       /* First test before acquiring mutex - solves deadlocks when we
+         * re-enter the quota code and are already holding the mutex */
        if (IS_NOQUOTA(inode)) {
 out_sub:
                inode_sub_bytes(inode, number);
@@ -1132,8 +1161,8 @@ int dquot_free_inode(const struct inode *inode, unsigned long number)
 {
        unsigned int cnt;
 
-       /* First test before acquiring semaphore - solves deadlocks when we
-         * re-enter the quota code and are already holding the semaphore */
+       /* First test before acquiring mutex - solves deadlocks when we
+         * re-enter the quota code and are already holding the mutex */
        if (IS_NOQUOTA(inode))
                return QUOTA_OK;
        down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
@@ -1172,8 +1201,8 @@ int dquot_transfer(struct inode *inode, struct iattr *iattr)
            chgid = (iattr->ia_valid & ATTR_GID) && inode->i_gid != iattr->ia_gid;
        char warntype[MAXQUOTAS];
 
-       /* First test before acquiring semaphore - solves deadlocks when we
-         * re-enter the quota code and are already holding the semaphore */
+       /* First test before acquiring mutex - solves deadlocks when we
+         * re-enter the quota code and are already holding the mutex */
        if (IS_NOQUOTA(inode))
                return QUOTA_OK;
        /* Clear the arrays */
@@ -1267,9 +1296,9 @@ int dquot_commit_info(struct super_block *sb, int type)
        int ret;
        struct quota_info *dqopt = sb_dqopt(sb);
 
-       down(&dqopt->dqio_sem);
+       mutex_lock(&dqopt->dqio_mutex);
        ret = dqopt->ops[type]->write_file_info(sb, type);
-       up(&dqopt->dqio_sem);
+       mutex_unlock(&dqopt->dqio_mutex);
        return ret;
 }
 
@@ -1323,13 +1352,11 @@ int vfs_quota_off(struct super_block *sb, int type)
        int cnt;
        struct quota_info *dqopt = sb_dqopt(sb);
        struct inode *toputinode[MAXQUOTAS];
-       struct vfsmount *toputmnt[MAXQUOTAS];
 
        /* We need to serialize quota_off() for device */
-       down(&dqopt->dqonoff_sem);
+       mutex_lock(&dqopt->dqonoff_mutex);
        for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
                toputinode[cnt] = NULL;
-               toputmnt[cnt] = NULL;
                if (type != -1 && cnt != type)
                        continue;
                if (!sb_has_quota_enabled(sb, cnt))
@@ -1350,20 +1377,15 @@ int vfs_quota_off(struct super_block *sb, int type)
                put_quota_format(dqopt->info[cnt].dqi_format);
 
                toputinode[cnt] = dqopt->files[cnt];
-               toputmnt[cnt] = dqopt->mnt[cnt];
                dqopt->files[cnt] = NULL;
-               dqopt->mnt[cnt] = NULL;
                dqopt->info[cnt].dqi_flags = 0;
                dqopt->info[cnt].dqi_igrace = 0;
                dqopt->info[cnt].dqi_bgrace = 0;
                dqopt->ops[cnt] = NULL;
        }
-       up(&dqopt->dqonoff_sem);
+       mutex_unlock(&dqopt->dqonoff_mutex);
        /* Sync the superblock so that buffers with quota data are written to
-        * disk (and so userspace sees correct data afterwards).
-        * The reference to vfsmnt we are still holding protects us from
-        * umount (we don't have it only when quotas are turned on/off for
-        * journal replay but in that case we are guarded by the fs anyway). */
+        * disk (and so userspace sees correct data afterwards). */
        if (sb->s_op->sync_fs)
                sb->s_op->sync_fs(sb, 1);
        sync_blockdev(sb->s_bdev);
@@ -1374,23 +1396,19 @@ int vfs_quota_off(struct super_block *sb, int type)
         * changes done by userspace on the next quotaon() */
        for (cnt = 0; cnt < MAXQUOTAS; cnt++)
                if (toputinode[cnt]) {
-                       down(&dqopt->dqonoff_sem);
+                       mutex_lock(&dqopt->dqonoff_mutex);
                        /* If quota was reenabled in the meantime, we have
                         * nothing to do */
                        if (!sb_has_quota_enabled(sb, cnt)) {
-                               down(&toputinode[cnt]->i_sem);
+                               mutex_lock(&toputinode[cnt]->i_mutex);
                                toputinode[cnt]->i_flags &= ~(S_IMMUTABLE |
                                  S_NOATIME | S_NOQUOTA);
                                truncate_inode_pages(&toputinode[cnt]->i_data, 0);
-                               up(&toputinode[cnt]->i_sem);
+                               mutex_unlock(&toputinode[cnt]->i_mutex);
                                mark_inode_dirty(toputinode[cnt]);
                                iput(toputinode[cnt]);
                        }
-                       up(&dqopt->dqonoff_sem);
-                       /* We don't hold the reference when we turned on quotas
-                        * just for the journal replay... */
-                       if (toputmnt[cnt])
-                               mntput(toputmnt[cnt]);
+                       mutex_unlock(&dqopt->dqonoff_mutex);
                }
        if (sb->s_bdev)
                invalidate_bdev(sb->s_bdev, 0);
@@ -1430,8 +1448,8 @@ static int vfs_quota_on_inode(struct inode *inode, int type, int format_id)
        write_inode_now(inode, 1);
        /* And now flush the block cache so that kernel sees the changes */
        invalidate_bdev(sb->s_bdev, 0);
-       down(&inode->i_sem);
-       down(&dqopt->dqonoff_sem);
+       mutex_lock(&inode->i_mutex);
+       mutex_lock(&dqopt->dqonoff_mutex);
        if (sb_has_quota_enabled(sb, type)) {
                error = -EBUSY;
                goto out_lock;
@@ -1443,6 +1461,7 @@ static int vfs_quota_on_inode(struct inode *inode, int type, int format_id)
        oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE | S_NOQUOTA);
        inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE;
        up_write(&dqopt->dqptr_sem);
+       sb->dq_op->drop(inode);
 
        error = -EIO;
        dqopt->files[type] = igrab(inode);
@@ -1455,17 +1474,17 @@ static int vfs_quota_on_inode(struct inode *inode, int type, int format_id)
        dqopt->ops[type] = fmt->qf_ops;
        dqopt->info[type].dqi_format = fmt;
        INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list);
-       down(&dqopt->dqio_sem);
+       mutex_lock(&dqopt->dqio_mutex);
        if ((error = dqopt->ops[type]->read_file_info(sb, type)) < 0) {
-               up(&dqopt->dqio_sem);
+               mutex_unlock(&dqopt->dqio_mutex);
                goto out_file_init;
        }
-       up(&dqopt->dqio_sem);
-       up(&inode->i_sem);
+       mutex_unlock(&dqopt->dqio_mutex);
+       mutex_unlock(&inode->i_mutex);
        set_enable_flags(dqopt, type);
 
        add_dquot_ref(sb, type);
-       up(&dqopt->dqonoff_sem);
+       mutex_unlock(&dqopt->dqonoff_mutex);
 
        return 0;
 
@@ -1473,7 +1492,7 @@ out_file_init:
        dqopt->files[type] = NULL;
        iput(inode);
 out_lock:
-       up(&dqopt->dqonoff_sem);
+       mutex_unlock(&dqopt->dqonoff_mutex);
        if (oldflags != -1) {
                down_write(&dqopt->dqptr_sem);
                /* Set the flags back (in the case of accidental quotaon()
@@ -1482,7 +1501,7 @@ out_lock:
                inode->i_flags |= oldflags;
                up_write(&dqopt->dqptr_sem);
        }
-       up(&inode->i_sem);
+       mutex_unlock(&inode->i_mutex);
 out_fmt:
        put_quota_format(fmt);
 
@@ -1504,11 +1523,8 @@ int vfs_quota_on(struct super_block *sb, int type, int format_id, char *path)
        /* Quota file not on the same filesystem? */
        if (nd.mnt->mnt_sb != sb)
                error = -EXDEV;
-       else {
+       else
                error = vfs_quota_on_inode(nd.dentry->d_inode, type, format_id);
-               if (!error)
-                       sb_dqopt(sb)->mnt[type] = mntget(nd.mnt);
-       }
 out_path:
        path_release(&nd);
        return error;
@@ -1518,14 +1534,28 @@ out_path:
  * This function is used when filesystem needs to initialize quotas
  * during mount time.
  */
-int vfs_quota_on_mount(int type, int format_id, struct dentry *dentry)
+int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
+               int format_id, int type)
 {
+       struct dentry *dentry;
        int error;
 
+       dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name));
+       if (IS_ERR(dentry))
+               return PTR_ERR(dentry);
+
+       if (!dentry->d_inode) {
+               error = -ENOENT;
+               goto out;
+       }
+
        error = security_quota_on(dentry);
-       if (error)
-               return error;
-       return vfs_quota_on_inode(dentry->d_inode, type, format_id);
+       if (!error)
+               error = vfs_quota_on_inode(dentry->d_inode, type, format_id);
+
+out:
+       dput(dentry);
+       return error;
 }
 
 /* Generic routine for getting common part of quota structure */
@@ -1550,14 +1580,14 @@ int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *d
 {
        struct dquot *dquot;
 
-       down(&sb_dqopt(sb)->dqonoff_sem);
+       mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
        if (!(dquot = dqget(sb, id, type))) {
-               up(&sb_dqopt(sb)->dqonoff_sem);
+               mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
                return -ESRCH;
        }
        do_get_dqblk(dquot, di);
        dqput(dquot);
-       up(&sb_dqopt(sb)->dqonoff_sem);
+       mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
        return 0;
 }
 
@@ -1619,14 +1649,14 @@ int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *d
 {
        struct dquot *dquot;
 
-       down(&sb_dqopt(sb)->dqonoff_sem);
+       mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
        if (!(dquot = dqget(sb, id, type))) {
-               up(&sb_dqopt(sb)->dqonoff_sem);
+               mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
                return -ESRCH;
        }
        do_set_dqblk(dquot, di);
        dqput(dquot);
-       up(&sb_dqopt(sb)->dqonoff_sem);
+       mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
        return 0;
 }
 
@@ -1635,9 +1665,9 @@ int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
 {
        struct mem_dqinfo *mi;
   
-       down(&sb_dqopt(sb)->dqonoff_sem);
+       mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
        if (!sb_has_quota_enabled(sb, type)) {
-               up(&sb_dqopt(sb)->dqonoff_sem);
+               mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
                return -ESRCH;
        }
        mi = sb_dqopt(sb)->info + type;
@@ -1647,7 +1677,7 @@ int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
        ii->dqi_flags = mi->dqi_flags & DQF_MASK;
        ii->dqi_valid = IIF_ALL;
        spin_unlock(&dq_data_lock);
-       up(&sb_dqopt(sb)->dqonoff_sem);
+       mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
        return 0;
 }
 
@@ -1656,9 +1686,9 @@ int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
 {
        struct mem_dqinfo *mi;
 
-       down(&sb_dqopt(sb)->dqonoff_sem);
+       mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
        if (!sb_has_quota_enabled(sb, type)) {
-               up(&sb_dqopt(sb)->dqonoff_sem);
+               mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
                return -ESRCH;
        }
        mi = sb_dqopt(sb)->info + type;
@@ -1673,7 +1703,7 @@ int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
        mark_info_dirty(sb, type);
        /* Force write to disk */
        sb->dq_op->write_info(sb, type);
-       up(&sb_dqopt(sb)->dqonoff_sem);
+       mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
        return 0;
 }
 
@@ -1794,7 +1824,8 @@ static int __init dquot_init(void)
 
        dquot_cachep = kmem_cache_create("dquot", 
                        sizeof(struct dquot), sizeof(unsigned long) * 4,
-                       SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_PANIC,
+                       (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
+                               SLAB_MEM_SPREAD|SLAB_PANIC),
                        NULL, NULL);
 
        order = 0;