PageRenderTime 112ms CodeModel.GetById 2ms app.highlight 99ms RepoModel.GetById 1ms app.codeStats 0ms

/fs/gfs2/quota.c

https://bitbucket.org/bradfa/linux
C | 1615 lines | 1249 code | 284 blank | 82 comment | 228 complexity | 3367b54fbbdcd0951c6d7db8415c56a0 MD5 | raw file
   1/*
   2 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3 * Copyright (C) 2004-2007 Red Hat, Inc.  All rights reserved.
   4 *
   5 * This copyrighted material is made available to anyone wishing to use,
   6 * modify, copy, or redistribute it subject to the terms and conditions
   7 * of the GNU General Public License version 2.
   8 */
   9
  10/*
  11 * Quota change tags are associated with each transaction that allocates or
  12 * deallocates space.  Those changes are accumulated locally to each node (in a
  13 * per-node file) and then are periodically synced to the quota file.  This
  14 * avoids the bottleneck of constantly touching the quota file, but introduces
  15 * fuzziness in the current usage value of IDs that are being used on different
  16 * nodes in the cluster simultaneously.  So, it is possible for a user on
  17 * multiple nodes to overrun their quota, but that overrun is controlable.
  18 * Since quota tags are part of transactions, there is no need for a quota check
  19 * program to be run on node crashes or anything like that.
  20 *
  21 * There are couple of knobs that let the administrator manage the quota
  22 * fuzziness.  "quota_quantum" sets the maximum time a quota change can be
  23 * sitting on one node before being synced to the quota file.  (The default is
  24 * 60 seconds.)  Another knob, "quota_scale" controls how quickly the frequency
  25 * of quota file syncs increases as the user moves closer to their limit.  The
  26 * more frequent the syncs, the more accurate the quota enforcement, but that
  27 * means that there is more contention between the nodes for the quota file.
  28 * The default value is one.  This sets the maximum theoretical quota overrun
  29 * (with infinite node with infinite bandwidth) to twice the user's limit.  (In
  30 * practice, the maximum overrun you see should be much less.)  A "quota_scale"
  31 * number greater than one makes quota syncs more frequent and reduces the
  32 * maximum overrun.  Numbers less than one (but greater than zero) make quota
  33 * syncs less frequent.
  34 *
  35 * GFS quotas also use per-ID Lock Value Blocks (LVBs) to cache the contents of
  36 * the quota file, so it is not being constantly read.
  37 */
  38
  39#include <linux/sched.h>
  40#include <linux/slab.h>
  41#include <linux/mm.h>
  42#include <linux/spinlock.h>
  43#include <linux/completion.h>
  44#include <linux/buffer_head.h>
  45#include <linux/sort.h>
  46#include <linux/fs.h>
  47#include <linux/bio.h>
  48#include <linux/gfs2_ondisk.h>
  49#include <linux/kthread.h>
  50#include <linux/freezer.h>
  51#include <linux/quota.h>
  52#include <linux/dqblk_xfs.h>
  53
  54#include "gfs2.h"
  55#include "incore.h"
  56#include "bmap.h"
  57#include "glock.h"
  58#include "glops.h"
  59#include "log.h"
  60#include "meta_io.h"
  61#include "quota.h"
  62#include "rgrp.h"
  63#include "super.h"
  64#include "trans.h"
  65#include "inode.h"
  66#include "util.h"
  67
  68struct gfs2_quota_change_host {
  69	u64 qc_change;
  70	u32 qc_flags; /* GFS2_QCF_... */
  71	struct kqid qc_id;
  72};
  73
  74static LIST_HEAD(qd_lru_list);
  75static atomic_t qd_lru_count = ATOMIC_INIT(0);
  76static DEFINE_SPINLOCK(qd_lru_lock);
  77
  78int gfs2_shrink_qd_memory(struct shrinker *shrink, struct shrink_control *sc)
  79{
  80	struct gfs2_quota_data *qd;
  81	struct gfs2_sbd *sdp;
  82	int nr_to_scan = sc->nr_to_scan;
  83
  84	if (nr_to_scan == 0)
  85		goto out;
  86
  87	if (!(sc->gfp_mask & __GFP_FS))
  88		return -1;
  89
  90	spin_lock(&qd_lru_lock);
  91	while (nr_to_scan && !list_empty(&qd_lru_list)) {
  92		qd = list_entry(qd_lru_list.next,
  93				struct gfs2_quota_data, qd_reclaim);
  94		sdp = qd->qd_gl->gl_sbd;
  95
  96		/* Free from the filesystem-specific list */
  97		list_del(&qd->qd_list);
  98
  99		gfs2_assert_warn(sdp, !qd->qd_change);
 100		gfs2_assert_warn(sdp, !qd->qd_slot_count);
 101		gfs2_assert_warn(sdp, !qd->qd_bh_count);
 102
 103		gfs2_glock_put(qd->qd_gl);
 104		atomic_dec(&sdp->sd_quota_count);
 105
 106		/* Delete it from the common reclaim list */
 107		list_del_init(&qd->qd_reclaim);
 108		atomic_dec(&qd_lru_count);
 109		spin_unlock(&qd_lru_lock);
 110		kmem_cache_free(gfs2_quotad_cachep, qd);
 111		spin_lock(&qd_lru_lock);
 112		nr_to_scan--;
 113	}
 114	spin_unlock(&qd_lru_lock);
 115
 116out:
 117	return (atomic_read(&qd_lru_count) * sysctl_vfs_cache_pressure) / 100;
 118}
 119
 120static u64 qd2index(struct gfs2_quota_data *qd)
 121{
 122	struct kqid qid = qd->qd_id;
 123	return (2 * (u64)from_kqid(&init_user_ns, qid)) +
 124		(qid.type == USRQUOTA) ? 0 : 1;
 125}
 126
 127static u64 qd2offset(struct gfs2_quota_data *qd)
 128{
 129	u64 offset;
 130
 131	offset = qd2index(qd);
 132	offset *= sizeof(struct gfs2_quota);
 133
 134	return offset;
 135}
 136
 137static int qd_alloc(struct gfs2_sbd *sdp, struct kqid qid,
 138		    struct gfs2_quota_data **qdp)
 139{
 140	struct gfs2_quota_data *qd;
 141	int error;
 142
 143	qd = kmem_cache_zalloc(gfs2_quotad_cachep, GFP_NOFS);
 144	if (!qd)
 145		return -ENOMEM;
 146
 147	atomic_set(&qd->qd_count, 1);
 148	qd->qd_id = qid;
 149	qd->qd_slot = -1;
 150	INIT_LIST_HEAD(&qd->qd_reclaim);
 151
 152	error = gfs2_glock_get(sdp, qd2index(qd),
 153			      &gfs2_quota_glops, CREATE, &qd->qd_gl);
 154	if (error)
 155		goto fail;
 156
 157	*qdp = qd;
 158
 159	return 0;
 160
 161fail:
 162	kmem_cache_free(gfs2_quotad_cachep, qd);
 163	return error;
 164}
 165
 166static int qd_get(struct gfs2_sbd *sdp, struct kqid qid,
 167		  struct gfs2_quota_data **qdp)
 168{
 169	struct gfs2_quota_data *qd = NULL, *new_qd = NULL;
 170	int error, found;
 171
 172	*qdp = NULL;
 173
 174	for (;;) {
 175		found = 0;
 176		spin_lock(&qd_lru_lock);
 177		list_for_each_entry(qd, &sdp->sd_quota_list, qd_list) {
 178			if (qid_eq(qd->qd_id, qid)) {
 179				if (!atomic_read(&qd->qd_count) &&
 180				    !list_empty(&qd->qd_reclaim)) {
 181					/* Remove it from reclaim list */
 182					list_del_init(&qd->qd_reclaim);
 183					atomic_dec(&qd_lru_count);
 184				}
 185				atomic_inc(&qd->qd_count);
 186				found = 1;
 187				break;
 188			}
 189		}
 190
 191		if (!found)
 192			qd = NULL;
 193
 194		if (!qd && new_qd) {
 195			qd = new_qd;
 196			list_add(&qd->qd_list, &sdp->sd_quota_list);
 197			atomic_inc(&sdp->sd_quota_count);
 198			new_qd = NULL;
 199		}
 200
 201		spin_unlock(&qd_lru_lock);
 202
 203		if (qd) {
 204			if (new_qd) {
 205				gfs2_glock_put(new_qd->qd_gl);
 206				kmem_cache_free(gfs2_quotad_cachep, new_qd);
 207			}
 208			*qdp = qd;
 209			return 0;
 210		}
 211
 212		error = qd_alloc(sdp, qid, &new_qd);
 213		if (error)
 214			return error;
 215	}
 216}
 217
 218static void qd_hold(struct gfs2_quota_data *qd)
 219{
 220	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
 221	gfs2_assert(sdp, atomic_read(&qd->qd_count));
 222	atomic_inc(&qd->qd_count);
 223}
 224
 225static void qd_put(struct gfs2_quota_data *qd)
 226{
 227	if (atomic_dec_and_lock(&qd->qd_count, &qd_lru_lock)) {
 228		/* Add to the reclaim list */
 229		list_add_tail(&qd->qd_reclaim, &qd_lru_list);
 230		atomic_inc(&qd_lru_count);
 231		spin_unlock(&qd_lru_lock);
 232	}
 233}
 234
 235static int slot_get(struct gfs2_quota_data *qd)
 236{
 237	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
 238	unsigned int c, o = 0, b;
 239	unsigned char byte = 0;
 240
 241	spin_lock(&qd_lru_lock);
 242
 243	if (qd->qd_slot_count++) {
 244		spin_unlock(&qd_lru_lock);
 245		return 0;
 246	}
 247
 248	for (c = 0; c < sdp->sd_quota_chunks; c++)
 249		for (o = 0; o < PAGE_SIZE; o++) {
 250			byte = sdp->sd_quota_bitmap[c][o];
 251			if (byte != 0xFF)
 252				goto found;
 253		}
 254
 255	goto fail;
 256
 257found:
 258	for (b = 0; b < 8; b++)
 259		if (!(byte & (1 << b)))
 260			break;
 261	qd->qd_slot = c * (8 * PAGE_SIZE) + o * 8 + b;
 262
 263	if (qd->qd_slot >= sdp->sd_quota_slots)
 264		goto fail;
 265
 266	sdp->sd_quota_bitmap[c][o] |= 1 << b;
 267
 268	spin_unlock(&qd_lru_lock);
 269
 270	return 0;
 271
 272fail:
 273	qd->qd_slot_count--;
 274	spin_unlock(&qd_lru_lock);
 275	return -ENOSPC;
 276}
 277
 278static void slot_hold(struct gfs2_quota_data *qd)
 279{
 280	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
 281
 282	spin_lock(&qd_lru_lock);
 283	gfs2_assert(sdp, qd->qd_slot_count);
 284	qd->qd_slot_count++;
 285	spin_unlock(&qd_lru_lock);
 286}
 287
 288static void slot_put(struct gfs2_quota_data *qd)
 289{
 290	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
 291
 292	spin_lock(&qd_lru_lock);
 293	gfs2_assert(sdp, qd->qd_slot_count);
 294	if (!--qd->qd_slot_count) {
 295		gfs2_icbit_munge(sdp, sdp->sd_quota_bitmap, qd->qd_slot, 0);
 296		qd->qd_slot = -1;
 297	}
 298	spin_unlock(&qd_lru_lock);
 299}
 300
 301static int bh_get(struct gfs2_quota_data *qd)
 302{
 303	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
 304	struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
 305	unsigned int block, offset;
 306	struct buffer_head *bh;
 307	int error;
 308	struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
 309
 310	mutex_lock(&sdp->sd_quota_mutex);
 311
 312	if (qd->qd_bh_count++) {
 313		mutex_unlock(&sdp->sd_quota_mutex);
 314		return 0;
 315	}
 316
 317	block = qd->qd_slot / sdp->sd_qc_per_block;
 318	offset = qd->qd_slot % sdp->sd_qc_per_block;
 319
 320	bh_map.b_size = 1 << ip->i_inode.i_blkbits;
 321	error = gfs2_block_map(&ip->i_inode, block, &bh_map, 0);
 322	if (error)
 323		goto fail;
 324	error = gfs2_meta_read(ip->i_gl, bh_map.b_blocknr, DIO_WAIT, &bh);
 325	if (error)
 326		goto fail;
 327	error = -EIO;
 328	if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_QC))
 329		goto fail_brelse;
 330
 331	qd->qd_bh = bh;
 332	qd->qd_bh_qc = (struct gfs2_quota_change *)
 333		(bh->b_data + sizeof(struct gfs2_meta_header) +
 334		 offset * sizeof(struct gfs2_quota_change));
 335
 336	mutex_unlock(&sdp->sd_quota_mutex);
 337
 338	return 0;
 339
 340fail_brelse:
 341	brelse(bh);
 342fail:
 343	qd->qd_bh_count--;
 344	mutex_unlock(&sdp->sd_quota_mutex);
 345	return error;
 346}
 347
 348static void bh_put(struct gfs2_quota_data *qd)
 349{
 350	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
 351
 352	mutex_lock(&sdp->sd_quota_mutex);
 353	gfs2_assert(sdp, qd->qd_bh_count);
 354	if (!--qd->qd_bh_count) {
 355		brelse(qd->qd_bh);
 356		qd->qd_bh = NULL;
 357		qd->qd_bh_qc = NULL;
 358	}
 359	mutex_unlock(&sdp->sd_quota_mutex);
 360}
 361
 362static int qd_fish(struct gfs2_sbd *sdp, struct gfs2_quota_data **qdp)
 363{
 364	struct gfs2_quota_data *qd = NULL;
 365	int error;
 366	int found = 0;
 367
 368	*qdp = NULL;
 369
 370	if (sdp->sd_vfs->s_flags & MS_RDONLY)
 371		return 0;
 372
 373	spin_lock(&qd_lru_lock);
 374
 375	list_for_each_entry(qd, &sdp->sd_quota_list, qd_list) {
 376		if (test_bit(QDF_LOCKED, &qd->qd_flags) ||
 377		    !test_bit(QDF_CHANGE, &qd->qd_flags) ||
 378		    qd->qd_sync_gen >= sdp->sd_quota_sync_gen)
 379			continue;
 380
 381		list_move_tail(&qd->qd_list, &sdp->sd_quota_list);
 382
 383		set_bit(QDF_LOCKED, &qd->qd_flags);
 384		gfs2_assert_warn(sdp, atomic_read(&qd->qd_count));
 385		atomic_inc(&qd->qd_count);
 386		qd->qd_change_sync = qd->qd_change;
 387		gfs2_assert_warn(sdp, qd->qd_slot_count);
 388		qd->qd_slot_count++;
 389		found = 1;
 390
 391		break;
 392	}
 393
 394	if (!found)
 395		qd = NULL;
 396
 397	spin_unlock(&qd_lru_lock);
 398
 399	if (qd) {
 400		gfs2_assert_warn(sdp, qd->qd_change_sync);
 401		error = bh_get(qd);
 402		if (error) {
 403			clear_bit(QDF_LOCKED, &qd->qd_flags);
 404			slot_put(qd);
 405			qd_put(qd);
 406			return error;
 407		}
 408	}
 409
 410	*qdp = qd;
 411
 412	return 0;
 413}
 414
 415static int qd_trylock(struct gfs2_quota_data *qd)
 416{
 417	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
 418
 419	if (sdp->sd_vfs->s_flags & MS_RDONLY)
 420		return 0;
 421
 422	spin_lock(&qd_lru_lock);
 423
 424	if (test_bit(QDF_LOCKED, &qd->qd_flags) ||
 425	    !test_bit(QDF_CHANGE, &qd->qd_flags)) {
 426		spin_unlock(&qd_lru_lock);
 427		return 0;
 428	}
 429
 430	list_move_tail(&qd->qd_list, &sdp->sd_quota_list);
 431
 432	set_bit(QDF_LOCKED, &qd->qd_flags);
 433	gfs2_assert_warn(sdp, atomic_read(&qd->qd_count));
 434	atomic_inc(&qd->qd_count);
 435	qd->qd_change_sync = qd->qd_change;
 436	gfs2_assert_warn(sdp, qd->qd_slot_count);
 437	qd->qd_slot_count++;
 438
 439	spin_unlock(&qd_lru_lock);
 440
 441	gfs2_assert_warn(sdp, qd->qd_change_sync);
 442	if (bh_get(qd)) {
 443		clear_bit(QDF_LOCKED, &qd->qd_flags);
 444		slot_put(qd);
 445		qd_put(qd);
 446		return 0;
 447	}
 448
 449	return 1;
 450}
 451
 452static void qd_unlock(struct gfs2_quota_data *qd)
 453{
 454	gfs2_assert_warn(qd->qd_gl->gl_sbd,
 455			 test_bit(QDF_LOCKED, &qd->qd_flags));
 456	clear_bit(QDF_LOCKED, &qd->qd_flags);
 457	bh_put(qd);
 458	slot_put(qd);
 459	qd_put(qd);
 460}
 461
 462static int qdsb_get(struct gfs2_sbd *sdp, struct kqid qid,
 463		    struct gfs2_quota_data **qdp)
 464{
 465	int error;
 466
 467	error = qd_get(sdp, qid, qdp);
 468	if (error)
 469		return error;
 470
 471	error = slot_get(*qdp);
 472	if (error)
 473		goto fail;
 474
 475	error = bh_get(*qdp);
 476	if (error)
 477		goto fail_slot;
 478
 479	return 0;
 480
 481fail_slot:
 482	slot_put(*qdp);
 483fail:
 484	qd_put(*qdp);
 485	return error;
 486}
 487
 488static void qdsb_put(struct gfs2_quota_data *qd)
 489{
 490	bh_put(qd);
 491	slot_put(qd);
 492	qd_put(qd);
 493}
 494
 495int gfs2_quota_hold(struct gfs2_inode *ip, kuid_t uid, kgid_t gid)
 496{
 497	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 498	struct gfs2_quota_data **qd;
 499	int error;
 500
 501	if (ip->i_res == NULL) {
 502		error = gfs2_rs_alloc(ip);
 503		if (error)
 504			return error;
 505	}
 506
 507	qd = ip->i_res->rs_qa_qd;
 508
 509	if (gfs2_assert_warn(sdp, !ip->i_res->rs_qa_qd_num) ||
 510	    gfs2_assert_warn(sdp, !test_bit(GIF_QD_LOCKED, &ip->i_flags)))
 511		return -EIO;
 512
 513	if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
 514		return 0;
 515
 516	error = qdsb_get(sdp, make_kqid_uid(ip->i_inode.i_uid), qd);
 517	if (error)
 518		goto out;
 519	ip->i_res->rs_qa_qd_num++;
 520	qd++;
 521
 522	error = qdsb_get(sdp, make_kqid_gid(ip->i_inode.i_gid), qd);
 523	if (error)
 524		goto out;
 525	ip->i_res->rs_qa_qd_num++;
 526	qd++;
 527
 528	if (!uid_eq(uid, NO_UID_QUOTA_CHANGE) &&
 529	    !uid_eq(uid, ip->i_inode.i_uid)) {
 530		error = qdsb_get(sdp, make_kqid_uid(uid), qd);
 531		if (error)
 532			goto out;
 533		ip->i_res->rs_qa_qd_num++;
 534		qd++;
 535	}
 536
 537	if (!gid_eq(gid, NO_GID_QUOTA_CHANGE) &&
 538	    !gid_eq(gid, ip->i_inode.i_gid)) {
 539		error = qdsb_get(sdp, make_kqid_gid(gid), qd);
 540		if (error)
 541			goto out;
 542		ip->i_res->rs_qa_qd_num++;
 543		qd++;
 544	}
 545
 546out:
 547	if (error)
 548		gfs2_quota_unhold(ip);
 549	return error;
 550}
 551
 552void gfs2_quota_unhold(struct gfs2_inode *ip)
 553{
 554	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 555	unsigned int x;
 556
 557	if (ip->i_res == NULL)
 558		return;
 559	gfs2_assert_warn(sdp, !test_bit(GIF_QD_LOCKED, &ip->i_flags));
 560
 561	for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {
 562		qdsb_put(ip->i_res->rs_qa_qd[x]);
 563		ip->i_res->rs_qa_qd[x] = NULL;
 564	}
 565	ip->i_res->rs_qa_qd_num = 0;
 566}
 567
 568static int sort_qd(const void *a, const void *b)
 569{
 570	const struct gfs2_quota_data *qd_a = *(const struct gfs2_quota_data **)a;
 571	const struct gfs2_quota_data *qd_b = *(const struct gfs2_quota_data **)b;
 572
 573	if (qid_lt(qd_a->qd_id, qd_b->qd_id))
 574		return -1;
 575	if (qid_lt(qd_b->qd_id, qd_a->qd_id))
 576		return 1;
 577	return 0;
 578}
 579
 580static void do_qc(struct gfs2_quota_data *qd, s64 change)
 581{
 582	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
 583	struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
 584	struct gfs2_quota_change *qc = qd->qd_bh_qc;
 585	s64 x;
 586
 587	mutex_lock(&sdp->sd_quota_mutex);
 588	gfs2_trans_add_meta(ip->i_gl, qd->qd_bh);
 589
 590	if (!test_bit(QDF_CHANGE, &qd->qd_flags)) {
 591		qc->qc_change = 0;
 592		qc->qc_flags = 0;
 593		if (qd->qd_id.type == USRQUOTA)
 594			qc->qc_flags = cpu_to_be32(GFS2_QCF_USER);
 595		qc->qc_id = cpu_to_be32(from_kqid(&init_user_ns, qd->qd_id));
 596	}
 597
 598	x = be64_to_cpu(qc->qc_change) + change;
 599	qc->qc_change = cpu_to_be64(x);
 600
 601	spin_lock(&qd_lru_lock);
 602	qd->qd_change = x;
 603	spin_unlock(&qd_lru_lock);
 604
 605	if (!x) {
 606		gfs2_assert_warn(sdp, test_bit(QDF_CHANGE, &qd->qd_flags));
 607		clear_bit(QDF_CHANGE, &qd->qd_flags);
 608		qc->qc_flags = 0;
 609		qc->qc_id = 0;
 610		slot_put(qd);
 611		qd_put(qd);
 612	} else if (!test_and_set_bit(QDF_CHANGE, &qd->qd_flags)) {
 613		qd_hold(qd);
 614		slot_hold(qd);
 615	}
 616
 617	mutex_unlock(&sdp->sd_quota_mutex);
 618}
 619
 620/**
 621 * gfs2_adjust_quota - adjust record of current block usage
 622 * @ip: The quota inode
 623 * @loc: Offset of the entry in the quota file
 624 * @change: The amount of usage change to record
 625 * @qd: The quota data
 626 * @fdq: The updated limits to record
 627 *
 628 * This function was mostly borrowed from gfs2_block_truncate_page which was
 629 * in turn mostly borrowed from ext3
 630 *
 631 * Returns: 0 or -ve on error
 632 */
 633
 634static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc,
 635			     s64 change, struct gfs2_quota_data *qd,
 636			     struct fs_disk_quota *fdq)
 637{
 638	struct inode *inode = &ip->i_inode;
 639	struct gfs2_sbd *sdp = GFS2_SB(inode);
 640	struct address_space *mapping = inode->i_mapping;
 641	unsigned long index = loc >> PAGE_CACHE_SHIFT;
 642	unsigned offset = loc & (PAGE_CACHE_SIZE - 1);
 643	unsigned blocksize, iblock, pos;
 644	struct buffer_head *bh;
 645	struct page *page;
 646	void *kaddr, *ptr;
 647	struct gfs2_quota q, *qp;
 648	int err, nbytes;
 649	u64 size;
 650
 651	if (gfs2_is_stuffed(ip)) {
 652		err = gfs2_unstuff_dinode(ip, NULL);
 653		if (err)
 654			return err;
 655	}
 656
 657	memset(&q, 0, sizeof(struct gfs2_quota));
 658	err = gfs2_internal_read(ip, (char *)&q, &loc, sizeof(q));
 659	if (err < 0)
 660		return err;
 661
 662	err = -EIO;
 663	qp = &q;
 664	qp->qu_value = be64_to_cpu(qp->qu_value);
 665	qp->qu_value += change;
 666	qp->qu_value = cpu_to_be64(qp->qu_value);
 667	qd->qd_qb.qb_value = qp->qu_value;
 668	if (fdq) {
 669		if (fdq->d_fieldmask & FS_DQ_BSOFT) {
 670			qp->qu_warn = cpu_to_be64(fdq->d_blk_softlimit >> sdp->sd_fsb2bb_shift);
 671			qd->qd_qb.qb_warn = qp->qu_warn;
 672		}
 673		if (fdq->d_fieldmask & FS_DQ_BHARD) {
 674			qp->qu_limit = cpu_to_be64(fdq->d_blk_hardlimit >> sdp->sd_fsb2bb_shift);
 675			qd->qd_qb.qb_limit = qp->qu_limit;
 676		}
 677		if (fdq->d_fieldmask & FS_DQ_BCOUNT) {
 678			qp->qu_value = cpu_to_be64(fdq->d_bcount >> sdp->sd_fsb2bb_shift);
 679			qd->qd_qb.qb_value = qp->qu_value;
 680		}
 681	}
 682
 683	/* Write the quota into the quota file on disk */
 684	ptr = qp;
 685	nbytes = sizeof(struct gfs2_quota);
 686get_a_page:
 687	page = find_or_create_page(mapping, index, GFP_NOFS);
 688	if (!page)
 689		return -ENOMEM;
 690
 691	blocksize = inode->i_sb->s_blocksize;
 692	iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
 693
 694	if (!page_has_buffers(page))
 695		create_empty_buffers(page, blocksize, 0);
 696
 697	bh = page_buffers(page);
 698	pos = blocksize;
 699	while (offset >= pos) {
 700		bh = bh->b_this_page;
 701		iblock++;
 702		pos += blocksize;
 703	}
 704
 705	if (!buffer_mapped(bh)) {
 706		gfs2_block_map(inode, iblock, bh, 1);
 707		if (!buffer_mapped(bh))
 708			goto unlock_out;
 709		/* If it's a newly allocated disk block for quota, zero it */
 710		if (buffer_new(bh))
 711			zero_user(page, pos - blocksize, bh->b_size);
 712	}
 713
 714	if (PageUptodate(page))
 715		set_buffer_uptodate(bh);
 716
 717	if (!buffer_uptodate(bh)) {
 718		ll_rw_block(READ | REQ_META, 1, &bh);
 719		wait_on_buffer(bh);
 720		if (!buffer_uptodate(bh))
 721			goto unlock_out;
 722	}
 723
 724	gfs2_trans_add_meta(ip->i_gl, bh);
 725
 726	kaddr = kmap_atomic(page);
 727	if (offset + sizeof(struct gfs2_quota) > PAGE_CACHE_SIZE)
 728		nbytes = PAGE_CACHE_SIZE - offset;
 729	memcpy(kaddr + offset, ptr, nbytes);
 730	flush_dcache_page(page);
 731	kunmap_atomic(kaddr);
 732	unlock_page(page);
 733	page_cache_release(page);
 734
 735	/* If quota straddles page boundary, we need to update the rest of the
 736	 * quota at the beginning of the next page */
 737	if ((offset + sizeof(struct gfs2_quota)) > PAGE_CACHE_SIZE) {
 738		ptr = ptr + nbytes;
 739		nbytes = sizeof(struct gfs2_quota) - nbytes;
 740		offset = 0;
 741		index++;
 742		goto get_a_page;
 743	}
 744
 745	size = loc + sizeof(struct gfs2_quota);
 746	if (size > inode->i_size)
 747		i_size_write(inode, size);
 748	inode->i_mtime = inode->i_atime = CURRENT_TIME;
 749	mark_inode_dirty(inode);
 750	return 0;
 751
 752unlock_out:
 753	unlock_page(page);
 754	page_cache_release(page);
 755	return err;
 756}
 757
 758static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)
 759{
 760	struct gfs2_sbd *sdp = (*qda)->qd_gl->gl_sbd;
 761	struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
 762	unsigned int data_blocks, ind_blocks;
 763	struct gfs2_holder *ghs, i_gh;
 764	unsigned int qx, x;
 765	struct gfs2_quota_data *qd;
 766	unsigned reserved;
 767	loff_t offset;
 768	unsigned int nalloc = 0, blocks;
 769	int error;
 770
 771	error = gfs2_rs_alloc(ip);
 772	if (error)
 773		return error;
 774
 775	gfs2_write_calc_reserv(ip, sizeof(struct gfs2_quota),
 776			      &data_blocks, &ind_blocks);
 777
 778	ghs = kcalloc(num_qd, sizeof(struct gfs2_holder), GFP_NOFS);
 779	if (!ghs)
 780		return -ENOMEM;
 781
 782	sort(qda, num_qd, sizeof(struct gfs2_quota_data *), sort_qd, NULL);
 783	mutex_lock(&ip->i_inode.i_mutex);
 784	for (qx = 0; qx < num_qd; qx++) {
 785		error = gfs2_glock_nq_init(qda[qx]->qd_gl, LM_ST_EXCLUSIVE,
 786					   GL_NOCACHE, &ghs[qx]);
 787		if (error)
 788			goto out;
 789	}
 790
 791	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
 792	if (error)
 793		goto out;
 794
 795	for (x = 0; x < num_qd; x++) {
 796		offset = qd2offset(qda[x]);
 797		if (gfs2_write_alloc_required(ip, offset,
 798					      sizeof(struct gfs2_quota)))
 799			nalloc++;
 800	}
 801
 802	/* 
 803	 * 1 blk for unstuffing inode if stuffed. We add this extra
 804	 * block to the reservation unconditionally. If the inode
 805	 * doesn't need unstuffing, the block will be released to the 
 806	 * rgrp since it won't be allocated during the transaction
 807	 */
 808	/* +3 in the end for unstuffing block, inode size update block
 809	 * and another block in case quota straddles page boundary and 
 810	 * two blocks need to be updated instead of 1 */
 811	blocks = num_qd * data_blocks + RES_DINODE + num_qd + 3;
 812
 813	reserved = 1 + (nalloc * (data_blocks + ind_blocks));
 814	error = gfs2_inplace_reserve(ip, reserved, 0);
 815	if (error)
 816		goto out_alloc;
 817
 818	if (nalloc)
 819		blocks += gfs2_rg_blocks(ip, reserved) + nalloc * ind_blocks + RES_STATFS;
 820
 821	error = gfs2_trans_begin(sdp, blocks, 0);
 822	if (error)
 823		goto out_ipres;
 824
 825	for (x = 0; x < num_qd; x++) {
 826		qd = qda[x];
 827		offset = qd2offset(qd);
 828		error = gfs2_adjust_quota(ip, offset, qd->qd_change_sync, qd, NULL);
 829		if (error)
 830			goto out_end_trans;
 831
 832		do_qc(qd, -qd->qd_change_sync);
 833		set_bit(QDF_REFRESH, &qd->qd_flags);
 834	}
 835
 836	error = 0;
 837
 838out_end_trans:
 839	gfs2_trans_end(sdp);
 840out_ipres:
 841	gfs2_inplace_release(ip);
 842out_alloc:
 843	gfs2_glock_dq_uninit(&i_gh);
 844out:
 845	while (qx--)
 846		gfs2_glock_dq_uninit(&ghs[qx]);
 847	mutex_unlock(&ip->i_inode.i_mutex);
 848	kfree(ghs);
 849	gfs2_log_flush(ip->i_gl->gl_sbd, ip->i_gl);
 850	return error;
 851}
 852
 853static int update_qd(struct gfs2_sbd *sdp, struct gfs2_quota_data *qd)
 854{
 855	struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
 856	struct gfs2_quota q;
 857	struct gfs2_quota_lvb *qlvb;
 858	loff_t pos;
 859	int error;
 860
 861	memset(&q, 0, sizeof(struct gfs2_quota));
 862	pos = qd2offset(qd);
 863	error = gfs2_internal_read(ip, (char *)&q, &pos, sizeof(q));
 864	if (error < 0)
 865		return error;
 866
 867	qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lksb.sb_lvbptr;
 868	qlvb->qb_magic = cpu_to_be32(GFS2_MAGIC);
 869	qlvb->__pad = 0;
 870	qlvb->qb_limit = q.qu_limit;
 871	qlvb->qb_warn = q.qu_warn;
 872	qlvb->qb_value = q.qu_value;
 873	qd->qd_qb = *qlvb;
 874
 875	return 0;
 876}
 877
 878static int do_glock(struct gfs2_quota_data *qd, int force_refresh,
 879		    struct gfs2_holder *q_gh)
 880{
 881	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
 882	struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
 883	struct gfs2_holder i_gh;
 884	int error;
 885
 886restart:
 887	error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_SHARED, 0, q_gh);
 888	if (error)
 889		return error;
 890
 891	qd->qd_qb = *(struct gfs2_quota_lvb *)qd->qd_gl->gl_lksb.sb_lvbptr;
 892
 893	if (force_refresh || qd->qd_qb.qb_magic != cpu_to_be32(GFS2_MAGIC)) {
 894		gfs2_glock_dq_uninit(q_gh);
 895		error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE,
 896					   GL_NOCACHE, q_gh);
 897		if (error)
 898			return error;
 899
 900		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
 901		if (error)
 902			goto fail;
 903
 904		error = update_qd(sdp, qd);
 905		if (error)
 906			goto fail_gunlock;
 907
 908		gfs2_glock_dq_uninit(&i_gh);
 909		gfs2_glock_dq_uninit(q_gh);
 910		force_refresh = 0;
 911		goto restart;
 912	}
 913
 914	return 0;
 915
 916fail_gunlock:
 917	gfs2_glock_dq_uninit(&i_gh);
 918fail:
 919	gfs2_glock_dq_uninit(q_gh);
 920	return error;
 921}
 922
 923int gfs2_quota_lock(struct gfs2_inode *ip, kuid_t uid, kgid_t gid)
 924{
 925	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 926	struct gfs2_quota_data *qd;
 927	unsigned int x;
 928	int error = 0;
 929
 930	error = gfs2_quota_hold(ip, uid, gid);
 931	if (error)
 932		return error;
 933
 934	if (capable(CAP_SYS_RESOURCE) ||
 935	    sdp->sd_args.ar_quota != GFS2_QUOTA_ON)
 936		return 0;
 937
 938	sort(ip->i_res->rs_qa_qd, ip->i_res->rs_qa_qd_num,
 939	     sizeof(struct gfs2_quota_data *), sort_qd, NULL);
 940
 941	for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {
 942		int force = NO_FORCE;
 943		qd = ip->i_res->rs_qa_qd[x];
 944		if (test_and_clear_bit(QDF_REFRESH, &qd->qd_flags))
 945			force = FORCE;
 946		error = do_glock(qd, force, &ip->i_res->rs_qa_qd_ghs[x]);
 947		if (error)
 948			break;
 949	}
 950
 951	if (!error)
 952		set_bit(GIF_QD_LOCKED, &ip->i_flags);
 953	else {
 954		while (x--)
 955			gfs2_glock_dq_uninit(&ip->i_res->rs_qa_qd_ghs[x]);
 956		gfs2_quota_unhold(ip);
 957	}
 958
 959	return error;
 960}
 961
 962static int need_sync(struct gfs2_quota_data *qd)
 963{
 964	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
 965	struct gfs2_tune *gt = &sdp->sd_tune;
 966	s64 value;
 967	unsigned int num, den;
 968	int do_sync = 1;
 969
 970	if (!qd->qd_qb.qb_limit)
 971		return 0;
 972
 973	spin_lock(&qd_lru_lock);
 974	value = qd->qd_change;
 975	spin_unlock(&qd_lru_lock);
 976
 977	spin_lock(&gt->gt_spin);
 978	num = gt->gt_quota_scale_num;
 979	den = gt->gt_quota_scale_den;
 980	spin_unlock(&gt->gt_spin);
 981
 982	if (value < 0)
 983		do_sync = 0;
 984	else if ((s64)be64_to_cpu(qd->qd_qb.qb_value) >=
 985		 (s64)be64_to_cpu(qd->qd_qb.qb_limit))
 986		do_sync = 0;
 987	else {
 988		value *= gfs2_jindex_size(sdp) * num;
 989		value = div_s64(value, den);
 990		value += (s64)be64_to_cpu(qd->qd_qb.qb_value);
 991		if (value < (s64)be64_to_cpu(qd->qd_qb.qb_limit))
 992			do_sync = 0;
 993	}
 994
 995	return do_sync;
 996}
 997
 998void gfs2_quota_unlock(struct gfs2_inode *ip)
 999{
1000	struct gfs2_quota_data *qda[4];
1001	unsigned int count = 0;
1002	unsigned int x;
1003
1004	if (!test_and_clear_bit(GIF_QD_LOCKED, &ip->i_flags))
1005		goto out;
1006
1007	for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {
1008		struct gfs2_quota_data *qd;
1009		int sync;
1010
1011		qd = ip->i_res->rs_qa_qd[x];
1012		sync = need_sync(qd);
1013
1014		gfs2_glock_dq_uninit(&ip->i_res->rs_qa_qd_ghs[x]);
1015
1016		if (sync && qd_trylock(qd))
1017			qda[count++] = qd;
1018	}
1019
1020	if (count) {
1021		do_sync(count, qda);
1022		for (x = 0; x < count; x++)
1023			qd_unlock(qda[x]);
1024	}
1025
1026out:
1027	gfs2_quota_unhold(ip);
1028}
1029
1030#define MAX_LINE 256
1031
1032static int print_message(struct gfs2_quota_data *qd, char *type)
1033{
1034	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
1035
1036	printk(KERN_INFO "GFS2: fsid=%s: quota %s for %s %u\n",
1037	       sdp->sd_fsname, type,
1038	       (qd->qd_id.type == USRQUOTA) ? "user" : "group",
1039	       from_kqid(&init_user_ns, qd->qd_id));
1040
1041	return 0;
1042}
1043
1044int gfs2_quota_check(struct gfs2_inode *ip, kuid_t uid, kgid_t gid)
1045{
1046	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1047	struct gfs2_quota_data *qd;
1048	s64 value;
1049	unsigned int x;
1050	int error = 0;
1051
1052	if (!test_bit(GIF_QD_LOCKED, &ip->i_flags))
1053		return 0;
1054
1055        if (sdp->sd_args.ar_quota != GFS2_QUOTA_ON)
1056                return 0;
1057
1058	for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {
1059		qd = ip->i_res->rs_qa_qd[x];
1060
1061		if (!(qid_eq(qd->qd_id, make_kqid_uid(uid)) ||
1062		      qid_eq(qd->qd_id, make_kqid_gid(gid))))
1063			continue;
1064
1065		value = (s64)be64_to_cpu(qd->qd_qb.qb_value);
1066		spin_lock(&qd_lru_lock);
1067		value += qd->qd_change;
1068		spin_unlock(&qd_lru_lock);
1069
1070		if (be64_to_cpu(qd->qd_qb.qb_limit) && (s64)be64_to_cpu(qd->qd_qb.qb_limit) < value) {
1071			print_message(qd, "exceeded");
1072			quota_send_warning(qd->qd_id,
1073					   sdp->sd_vfs->s_dev, QUOTA_NL_BHARDWARN);
1074
1075			error = -EDQUOT;
1076			break;
1077		} else if (be64_to_cpu(qd->qd_qb.qb_warn) &&
1078			   (s64)be64_to_cpu(qd->qd_qb.qb_warn) < value &&
1079			   time_after_eq(jiffies, qd->qd_last_warn +
1080					 gfs2_tune_get(sdp,
1081						gt_quota_warn_period) * HZ)) {
1082			quota_send_warning(qd->qd_id,
1083					   sdp->sd_vfs->s_dev, QUOTA_NL_BSOFTWARN);
1084			error = print_message(qd, "warning");
1085			qd->qd_last_warn = jiffies;
1086		}
1087	}
1088
1089	return error;
1090}
1091
1092void gfs2_quota_change(struct gfs2_inode *ip, s64 change,
1093		       kuid_t uid, kgid_t gid)
1094{
1095	struct gfs2_quota_data *qd;
1096	unsigned int x;
1097
1098	if (gfs2_assert_warn(GFS2_SB(&ip->i_inode), change))
1099		return;
1100	if (ip->i_diskflags & GFS2_DIF_SYSTEM)
1101		return;
1102
1103	for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {
1104		qd = ip->i_res->rs_qa_qd[x];
1105
1106		if (qid_eq(qd->qd_id, make_kqid_uid(uid)) ||
1107		    qid_eq(qd->qd_id, make_kqid_gid(gid))) {
1108			do_qc(qd, change);
1109		}
1110	}
1111}
1112
1113int gfs2_quota_sync(struct super_block *sb, int type)
1114{
1115	struct gfs2_sbd *sdp = sb->s_fs_info;
1116	struct gfs2_quota_data **qda;
1117	unsigned int max_qd = gfs2_tune_get(sdp, gt_quota_simul_sync);
1118	unsigned int num_qd;
1119	unsigned int x;
1120	int error = 0;
1121
1122	sdp->sd_quota_sync_gen++;
1123
1124	qda = kcalloc(max_qd, sizeof(struct gfs2_quota_data *), GFP_KERNEL);
1125	if (!qda)
1126		return -ENOMEM;
1127
1128	do {
1129		num_qd = 0;
1130
1131		for (;;) {
1132			error = qd_fish(sdp, qda + num_qd);
1133			if (error || !qda[num_qd])
1134				break;
1135			if (++num_qd == max_qd)
1136				break;
1137		}
1138
1139		if (num_qd) {
1140			if (!error)
1141				error = do_sync(num_qd, qda);
1142			if (!error)
1143				for (x = 0; x < num_qd; x++)
1144					qda[x]->qd_sync_gen =
1145						sdp->sd_quota_sync_gen;
1146
1147			for (x = 0; x < num_qd; x++)
1148				qd_unlock(qda[x]);
1149		}
1150	} while (!error && num_qd == max_qd);
1151
1152	kfree(qda);
1153
1154	return error;
1155}
1156
1157static int gfs2_quota_sync_timeo(struct super_block *sb, int type)
1158{
1159	return gfs2_quota_sync(sb, type);
1160}
1161
1162int gfs2_quota_refresh(struct gfs2_sbd *sdp, struct kqid qid)
1163{
1164	struct gfs2_quota_data *qd;
1165	struct gfs2_holder q_gh;
1166	int error;
1167
1168	error = qd_get(sdp, qid, &qd);
1169	if (error)
1170		return error;
1171
1172	error = do_glock(qd, FORCE, &q_gh);
1173	if (!error)
1174		gfs2_glock_dq_uninit(&q_gh);
1175
1176	qd_put(qd);
1177	return error;
1178}
1179
1180static void gfs2_quota_change_in(struct gfs2_quota_change_host *qc, const void *buf)
1181{
1182	const struct gfs2_quota_change *str = buf;
1183
1184	qc->qc_change = be64_to_cpu(str->qc_change);
1185	qc->qc_flags = be32_to_cpu(str->qc_flags);
1186	qc->qc_id = make_kqid(&init_user_ns,
1187			      (qc->qc_flags & GFS2_QCF_USER)?USRQUOTA:GRPQUOTA,
1188			      be32_to_cpu(str->qc_id));
1189}
1190
1191int gfs2_quota_init(struct gfs2_sbd *sdp)
1192{
1193	struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
1194	u64 size = i_size_read(sdp->sd_qc_inode);
1195	unsigned int blocks = size >> sdp->sd_sb.sb_bsize_shift;
1196	unsigned int x, slot = 0;
1197	unsigned int found = 0;
1198	u64 dblock;
1199	u32 extlen = 0;
1200	int error;
1201
1202	if (gfs2_check_internal_file_size(sdp->sd_qc_inode, 1, 64 << 20))
1203		return -EIO;
1204
1205	sdp->sd_quota_slots = blocks * sdp->sd_qc_per_block;
1206	sdp->sd_quota_chunks = DIV_ROUND_UP(sdp->sd_quota_slots, 8 * PAGE_SIZE);
1207
1208	error = -ENOMEM;
1209
1210	sdp->sd_quota_bitmap = kcalloc(sdp->sd_quota_chunks,
1211				       sizeof(unsigned char *), GFP_NOFS);
1212	if (!sdp->sd_quota_bitmap)
1213		return error;
1214
1215	for (x = 0; x < sdp->sd_quota_chunks; x++) {
1216		sdp->sd_quota_bitmap[x] = kzalloc(PAGE_SIZE, GFP_NOFS);
1217		if (!sdp->sd_quota_bitmap[x])
1218			goto fail;
1219	}
1220
1221	for (x = 0; x < blocks; x++) {
1222		struct buffer_head *bh;
1223		unsigned int y;
1224
1225		if (!extlen) {
1226			int new = 0;
1227			error = gfs2_extent_map(&ip->i_inode, x, &new, &dblock, &extlen);
1228			if (error)
1229				goto fail;
1230		}
1231		error = -EIO;
1232		bh = gfs2_meta_ra(ip->i_gl, dblock, extlen);
1233		if (!bh)
1234			goto fail;
1235		if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_QC)) {
1236			brelse(bh);
1237			goto fail;
1238		}
1239
1240		for (y = 0; y < sdp->sd_qc_per_block && slot < sdp->sd_quota_slots;
1241		     y++, slot++) {
1242			struct gfs2_quota_change_host qc;
1243			struct gfs2_quota_data *qd;
1244
1245			gfs2_quota_change_in(&qc, bh->b_data +
1246					  sizeof(struct gfs2_meta_header) +
1247					  y * sizeof(struct gfs2_quota_change));
1248			if (!qc.qc_change)
1249				continue;
1250
1251			error = qd_alloc(sdp, qc.qc_id, &qd);
1252			if (error) {
1253				brelse(bh);
1254				goto fail;
1255			}
1256
1257			set_bit(QDF_CHANGE, &qd->qd_flags);
1258			qd->qd_change = qc.qc_change;
1259			qd->qd_slot = slot;
1260			qd->qd_slot_count = 1;
1261
1262			spin_lock(&qd_lru_lock);
1263			gfs2_icbit_munge(sdp, sdp->sd_quota_bitmap, slot, 1);
1264			list_add(&qd->qd_list, &sdp->sd_quota_list);
1265			atomic_inc(&sdp->sd_quota_count);
1266			spin_unlock(&qd_lru_lock);
1267
1268			found++;
1269		}
1270
1271		brelse(bh);
1272		dblock++;
1273		extlen--;
1274	}
1275
1276	if (found)
1277		fs_info(sdp, "found %u quota changes\n", found);
1278
1279	return 0;
1280
1281fail:
1282	gfs2_quota_cleanup(sdp);
1283	return error;
1284}
1285
1286void gfs2_quota_cleanup(struct gfs2_sbd *sdp)
1287{
1288	struct list_head *head = &sdp->sd_quota_list;
1289	struct gfs2_quota_data *qd;
1290	unsigned int x;
1291
1292	spin_lock(&qd_lru_lock);
1293	while (!list_empty(head)) {
1294		qd = list_entry(head->prev, struct gfs2_quota_data, qd_list);
1295
1296		if (atomic_read(&qd->qd_count) > 1 ||
1297		    (atomic_read(&qd->qd_count) &&
1298		     !test_bit(QDF_CHANGE, &qd->qd_flags))) {
1299			list_move(&qd->qd_list, head);
1300			spin_unlock(&qd_lru_lock);
1301			schedule();
1302			spin_lock(&qd_lru_lock);
1303			continue;
1304		}
1305
1306		list_del(&qd->qd_list);
1307		/* Also remove if this qd exists in the reclaim list */
1308		if (!list_empty(&qd->qd_reclaim)) {
1309			list_del_init(&qd->qd_reclaim);
1310			atomic_dec(&qd_lru_count);
1311		}
1312		atomic_dec(&sdp->sd_quota_count);
1313		spin_unlock(&qd_lru_lock);
1314
1315		if (!atomic_read(&qd->qd_count)) {
1316			gfs2_assert_warn(sdp, !qd->qd_change);
1317			gfs2_assert_warn(sdp, !qd->qd_slot_count);
1318		} else
1319			gfs2_assert_warn(sdp, qd->qd_slot_count == 1);
1320		gfs2_assert_warn(sdp, !qd->qd_bh_count);
1321
1322		gfs2_glock_put(qd->qd_gl);
1323		kmem_cache_free(gfs2_quotad_cachep, qd);
1324
1325		spin_lock(&qd_lru_lock);
1326	}
1327	spin_unlock(&qd_lru_lock);
1328
1329	gfs2_assert_warn(sdp, !atomic_read(&sdp->sd_quota_count));
1330
1331	if (sdp->sd_quota_bitmap) {
1332		for (x = 0; x < sdp->sd_quota_chunks; x++)
1333			kfree(sdp->sd_quota_bitmap[x]);
1334		kfree(sdp->sd_quota_bitmap);
1335	}
1336}
1337
1338static void quotad_error(struct gfs2_sbd *sdp, const char *msg, int error)
1339{
1340	if (error == 0 || error == -EROFS)
1341		return;
1342	if (!test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
1343		fs_err(sdp, "gfs2_quotad: %s error %d\n", msg, error);
1344}
1345
1346static void quotad_check_timeo(struct gfs2_sbd *sdp, const char *msg,
1347			       int (*fxn)(struct super_block *sb, int type),
1348			       unsigned long t, unsigned long *timeo,
1349			       unsigned int *new_timeo)
1350{
1351	if (t >= *timeo) {
1352		int error = fxn(sdp->sd_vfs, 0);
1353		quotad_error(sdp, msg, error);
1354		*timeo = gfs2_tune_get_i(&sdp->sd_tune, new_timeo) * HZ;
1355	} else {
1356		*timeo -= t;
1357	}
1358}
1359
1360static void quotad_check_trunc_list(struct gfs2_sbd *sdp)
1361{
1362	struct gfs2_inode *ip;
1363
1364	while(1) {
1365		ip = NULL;
1366		spin_lock(&sdp->sd_trunc_lock);
1367		if (!list_empty(&sdp->sd_trunc_list)) {
1368			ip = list_entry(sdp->sd_trunc_list.next,
1369					struct gfs2_inode, i_trunc_list);
1370			list_del_init(&ip->i_trunc_list);
1371		}
1372		spin_unlock(&sdp->sd_trunc_lock);
1373		if (ip == NULL)
1374			return;
1375		gfs2_glock_finish_truncate(ip);
1376	}
1377}
1378
1379void gfs2_wake_up_statfs(struct gfs2_sbd *sdp) {
1380	if (!sdp->sd_statfs_force_sync) {
1381		sdp->sd_statfs_force_sync = 1;
1382		wake_up(&sdp->sd_quota_wait);
1383	}
1384}
1385
1386
1387/**
1388 * gfs2_quotad - Write cached quota changes into the quota file
1389 * @sdp: Pointer to GFS2 superblock
1390 *
1391 */
1392
1393int gfs2_quotad(void *data)
1394{
1395	struct gfs2_sbd *sdp = data;
1396	struct gfs2_tune *tune = &sdp->sd_tune;
1397	unsigned long statfs_timeo = 0;
1398	unsigned long quotad_timeo = 0;
1399	unsigned long t = 0;
1400	DEFINE_WAIT(wait);
1401	int empty;
1402
1403	while (!kthread_should_stop()) {
1404
1405		/* Update the master statfs file */
1406		if (sdp->sd_statfs_force_sync) {
1407			int error = gfs2_statfs_sync(sdp->sd_vfs, 0);
1408			quotad_error(sdp, "statfs", error);
1409			statfs_timeo = gfs2_tune_get(sdp, gt_statfs_quantum) * HZ;
1410		}
1411		else
1412			quotad_check_timeo(sdp, "statfs", gfs2_statfs_sync, t,
1413				   	   &statfs_timeo,
1414					   &tune->gt_statfs_quantum);
1415
1416		/* Update quota file */
1417		quotad_check_timeo(sdp, "sync", gfs2_quota_sync_timeo, t,
1418				   &quotad_timeo, &tune->gt_quota_quantum);
1419
1420		/* Check for & recover partially truncated inodes */
1421		quotad_check_trunc_list(sdp);
1422
1423		try_to_freeze();
1424
1425		t = min(quotad_timeo, statfs_timeo);
1426
1427		prepare_to_wait(&sdp->sd_quota_wait, &wait, TASK_INTERRUPTIBLE);
1428		spin_lock(&sdp->sd_trunc_lock);
1429		empty = list_empty(&sdp->sd_trunc_list);
1430		spin_unlock(&sdp->sd_trunc_lock);
1431		if (empty && !sdp->sd_statfs_force_sync)
1432			t -= schedule_timeout(t);
1433		else
1434			t = 0;
1435		finish_wait(&sdp->sd_quota_wait, &wait);
1436	}
1437
1438	return 0;
1439}
1440
1441static int gfs2_quota_get_xstate(struct super_block *sb,
1442				 struct fs_quota_stat *fqs)
1443{
1444	struct gfs2_sbd *sdp = sb->s_fs_info;
1445
1446	memset(fqs, 0, sizeof(struct fs_quota_stat));
1447	fqs->qs_version = FS_QSTAT_VERSION;
1448
1449	switch (sdp->sd_args.ar_quota) {
1450	case GFS2_QUOTA_ON:
1451		fqs->qs_flags |= (FS_QUOTA_UDQ_ENFD | FS_QUOTA_GDQ_ENFD);
1452		/*FALLTHRU*/
1453	case GFS2_QUOTA_ACCOUNT:
1454		fqs->qs_flags |= (FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT);
1455		break;
1456	case GFS2_QUOTA_OFF:
1457		break;
1458	}
1459
1460	if (sdp->sd_quota_inode) {
1461		fqs->qs_uquota.qfs_ino = GFS2_I(sdp->sd_quota_inode)->i_no_addr;
1462		fqs->qs_uquota.qfs_nblks = sdp->sd_quota_inode->i_blocks;
1463	}
1464	fqs->qs_uquota.qfs_nextents = 1; /* unsupported */
1465	fqs->qs_gquota = fqs->qs_uquota; /* its the same inode in both cases */
1466	fqs->qs_incoredqs = atomic_read(&qd_lru_count);
1467	return 0;
1468}
1469
1470static int gfs2_get_dqblk(struct super_block *sb, struct kqid qid,
1471			  struct fs_disk_quota *fdq)
1472{
1473	struct gfs2_sbd *sdp = sb->s_fs_info;
1474	struct gfs2_quota_lvb *qlvb;
1475	struct gfs2_quota_data *qd;
1476	struct gfs2_holder q_gh;
1477	int error;
1478
1479	memset(fdq, 0, sizeof(struct fs_disk_quota));
1480
1481	if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
1482		return -ESRCH; /* Crazy XFS error code */
1483
1484	if ((qid.type != USRQUOTA) &&
1485	    (qid.type != GRPQUOTA))
1486		return -EINVAL;
1487
1488	error = qd_get(sdp, qid, &qd);
1489	if (error)
1490		return error;
1491	error = do_glock(qd, FORCE, &q_gh);
1492	if (error)
1493		goto out;
1494
1495	qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lksb.sb_lvbptr;
1496	fdq->d_version = FS_DQUOT_VERSION;
1497	fdq->d_flags = (qid.type == USRQUOTA) ? FS_USER_QUOTA : FS_GROUP_QUOTA;
1498	fdq->d_id = from_kqid_munged(current_user_ns(), qid);
1499	fdq->d_blk_hardlimit = be64_to_cpu(qlvb->qb_limit) << sdp->sd_fsb2bb_shift;
1500	fdq->d_blk_softlimit = be64_to_cpu(qlvb->qb_warn) << sdp->sd_fsb2bb_shift;
1501	fdq->d_bcount = be64_to_cpu(qlvb->qb_value) << sdp->sd_fsb2bb_shift;
1502
1503	gfs2_glock_dq_uninit(&q_gh);
1504out:
1505	qd_put(qd);
1506	return error;
1507}
1508
1509/* GFS2 only supports a subset of the XFS fields */
1510#define GFS2_FIELDMASK (FS_DQ_BSOFT|FS_DQ_BHARD|FS_DQ_BCOUNT)
1511
1512static int gfs2_set_dqblk(struct super_block *sb, struct kqid qid,
1513			  struct fs_disk_quota *fdq)
1514{
1515	struct gfs2_sbd *sdp = sb->s_fs_info;
1516	struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
1517	struct gfs2_quota_data *qd;
1518	struct gfs2_holder q_gh, i_gh;
1519	unsigned int data_blocks, ind_blocks;
1520	unsigned int blocks = 0;
1521	int alloc_required;
1522	loff_t offset;
1523	int error;
1524
1525	if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
1526		return -ESRCH; /* Crazy XFS error code */
1527
1528	if ((qid.type != USRQUOTA) &&
1529	    (qid.type != GRPQUOTA))
1530		return -EINVAL;
1531
1532	if (fdq->d_fieldmask & ~GFS2_FIELDMASK)
1533		return -EINVAL;
1534
1535	error = qd_get(sdp, qid, &qd);
1536	if (error)
1537		return error;
1538
1539	error = gfs2_rs_alloc(ip);
1540	if (error)
1541		goto out_put;
1542
1543	mutex_lock(&ip->i_inode.i_mutex);
1544	error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE, 0, &q_gh);
1545	if (error)
1546		goto out_unlockput;
1547	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
1548	if (error)
1549		goto out_q;
1550
1551	/* Check for existing entry, if none then alloc new blocks */
1552	error = update_qd(sdp, qd);
1553	if (error)
1554		goto out_i;
1555
1556	/* If nothing has changed, this is a no-op */
1557	if ((fdq->d_fieldmask & FS_DQ_BSOFT) &&
1558	    ((fdq->d_blk_softlimit >> sdp->sd_fsb2bb_shift) == be64_to_cpu(qd->qd_qb.qb_warn)))
1559		fdq->d_fieldmask ^= FS_DQ_BSOFT;
1560
1561	if ((fdq->d_fieldmask & FS_DQ_BHARD) &&
1562	    ((fdq->d_blk_hardlimit >> sdp->sd_fsb2bb_shift) == be64_to_cpu(qd->qd_qb.qb_limit)))
1563		fdq->d_fieldmask ^= FS_DQ_BHARD;
1564
1565	if ((fdq->d_fieldmask & FS_DQ_BCOUNT) &&
1566	    ((fdq->d_bcount >> sdp->sd_fsb2bb_shift) == be64_to_cpu(qd->qd_qb.qb_value)))
1567		fdq->d_fieldmask ^= FS_DQ_BCOUNT;
1568
1569	if (fdq->d_fieldmask == 0)
1570		goto out_i;
1571
1572	offset = qd2offset(qd);
1573	alloc_required = gfs2_write_alloc_required(ip, offset, sizeof(struct gfs2_quota));
1574	if (gfs2_is_stuffed(ip))
1575		alloc_required = 1;
1576	if (alloc_required) {
1577		gfs2_write_calc_reserv(ip, sizeof(struct gfs2_quota),
1578				       &data_blocks, &ind_blocks);
1579		blocks = 1 + data_blocks + ind_blocks;
1580		error = gfs2_inplace_reserve(ip, blocks, 0);
1581		if (error)
1582			goto out_i;
1583		blocks += gfs2_rg_blocks(ip, blocks);
1584	}
1585
1586	/* Some quotas span block boundaries and can update two blocks,
1587	   adding an extra block to the transaction to handle such quotas */
1588	error = gfs2_trans_begin(sdp, blocks + RES_DINODE + 2, 0);
1589	if (error)
1590		goto out_release;
1591
1592	/* Apply changes */
1593	error = gfs2_adjust_quota(ip, offset, 0, qd, fdq);
1594
1595	gfs2_trans_end(sdp);
1596out_release:
1597	if (alloc_required)
1598		gfs2_inplace_release(ip);
1599out_i:
1600	gfs2_glock_dq_uninit(&i_gh);
1601out_q:
1602	gfs2_glock_dq_uninit(&q_gh);
1603out_unlockput:
1604	mutex_unlock(&ip->i_inode.i_mutex);
1605out_put:
1606	qd_put(qd);
1607	return error;
1608}
1609
1610const struct quotactl_ops gfs2_quotactl_ops = {
1611	.quota_sync     = gfs2_quota_sync,
1612	.get_xstate     = gfs2_quota_get_xstate,
1613	.get_dqblk	= gfs2_get_dqblk,
1614	.set_dqblk	= gfs2_set_dqblk,
1615};