PageRenderTime 94ms CodeModel.GetById 2ms app.highlight 80ms RepoModel.GetById 1ms app.codeStats 1ms

/fs/gfs2/quota.c

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