patch-2.1.101 linux/fs/dquot.c
Next file: linux/fs/ext2/balloc.c
Previous file: linux/fs/buffer.c
Back to the patch index
Back to the overall index
- Lines: 1496
- Date:
Fri May 8 17:54:39 1998
- Orig file:
v2.1.100/linux/fs/dquot.c
- Orig date:
Thu May 7 22:51:53 1998
diff -u --recursive --new-file v2.1.100/linux/fs/dquot.c linux/fs/dquot.c
@@ -9,33 +9,22 @@
* have a consistent diskquota tracking system. The ideas of both
* user and group quotas are based on the Melbourne quota system as
* used on BSD derived systems. The internal implementation is
- * based on the LINUX inode-subsystem with added complexity of the
- * diskquota system. This implementation is not based on any BSD
- * kernel sourcecode.
+ * based on one of the several variants of the LINUX inode-subsystem
+ * with added complexity of the diskquota system.
*
- * Version: $Id: dquot.c,v 1.11 1997/01/06 06:53:02 davem Exp $
+ * Version: $Id: dquot.c,v 6.3 1996/11/17 18:35:34 mvw Exp mvw $
*
- * Author: Marco van Wieringen <mvw@mcs.ow.nl> <mvw@tnix.net>
- *
- * Fixes: Dmitry Gorodchanin <pgmdsg@ibi.com>, 11 Feb 96
- * removed race conditions in dqput(), dqget() and iput().
- * Andi Kleen removed all verify_area() calls, 31 Dec 96
- * Nick Kralevich <nickkral@cal.alumni.berkeley.edu>, 21 Jul 97
- * Fixed a condition where user and group quotas could get mixed up.
+ * Author: Marco van Wieringen <mvw@planets.elm.net>
*
- * Chris Rankin <rankinc@bellsouth.net>, 31 Dec 97, 2-4 Jan 98
- * Fixed kernel API so that the user can get the quota for any
- * group s/he belongs to. Also return useful error codes when
- * turning quotas off, and fixed sync_dquot() so that all devices
- * are synced when dev==NODEV.
- *
- * (C) Copyright 1994, 1995 Marco van Wieringen
+ * Fixes: Dmitry Gorodchanin <pgmdsg@ibi.com>, 11 Feb 96
*
+ * (C) Copyright 1994 - 1997 Marco van Wieringen
*/
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/sched.h>
+
#include <linux/types.h>
#include <linux/string.h>
#include <linux/fcntl.h>
@@ -46,129 +35,153 @@
#include <linux/mount.h>
#include <linux/smp.h>
#include <linux/smp_lock.h>
+#include <linux/init.h>
+#include <linux/slab.h>
#include <asm/uaccess.h>
-#define __DQUOT_VERSION__ "dquot_5.6.0"
+#define __DQUOT_VERSION__ "dquot_6.4.0"
+
+int nr_dquots = 0, nr_free_dquots = 0;
+int max_dquots = NR_DQUOTS;
static char quotamessage[MAX_QUOTA_MESSAGE];
static char *quotatypes[] = INITQFNAMES;
-static int nr_dquots = 0, nr_free_dquots = 0;
-static struct dquot *hash_table[NR_DQHASH];
-static struct dquot *first_dquot;
+static kmem_cache_t *dquot_cachep;
+
+static struct dquot *dquot_hash[NR_DQHASH];
+static struct free_dquot_queue {
+ struct dquot *head;
+ struct dquot **last;
+} free_dquots = { NULL, &free_dquots.head };
+static struct dquot *inuse_list = NULL;
+static int dquot_updating[NR_DQHASH];
+
static struct dqstats dqstats;
+static struct wait_queue *dquot_wait = (struct wait_queue *)NULL,
+ *update_wait = (struct wait_queue *)NULL;
-static struct wait_queue *dquot_wait = (struct wait_queue *)NULL;
+static inline char is_enabled(struct vfsmount *vfsmnt, short type)
+{
+ switch (type) {
+ case USRQUOTA:
+ return((vfsmnt->mnt_dquot.flags & DQUOT_USR_ENABLED) != 0);
+ case GRPQUOTA:
+ return((vfsmnt->mnt_dquot.flags & DQUOT_GRP_ENABLED) != 0);
+ }
+ return(0);
+}
-extern void add_dquot_ref(kdev_t dev, short type);
-extern void reset_dquot_ptrs(kdev_t dev, short type);
+static inline char sb_has_quota_enabled(struct super_block *sb, short type)
+{
+ struct vfsmount *vfsmnt;
-#ifndef min
-#define min(a,b) ((a) < (b)) ? (a) : (b)
-#endif
+ return((vfsmnt = lookup_vfsmnt(sb->s_dev)) != (struct vfsmount *)NULL && is_enabled(vfsmnt, type));
+}
-/*
- * Functions for management of the hashlist.
- */
-static inline int const hashfn(kdev_t dev, unsigned int id, short type)
+static inline char dev_has_quota_enabled(kdev_t dev, short type)
{
- return((HASHDEV(dev) ^ id) * (MAXQUOTAS - type)) % NR_DQHASH;
+ struct vfsmount *vfsmnt;
+
+ return((vfsmnt = lookup_vfsmnt(dev)) != (struct vfsmount *)NULL && is_enabled(vfsmnt, type));
}
-static inline struct dquot **const hash(kdev_t dev, unsigned int id, short type)
+static inline int const hashfn(kdev_t dev, unsigned int id, short type)
{
- return(hash_table + hashfn(dev, id, type));
+ return((HASHDEV(dev) ^ id) * (MAXQUOTAS - type)) % NR_DQHASH;
}
-static inline int has_quota_enabled(kdev_t dev, short type)
+static inline void insert_dquot_hash(struct dquot *dquot)
{
- struct vfsmount *vfsmnt;
+ struct dquot **htable;
- return((vfsmnt = lookup_vfsmnt(dev)) != (struct vfsmount *)NULL &&
- (vfsmnt->mnt_quotas[type] != (struct file *)NULL));
+ htable = &dquot_hash[hashfn(dquot->dq_dev, dquot->dq_id, dquot->dq_type)];
+ if ((dquot->dq_hash_next = *htable) != NULL)
+ (*htable)->dq_hash_pprev = &dquot->dq_hash_next;
+ *htable = dquot;
+ dquot->dq_hash_pprev = htable;
}
-static void insert_dquot_free(struct dquot *dquot)
+static inline void hash_dquot(struct dquot *dquot)
{
- dquot->dq_next = first_dquot;
- dquot->dq_prev = first_dquot->dq_prev;
- dquot->dq_next->dq_prev = dquot;
- dquot->dq_prev->dq_next = dquot;
- first_dquot = dquot;
+ insert_dquot_hash(dquot);
}
-static void remove_dquot_free(struct dquot *dquot)
+static inline void unhash_dquot(struct dquot *dquot)
{
- if (first_dquot == dquot)
- first_dquot = first_dquot->dq_next;
- if (dquot->dq_next)
- dquot->dq_next->dq_prev = dquot->dq_prev;
- if (dquot->dq_prev)
- dquot->dq_prev->dq_next = dquot->dq_next;
- dquot->dq_next = dquot->dq_prev = NODQUOT;
+ if (dquot->dq_hash_pprev) {
+ if (dquot->dq_hash_next)
+ dquot->dq_hash_next->dq_hash_pprev = dquot->dq_hash_pprev;
+ *(dquot->dq_hash_pprev) = dquot->dq_hash_next;
+ dquot->dq_hash_pprev = NULL;
+ }
}
-static void insert_dquot_hash(struct dquot *dquot)
+static inline struct dquot *find_dquot(unsigned int hashent, kdev_t dev, unsigned int id, short type)
{
- struct dquot **hash_ent;
+ struct dquot *dquot;
- hash_ent = hash(dquot->dq_dev, dquot->dq_id, dquot->dq_type);
- dquot->dq_hash_next = *hash_ent;
- dquot->dq_hash_prev = NODQUOT;
- if (dquot->dq_hash_next)
- dquot->dq_hash_next->dq_hash_prev = dquot;
- *hash_ent = dquot;
+ for (dquot = dquot_hash[hashent]; dquot; dquot = dquot->dq_hash_next)
+ if (dquot->dq_dev == dev && dquot->dq_id == id && dquot->dq_type == type)
+ break;
+ return dquot;
}
-static void remove_dquot_hash(struct dquot *dquot)
+static inline void put_dquot_head(struct dquot *dquot)
{
- struct dquot **hash_ent;
+ if ((dquot->dq_next = free_dquots.head) != NULL)
+ free_dquots.head->dq_pprev = &dquot->dq_next;
+ else
+ free_dquots.last = &dquot->dq_next;
+ free_dquots.head = dquot;
+ dquot->dq_pprev = &free_dquots.head;
+ nr_free_dquots++;
+}
- hash_ent = hash(dquot->dq_dev, dquot->dq_id, dquot->dq_type);
- if (*hash_ent == dquot)
- *hash_ent = dquot->dq_hash_next;
- if (dquot->dq_hash_next)
- dquot->dq_hash_next->dq_hash_prev = dquot->dq_hash_prev;
- if (dquot->dq_hash_prev)
- dquot->dq_hash_prev->dq_hash_next = dquot->dq_hash_next;
- dquot->dq_hash_prev = dquot->dq_hash_next = NODQUOT;
+static inline void put_dquot_last(struct dquot *dquot)
+{
+ dquot->dq_next = NULL;
+ dquot->dq_pprev = free_dquots.last;
+ *free_dquots.last = dquot;
+ free_dquots.last = &dquot->dq_next;
+ nr_free_dquots++;
}
-static void put_last_free(struct dquot *dquot)
+static inline void remove_free_dquot(struct dquot *dquot)
{
- remove_dquot_free(dquot);
- dquot->dq_prev = first_dquot->dq_prev;
- dquot->dq_prev->dq_next = dquot;
- dquot->dq_next = first_dquot;
- dquot->dq_next->dq_prev = dquot;
+ if (dquot->dq_pprev) {
+ if (dquot->dq_next)
+ dquot->dq_next->dq_pprev = dquot->dq_pprev;
+ else
+ free_dquots.last = dquot->dq_pprev;
+ *dquot->dq_pprev = dquot->dq_next;
+ dquot->dq_pprev = NULL;
+ nr_free_dquots--;
+ }
}
-static void grow_dquots(void)
+static inline void put_inuse(struct dquot *dquot)
{
- struct dquot *dquot;
- int cnt;
+ if ((dquot->dq_next = inuse_list) != NULL)
+ inuse_list->dq_pprev = &dquot->dq_next;
+ inuse_list = dquot;
+ dquot->dq_pprev = &inuse_list;
+}
- if (!(dquot = (struct dquot*) get_free_page(GFP_KERNEL)))
- return;
- dqstats.pages_allocated++;
- cnt = PAGE_SIZE / sizeof(struct dquot);
- nr_dquots += cnt;
- nr_free_dquots += cnt;
- if (!first_dquot) {
- dquot->dq_next = dquot->dq_prev = first_dquot = dquot++;
- cnt--;
+static inline void remove_inuse(struct dquot *dquot)
+{
+ if (dquot->dq_pprev) {
+ if (dquot->dq_next)
+ dquot->dq_next->dq_pprev = dquot->dq_pprev;
+ *dquot->dq_pprev = dquot->dq_next;
+ dquot->dq_pprev = NULL;
}
- for (; cnt; cnt--)
- insert_dquot_free(dquot++);
}
-/*
- * Functions for locking and waiting on dquots.
- */
static void __wait_on_dquot(struct dquot *dquot)
{
- struct wait_queue wait = {current, NULL};
+ struct wait_queue wait = { current, NULL };
add_wait_queue(&dquot->dq_wait, &wait);
repeat:
@@ -202,39 +215,22 @@
wake_up(&dquot->dq_wait);
}
}
-/*
- * Note that we don't want to disturb any wait-queues when we discard
- * an dquot.
- *
- * FIXME: As soon as we have a nice solution for the inode problem we
- * can also fix this one. I.e. the volatile part.
- */
-static void clear_dquot(struct dquot * dquot)
-{
- struct wait_queue *wait;
-
- wait_on_dquot(dquot);
- remove_dquot_hash(dquot);
- remove_dquot_free(dquot);
- wait = ((volatile struct dquot *) dquot)->dq_wait;
- if (dquot->dq_count)
- nr_free_dquots++;
- memset(dquot, 0, sizeof(*dquot));
- ((volatile struct dquot *) dquot)->dq_wait = wait;
- insert_dquot_free(dquot);
-}
static void write_dquot(struct dquot *dquot)
{
- short type = dquot->dq_type;
- struct file *filp = dquot->dq_mnt->mnt_quotas[type];
+ short type;
+ struct file *filp;
mm_segment_t fs;
loff_t offset;
+ type = dquot->dq_type;
+ filp = dquot->dq_mnt->mnt_dquot.files[type];
+
if (!(dquot->dq_flags & DQ_MOD) || (filp == (struct file *)NULL))
return;
+
lock_dquot(dquot);
- down(&dquot->dq_mnt->mnt_sem);
+ down(&dquot->dq_mnt->mnt_dquot.semaphore);
offset = dqoff(dquot->dq_id);
fs = get_fs();
set_fs(KERNEL_DS);
@@ -242,29 +238,35 @@
if (filp->f_op->write(filp, (char *)&dquot->dq_dqb, sizeof(struct dqblk), &offset) == sizeof(struct dqblk))
dquot->dq_flags &= ~DQ_MOD;
- up(&dquot->dq_mnt->mnt_sem);
+ up(&dquot->dq_mnt->mnt_dquot.semaphore);
set_fs(fs);
+
unlock_dquot(dquot);
dqstats.writes++;
}
static void read_dquot(struct dquot *dquot)
{
- short type = dquot->dq_type;
- struct file *filp = dquot->dq_mnt->mnt_quotas[type];
+ short type;
+ struct file *filp;
mm_segment_t fs;
loff_t offset;
+ type = dquot->dq_type;
+ filp = dquot->dq_mnt->mnt_dquot.files[type];
+
if (filp == (struct file *)NULL)
return;
+
lock_dquot(dquot);
- down(&dquot->dq_mnt->mnt_sem);
+ down(&dquot->dq_mnt->mnt_dquot.semaphore);
offset = dqoff(dquot->dq_id);
fs = get_fs();
set_fs(KERNEL_DS);
filp->f_op->read(filp, (char *)&dquot->dq_dqb, sizeof(struct dqblk), &offset);
- up(&dquot->dq_mnt->mnt_sem);
+ up(&dquot->dq_mnt->mnt_dquot.semaphore);
set_fs(fs);
+
if (dquot->dq_bhardlimit == 0 && dquot->dq_bsoftlimit == 0 &&
dquot->dq_ihardlimit == 0 && dquot->dq_isoftlimit == 0)
dquot->dq_flags |= DQ_FAKE;
@@ -272,46 +274,292 @@
dqstats.reads++;
}
+void clear_dquot(struct dquot *dquot)
+{
+ struct wait_queue *wait;
+
+ /* So we don't disappear. */
+ dquot->dq_count++;
+
+ wait_on_dquot(dquot);
+
+ if (--dquot->dq_count > 0)
+ remove_inuse(dquot);
+ else
+ remove_free_dquot(dquot);
+ unhash_dquot(dquot);
+ wait = dquot->dq_wait;
+ memset(dquot, 0, sizeof(*dquot)); barrier();
+ dquot->dq_wait = wait;
+ put_dquot_head(dquot);
+}
+
+void invalidate_dquots(kdev_t dev, short type)
+{
+ struct dquot *dquot, *next = NULL;
+ int pass = 0;
+
+ dquot = free_dquots.head;
+repeat:
+ while (dquot) {
+ next = dquot->dq_next;
+ if (dquot->dq_dev != dev || dquot->dq_type != type)
+ goto next;
+ clear_dquot(dquot);
+ next:
+ dquot = next;
+ }
+
+ if (pass == 0) {
+ dquot = inuse_list;
+ pass = 1;
+ goto repeat;
+ }
+}
+
int sync_dquots(kdev_t dev, short type)
{
- struct dquot *dquot = first_dquot;
- int i;
+ struct dquot *dquot, *next;
+ int pass = 0;
- dqstats.syncs++;
- for (i = 0; i < nr_dquots * 2; i++, dquot = dquot->dq_next) {
- if ((dev != NODEV && dquot->dq_dev != dev) || dquot->dq_count == 0 )
- continue;
- if (type != -1 && dquot->dq_type != type)
- continue;
+ dquot = free_dquots.head;
+repeat:
+ while (dquot) {
+ next = dquot->dq_next;
+ if ((dev && dquot->dq_dev != dev) ||
+ (type != -1 && dquot->dq_type != type))
+ goto next;
wait_on_dquot(dquot);
if (dquot->dq_flags & DQ_MOD)
write_dquot(dquot);
+ next:
+ dquot = next;
+ }
+
+ if (pass == 0) {
+ dquot = inuse_list;
+ pass = 1;
+ goto repeat;
}
+ dqstats.syncs++;
return(0);
}
-/*
- * Trash the cache for a certain type on a device.
- */
-void invalidate_dquots(kdev_t dev, short type)
+void dqput(struct dquot *dquot)
{
- struct dquot *dquot, *next;
- int cnt;
+ if (!dquot)
+ return;
- next = first_dquot;
- for (cnt = nr_dquots ; cnt > 0 ; cnt--) {
- dquot = next;
- next = dquot->dq_next;
- if (dquot->dq_dev != dev || dquot->dq_type != type)
+ /*
+ * If the dq_mnt pointer isn't initialized this entry needs no
+ * checking and doesn't need to be written. It just an empty
+ * dquot that is put back on to the freelist.
+ */
+ if (dquot->dq_mnt != (struct vfsmount *)NULL) {
+ dqstats.drops++;
+ wait_on_dquot(dquot);
+
+ if (!dquot->dq_count) {
+ printk("VFS: dqput: trying to free free dquot\n");
+ printk("VFS: device %s, dquot of %s %d\n", kdevname(dquot->dq_dev),
+ quotatypes[dquot->dq_type], dquot->dq_id);
+ return;
+ }
+we_slept:
+ if (dquot->dq_count > 1) {
+ dquot->dq_count--;
+ return;
+ } else {
+ wake_up(&dquot_wait);
+
+ if (dquot->dq_flags & DQ_MOD) {
+ write_dquot(dquot);
+ wait_on_dquot(dquot);
+ goto we_slept;
+ }
+ }
+ }
+
+ if (--dquot->dq_count == 0) {
+ remove_inuse(dquot);
+ put_dquot_last(dquot); /* Place at end of LRU free queue */
+ }
+
+ return;
+}
+
+static void grow_dquots(void)
+{
+ struct dquot *dquot;
+ int cnt = 32;
+
+ while (cnt > 0) {
+ dquot = kmem_cache_alloc(dquot_cachep, SLAB_KERNEL);
+ if(!dquot)
+ return;
+
+ nr_dquots++;
+ memset((caddr_t)dquot, 0, sizeof(struct dquot));
+ put_dquot_head(dquot);
+ cnt--;
+ }
+}
+
+static struct dquot *find_best_candidate_weighted(struct dquot *dquot)
+{
+ int limit, myscore;
+ unsigned long bestscore;
+ struct dquot *best = NULL;
+
+ if (dquot) {
+ bestscore = 2147483647;
+ limit = nr_free_dquots >> 2;
+ do {
+ if (!((dquot->dq_flags & DQ_LOCKED) || (dquot->dq_flags & DQ_MOD))) {
+ myscore = dquot->dq_referenced;
+ if (myscore < bestscore) {
+ bestscore = myscore;
+ best = dquot;
+ }
+ }
+ dquot = dquot->dq_next;
+ } while (dquot && --limit);
+ }
+ return best;
+}
+
+static inline struct dquot *find_best_free(struct dquot *dquot)
+{
+ int limit;
+
+ if (dquot) {
+ limit = nr_free_dquots >> 5;
+ do {
+ if (dquot->dq_referenced == 0)
+ return dquot;
+ dquot = dquot->dq_next;
+ } while (dquot && --limit);
+ }
+ return NULL;
+}
+
+struct dquot *get_empty_dquot(void)
+{
+ struct dquot *dquot;
+
+repeat:
+ dquot = find_best_free(free_dquots.head);
+ if (!dquot)
+ goto pressure;
+got_it:
+ dquot->dq_count++;
+ wait_on_dquot(dquot);
+ unhash_dquot(dquot);
+ remove_free_dquot(dquot);
+
+ memset(dquot, 0, sizeof(*dquot));
+ dquot->dq_count = 1;
+
+ put_inuse(dquot);
+ return dquot;
+pressure:
+ if (nr_dquots < max_dquots) {
+ grow_dquots();
+ goto repeat;
+ }
+
+ dquot = find_best_candidate_weighted(free_dquots.head);
+ if (!dquot) {
+ printk("VFS: No free dquots, contact mvw@planets.elm.net\n");
+ sleep_on(&dquot_wait);
+ goto repeat;
+ }
+ if (dquot->dq_flags & DQ_LOCKED) {
+ wait_on_dquot(dquot);
+ goto repeat;
+ } else if (dquot->dq_flags & DQ_MOD) {
+ write_dquot(dquot);
+ goto repeat;
+ }
+ goto got_it;
+}
+
+struct dquot *dqget(kdev_t dev, unsigned int id, short type)
+{
+ unsigned int hashent = hashfn(dev, id, type);
+ struct dquot *dquot, *empty = NULL;
+ struct vfsmount *vfsmnt;
+
+ if ((vfsmnt = lookup_vfsmnt(dev)) == (struct vfsmount *)NULL || is_enabled(vfsmnt, type) == 0)
+ return(NODQUOT);
+
+we_slept:
+ if ((dquot = find_dquot(hashent, dev, id, type)) == NULL) {
+ if (empty == NULL) {
+ dquot_updating[hashent]++;
+ empty = get_empty_dquot();
+ if (!--dquot_updating[hashent])
+ wake_up(&update_wait);
+ goto we_slept;
+ }
+ dquot = empty;
+ dquot->dq_id = id;
+ dquot->dq_type = type;
+ dquot->dq_dev = dev;
+ dquot->dq_mnt = vfsmnt;
+ read_dquot(dquot);
+ hash_dquot(dquot);
+ } else {
+ if (!dquot->dq_count++) {
+ remove_free_dquot(dquot);
+ put_inuse(dquot);
+ } else
+ dqstats.cache_hits++;
+ wait_on_dquot(dquot);
+ if (empty)
+ dqput(empty);
+ }
+
+ while (dquot_updating[hashent])
+ sleep_on(&update_wait);
+
+ dquot->dq_referenced++;
+ dqstats.lookups++;
+
+ return dquot;
+}
+
+static void add_dquot_ref(kdev_t dev, short type)
+{
+ struct file *filp;
+ struct inode *inode;
+
+ for (filp = inuse_filps; filp; filp = filp->f_next) {
+ inode = filp->f_dentry->d_inode;
+ if (!inode || inode->i_dev != dev)
continue;
- if (dquot->dq_flags & DQ_LOCKED) {
- printk("VFS: dquot busy on removed device %s\n", kdevname(dev));
+ if (filp->f_mode & FMODE_WRITE && inode->i_sb && inode->i_sb->dq_op) {
+ inode->i_sb->dq_op->initialize(inode, type);
+ inode->i_flags |= S_QUOTA;
+ }
+ }
+}
+
+static void reset_dquot_ptrs(kdev_t dev, short type)
+{
+ struct file *filp;
+ struct inode *inode;
+
+ for (filp = inuse_filps; filp; filp = filp->f_next) {
+ inode = filp->f_dentry->d_inode;
+ if (!inode || inode->i_dev != dev)
continue;
+ if (IS_QUOTAINIT(inode)) {
+ if (inode->i_sb && inode->i_sb->dq_op)
+ inode->i_sb->dq_op->drop(inode);
+ inode->i_dquot[type] = NODQUOT;
+ inode->i_flags &= ~S_QUOTA;
}
- if (dquot->dq_flags & DQ_MOD)
- write_dquot(dquot);
- dqstats.drops++;
- clear_dquot(dquot);
}
}
@@ -359,229 +607,108 @@
unlock_dquot(dquot);
}
-static inline int need_print_warning(short type, struct dquot *dquot)
+static inline char need_print_warning(short type, uid_t initiator, struct dquot *dquot)
{
switch (type) {
case USRQUOTA:
- return(current->fsuid == dquot->dq_id);
+ return(initiator == dquot->dq_id);
case GRPQUOTA:
- return(current->fsgid == dquot->dq_id);
+ return(initiator == dquot->dq_id);
}
return(0);
}
-static int check_idq(struct dquot *dquot, short type, u_long short inodes)
+static inline char ignore_hardlimit(struct dquot *dquot, uid_t initiator)
+{
+ return(initiator == 0 && dquot->dq_mnt->mnt_dquot.rsquash[dquot->dq_type] == 0);
+}
+
+static int check_idq(struct dquot *dquot, short type, u_long short inodes, uid_t initiator, struct tty_struct *tty)
{
if (inodes <= 0 || dquot->dq_flags & DQ_FAKE)
return(QUOTA_OK);
+
if (dquot->dq_ihardlimit &&
- (dquot->dq_curinodes + inodes) > dquot->dq_ihardlimit &&
- !capable(CAP_SYS_RESOURCE)) {
+ (dquot->dq_curinodes + inodes) > dquot->dq_ihardlimit &&
+ !ignore_hardlimit(dquot, initiator)) {
if ((dquot->dq_flags & DQ_INODES) == 0 &&
- need_print_warning(type, dquot)) {
- sprintf(quotamessage, "%s: write failed, %s file limit reached\r\n",
+ need_print_warning(type, initiator, dquot)) {
+ sprintf(quotamessage, "%s: write failed, %s file limit reached\n",
dquot->dq_mnt->mnt_dirname, quotatypes[type]);
- tty_write_message(current->tty, quotamessage);
+ tty_write_message(tty, quotamessage);
dquot->dq_flags |= DQ_INODES;
}
return(NO_QUOTA);
}
+
if (dquot->dq_isoftlimit &&
(dquot->dq_curinodes + inodes) > dquot->dq_isoftlimit &&
- dquot->dq_itime && CURRENT_TIME >= dquot->dq_itime &&
- !capable(CAP_SYS_RESOURCE)) {
- if (need_print_warning(type, dquot)) {
- sprintf(quotamessage, "%s: warning, %s file quota exceeded too long.\r\n",
+ dquot->dq_itime && CURRENT_TIME >= dquot->dq_itime &&
+ !ignore_hardlimit(dquot, initiator)) {
+ if (need_print_warning(type, initiator, dquot)) {
+ sprintf(quotamessage, "%s: warning, %s file quota exceeded too long.\n",
dquot->dq_mnt->mnt_dirname, quotatypes[type]);
- tty_write_message(current->tty, quotamessage);
+ tty_write_message(tty, quotamessage);
}
return(NO_QUOTA);
}
+
if (dquot->dq_isoftlimit &&
(dquot->dq_curinodes + inodes) > dquot->dq_isoftlimit &&
- dquot->dq_itime == 0 &&
- !capable(CAP_SYS_RESOURCE)) {
- if (need_print_warning(type, dquot)) {
- sprintf(quotamessage, "%s: warning, %s file quota exceeded\r\n",
+ dquot->dq_itime == 0) {
+ if (need_print_warning(type, initiator, dquot)) {
+ sprintf(quotamessage, "%s: warning, %s file quota exceeded\n",
dquot->dq_mnt->mnt_dirname, quotatypes[type]);
- tty_write_message(current->tty, quotamessage);
+ tty_write_message(tty, quotamessage);
}
- dquot->dq_itime = CURRENT_TIME + dquot->dq_mnt->mnt_iexp[type];
+ dquot->dq_itime = CURRENT_TIME + dquot->dq_mnt->mnt_dquot.inode_expire[type];
}
+
return(QUOTA_OK);
}
-static int check_bdq(struct dquot *dquot, short type, u_long blocks)
+static int check_bdq(struct dquot *dquot, short type, u_long blocks, uid_t initiator, struct tty_struct *tty, char warn)
{
if (blocks <= 0 || dquot->dq_flags & DQ_FAKE)
return(QUOTA_OK);
+
if (dquot->dq_bhardlimit &&
- (dquot->dq_curblocks + blocks) > dquot->dq_bhardlimit &&
- !capable(CAP_SYS_RESOURCE)) {
- if ((dquot->dq_flags & DQ_BLKS) == 0 &&
- need_print_warning(type, dquot)) {
- sprintf(quotamessage, "%s: write failed, %s disk limit reached.\r\n",
+ (dquot->dq_curblocks + blocks) > dquot->dq_bhardlimit &&
+ !ignore_hardlimit(dquot, initiator)) {
+ if (warn && (dquot->dq_flags & DQ_BLKS) == 0 &&
+ need_print_warning(type, initiator, dquot)) {
+ sprintf(quotamessage, "%s: write failed, %s disk limit reached.\n",
dquot->dq_mnt->mnt_dirname, quotatypes[type]);
- tty_write_message(current->tty, quotamessage);
+ tty_write_message(tty, quotamessage);
dquot->dq_flags |= DQ_BLKS;
}
return(NO_QUOTA);
}
+
if (dquot->dq_bsoftlimit &&
(dquot->dq_curblocks + blocks) > dquot->dq_bsoftlimit &&
- dquot->dq_btime && CURRENT_TIME >= dquot->dq_btime &&
- !capable(CAP_SYS_RESOURCE)) {
- if (need_print_warning(type, dquot)) {
- sprintf(quotamessage, "%s: write failed, %s disk quota exceeded too long.\r\n",
+ dquot->dq_btime && CURRENT_TIME >= dquot->dq_btime &&
+ !ignore_hardlimit(dquot, initiator)) {
+ if (warn && need_print_warning(type, initiator, dquot)) {
+ sprintf(quotamessage, "%s: write failed, %s disk quota exceeded too long.\n",
dquot->dq_mnt->mnt_dirname, quotatypes[type]);
- tty_write_message(current->tty, quotamessage);
+ tty_write_message(tty, quotamessage);
}
return(NO_QUOTA);
}
+
if (dquot->dq_bsoftlimit &&
(dquot->dq_curblocks + blocks) > dquot->dq_bsoftlimit &&
- dquot->dq_btime == 0 &&
- !capable(CAP_SYS_RESOURCE)) {
- if (need_print_warning(type, dquot)) {
- sprintf(quotamessage, "%s: warning, %s disk quota exceeded\r\n",
+ dquot->dq_btime == 0) {
+ if (warn && need_print_warning(type, initiator, dquot)) {
+ sprintf(quotamessage, "%s: warning, %s disk quota exceeded\n",
dquot->dq_mnt->mnt_dirname, quotatypes[type]);
- tty_write_message(current->tty, quotamessage);
- }
- dquot->dq_btime = CURRENT_TIME + dquot->dq_mnt->mnt_bexp[type];
- }
- return(QUOTA_OK);
-}
-
-static void dqput(struct dquot *dquot)
-{
- if (!dquot)
- return;
- /*
- * If the dq_mnt pointer isn't initialized this entry needs no
- * checking and doesn't need to be written. It just an empty
- * dquot that is put back into the freelist.
- */
- if (dquot->dq_mnt != (struct vfsmount *)NULL) {
- dqstats.drops++;
- wait_on_dquot(dquot);
- if (!dquot->dq_count) {
- printk("VFS: dqput: trying to free free dquot\n");
- printk("VFS: device %s, dquot of %s %d\n", kdevname(dquot->dq_dev),
- quotatypes[dquot->dq_type], dquot->dq_id);
- return;
+ tty_write_message(tty, quotamessage);
}
-repeat:
- if (dquot->dq_count > 1) {
- dquot->dq_count--;
- return;
- }
- wake_up(&dquot_wait);
- if (dquot->dq_flags & DQ_MOD) {
- write_dquot(dquot); /* we can sleep - so do again */
- wait_on_dquot(dquot);
- goto repeat;
- }
- }
- if (dquot->dq_count) {
- dquot->dq_count--;
- nr_free_dquots++;
+ dquot->dq_btime = CURRENT_TIME + dquot->dq_mnt->mnt_dquot.block_expire[type];
}
- return;
-}
-
-static struct dquot *get_empty_dquot(void)
-{
- struct dquot *dquot, *best;
- int cnt;
-
- if (nr_dquots < NR_DQUOTS && nr_free_dquots < (nr_dquots >> 2))
- grow_dquots();
-repeat:
- dquot = first_dquot;
- best = NODQUOT;
- for (cnt = 0; cnt < nr_dquots; dquot = dquot->dq_next, cnt++) {
- if (!dquot->dq_count) {
- if (!best)
- best = dquot;
- if (!(dquot->dq_flags & DQ_MOD) && !(dquot->dq_flags & DQ_LOCKED)) {
- best = dquot;
- break;
- }
- }
- }
- if (!best || best->dq_flags & DQ_MOD || best->dq_flags & DQ_LOCKED)
- if (nr_dquots < NR_DQUOTS) {
- grow_dquots();
- goto repeat;
- }
- dquot = best;
- if (!dquot) {
- printk("VFS: No free dquots - contact mvw@mcs.ow.org\n");
- sleep_on(&dquot_wait);
- goto repeat;
- }
- if (dquot->dq_flags & DQ_LOCKED) {
- wait_on_dquot(dquot);
- goto repeat;
- }
- if (dquot->dq_flags & DQ_MOD) {
- write_dquot(dquot);
- goto repeat;
- }
- if (dquot->dq_count)
- goto repeat;
- clear_dquot(dquot);
- dquot->dq_count = 1;
- nr_free_dquots--;
- if (nr_free_dquots < 0) {
- printk ("VFS: get_empty_dquot: bad free dquot count.\n");
- nr_free_dquots = 0;
- }
- return(dquot);
-}
-
-static struct dquot *dqget(kdev_t dev, unsigned int id, short type)
-{
- struct dquot *dquot, *empty;
- struct vfsmount *vfsmnt;
-
- if ((vfsmnt = lookup_vfsmnt(dev)) == (struct vfsmount *)NULL ||
- (vfsmnt->mnt_quotas[type] == (struct file *)0))
- return(NODQUOT);
- dqstats.lookups++;
- empty = get_empty_dquot();
-repeat:
- dquot = *(hash(dev, id, type));
- while (dquot) {
- if (dquot->dq_dev != dev || dquot->dq_id != id ||
- dquot->dq_type != type) {
- dquot = dquot->dq_hash_next;
- continue;
- }
- wait_on_dquot(dquot);
- if (dquot->dq_dev != dev || dquot->dq_id != id ||
- dquot->dq_type != type)
- goto repeat;
- if (!dquot->dq_count)
- nr_free_dquots--;
- dquot->dq_count++;
- if (empty)
- dqput(empty);
- dqstats.cache_hits++;
- return(dquot);
- }
- if (!empty)
- return(NODQUOT);
- dquot = empty;
- dquot->dq_id = id;
- dquot->dq_type = type;
- dquot->dq_dev = dev;
- dquot->dq_mnt = vfsmnt;
- put_last_free(dquot);
- insert_dquot_hash(dquot);
- read_dquot(dquot);
- return(dquot);
+ return(QUOTA_OK);
}
/*
@@ -590,54 +717,57 @@
*/
static int set_dqblk(kdev_t dev, int id, short type, int flags, struct dqblk *dqblk)
{
+ int error;
struct dquot *dquot;
struct dqblk dq_dqblk;
if (dqblk == (struct dqblk *)NULL)
return(-EFAULT);
- if (flags & QUOTA_SYSCALL) {
- if (copy_from_user(&dq_dqblk, dqblk, sizeof(struct dqblk)))
- return -EFAULT;
- } else {
- memcpy(&dq_dqblk, dqblk, sizeof(struct dqblk));
- }
+ if (flags & QUOTA_SYSCALL)
+ if ((error = copy_from_user((caddr_t)&dq_dqblk, (caddr_t)dqblk, sizeof(struct dqblk))) != 0)
+ return(error);
+ else
+ memcpy((caddr_t)&dq_dqblk, (caddr_t)dqblk, sizeof(struct dqblk));
+
if ((dquot = dqget(dev, id, type)) != NODQUOT) {
lock_dquot(dquot);
- if (id > 0 && (flags & (SET_QUOTA|SET_QLIMIT))) {
+
+ if (id > 0 && ((flags & SET_QUOTA) || (flags & SET_QLIMIT))) {
dquot->dq_bhardlimit = dq_dqblk.dqb_bhardlimit;
dquot->dq_bsoftlimit = dq_dqblk.dqb_bsoftlimit;
dquot->dq_ihardlimit = dq_dqblk.dqb_ihardlimit;
dquot->dq_isoftlimit = dq_dqblk.dqb_isoftlimit;
}
- if (flags & (SET_QUOTA|SET_USE)) {
+
+ if ((flags & SET_QUOTA) || (flags & SET_USE)) {
if (dquot->dq_isoftlimit &&
dquot->dq_curinodes < dquot->dq_isoftlimit &&
dq_dqblk.dqb_curinodes >= dquot->dq_isoftlimit)
- dquot->dq_itime = CURRENT_TIME + dquot->dq_mnt->mnt_iexp[type];
+ dquot->dq_itime = CURRENT_TIME + dquot->dq_mnt->mnt_dquot.inode_expire[type];
dquot->dq_curinodes = dq_dqblk.dqb_curinodes;
if (dquot->dq_curinodes < dquot->dq_isoftlimit)
dquot->dq_flags &= ~DQ_INODES;
if (dquot->dq_bsoftlimit &&
dquot->dq_curblocks < dquot->dq_bsoftlimit &&
dq_dqblk.dqb_curblocks >= dquot->dq_bsoftlimit)
- dquot->dq_btime = CURRENT_TIME + dquot->dq_mnt->mnt_bexp[type];
+ dquot->dq_btime = CURRENT_TIME + dquot->dq_mnt->mnt_dquot.block_expire[type];
dquot->dq_curblocks = dq_dqblk.dqb_curblocks;
if (dquot->dq_curblocks < dquot->dq_bsoftlimit)
dquot->dq_flags &= ~DQ_BLKS;
}
+
if (id == 0) {
- /*
- * Change in expiretimes, change them in dq_mnt.
- */
- dquot->dq_mnt->mnt_bexp[type] = dquot->dq_btime = dq_dqblk.dqb_btime;
- dquot->dq_mnt->mnt_iexp[type] = dquot->dq_itime = dq_dqblk.dqb_itime;
+ dquot->dq_mnt->mnt_dquot.block_expire[type] = dquot->dq_btime = dq_dqblk.dqb_btime;
+ dquot->dq_mnt->mnt_dquot.inode_expire[type] = dquot->dq_itime = dq_dqblk.dqb_itime;
}
+
if (dq_dqblk.dqb_bhardlimit == 0 && dq_dqblk.dqb_bsoftlimit == 0 &&
dq_dqblk.dqb_ihardlimit == 0 && dq_dqblk.dqb_isoftlimit == 0)
dquot->dq_flags |= DQ_FAKE;
else
dquot->dq_flags &= ~DQ_FAKE;
+
dquot->dq_flags |= DQ_MOD;
unlock_dquot(dquot);
dqput(dquot);
@@ -650,14 +780,14 @@
struct dquot *dquot;
int error;
- if (has_quota_enabled(dev, type)) {
+ if (dev_has_quota_enabled(dev, type)) {
if (dqblk == (struct dqblk *)NULL)
return(-EFAULT);
if ((dquot = dqget(dev, id, type)) != NODQUOT) {
- error = copy_to_user(dqblk, (char *)&dquot->dq_dqb, sizeof(struct dqblk));
+ error = copy_to_user((caddr_t)dqblk, (caddr_t)&dquot->dq_dqb, sizeof(struct dqblk));
dqput(dquot);
- return error ? -EFAULT : 0;
+ return(error);
}
}
return(-ESRCH);
@@ -667,25 +797,67 @@
{
dqstats.allocated_dquots = nr_dquots;
dqstats.free_dquots = nr_free_dquots;
- return copy_to_user(addr, (caddr_t)&dqstats, sizeof(struct dqstats))
- ? -EFAULT : 0;
+ return(copy_to_user(addr, (caddr_t)&dqstats, sizeof(struct dqstats)));
+}
+
+static int quota_root_squash(kdev_t dev, short type, int *addr)
+{
+ struct vfsmount *vfsmnt;
+ int new_value, error;
+
+ if ((vfsmnt = lookup_vfsmnt(dev)) == (struct vfsmount *)NULL)
+ return(-ENODEV);
+
+ if ((error = copy_from_user((caddr_t)&new_value, (caddr_t)addr, sizeof(int))) != 0)
+ return(error);
+
+ vfsmnt->mnt_dquot.rsquash[type] = new_value;
+ return(0);
}
/*
- * Initialize pointer in an inode to the right dquots.
+ * This is a simple algorithm that calculates the size of a file in blocks.
+ * This is only used on filesystems that do not have an i_blocks count.
+ */
+static u_long isize_to_blocks(size_t isize, size_t blksize)
+{
+ u_long blocks;
+ u_long indirect;
+
+ if (!blksize)
+ blksize = BLOCK_SIZE;
+ blocks = (isize / blksize) + ((isize % blksize) ? 1 : 0);
+ if (blocks > 10) {
+ indirect = ((blocks - 11) >> 8) + 1; /* single indirect blocks */
+ if (blocks > (10 + 256)) {
+ indirect += ((blocks - 267) >> 16) + 1; /* double indirect blocks */
+ if (blocks > (10 + 256 + (256 << 8)))
+ indirect++; /* triple indirect blocks */
+ }
+ blocks += indirect;
+ }
+ return(blocks);
+}
+
+/*
+ * Externally referenced functions through dquot_operations in inode.
*/
void dquot_initialize(struct inode *inode, short type)
{
+ struct dquot *dquot;
unsigned int id = 0;
short cnt;
- struct dquot *tmp;
- if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) {
+ if (S_ISREG(inode->i_mode) ||
+ S_ISDIR(inode->i_mode) ||
+ S_ISLNK(inode->i_mode)) {
for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
if (type != -1 && cnt != type)
continue;
- if (!has_quota_enabled(inode->i_dev, cnt))
+
+ if (!sb_has_quota_enabled(inode->i_sb, cnt))
continue;
+
if (inode->i_dquot[cnt] == NODQUOT) {
switch (cnt) {
case USRQUOTA:
@@ -695,17 +867,13 @@
id = inode->i_gid;
break;
}
-
- tmp = dqget(inode->i_dev, id, cnt);
- /* We may sleep in dqget(), so check it again.
- * Dmitry Gorodchanin 02/11/96
- */
+ dquot = dqget(inode->i_dev, id, cnt);
if (inode->i_dquot[cnt] != NODQUOT) {
- dqput(tmp);
+ dqput(dquot);
continue;
}
- inode->i_dquot[cnt] = tmp;
- inode->i_flags |= S_WRITE;
+ inode->i_dquot[cnt] = dquot;
+ inode->i_flags |= S_QUOTA;
}
}
}
@@ -713,82 +881,58 @@
void dquot_drop(struct inode *inode)
{
+ struct dquot *dquot;
short cnt;
- struct dquot * tmp;
+ inode->i_flags &= ~S_QUOTA;
for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
if (inode->i_dquot[cnt] == NODQUOT)
continue;
- /* We can sleep at dqput(). So we must do it this way.
- * Dmitry Gorodchanin 02/11/96
- */
- tmp = inode->i_dquot[cnt];
+ dquot = inode->i_dquot[cnt];
inode->i_dquot[cnt] = NODQUOT;
- dqput(tmp);
- }
- inode->i_flags &= ~S_WRITE;
-}
-
-/*
- * This is a simple algorithm that calculates the size of a file in blocks.
- * This is only used on filesystems that do not have an i_blocks count.
- */
-static u_long isize_to_blocks(size_t isize, size_t blksize)
-{
- u_long blocks;
- u_long indirect;
-
- if (!blksize)
- blksize = BLOCK_SIZE;
- blocks = (isize / blksize) + ((isize % blksize) ? 1 : 0);
- if (blocks > 10) {
- indirect = ((blocks - 11) >> 8) + 1; /* single indirect blocks */
- if (blocks > (10 + 256)) {
- indirect += ((blocks - 267) >> 16) + 1; /* double indirect blocks */
- if (blocks > (10 + 256 + (256 << 8)))
- indirect++; /* triple indirect blocks */
- }
- blocks += indirect;
+ dqput(dquot);
}
- return(blocks);
}
-/*
- * Externally referenced functions through dquot_operations.
- */
-int dquot_alloc_block(const struct inode *inode, unsigned long number)
+int dquot_alloc_block(const struct inode *inode, unsigned long number, uid_t initiator, char warn)
{
unsigned short cnt;
+ struct tty_struct *tty = current->tty;
for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
if (inode->i_dquot[cnt] == NODQUOT)
continue;
- if (check_bdq(inode->i_dquot[cnt], cnt, number))
+ if (check_bdq(inode->i_dquot[cnt], cnt, number, initiator, tty, warn))
return(NO_QUOTA);
}
+
for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
if (inode->i_dquot[cnt] == NODQUOT)
continue;
dquot_incr_blocks(inode->i_dquot[cnt], number);
}
+
return(QUOTA_OK);
}
-int dquot_alloc_inode(const struct inode *inode, unsigned long number)
+int dquot_alloc_inode(const struct inode *inode, unsigned long number, uid_t initiator)
{
unsigned short cnt;
+ struct tty_struct *tty = current->tty;
for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
if (inode->i_dquot[cnt] == NODQUOT)
continue;
- if (check_idq(inode->i_dquot[cnt], cnt, number))
+ if (check_idq(inode->i_dquot[cnt], cnt, number, initiator, tty))
return(NO_QUOTA);
}
+
for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
if (inode->i_dquot[cnt] == NODQUOT)
continue;
dquot_incr_inodes(inode->i_dquot[cnt], number);
}
+
return(QUOTA_OK);
}
@@ -817,11 +961,12 @@
/*
* Transfer the number of inode and blocks from one diskquota to an other.
*/
-int dquot_transfer(struct inode *inode, struct iattr *iattr, char direction)
+int dquot_transfer(struct inode *inode, struct iattr *iattr, char direction, uid_t initiator)
{
unsigned long blocks;
struct dquot *transfer_from[MAXQUOTAS];
struct dquot *transfer_to[MAXQUOTAS];
+ struct tty_struct *tty = current->tty;
short cnt, disc;
/*
@@ -840,7 +985,7 @@
transfer_from[cnt] = NODQUOT;
transfer_to[cnt] = NODQUOT;
- if (!has_quota_enabled(inode->i_dev, cnt))
+ if (!sb_has_quota_enabled(inode->i_sb, cnt))
continue;
switch (cnt) {
@@ -858,8 +1003,8 @@
break;
}
- if (check_idq(transfer_to[cnt], cnt, 1) == NO_QUOTA ||
- check_bdq(transfer_to[cnt], cnt, blocks) == NO_QUOTA) {
+ if (check_idq(transfer_to[cnt], cnt, 1, initiator, tty) == NO_QUOTA ||
+ check_bdq(transfer_to[cnt], cnt, blocks, initiator, tty, 0) == NO_QUOTA) {
for (disc = 0; disc <= cnt; disc++) {
dqput(transfer_from[disc]);
dqput(transfer_to[disc]);
@@ -883,10 +1028,12 @@
dquot_decr_inodes(transfer_from[cnt], 1);
dquot_decr_blocks(transfer_from[cnt], blocks);
}
+
if (transfer_to[cnt] != NODQUOT) {
dquot_incr_inodes(transfer_to[cnt], 1);
dquot_incr_blocks(transfer_to[cnt], blocks);
}
+
if (inode->i_dquot[cnt] != NODQUOT) {
dqput(transfer_from[cnt]);
dqput(inode->i_dquot[cnt]);
@@ -896,16 +1043,24 @@
dqput(transfer_to[cnt]);
}
}
+
return(QUOTA_OK);
}
-void dquot_init(void)
+
+__initfunc(void dquot_init_hash(void))
{
- printk(KERN_NOTICE "VFS: Diskquotas version %s initialized\r\n",
- __DQUOT_VERSION__);
- memset(hash_table, 0, sizeof(hash_table));
+ printk(KERN_NOTICE "VFS: Diskquotas version %s initialized\n", __DQUOT_VERSION__);
+
+ dquot_cachep = kmem_cache_create("dquot", sizeof(struct dquot),
+ sizeof(unsigned long) * 4,
+ SLAB_HWCACHE_ALIGN, NULL, NULL);
+
+ if (!dquot_cachep)
+ panic("Cannot create dquot SLAB cache\n");
+
+ memset(dquot_hash, 0, sizeof(dquot_hash));
memset((caddr_t)&dqstats, 0, sizeof(dqstats));
- first_dquot = NODQUOT;
}
/*
@@ -921,6 +1076,30 @@
dquot_transfer
};
+static inline void set_enable_flags(struct vfsmount *vfsmnt, short type)
+{
+ switch (type) {
+ case USRQUOTA:
+ vfsmnt->mnt_dquot.flags |= DQUOT_USR_ENABLED;
+ break;
+ case GRPQUOTA:
+ vfsmnt->mnt_dquot.flags |= DQUOT_GRP_ENABLED;
+ break;
+ }
+}
+
+static inline void reset_enable_flags(struct vfsmount *vfsmnt, short type)
+{
+ switch (type) {
+ case USRQUOTA:
+ vfsmnt->mnt_dquot.flags &= ~DQUOT_USR_ENABLED;
+ break;
+ case GRPQUOTA:
+ vfsmnt->mnt_dquot.flags &= ~DQUOT_GRP_ENABLED;
+ break;
+ }
+}
+
/*
* Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
*/
@@ -929,25 +1108,28 @@
struct vfsmount *vfsmnt;
short cnt;
- if ( !(vfsmnt = lookup_vfsmnt(dev)) )
- return -ENODEV;
-
for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
if (type != -1 && cnt != type)
continue;
- if (vfsmnt->mnt_quotas[cnt] == (struct file *)NULL)
- {
- if(type == -1)
- continue;
- return -ESRCH;
- }
+
+ if ((vfsmnt = lookup_vfsmnt(dev)) == (struct vfsmount *)NULL ||
+ is_enabled(vfsmnt, cnt) == 0 ||
+ vfsmnt->mnt_sb == (struct super_block *)NULL)
+ continue;
+
vfsmnt->mnt_sb->dq_op = (struct dquot_operations *)NULL;
+
reset_dquot_ptrs(dev, cnt);
invalidate_dquots(dev, cnt);
- fput(vfsmnt->mnt_quotas[cnt]);
- vfsmnt->mnt_quotas[cnt] = (struct file *)NULL;
- vfsmnt->mnt_iexp[cnt] = vfsmnt->mnt_bexp[cnt] = (time_t)NULL;
+
+ fput(vfsmnt->mnt_dquot.files[cnt]);
+
+ reset_enable_flags(vfsmnt, cnt);
+ vfsmnt->mnt_dquot.files[cnt] = (struct file *)NULL;
+ vfsmnt->mnt_dquot.inode_expire[cnt] = 0;
+ vfsmnt->mnt_dquot.block_expire[cnt] = 0;
}
+
return(0);
}
@@ -962,11 +1144,11 @@
int error;
vfsmnt = lookup_vfsmnt(dev);
- if (vfsmnt == NULL)
+ if (vfsmnt == (struct vfsmount *)NULL)
return -ENODEV;
- if (vfsmnt->mnt_quotas[type] != NULL)
- return -EBUSY;
+ if (is_enabled(vfsmnt, type))
+ return(-EBUSY);
tmp = getname(path);
error = PTR_ERR(tmp);
@@ -986,8 +1168,13 @@
return -EACCES;
}
+ if (inode->i_size == 0 || (inode->i_size % sizeof(struct dqblk)) != 0) {
+ iput(inode);
+ return(-EINVAL);
+ }
+
filp = get_empty_filp();
- if (filp != NULL) {
+ if (filp != (struct file *)NULL) {
filp->f_mode = (O_RDWR + 1) & O_ACCMODE;
filp->f_flags = O_RDWR;
filp->f_dentry = dentry;
@@ -1000,14 +1187,18 @@
if (filp->f_op && filp->f_op->open)
error = filp->f_op->open(inode, filp);
if (!error) {
- vfsmnt->mnt_quotas[type] = filp;
+ set_enable_flags(vfsmnt, type);
+ vfsmnt->mnt_dquot.files[type] = filp;
+
dquot = dqget(dev, 0, type);
- vfsmnt->mnt_iexp[type] = (dquot) ? dquot->dq_itime : MAX_IQ_TIME;
- vfsmnt->mnt_bexp[type] = (dquot) ? dquot->dq_btime : MAX_DQ_TIME;
+ vfsmnt->mnt_dquot.inode_expire[type] = (dquot) ? dquot->dq_itime : MAX_IQ_TIME;
+ vfsmnt->mnt_dquot.block_expire[type] = (dquot) ? dquot->dq_btime : MAX_DQ_TIME;
dqput(dquot);
+
vfsmnt->mnt_sb->dq_op = &dquot_operations;
add_dquot_ref(dev, type);
- return 0;
+
+ return(0);
}
put_write_access(inode);
}
@@ -1016,8 +1207,10 @@
put_filp(filp);
} else
error = -EMFILE;
+
dput(dentry);
- return error;
+
+ return(error);
}
/*
@@ -1045,17 +1238,17 @@
break;
case Q_GETQUOTA:
if (((type == USRQUOTA && current->uid != id) ||
- (type == GRPQUOTA && in_group_p(id))) &&
- !capable(CAP_SYS_ADMIN))
+ (type == GRPQUOTA && current->gid != id)) &&
+ !capable(CAP_SYS_RESOURCE))
goto out;
break;
default:
- if (!capable(CAP_SYS_ADMIN))
+ if (!capable(CAP_SYS_RESOURCE))
goto out;
}
ret = -EINVAL;
- dev = NODEV;
+ dev = 0;
if (special != NULL || (cmds != Q_SYNC && cmds != Q_GETSTATS)) {
mode_t mode;
struct dentry * dentry;
@@ -1098,12 +1291,17 @@
goto out;
case Q_GETSTATS:
ret = get_stats(addr);
+ goto out;
+ case Q_RSQUASH:
+ ret = quota_root_squash(dev, type, (int *) addr);
+ goto out;
default:
goto out;
}
flags |= QUOTA_SYSCALL;
- if (has_quota_enabled(dev, type))
+
+ if (dev_has_quota_enabled(dev, type))
ret = set_dqblk(dev, id, type, flags, (struct dqblk *) addr);
else
ret = -ESRCH;
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen, slshen@lbl.gov