GFS2: Another quota of quotas
Subsystems (2)
Linus pulled the -nmw tree a few days ago, and I've rebased the tree with a couple of minor patches in there. In the mean time I've been working on the quota subsystem, and here is my current set of quota patches which I hope that I'll be able to roll into the -nmw tree fairly shortly now.
I've done some basic testing, but more remains to be done,
Steve.
PATCH 1/12 GFS2: Alter arguments of gfs2_quota/statfs_sync
These two functions are altered so that gfs2_quota_sync may in future be called directly from the VFS. The GFS2 superblock changes to a VFS super block and there is an addition of an int argument which is currently ignored.
--- fs/gfs2/quota.c | 7 ++++--- fs/gfs2/quota.h | 2 +- fs/gfs2/super.c | 7 ++++--- fs/gfs2/super.h | 2 +- fs/gfs2/sys.c | 4 ++-- 5 files changed, 12 insertions(+), 10 deletions(-)
fs/gfs2/quota.c +4 -3
@@ -1069,8 +1069,9 @@ void gfs2_quota_change(struct gfs2_inode *ip, s64 change, } } -int gfs2_quota_sync (struct gfs2_sbd *sdp) +int gfs2_quota_sync (struct super_block *sb,int type) { +struct gfs2_sbd *sdp = sb->s_fs_info;struct gfs2_quota_data **qda;unsigned int max_qd =gfs2_tune_get (sdp, gt_quota_simul_sync);unsigned int num_qd;
@@ -1298,12 +1299,12 @@ static void quotad_error(struct gfs2_sbd *sdp, const char *msg, int error) }static void quotad_check_timeo (struct gfs2_sbd *sdp,const char *msg, -int (*fxn)(struct gfs2_sbd *sdp), +int (*fxn)(struct super_block *sb,int type),unsigned long t,unsigned long *timeo,unsigned int *new_timeo) {if (t >= *timeo) { -int error =fxn (sdp); +int error =fxn (sdp->sd_vfs,0 );quotad_error (sdp, msg, error); *timeo =gfs2_tune_get_i (&sdp->sd_tune, new_timeo) *HZ ; }else {
fs/gfs2/quota.h +1 -1
@@ -25,7 +25,7 @@ extern int gfs2_quota_check(struct gfs2_inode *ip, u32 uid, u32 gid);extern void gfs2_quota_change (struct gfs2_inode *ip,s64 change,u32 uid,u32 gid); -extern int gfs2_quota_sync (struct gfs2_sbd *sdp); +extern int gfs2_quota_sync (struct super_block *sb,int type);extern int gfs2_quota_refresh (struct gfs2_sbd *sdp,int user,u32 id);extern int gfs2_quota_init (struct gfs2_sbd *sdp);
fs/gfs2/super.c +4 -3
@@ -484,8 +484,9 @@ void update_statfs(struct gfs2_sbd *sdp, struct buffer_head *m_bh,gfs2_statfs_change_out (m_sc, m_bh->b_data +sizeof (struct gfs2_dinode )); } -int gfs2_statfs_sync (struct gfs2_sbd *sdp) +int gfs2_statfs_sync (struct super_block *sb,int type) { +struct gfs2_sbd *sdp = sb->s_fs_info;struct gfs2_inode *m_ip =GFS2_I (sdp->sd_statfs_inode);struct gfs2_inode *l_ip =GFS2_I (sdp->sd_sc_inode);struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
@@ -712,8 +713,8 @@ static int gfs2_make_fs_ro(struct gfs2_sbd *sdp)int error;flush_workqueue (gfs2_delete_workqueue); -gfs2_quota_sync (sdp); -gfs2_statfs_sync (sdp); +gfs2_quota_sync (sdp->sd_vfs,0 ); +gfs2_statfs_sync (sdp->sd_vfs,0 ); error =gfs2_glock_nq_init (sdp->sd_trans_gl,LM_ST_SHARED ,GL_NOCACHE , &t_gh);
fs/gfs2/super.h +1 -1
@@ -44,7 +44,7 @@ extern void gfs2_statfs_change_in(struct gfs2_statfs_change_host *sc, const void *buf);extern void update_statfs (struct gfs2_sbd *sdp,struct buffer_head *m_bh,struct buffer_head *l_bh); -extern int gfs2_statfs_sync (struct gfs2_sbd *sdp); +extern int gfs2_statfs_sync (struct super_block *sb,int type);extern int gfs2_freeze_fs (struct gfs2_sbd *sdp);extern void gfs2_unfreeze_fs (struct gfs2_sbd *sdp);
fs/gfs2/sys.c +2 -2
@@ -158,7 +158,7 @@ static ssize_t statfs_sync_store(struct gfs2_sbd *sdp, const char *buf,if (simple_strtol (buf,NULL ,0 ) !=1 )return -EINVAL ; -gfs2_statfs_sync (sdp); +gfs2_statfs_sync (sdp->sd_vfs,0 );return len; }
@@ -171,7 +171,7 @@ static ssize_t quota_sync_store(struct gfs2_sbd *sdp, const char *buf,if (simple_strtol (buf,NULL ,0 ) !=1 )return -EINVAL ; -gfs2_quota_sync (sdp); +gfs2_quota_sync (sdp->sd_vfs,0 );return len; }
Signature · 1 line
1.6.2.5
PATCH 2/12 GFS2: Hook gfs2_quota_sync into VFS via gfs2_quotactl_ops
The plan is to add further operations to the gfs2_quotactl_ops in future patches. The sync operation is easy, so we start with that one.
We plan to use the XFS quota control functions because they more closely match the GFS2 ones.
--- fs/gfs2/Kconfig | 2 ++ fs/gfs2/ops_fstype.c | 3 +++ fs/gfs2/quota.c | 4 ++++ fs/gfs2/quota.h | 1 + 4 files changed, 10 insertions(+), 0 deletions(-)
fs/gfs2/Kconfig +2 -0
@@ -8,6 +8,8 @@ config GFS2_FS select FS_POSIX_ACL select CRC32 select SLOW_WORK + select QUOTA + select QUOTACTL help A cluster filesystem.
fs/gfs2/ops_fstype.c +3 -0
@@ -18,6 +18,7 @@#include <linux/mount.h> #include <linux/gfs2_ondisk.h> #include <linux/slow-work.h> +#include <linux/quotaops.h> #include "gfs2.h" #include "incore.h"
@@ -1148,6 +1149,8 @@ static int fill_super(struct super_block *sb, void *data, int silent) sb->s_op = &gfs2_super_ops; sb->s_export_op = &gfs2_export_ops; sb->s_xattr = gfs2_xattr_handlers; + sb->s_qcop = &gfs2_quotactl_ops; +sb_dqopt (sb)->flags |=DQUOT_QUOTA_SYS_FILE ; sb->s_time_gran =1 ; sb->s_maxbytes =MAX_LFS_FILESIZE ;
fs/gfs2/quota.c +4 -0
@@ -1378,3 +1378,7 @@ int gfs2_quotad(void *data)return 0 ; } +const struct quotactl_ops gfs2_quotactl_ops = { + .quota_sync = gfs2_quota_sync, +}; +
fs/gfs2/quota.h +1 -0
@@ -50,5 +50,6 @@ static inline int gfs2_quota_lock_check(struct gfs2_inode *ip) }extern int gfs2_shrink_qd_memory (int nr,gfp_t gfp_mask); +extern const struct quotactl_ops gfs2_quotactl_ops;#endif /* __QUOTA_DOT_H__ */
Signature · 1 line
1.6.2.5
PATCH 3/12 GFS2: Remove obsolete code in quota.c
There is no point in testing for GLF_DEMOTE here, we might as well always release the glock at that point.
--- fs/gfs2/glock.h | 9 --------- fs/gfs2/quota.c | 13 +++++-------- 2 files changed, 5 insertions(+), 17 deletions(-)
fs/gfs2/glock.h +0 -9
@@ -180,15 +180,6 @@ static inline int gfs2_glock_is_held_shrd(struct gfs2_glock *gl)return gl->gl_state ==LM_ST_SHARED ; } -static inline int gfs2_glock_is_blocking (struct gfs2_glock *gl) -{ -int ret; -spin_lock (&gl->gl_spin); - ret =test_bit (GLF_DEMOTE , &gl->gl_flags); -spin_unlock (&gl->gl_spin); -return ret; -} -int gfs2_glock_get (struct gfs2_sbd *sdp,u64 number,const struct gfs2_glock_operations *glops,int create,struct gfs2_glock **glp);
fs/gfs2/quota.c +5 -8
@@ -843,9 +843,8 @@ restart:if (force_refresh || qd->qd_qb.qb_magic !=cpu_to_be32 (GFS2_MAGIC )) {loff_t pos;gfs2_glock_dq_uninit (q_gh); - error =gfs2_glock_nq_init (qd->qd_gl, -LM_ST_EXCLUSIVE ,GL_NOCACHE , - q_gh); + error =gfs2_glock_nq_init (qd->qd_gl,LM_ST_EXCLUSIVE , +GL_NOCACHE , q_gh);if (error)return error;
@@ -871,11 +870,9 @@ restart: qlvb->qb_value =cpu_to_be64 (q.qu_value); qd->qd_qb = *qlvb; -if (gfs2_glock_is_blocking (qd->qd_gl)) { -gfs2_glock_dq_uninit (q_gh); - force_refresh =0 ; - goto restart; - } +gfs2_glock_dq_uninit (q_gh); + force_refresh =0 ; + goto restart; }return 0 ;
Signature · 1 line
1.6.2.5
PATCH 4/12 GFS2: Add get_xstate quota function
This allows querying of the quota state via the XFS quota API.
--- fs/gfs2/quota.c | 23 +++++++++++++++++++++++ 1 files changed, 23 insertions(+), 0 deletions(-)
fs/gfs2/quota.c +23 -0
@@ -47,6 +47,7 @@#include <linux/gfs2_ondisk.h> #include <linux/kthread.h> #include <linux/freezer.h> +#include <linux/dqblk_xfs.h> #include "gfs2.h" #include "incore.h"
@@ -1375,7 +1376,29 @@ int gfs2_quotad(void *data)return 0 ; } +static int gfs2_quota_get_xstate (struct super_block *sb, +struct fs_quota_stat *fqs) +{ +struct gfs2_sbd *sdp = sb->s_fs_info; + +memset (fqs,0 ,sizeof (struct fs_quota_stat )); + fqs->qs_version =FS_QSTAT_VERSION ; +if (sdp->sd_args.ar_quota ==GFS2_QUOTA_ON ) + fqs->qs_flags = (XFS_QUOTA_UDQ_ENFD |XFS_QUOTA_GDQ_ENFD ); +else if (sdp->sd_args.ar_quota ==GFS2_QUOTA_ACCOUNT ) + fqs->qs_flags = (XFS_QUOTA_UDQ_ACCT |XFS_QUOTA_GDQ_ACCT ); +if (sdp->sd_quota_inode) { + fqs->qs_uquota.qfs_ino =GFS2_I (sdp->sd_quota_inode)->i_no_addr; + fqs->qs_uquota.qfs_nblks = sdp->sd_quota_inode->i_blocks; + } + fqs->qs_uquota.qfs_nextents =1 ;/* unsupported */ + fqs->qs_gquota = fqs->qs_uquota;/* its the same inode in both cases */ + fqs->qs_incoredqs =atomic_read (&qd_lru_count); +return 0 ; +} +const struct quotactl_ops gfs2_quotactl_ops = { .quota_sync = gfs2_quota_sync, + .get_xstate = gfs2_quota_get_xstate, };
Signature · 1 line
1.6.2.5
PATCH 5/12 GFS2: Add proper error reporting to quota sync via sysfs
For some reason, the errors were not making it to userspace.
--- fs/gfs2/sys.c | 10 ++++++---- 1 files changed, 6 insertions(+), 4 deletions(-)
fs/gfs2/sys.c +6 -4
@@ -178,6 +178,7 @@ static ssize_t quota_sync_store(struct gfs2_sbd *sdp, const char *buf,static ssize_t quota_refresh_user_store (struct gfs2_sbd *sdp,const char *buf,size_t len) { +int error;u32 id;if (!capable (CAP_SYS_ADMIN ))
@@ -185,13 +186,14 @@ static ssize_t quota_refresh_user_store(struct gfs2_sbd *sdp, const char *buf, id =simple_strtoul (buf,NULL ,0 ); -gfs2_quota_refresh (sdp,1 , id); -return len; + error =gfs2_quota_refresh (sdp,1 , id); +return error ? error : len; }static ssize_t quota_refresh_group_store (struct gfs2_sbd *sdp,const char *buf,size_t len) { +int error;u32 id;if (!capable (CAP_SYS_ADMIN ))
@@ -199,8 +201,8 @@ static ssize_t quota_refresh_group_store(struct gfs2_sbd *sdp, const char *buf, id =simple_strtoul (buf,NULL ,0 ); -gfs2_quota_refresh (sdp,0 , id); -return len; + error =gfs2_quota_refresh (sdp,0 , id); +return error ? error : len; }static ssize_t demote_rq_store (struct gfs2_sbd *sdp,const char *buf,size_t len)
Signature · 1 line
1.6.2.5
PATCH 6/12 GFS2: Remove constant argument from qdsb_get()
The "create" argument to qdsb_get() was only ever set to true, so this patch removes that argument.
--- fs/gfs2/quota.c | 12 ++++++------ 1 files changed, 6 insertions(+), 6 deletions(-)
fs/gfs2/quota.c +6 -6
@@ -462,12 +462,12 @@ static void qd_unlock(struct gfs2_quota_data *qd)qd_put (qd); } -static int qdsb_get (struct gfs2_sbd *sdp,int user,u32 id,int create, +static int qdsb_get (struct gfs2_sbd *sdp,int user,u32 id,struct gfs2_quota_data **qdp) {int error; - error =qd_get (sdp, user, id, create, qdp); + error =qd_get (sdp, user, id,CREATE , qdp);if (error)return error;
@@ -509,20 +509,20 @@ int gfs2_quota_hold(struct gfs2_inode *ip, u32 uid, u32 gid)if (sdp->sd_args.ar_quota ==GFS2_QUOTA_OFF )return 0 ; - error =qdsb_get (sdp,QUOTA_USER , ip->i_inode.i_uid,CREATE , qd); + error =qdsb_get (sdp,QUOTA_USER , ip->i_inode.i_uid, qd);if (error) goto out; al->al_qd_num++; qd++; - error =qdsb_get (sdp,QUOTA_GROUP , ip->i_inode.i_gid,CREATE , qd); + error =qdsb_get (sdp,QUOTA_GROUP , ip->i_inode.i_gid, qd);if (error) goto out; al->al_qd_num++; qd++;if (uid !=NO_QUOTA_CHANGE && uid != ip->i_inode.i_uid) { - error =qdsb_get (sdp,QUOTA_USER , uid,CREATE , qd); + error =qdsb_get (sdp,QUOTA_USER , uid, qd);if (error) goto out; al->al_qd_num++;
@@ -530,7 +530,7 @@ int gfs2_quota_hold(struct gfs2_inode *ip, u32 uid, u32 gid) }if (gid !=NO_QUOTA_CHANGE && gid != ip->i_inode.i_gid) { - error =qdsb_get (sdp,QUOTA_GROUP , gid,CREATE , qd); + error =qdsb_get (sdp,QUOTA_GROUP , gid, qd);if (error) goto out; al->al_qd_num++;
Signature · 1 line
1.6.2.5
PATCH 7/12 GFS2: Remove constant argument from qd_get()
This function was only ever called with the "create" argument set to true, so we can remove it.
--- fs/gfs2/quota.c | 8 ++++---- 1 files changed, 4 insertions(+), 4 deletions(-)
fs/gfs2/quota.c +4 -4
@@ -165,7 +165,7 @@ fail:return error; } -static int qd_get (struct gfs2_sbd *sdp,int user,u32 id,int create, +static int qd_get (struct gfs2_sbd *sdp,int user,u32 id,struct gfs2_quota_data **qdp) {struct gfs2_quota_data *qd =NULL , *new_qd =NULL ;
@@ -203,7 +203,7 @@ static int qd_get(struct gfs2_sbd *sdp, int user, u32 id, int create,spin_unlock (&qd_lru_lock); -if (qd || !create) { +if (qd) {if (new_qd) {gfs2_glock_put (new_qd->qd_gl);kmem_cache_free (gfs2_quotad_cachep, new_qd);
@@ -467,7 +467,7 @@ static int qdsb_get(struct gfs2_sbd *sdp, int user, u32 id, {int error; - error =qd_get (sdp, user, id,CREATE , qdp); + error =qd_get (sdp, user, id, qdp);if (error)return error;
@@ -1117,7 +1117,7 @@ int gfs2_quota_refresh(struct gfs2_sbd *sdp, int user, u32 id)struct gfs2_holder q_gh;int error; - error =qd_get (sdp, user, id,CREATE , &qd); + error =qd_get (sdp, user, id, &qd);if (error)return error;
Signature · 1 line
1.6.2.5
PATCH 8/12 GFS2: Clean up gfs2_adjust_quota() and do_glock()
Both of these functions contained confusing and in one case duplicate code. This patch adds a new check in do_glock() so that we report -ENOENT if we are asked to sync a quota entry which doesn't exist. Due to the previous patch this is now reported correctly to userspace.
Also there are a few new comments, and I hope that the code is easier to understand now.
--- fs/gfs2/quota.c | 82 +++++++++++++++++------------------------------------- 1 files changed, 26 insertions(+), 56 deletions(-)
fs/gfs2/quota.c +26 -56
@@ -15,7 +15,7 @@* fuzziness in the current usage value of IDs that are being used on different * nodes in the cluster simultaneously. So, it is possible for a user on * multiple nodes to overrun their quota, but that overrun is controlable. -* Since quota tags are part of transactions, there is no need to a quota check +* Since quota tags are part of transactions, there is no need for a quota check * program to be run on node crashes or anything like that. * * There are couple of knobs that let the administrator manage the quota
@@ -66,13 +66,6 @@#define QUOTA_USER 1#define QUOTA_GROUP 0 -struct gfs2_quota_host { -u64 qu_limit; -u64 qu_warn; -s64 qu_value; -u32 qu_ll_next; -}; -struct gfs2_quota_change_host {u64 qc_change;u32 qc_flags;/* GFS2_QCF_... */
@@ -618,33 +611,19 @@ static void do_qc(struct gfs2_quota_data *qd, s64 change)mutex_unlock (&sdp->sd_quota_mutex); } -static void gfs2_quota_in (struct gfs2_quota_host *qu,const void *buf) -{ -const struct gfs2_quota *str = buf; - - qu->qu_limit =be64_to_cpu (str->qu_limit); - qu->qu_warn =be64_to_cpu (str->qu_warn); - qu->qu_value =be64_to_cpu (str->qu_value); - qu->qu_ll_next =be32_to_cpu (str->qu_ll_next); -} - -static void gfs2_quota_out (const struct gfs2_quota_host *qu,void *buf) -{ -struct gfs2_quota *str = buf; - - str->qu_limit =cpu_to_be64 (qu->qu_limit); - str->qu_warn =cpu_to_be64 (qu->qu_warn); - str->qu_value =cpu_to_be64 (qu->qu_value); - str->qu_ll_next =cpu_to_be32 (qu->qu_ll_next); -memset (&str->qu_reserved,0 ,sizeof (str->qu_reserved)); -} -/** -* gfs2_adjust_quota +* gfs2_adjust_quota - adjust record of current block usage +* @ip: The quota inode +* @loc: Offset of the entry in the quota file +* @change: The amount of change to record +* @qd: The quota data * * This function was mostly borrowed from gfs2_block_truncate_page which was * in turn mostly borrowed from ext3 +* +* Returns: 0 or -ve on error */ +static int gfs2_adjust_quota (struct gfs2_inode *ip,loff_t loc,s64 change,struct gfs2_quota_data *qd) {
@@ -656,8 +635,7 @@ static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc,struct buffer_head *bh;struct page *page;void *kaddr; -char *ptr; -struct gfs2_quota_host qp; +struct gfs2_quota *qp;s64 value;int err = -EIO ;
@@ -701,18 +679,13 @@ static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc,gfs2_trans_add_bh (ip->i_gl, bh,0 ); kaddr =kmap_atomic (page,KM_USER0 ); - ptr = kaddr + offset; -gfs2_quota_in (&qp, ptr); - qp.qu_value += change; - value = qp.qu_value; -gfs2_quota_out (&qp, ptr); + qp = kaddr + offset; + value = (s64 )be64_to_cpu (qp->qu_value) + change; + qp->qu_value =cpu_to_be64 (value); + qd->qd_qb.qb_value = qp->qu_value;flush_dcache_page (page);kunmap_atomic (kaddr,KM_USER0 ); err =0 ; - qd->qd_qb.qb_magic =cpu_to_be32 (GFS2_MAGIC ); - qd->qd_qb.qb_value =cpu_to_be64 (value); - ((struct gfs2_quota_lvb *)(qd->qd_gl->gl_lvb))->qb_magic =cpu_to_be32 (GFS2_MAGIC ); - ((struct gfs2_quota_lvb *)(qd->qd_gl->gl_lvb))->qb_value =cpu_to_be64 (value); unlock:unlock_page (page);page_cache_release (page);
@@ -741,8 +714,7 @@ static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)sort (qda, num_qd,sizeof (struct gfs2_quota_data *), sort_qd,NULL );for (qx =0 ; qx < num_qd; qx++) { - error =gfs2_glock_nq_init (qda[qx]->qd_gl, -LM_ST_EXCLUSIVE , + error =gfs2_glock_nq_init (qda[qx]->qd_gl,LM_ST_EXCLUSIVE ,GL_NOCACHE , &ghs[qx]);if (error) goto out;
@@ -797,8 +769,7 @@ static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda) qd = qda[x]; offset =qd2offset (qd); error =gfs2_adjust_quota (ip, offset, qd->qd_change_sync, - (struct gfs2_quota_data *) - qd); + (struct gfs2_quota_data *)qd);if (error) goto out_end_trans;
@@ -829,8 +800,7 @@ static int do_glock(struct gfs2_quota_data *qd, int force_refresh,struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;struct gfs2_inode *ip =GFS2_I (sdp->sd_quota_inode);struct gfs2_holder i_gh; -struct gfs2_quota_host q; -char buf[sizeof (struct gfs2_quota )]; +struct gfs2_quota q;int error;struct gfs2_quota_lvb *qlvb;
@@ -853,22 +823,23 @@ restart:if (error) goto fail; -memset (buf,0 ,sizeof (struct gfs2_quota )); +memset (&q,0 ,sizeof (struct gfs2_quota )); pos =qd2offset (qd); - error =gfs2_internal_read (ip,NULL , buf, &pos, -sizeof (struct gfs2_quota )); + error =gfs2_internal_read (ip,NULL , (char *)&q, &pos,sizeof (q));if (error <0 ) goto fail_gunlock; - +if ((error <sizeof (q)) && force_refresh) { + error = -ENOENT ; + goto fail_gunlock; + }gfs2_glock_dq_uninit (&i_gh); -gfs2_quota_in (&q, buf); qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb; qlvb->qb_magic =cpu_to_be32 (GFS2_MAGIC ); qlvb->__pad =0 ; - qlvb->qb_limit =cpu_to_be64 (q.qu_limit); - qlvb->qb_warn =cpu_to_be64 (q.qu_warn); - qlvb->qb_value =cpu_to_be64 (q.qu_value); + qlvb->qb_limit = q.qu_limit; + qlvb->qb_warn = q.qu_warn; + qlvb->qb_value = q.qu_value; qd->qd_qb = *qlvb;gfs2_glock_dq_uninit (q_gh);
@@ -1126,7 +1097,6 @@ int gfs2_quota_refresh(struct gfs2_sbd *sdp, int user, u32 id)gfs2_glock_dq_uninit (&q_gh);qd_put (qd); -return error; }
Signature · 1 line
1.6.2.5
PATCH 9/12 GFS2: Add get_xquota support
This adds support for viewing the current GFS2 quota settings via the XFS quota API. The setting of quotas will be addressed in a later patch. Fields which are not supported here are left set to zero.
--- fs/gfs2/quota.c | 43 +++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 43 insertions(+), 0 deletions(-)
fs/gfs2/quota.c +43 -0
@@ -1367,8 +1367,51 @@ static int gfs2_quota_get_xstate(struct super_block *sb,return 0 ; } +static int gfs2_xquota_get (struct super_block *sb,int type,qid_t id, +struct fs_disk_quota *fdq) +{ +struct gfs2_sbd *sdp = sb->s_fs_info; +struct gfs2_quota_lvb *qlvb; +struct gfs2_quota_data *qd; +struct gfs2_holder q_gh; +int error; + +memset (fdq,0 ,sizeof (struct fs_disk_quota )); + +if (sdp->sd_args.ar_quota ==GFS2_QUOTA_OFF ) +return -ESRCH ;/* Crazy XFS error code */ + +if (type ==USRQUOTA ) + type =QUOTA_USER ; +else if (type ==GRPQUOTA ) + type =QUOTA_GROUP ; +else +return -EINVAL ; + + error =qd_get (sdp, type, id, &qd); +if (error) +return error; + error =do_glock (qd,FORCE , &q_gh); +if (error) + goto out; + + qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb; + fdq->d_version =FS_DQUOT_VERSION ; + fdq->d_flags = (type ==QUOTA_USER ) ?XFS_USER_QUOTA :XFS_GROUP_QUOTA ; + fdq->d_id = id; + fdq->d_blk_hardlimit =be64_to_cpu (qlvb->qb_limit); + fdq->d_blk_softlimit =be64_to_cpu (qlvb->qb_warn); + fdq->d_bcount =be64_to_cpu (qlvb->qb_value); + +gfs2_glock_dq_uninit (&q_gh); +out: +qd_put (qd); +return 0 ; +} +const struct quotactl_ops gfs2_quotactl_ops = { .quota_sync = gfs2_quota_sync, .get_xstate = gfs2_quota_get_xstate, + .get_xquota = gfs2_xquota_get, };
Signature · 1 line
1.6.2.5
PATCH 10/12 VFS: Export dquot_send_warning
Sending a message to userspace in a generic format to warn of events (e.g. quota exceeded) in the quota subsystem is a generically useful feature. This patch makes some minor changes to the send_message function in dquot.c renaming it dquot_send_message and exporting it for use by filesystems which do not use the dquot quota code.
--- fs/quota/dquot.c | 45 ++++++++++++++++++++++++++++++--------------- include/linux/quota.h | 11 +++++++++++ 2 files changed, 41 insertions(+), 15 deletions(-)
fs/quota/dquot.c +30 -15
@@ -1082,8 +1082,21 @@ static struct genl_family quota_genl_family = { .maxattr = QUOTA_NL_A_MAX, }; -/* Send warning to userspace about user which exceeded quota */ -static void send_warning (const struct dquot *dquot,const char warntype) +/** +* dquot_send_warning - Send warning to userspace about exceeded quota +* @type: The quota type: USRQQUOTA, GRPQUOTA,... +* @id: The user or group id of the quota that was exceeded +* @dev: The device on which the fs is mounted (sb->s_dev) +* @warntype: The type of the warning: QUOTA_NL_... +* +* This can be used by filesystems (including those which don't use +* other parts of dquot) to send a message to userspace relating to +* quota limits. +* +*/ + +void dquot_send_warning (short type,unsigned int id,dev_t dev, +const char warntype) {static atomic_t seq;struct sk_buff *skb;
@@ -1108,21 +1121,19 @@ static void send_warning(const struct dquot *dquot, const char warntype) "VFS: Cannot store netlink header in quota warning.\n"); goto err_out; } - ret =nla_put_u32 (skb,QUOTA_NL_A_QTYPE , dquot->dq_type); + ret =nla_put_u32 (skb,QUOTA_NL_A_QTYPE , type);if (ret) goto attr_err_out; - ret =nla_put_u64 (skb,QUOTA_NL_A_EXCESS_ID , dquot->dq_id); + ret =nla_put_u64 (skb,QUOTA_NL_A_EXCESS_ID , id);if (ret) goto attr_err_out; ret =nla_put_u32 (skb,QUOTA_NL_A_WARNING , warntype);if (ret) goto attr_err_out; - ret =nla_put_u32 (skb,QUOTA_NL_A_DEV_MAJOR , -MAJOR (dquot->dq_sb->s_dev)); + ret =nla_put_u32 (skb,QUOTA_NL_A_DEV_MAJOR ,MAJOR (dev));if (ret) goto attr_err_out; - ret =nla_put_u32 (skb,QUOTA_NL_A_DEV_MINOR , -MINOR (dquot->dq_sb->s_dev)); + ret =nla_put_u32 (skb,QUOTA_NL_A_DEV_MINOR ,MINOR (dev));if (ret) goto attr_err_out; ret =nla_put_u64 (skb,QUOTA_NL_A_CAUSED_ID ,current_uid ());
@@ -1137,6 +1148,8 @@ attr_err_out: err_out: kfree_skb(skb); } +EXPORT_SYMBOL (dquot_send_warning); +#endif /* * Write warnings to the console and send warning messages over netlink.
@@ -1145,18 +1158,20 @@ err_out:*/ static void flush_warnings (struct dquot *const *dquots,char *warntype) { +struct dquot *dq;int i; -for (i =0 ; i <MAXQUOTAS ; i++) -if (dquots[i] && warntype[i] !=QUOTA_NL_NOWARN && - !warning_issued (dquots[i], warntype[i])) { +for (i =0 ; i <MAXQUOTAS ; i++) { + dq = dquots[i]; +if (dq && warntype[i] !=QUOTA_NL_NOWARN && + !warning_issued (dq, warntype[i])) {#ifdef CONFIG_PRINT_QUOTA_WARNING -print_warning (dquots[i], warntype[i]); -#endif -#ifdef CONFIG_QUOTA_NETLINK_INTERFACE -send_warning (dquots[i], warntype[i]); +print_warning (dq, warntype[i]);#endif +dquot_send_warning (dq->dq_type, dq->dq_id, + dq->dq_sb->s_dev, warntype[i]); } + } }static int ignore_hardlimit (struct dquot *dquot)
include/linux/quota.h +11 -0
@@ -376,6 +376,17 @@ static inline unsigned int dquot_generic_flag(unsigned int flags, int type)return flags >> _DQUOT_STATE_FLAGS; } +#ifdef CONFIG_QUOTA_NETLINK_INTERFACE +extern void dquot_send_warning (short type,unsigned int id,dev_t dev, +const char warntype); +#else +static inline void dquot_send_warning (short type,unsigned int id,dev_t dev, +const char warntype) +{ +return ; +} +#endif /* CONFIG_QUOTA_NETLINK_INTERFACE */ +struct quota_info {unsigned int flags;/* Flags for diskquotas on this device */ struct mutex dqio_mutex;/* lock device while I/O in progress */
Signature · 1 line
1.6.2.5
PATCH 11/12 GFS2: Use dquot_send_warning()
In reply to Steven WhitehouseFor some reason patches 11 and 12 didn't make it earlier. So I'm sending them on separately,
Steve.
From 377ccdd06591fb3dd40f936567e367b1f01319bc Mon Sep 17 00:00:00 2001
From: Steven Whitehouse <[email protected]>
Date: Thu, 17 Sep 2009 11:15:10 +0100
Subject: [PATCH 11/13] GFS2: Use dquot_send_warning()
This adds support to GFS2 to send quota warnings via netlink. Also it removes a stray \r which was left over from when the code used to print warnings on the console.
--- fs/gfs2/quota.c | 9 ++++++++- 1 files changed, 8 insertions(+), 1 deletions(-)
fs/gfs2/quota.c +8 -1
@@ -964,7 +964,7 @@ static int print_message(struct gfs2_quota_data *qd, char *type) {struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd; -printk (KERN_INFO "GFS2: fsid=%s: quota %s for %s %u\r\n" , +printk (KERN_INFO "GFS2: fsid=%s: quota %s for %s %u\n" , sdp->sd_fsname, type, (test_bit (QDF_USER , &qd->qd_flags)) ?"user" :"group" , qd->qd_id);
@@ -1001,6 +1001,10 @@ int gfs2_quota_check(struct gfs2_inode *ip, u32 uid, u32 gid)if (be64_to_cpu (qd->qd_qb.qb_limit) && (s64 )be64_to_cpu (qd->qd_qb.qb_limit) < value) {print_message (qd,"exceeded" ); +dquot_send_warning (test_bit (QDF_USER , &qd->qd_flags) ? +USRQUOTA :GRPQUOTA , qd->qd_id, + sdp->sd_vfs->s_dev,QUOTA_NL_BHARDWARN ); + error = -EDQUOT ;break ; } else if (be64_to_cpu(qd->qd_qb.qb_warn) &&
@@ -1008,6 +1012,9 @@ int gfs2_quota_check(struct gfs2_inode *ip, u32 uid, u32 gid) time_after_eq(jiffies, qd->qd_last_warn + gfs2_tune_get(sdp, gt_quota_warn_period) * HZ)) { +dquot_send_warning (test_bit (QDF_USER , &qd->qd_flags) ? +USRQUOTA :GRPQUOTA , qd->qd_id, + sdp->sd_vfs->s_dev,QUOTA_NL_BSOFTWARN ); error =print_message (qd,"warning" ); qd->qd_last_warn = jiffies; }
Signature · 1 line
1.6.2.5
PATCH 12/12 GFS2: Add set_xquota support
In reply to Steven WhitehouseFrom 0e027f964e98d9ca36c1fd2ba97ec54d0cefda16 Mon Sep 17 00:00:00 2001
From: Steven Whitehouse <[email protected]>
Date: Wed, 23 Sep 2009 13:50:49 +0100
Subject: [PATCH 12/12] GFS2: Add set_xquota support
This patch adds the ability to set GFS2 quota limit and warning levels via the XFS quota API.
--- fs/gfs2/quota.c | 198 +++++++++++++++++++++++++++++++++++++++++++++++------- 1 files changed, 172 insertions(+), 26 deletions(-)
fs/gfs2/quota.c +172 -26
@@ -615,8 +615,9 @@ static void do_qc(struct gfs2_quota_data *qd, s64 change)* gfs2_adjust_quota - adjust record of current block usage * @ip: The quota inode * @loc: Offset of the entry in the quota file -* @change: The amount of change to record +* @change: The amount of usage change to record * @qd: The quota data +* @fdq: The updated limits to record * * This function was mostly borrowed from gfs2_block_truncate_page which was * in turn mostly borrowed from ext3
@@ -625,19 +626,21 @@ static void do_qc(struct gfs2_quota_data *qd, s64 change)*/ static int gfs2_adjust_quota (struct gfs2_inode *ip,loff_t loc, -s64 change,struct gfs2_quota_data *qd) +s64 change,struct gfs2_quota_data *qd, +struct fs_disk_quota *fdq) {struct inode *inode = &ip->i_inode;struct address_space *mapping = inode->i_mapping;unsigned long index = loc >>PAGE_CACHE_SHIFT ;unsigned offset = loc & (PAGE_CACHE_SIZE -1 );unsigned blocksize, iblock, pos; -struct buffer_head *bh; +struct buffer_head *bh, *dibh;struct page *page;void *kaddr;struct gfs2_quota *qp;s64 value;int err = -EIO ; +u64 size;if (gfs2_is_stuffed (ip))gfs2_unstuff_dinode (ip,NULL );
@@ -683,9 +686,34 @@ static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc, value = (s64 )be64_to_cpu (qp->qu_value) + change; qp->qu_value =cpu_to_be64 (value); qd->qd_qb.qb_value = qp->qu_value; +if (fdq) { +if (fdq->d_fieldmask &FS_DQ_BSOFT ) { + qp->qu_warn =cpu_to_be64 (fdq->d_blk_softlimit); + qd->qd_qb.qb_warn = qp->qu_warn; + } +if (fdq->d_fieldmask &FS_DQ_BHARD ) { + qp->qu_limit =cpu_to_be64 (fdq->d_blk_hardlimit); + qd->qd_qb.qb_limit = qp->qu_limit; + } + }flush_dcache_page (page);kunmap_atomic (kaddr,KM_USER0 ); - err =0 ; + + err =gfs2_meta_inode_buffer (ip, &dibh); +if (err) + goto unlock; + + size = loc +sizeof (struct gfs2_quota ); +if (size > inode->i_size) { + ip->i_disksize = size; +i_size_write (inode, size); + } + inode->i_mtime = inode->i_atime =CURRENT_TIME ; +gfs2_trans_add_bh (ip->i_gl, dibh,1 ); +gfs2_dinode_out (ip, dibh->b_data); +brelse (dibh); +mark_inode_dirty (inode); + unlock:unlock_page (page);page_cache_release (page);
@@ -713,6 +741,7 @@ static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)return -ENOMEM ;sort (qda, num_qd,sizeof (struct gfs2_quota_data *), sort_qd,NULL ); +mutex_lock_nested (&ip->i_inode.i_mutex,I_MUTEX_QUOTA );for (qx =0 ; qx < num_qd; qx++) { error =gfs2_glock_nq_init (qda[qx]->qd_gl,LM_ST_EXCLUSIVE ,GL_NOCACHE , &ghs[qx]);
@@ -768,8 +797,7 @@ static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)for (x =0 ; x < num_qd; x++) { qd = qda[x]; offset =qd2offset (qd); - error =gfs2_adjust_quota (ip, offset, qd->qd_change_sync, - (struct gfs2_quota_data *)qd); + error =gfs2_adjust_quota (ip, offset, qd->qd_change_sync, qd,NULL );if (error) goto out_end_trans;
@@ -789,20 +817,44 @@ out_gunlock: out:while (qx--)gfs2_glock_dq_uninit (&ghs[qx]); +mutex_unlock (&ip->i_inode.i_mutex);kfree (ghs);gfs2_log_flush (ip->i_gl->gl_sbd, ip->i_gl);return error; } +static int update_qd (struct gfs2_sbd *sdp,struct gfs2_quota_data *qd) +{ +struct gfs2_inode *ip =GFS2_I (sdp->sd_quota_inode); +struct gfs2_quota q; +struct gfs2_quota_lvb *qlvb; +loff_t pos; +int error; + +memset (&q,0 ,sizeof (struct gfs2_quota )); + pos =qd2offset (qd); + error =gfs2_internal_read (ip,NULL , (char *)&q, &pos,sizeof (q)); +if (error <0 ) +return error; + + qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb; + qlvb->qb_magic =cpu_to_be32 (GFS2_MAGIC ); + qlvb->__pad =0 ; + qlvb->qb_limit = q.qu_limit; + qlvb->qb_warn = q.qu_warn; + qlvb->qb_value = q.qu_value; + qd->qd_qb = *qlvb; + +return 0 ; +} +static int do_glock (struct gfs2_quota_data *qd,int force_refresh,struct gfs2_holder *q_gh) {struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;struct gfs2_inode *ip =GFS2_I (sdp->sd_quota_inode);struct gfs2_holder i_gh; -struct gfs2_quota q;int error; -struct gfs2_quota_lvb *qlvb; restart: error =gfs2_glock_nq_init (qd->qd_gl,LM_ST_SHARED ,0 , q_gh);
@@ -812,7 +864,6 @@ restart: qd->qd_qb = *(struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb;if (force_refresh || qd->qd_qb.qb_magic !=cpu_to_be32 (GFS2_MAGIC )) { -loff_t pos;gfs2_glock_dq_uninit (q_gh); error =gfs2_glock_nq_init (qd->qd_gl,LM_ST_EXCLUSIVE ,GL_NOCACHE , q_gh);
@@ -823,25 +874,11 @@ restart:if (error) goto fail; -memset (&q,0 ,sizeof (struct gfs2_quota )); - pos =qd2offset (qd); - error =gfs2_internal_read (ip,NULL , (char *)&q, &pos,sizeof (q)); -if (error <0 ) - goto fail_gunlock; -if ((error <sizeof (q)) && force_refresh) { - error = -ENOENT ; + error =update_qd (sdp, qd); +if (error) goto fail_gunlock; - } -gfs2_glock_dq_uninit (&i_gh); - - qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb; - qlvb->qb_magic =cpu_to_be32 (GFS2_MAGIC ); - qlvb->__pad =0 ; - qlvb->qb_limit = q.qu_limit; - qlvb->qb_warn = q.qu_warn; - qlvb->qb_value = q.qu_value; - qd->qd_qb = *qlvb; +gfs2_glock_dq_uninit (&i_gh);gfs2_glock_dq_uninit (q_gh); force_refresh =0 ; goto restart;
@@ -1416,9 +1453,118 @@ out:return 0 ; } +/* GFS2 only supports a subset of the XFS fields */ +#define GFS2_FIELDMASK (FS_DQ_BSOFT|FS_DQ_BHARD) + +static int gfs2_xquota_set (struct super_block *sb,int type,qid_t id, +struct fs_disk_quota *fdq) +{ +struct gfs2_sbd *sdp = sb->s_fs_info; +struct gfs2_inode *ip =GFS2_I (sdp->sd_quota_inode); +struct gfs2_quota_data *qd; +struct gfs2_holder q_gh, i_gh; +unsigned int data_blocks, ind_blocks; +unsigned int blocks =0 ; +int alloc_required; +struct gfs2_alloc *al; +loff_t offset; +int error; + +if (sdp->sd_args.ar_quota ==GFS2_QUOTA_OFF ) +return -ESRCH ;/* Crazy XFS error code */ + +switch (type) { +case USRQUOTA : + type =QUOTA_USER ; +if (fdq->d_flags !=XFS_USER_QUOTA ) +return -EINVAL ; +break ; +case GRPQUOTA : + type =QUOTA_GROUP ; +if (fdq->d_flags !=XFS_GROUP_QUOTA ) +return -EINVAL ; +break ; +default : +return -EINVAL ; + } + +if (fdq->d_fieldmask & ~GFS2_FIELDMASK ) +return -EINVAL ; +if (fdq->d_id != id) +return -EINVAL ; + + error =qd_get (sdp, type, id, &qd); +if (error) +return error; + +mutex_lock (&ip->i_inode.i_mutex); + error =gfs2_glock_nq_init (qd->qd_gl,LM_ST_EXCLUSIVE ,0 , &q_gh); +if (error) + goto out_put; + error =gfs2_glock_nq_init (ip->i_gl,LM_ST_EXCLUSIVE ,0 , &i_gh); +if (error) + goto out_q; + +/* Check for existing entry, if none then alloc new blocks */ + error =update_qd (sdp, qd); +if (error) + goto out_i; + +/* If nothing has changed, this is a no-op */ +if ((fdq->d_fieldmask &FS_DQ_BSOFT ) && + (fdq->d_blk_softlimit ==be64_to_cpu (qd->qd_qb.qb_warn))) + fdq->d_fieldmask ^=FS_DQ_BSOFT ; +if ((fdq->d_fieldmask &FS_DQ_BHARD ) && + (fdq->d_blk_hardlimit ==be64_to_cpu (qd->qd_qb.qb_limit))) + fdq->d_fieldmask ^=FS_DQ_BHARD ; +if (fdq->d_fieldmask ==0 ) + goto out_i; + + offset =qd2offset (qd); + error =gfs2_write_alloc_required (ip, offset,sizeof (struct gfs2_quota ), + &alloc_required); +if (error) + goto out_i; +if (alloc_required) { + al =gfs2_alloc_get (ip); +if (al ==NULL ) + goto out_i; +gfs2_write_calc_reserv (ip,sizeof (struct gfs2_quota ), + &data_blocks, &ind_blocks); + blocks = al->al_requested =1 + data_blocks + ind_blocks; + error =gfs2_inplace_reserve (ip); +if (error) + goto out_alloc; + } + + error =gfs2_trans_begin (sdp, blocks +RES_DINODE +1 ,0 ); +if (error) + goto out_release; + +/* Apply changes */ + error =gfs2_adjust_quota (ip, offset,0 , qd, fdq); + +gfs2_trans_end (sdp); +out_release: +if (alloc_required) { +gfs2_inplace_release (ip); +out_alloc: +gfs2_alloc_put (ip); + } +out_i: +gfs2_glock_dq_uninit (&i_gh); +out_q: +gfs2_glock_dq_uninit (&q_gh); +out_put: +mutex_unlock (&ip->i_inode.i_mutex); +qd_put (qd); +return error; +} +const struct quotactl_ops gfs2_quotactl_ops = { .quota_sync = gfs2_quota_sync, .get_xstate = gfs2_quota_get_xstate, .get_xquota = gfs2_xquota_get, + .set_xquota = gfs2_xquota_set, };
Signature · 1 line
1.6.2.5