1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
4 * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
8 * Quota change tags are associated with each transaction that allocates or
9 * deallocates space. Those changes are accumulated locally to each node (in a
10 * per-node file) and then are periodically synced to the quota file. This
11 * avoids the bottleneck of constantly touching the quota file, but introduces
12 * fuzziness in the current usage value of IDs that are being used on different
13 * nodes in the cluster simultaneously. So, it is possible for a user on
14 * multiple nodes to overrun their quota, but that overrun is controlable.
15 * Since quota tags are part of transactions, there is no need for a quota check
16 * program to be run on node crashes or anything like that.
18 * There are couple of knobs that let the administrator manage the quota
19 * fuzziness. "quota_quantum" sets the maximum time a quota change can be
20 * sitting on one node before being synced to the quota file. (The default is
21 * 60 seconds.) Another knob, "quota_scale" controls how quickly the frequency
22 * of quota file syncs increases as the user moves closer to their limit. The
23 * more frequent the syncs, the more accurate the quota enforcement, but that
24 * means that there is more contention between the nodes for the quota file.
25 * The default value is one. This sets the maximum theoretical quota overrun
26 * (with infinite node with infinite bandwidth) to twice the user's limit. (In
27 * practice, the maximum overrun you see should be much less.) A "quota_scale"
28 * number greater than one makes quota syncs more frequent and reduces the
29 * maximum overrun. Numbers less than one (but greater than zero) make quota
30 * syncs less frequent.
32 * GFS quotas also use per-ID Lock Value Blocks (LVBs) to cache the contents of
33 * the quota file, so it is not being constantly read.
36 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
38 #include <linux/sched.h>
39 #include <linux/slab.h>
41 #include <linux/spinlock.h>
42 #include <linux/completion.h>
43 #include <linux/buffer_head.h>
44 #include <linux/sort.h>
46 #include <linux/bio.h>
47 #include <linux/gfs2_ondisk.h>
48 #include <linux/kthread.h>
49 #include <linux/freezer.h>
50 #include <linux/quota.h>
51 #include <linux/dqblk_xfs.h>
52 #include <linux/lockref.h>
53 #include <linux/list_lru.h>
54 #include <linux/rcupdate.h>
55 #include <linux/rculist_bl.h>
56 #include <linux/bit_spinlock.h>
57 #include <linux/jhash.h>
58 #include <linux/vmalloc.h>
74 #define GFS2_QD_HASH_SHIFT 12
75 #define GFS2_QD_HASH_SIZE BIT(GFS2_QD_HASH_SHIFT)
76 #define GFS2_QD_HASH_MASK (GFS2_QD_HASH_SIZE - 1)
78 /* Lock order: qd_lock -> bucket lock -> qd->lockref.lock -> lru lock */
79 /* -> sd_bitmap_lock */
80 static DEFINE_SPINLOCK(qd_lock
);
81 struct list_lru gfs2_qd_lru
;
83 static struct hlist_bl_head qd_hash_table
[GFS2_QD_HASH_SIZE
];
85 static unsigned int gfs2_qd_hash(const struct gfs2_sbd
*sdp
,
86 const struct kqid qid
)
90 h
= jhash(&sdp
, sizeof(struct gfs2_sbd
*), 0);
91 h
= jhash(&qid
, sizeof(struct kqid
), h
);
93 return h
& GFS2_QD_HASH_MASK
;
96 static inline void spin_lock_bucket(unsigned int hash
)
98 hlist_bl_lock(&qd_hash_table
[hash
]);
101 static inline void spin_unlock_bucket(unsigned int hash
)
103 hlist_bl_unlock(&qd_hash_table
[hash
]);
106 static void gfs2_qd_dealloc(struct rcu_head
*rcu
)
108 struct gfs2_quota_data
*qd
= container_of(rcu
, struct gfs2_quota_data
, qd_rcu
);
109 kmem_cache_free(gfs2_quotad_cachep
, qd
);
112 static void gfs2_qd_dispose(struct list_head
*list
)
114 struct gfs2_quota_data
*qd
;
115 struct gfs2_sbd
*sdp
;
117 while (!list_empty(list
)) {
118 qd
= list_first_entry(list
, struct gfs2_quota_data
, qd_lru
);
119 sdp
= qd
->qd_gl
->gl_name
.ln_sbd
;
121 list_del(&qd
->qd_lru
);
123 /* Free from the filesystem-specific list */
125 list_del(&qd
->qd_list
);
126 spin_unlock(&qd_lock
);
128 spin_lock_bucket(qd
->qd_hash
);
129 hlist_bl_del_rcu(&qd
->qd_hlist
);
130 spin_unlock_bucket(qd
->qd_hash
);
132 gfs2_assert_warn(sdp
, !qd
->qd_change
);
133 gfs2_assert_warn(sdp
, !qd
->qd_slot_count
);
134 gfs2_assert_warn(sdp
, !qd
->qd_bh_count
);
136 gfs2_glock_put(qd
->qd_gl
);
137 atomic_dec(&sdp
->sd_quota_count
);
139 /* Delete it from the common reclaim list */
140 call_rcu(&qd
->qd_rcu
, gfs2_qd_dealloc
);
145 static enum lru_status
gfs2_qd_isolate(struct list_head
*item
,
146 struct list_lru_one
*lru
, spinlock_t
*lru_lock
, void *arg
)
148 struct list_head
*dispose
= arg
;
149 struct gfs2_quota_data
*qd
= list_entry(item
, struct gfs2_quota_data
, qd_lru
);
151 if (!spin_trylock(&qd
->qd_lockref
.lock
))
154 if (qd
->qd_lockref
.count
== 0) {
155 lockref_mark_dead(&qd
->qd_lockref
);
156 list_lru_isolate_move(lru
, &qd
->qd_lru
, dispose
);
159 spin_unlock(&qd
->qd_lockref
.lock
);
163 static unsigned long gfs2_qd_shrink_scan(struct shrinker
*shrink
,
164 struct shrink_control
*sc
)
169 if (!(sc
->gfp_mask
& __GFP_FS
))
172 freed
= list_lru_shrink_walk(&gfs2_qd_lru
, sc
,
173 gfs2_qd_isolate
, &dispose
);
175 gfs2_qd_dispose(&dispose
);
180 static unsigned long gfs2_qd_shrink_count(struct shrinker
*shrink
,
181 struct shrink_control
*sc
)
183 return vfs_pressure_ratio(list_lru_shrink_count(&gfs2_qd_lru
, sc
));
186 struct shrinker gfs2_qd_shrinker
= {
187 .count_objects
= gfs2_qd_shrink_count
,
188 .scan_objects
= gfs2_qd_shrink_scan
,
189 .seeks
= DEFAULT_SEEKS
,
190 .flags
= SHRINKER_NUMA_AWARE
,
194 static u64
qd2index(struct gfs2_quota_data
*qd
)
196 struct kqid qid
= qd
->qd_id
;
197 return (2 * (u64
)from_kqid(&init_user_ns
, qid
)) +
198 ((qid
.type
== USRQUOTA
) ? 0 : 1);
201 static u64
qd2offset(struct gfs2_quota_data
*qd
)
205 offset
= qd2index(qd
);
206 offset
*= sizeof(struct gfs2_quota
);
211 static struct gfs2_quota_data
*qd_alloc(unsigned hash
, struct gfs2_sbd
*sdp
, struct kqid qid
)
213 struct gfs2_quota_data
*qd
;
216 qd
= kmem_cache_zalloc(gfs2_quotad_cachep
, GFP_NOFS
);
221 qd
->qd_lockref
.count
= 1;
222 spin_lock_init(&qd
->qd_lockref
.lock
);
225 INIT_LIST_HEAD(&qd
->qd_lru
);
228 error
= gfs2_glock_get(sdp
, qd2index(qd
),
229 &gfs2_quota_glops
, CREATE
, &qd
->qd_gl
);
236 kmem_cache_free(gfs2_quotad_cachep
, qd
);
240 static struct gfs2_quota_data
*gfs2_qd_search_bucket(unsigned int hash
,
241 const struct gfs2_sbd
*sdp
,
244 struct gfs2_quota_data
*qd
;
245 struct hlist_bl_node
*h
;
247 hlist_bl_for_each_entry_rcu(qd
, h
, &qd_hash_table
[hash
], qd_hlist
) {
248 if (!qid_eq(qd
->qd_id
, qid
))
250 if (qd
->qd_sbd
!= sdp
)
252 if (lockref_get_not_dead(&qd
->qd_lockref
)) {
253 list_lru_del(&gfs2_qd_lru
, &qd
->qd_lru
);
262 static int qd_get(struct gfs2_sbd
*sdp
, struct kqid qid
,
263 struct gfs2_quota_data
**qdp
)
265 struct gfs2_quota_data
*qd
, *new_qd
;
266 unsigned int hash
= gfs2_qd_hash(sdp
, qid
);
269 *qdp
= qd
= gfs2_qd_search_bucket(hash
, sdp
, qid
);
275 new_qd
= qd_alloc(hash
, sdp
, qid
);
280 spin_lock_bucket(hash
);
281 *qdp
= qd
= gfs2_qd_search_bucket(hash
, sdp
, qid
);
284 list_add(&new_qd
->qd_list
, &sdp
->sd_quota_list
);
285 hlist_bl_add_head_rcu(&new_qd
->qd_hlist
, &qd_hash_table
[hash
]);
286 atomic_inc(&sdp
->sd_quota_count
);
288 spin_unlock_bucket(hash
);
289 spin_unlock(&qd_lock
);
292 gfs2_glock_put(new_qd
->qd_gl
);
293 kmem_cache_free(gfs2_quotad_cachep
, new_qd
);
300 static void qd_hold(struct gfs2_quota_data
*qd
)
302 struct gfs2_sbd
*sdp
= qd
->qd_gl
->gl_name
.ln_sbd
;
303 gfs2_assert(sdp
, !__lockref_is_dead(&qd
->qd_lockref
));
304 lockref_get(&qd
->qd_lockref
);
307 static void qd_put(struct gfs2_quota_data
*qd
)
309 if (lockref_put_or_lock(&qd
->qd_lockref
))
312 qd
->qd_lockref
.count
= 0;
313 list_lru_add(&gfs2_qd_lru
, &qd
->qd_lru
);
314 spin_unlock(&qd
->qd_lockref
.lock
);
318 static int slot_get(struct gfs2_quota_data
*qd
)
320 struct gfs2_sbd
*sdp
= qd
->qd_sbd
;
324 spin_lock(&sdp
->sd_bitmap_lock
);
325 if (qd
->qd_slot_count
!= 0)
329 bit
= find_first_zero_bit(sdp
->sd_quota_bitmap
, sdp
->sd_quota_slots
);
330 if (bit
< sdp
->sd_quota_slots
) {
331 set_bit(bit
, sdp
->sd_quota_bitmap
);
337 spin_unlock(&sdp
->sd_bitmap_lock
);
342 static void slot_hold(struct gfs2_quota_data
*qd
)
344 struct gfs2_sbd
*sdp
= qd
->qd_sbd
;
346 spin_lock(&sdp
->sd_bitmap_lock
);
347 gfs2_assert(sdp
, qd
->qd_slot_count
);
349 spin_unlock(&sdp
->sd_bitmap_lock
);
352 static void slot_put(struct gfs2_quota_data
*qd
)
354 struct gfs2_sbd
*sdp
= qd
->qd_sbd
;
356 spin_lock(&sdp
->sd_bitmap_lock
);
357 gfs2_assert(sdp
, qd
->qd_slot_count
);
358 if (!--qd
->qd_slot_count
) {
359 BUG_ON(!test_and_clear_bit(qd
->qd_slot
, sdp
->sd_quota_bitmap
));
362 spin_unlock(&sdp
->sd_bitmap_lock
);
365 static int bh_get(struct gfs2_quota_data
*qd
)
367 struct gfs2_sbd
*sdp
= qd
->qd_gl
->gl_name
.ln_sbd
;
368 struct inode
*inode
= sdp
->sd_qc_inode
;
369 struct gfs2_inode
*ip
= GFS2_I(inode
);
370 unsigned int block
, offset
;
371 struct buffer_head
*bh
;
372 struct iomap iomap
= { };
375 mutex_lock(&sdp
->sd_quota_mutex
);
377 if (qd
->qd_bh_count
++) {
378 mutex_unlock(&sdp
->sd_quota_mutex
);
382 block
= qd
->qd_slot
/ sdp
->sd_qc_per_block
;
383 offset
= qd
->qd_slot
% sdp
->sd_qc_per_block
;
385 error
= gfs2_iomap_get(inode
,
386 (loff_t
)block
<< inode
->i_blkbits
,
387 i_blocksize(inode
), &iomap
);
391 if (iomap
.type
!= IOMAP_MAPPED
)
394 error
= gfs2_meta_read(ip
->i_gl
, iomap
.addr
>> inode
->i_blkbits
,
399 if (gfs2_metatype_check(sdp
, bh
, GFS2_METATYPE_QC
))
403 qd
->qd_bh_qc
= (struct gfs2_quota_change
*)
404 (bh
->b_data
+ sizeof(struct gfs2_meta_header
) +
405 offset
* sizeof(struct gfs2_quota_change
));
407 mutex_unlock(&sdp
->sd_quota_mutex
);
415 mutex_unlock(&sdp
->sd_quota_mutex
);
419 static void bh_put(struct gfs2_quota_data
*qd
)
421 struct gfs2_sbd
*sdp
= qd
->qd_gl
->gl_name
.ln_sbd
;
423 mutex_lock(&sdp
->sd_quota_mutex
);
424 gfs2_assert(sdp
, qd
->qd_bh_count
);
425 if (!--qd
->qd_bh_count
) {
430 mutex_unlock(&sdp
->sd_quota_mutex
);
433 static int qd_check_sync(struct gfs2_sbd
*sdp
, struct gfs2_quota_data
*qd
,
436 if (test_bit(QDF_LOCKED
, &qd
->qd_flags
) ||
437 !test_bit(QDF_CHANGE
, &qd
->qd_flags
) ||
438 (sync_gen
&& (qd
->qd_sync_gen
>= *sync_gen
)))
441 if (!lockref_get_not_dead(&qd
->qd_lockref
))
444 list_move_tail(&qd
->qd_list
, &sdp
->sd_quota_list
);
445 set_bit(QDF_LOCKED
, &qd
->qd_flags
);
446 qd
->qd_change_sync
= qd
->qd_change
;
451 static int qd_fish(struct gfs2_sbd
*sdp
, struct gfs2_quota_data
**qdp
)
453 struct gfs2_quota_data
*qd
= NULL
, *iter
;
458 if (sb_rdonly(sdp
->sd_vfs
))
463 list_for_each_entry(iter
, &sdp
->sd_quota_list
, qd_list
) {
464 if (qd_check_sync(sdp
, iter
, &sdp
->sd_quota_sync_gen
)) {
470 spin_unlock(&qd_lock
);
473 gfs2_assert_warn(sdp
, qd
->qd_change_sync
);
476 clear_bit(QDF_LOCKED
, &qd
->qd_flags
);
488 static void qd_unlock(struct gfs2_quota_data
*qd
)
490 gfs2_assert_warn(qd
->qd_gl
->gl_name
.ln_sbd
,
491 test_bit(QDF_LOCKED
, &qd
->qd_flags
));
492 clear_bit(QDF_LOCKED
, &qd
->qd_flags
);
498 static int qdsb_get(struct gfs2_sbd
*sdp
, struct kqid qid
,
499 struct gfs2_quota_data
**qdp
)
503 error
= qd_get(sdp
, qid
, qdp
);
507 error
= slot_get(*qdp
);
511 error
= bh_get(*qdp
);
524 static void qdsb_put(struct gfs2_quota_data
*qd
)
532 * gfs2_qa_get - make sure we have a quota allocations data structure,
534 * @ip: the inode for this reservation
536 int gfs2_qa_get(struct gfs2_inode
*ip
)
538 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
539 struct inode
*inode
= &ip
->i_inode
;
541 if (sdp
->sd_args
.ar_quota
== GFS2_QUOTA_OFF
)
544 spin_lock(&inode
->i_lock
);
545 if (ip
->i_qadata
== NULL
) {
546 struct gfs2_qadata
*tmp
;
548 spin_unlock(&inode
->i_lock
);
549 tmp
= kmem_cache_zalloc(gfs2_qadata_cachep
, GFP_NOFS
);
553 spin_lock(&inode
->i_lock
);
554 if (ip
->i_qadata
== NULL
)
557 kmem_cache_free(gfs2_qadata_cachep
, tmp
);
559 ip
->i_qadata
->qa_ref
++;
560 spin_unlock(&inode
->i_lock
);
564 void gfs2_qa_put(struct gfs2_inode
*ip
)
566 struct inode
*inode
= &ip
->i_inode
;
568 spin_lock(&inode
->i_lock
);
569 if (ip
->i_qadata
&& --ip
->i_qadata
->qa_ref
== 0) {
570 kmem_cache_free(gfs2_qadata_cachep
, ip
->i_qadata
);
573 spin_unlock(&inode
->i_lock
);
576 int gfs2_quota_hold(struct gfs2_inode
*ip
, kuid_t uid
, kgid_t gid
)
578 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
579 struct gfs2_quota_data
**qd
;
582 if (sdp
->sd_args
.ar_quota
== GFS2_QUOTA_OFF
)
585 error
= gfs2_qa_get(ip
);
589 qd
= ip
->i_qadata
->qa_qd
;
591 if (gfs2_assert_warn(sdp
, !ip
->i_qadata
->qa_qd_num
) ||
592 gfs2_assert_warn(sdp
, !test_bit(GIF_QD_LOCKED
, &ip
->i_flags
))) {
597 error
= qdsb_get(sdp
, make_kqid_uid(ip
->i_inode
.i_uid
), qd
);
600 ip
->i_qadata
->qa_qd_num
++;
603 error
= qdsb_get(sdp
, make_kqid_gid(ip
->i_inode
.i_gid
), qd
);
606 ip
->i_qadata
->qa_qd_num
++;
609 if (!uid_eq(uid
, NO_UID_QUOTA_CHANGE
) &&
610 !uid_eq(uid
, ip
->i_inode
.i_uid
)) {
611 error
= qdsb_get(sdp
, make_kqid_uid(uid
), qd
);
614 ip
->i_qadata
->qa_qd_num
++;
618 if (!gid_eq(gid
, NO_GID_QUOTA_CHANGE
) &&
619 !gid_eq(gid
, ip
->i_inode
.i_gid
)) {
620 error
= qdsb_get(sdp
, make_kqid_gid(gid
), qd
);
623 ip
->i_qadata
->qa_qd_num
++;
629 gfs2_quota_unhold(ip
);
634 void gfs2_quota_unhold(struct gfs2_inode
*ip
)
636 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
639 if (ip
->i_qadata
== NULL
)
642 gfs2_assert_warn(sdp
, !test_bit(GIF_QD_LOCKED
, &ip
->i_flags
));
644 for (x
= 0; x
< ip
->i_qadata
->qa_qd_num
; x
++) {
645 qdsb_put(ip
->i_qadata
->qa_qd
[x
]);
646 ip
->i_qadata
->qa_qd
[x
] = NULL
;
648 ip
->i_qadata
->qa_qd_num
= 0;
652 static int sort_qd(const void *a
, const void *b
)
654 const struct gfs2_quota_data
*qd_a
= *(const struct gfs2_quota_data
**)a
;
655 const struct gfs2_quota_data
*qd_b
= *(const struct gfs2_quota_data
**)b
;
657 if (qid_lt(qd_a
->qd_id
, qd_b
->qd_id
))
659 if (qid_lt(qd_b
->qd_id
, qd_a
->qd_id
))
664 static void do_qc(struct gfs2_quota_data
*qd
, s64 change
)
666 struct gfs2_sbd
*sdp
= qd
->qd_gl
->gl_name
.ln_sbd
;
667 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_qc_inode
);
668 struct gfs2_quota_change
*qc
= qd
->qd_bh_qc
;
671 mutex_lock(&sdp
->sd_quota_mutex
);
672 gfs2_trans_add_meta(ip
->i_gl
, qd
->qd_bh
);
674 if (!test_bit(QDF_CHANGE
, &qd
->qd_flags
)) {
677 if (qd
->qd_id
.type
== USRQUOTA
)
678 qc
->qc_flags
= cpu_to_be32(GFS2_QCF_USER
);
679 qc
->qc_id
= cpu_to_be32(from_kqid(&init_user_ns
, qd
->qd_id
));
682 x
= be64_to_cpu(qc
->qc_change
) + change
;
683 qc
->qc_change
= cpu_to_be64(x
);
687 spin_unlock(&qd_lock
);
690 gfs2_assert_warn(sdp
, test_bit(QDF_CHANGE
, &qd
->qd_flags
));
691 clear_bit(QDF_CHANGE
, &qd
->qd_flags
);
696 } else if (!test_and_set_bit(QDF_CHANGE
, &qd
->qd_flags
)) {
701 if (change
< 0) /* Reset quiet flag if we freed some blocks */
702 clear_bit(QDF_QMSG_QUIET
, &qd
->qd_flags
);
703 mutex_unlock(&sdp
->sd_quota_mutex
);
706 static int gfs2_write_buf_to_page(struct gfs2_inode
*ip
, unsigned long index
,
707 unsigned off
, void *buf
, unsigned bytes
)
709 struct inode
*inode
= &ip
->i_inode
;
710 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
711 struct address_space
*mapping
= inode
->i_mapping
;
713 struct buffer_head
*bh
;
716 unsigned bsize
= sdp
->sd_sb
.sb_bsize
, bnum
= 0, boff
= 0;
717 unsigned to_write
= bytes
, pg_off
= off
;
720 blk
= index
<< (PAGE_SHIFT
- sdp
->sd_sb
.sb_bsize_shift
);
723 page
= find_or_create_page(mapping
, index
, GFP_NOFS
);
726 if (!page_has_buffers(page
))
727 create_empty_buffers(page
, bsize
, 0);
729 bh
= page_buffers(page
);
731 /* Find the beginning block within the page */
732 if (pg_off
>= ((bnum
* bsize
) + bsize
)) {
733 bh
= bh
->b_this_page
;
738 if (!buffer_mapped(bh
)) {
739 gfs2_block_map(inode
, blk
, bh
, 1);
740 if (!buffer_mapped(bh
))
742 /* If it's a newly allocated disk block, zero it */
744 zero_user(page
, bnum
* bsize
, bh
->b_size
);
746 if (PageUptodate(page
))
747 set_buffer_uptodate(bh
);
748 if (!buffer_uptodate(bh
)) {
749 ll_rw_block(REQ_OP_READ
| REQ_META
| REQ_PRIO
, 1, &bh
);
751 if (!buffer_uptodate(bh
))
754 if (gfs2_is_jdata(ip
))
755 gfs2_trans_add_data(ip
->i_gl
, bh
);
757 gfs2_ordered_add_inode(ip
);
759 /* If we need to write to the next block as well */
760 if (to_write
> (bsize
- boff
)) {
761 pg_off
+= (bsize
- boff
);
762 to_write
-= (bsize
- boff
);
763 boff
= pg_off
% bsize
;
769 /* Write to the page, now that we have setup the buffer(s) */
770 kaddr
= kmap_atomic(page
);
771 memcpy(kaddr
+ off
, buf
, bytes
);
772 flush_dcache_page(page
);
773 kunmap_atomic(kaddr
);
785 static int gfs2_write_disk_quota(struct gfs2_inode
*ip
, struct gfs2_quota
*qp
,
788 unsigned long pg_beg
;
789 unsigned pg_off
, nbytes
, overflow
= 0;
790 int pg_oflow
= 0, error
;
793 nbytes
= sizeof(struct gfs2_quota
);
795 pg_beg
= loc
>> PAGE_SHIFT
;
796 pg_off
= offset_in_page(loc
);
798 /* If the quota straddles a page boundary, split the write in two */
799 if ((pg_off
+ nbytes
) > PAGE_SIZE
) {
801 overflow
= (pg_off
+ nbytes
) - PAGE_SIZE
;
805 error
= gfs2_write_buf_to_page(ip
, pg_beg
, pg_off
, ptr
,
807 /* If there's an overflow, write the remaining bytes to the next page */
808 if (!error
&& pg_oflow
)
809 error
= gfs2_write_buf_to_page(ip
, pg_beg
+ 1, 0,
810 ptr
+ nbytes
- overflow
,
816 * gfs2_adjust_quota - adjust record of current block usage
817 * @ip: The quota inode
818 * @loc: Offset of the entry in the quota file
819 * @change: The amount of usage change to record
820 * @qd: The quota data
821 * @fdq: The updated limits to record
823 * This function was mostly borrowed from gfs2_block_truncate_page which was
824 * in turn mostly borrowed from ext3
826 * Returns: 0 or -ve on error
829 static int gfs2_adjust_quota(struct gfs2_inode
*ip
, loff_t loc
,
830 s64 change
, struct gfs2_quota_data
*qd
,
831 struct qc_dqblk
*fdq
)
833 struct inode
*inode
= &ip
->i_inode
;
834 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
839 if (gfs2_is_stuffed(ip
)) {
840 err
= gfs2_unstuff_dinode(ip
);
845 memset(&q
, 0, sizeof(struct gfs2_quota
));
846 err
= gfs2_internal_read(ip
, (char *)&q
, &loc
, sizeof(q
));
850 loc
-= sizeof(q
); /* gfs2_internal_read would've advanced the loc ptr */
852 be64_add_cpu(&q
.qu_value
, change
);
853 if (((s64
)be64_to_cpu(q
.qu_value
)) < 0)
854 q
.qu_value
= 0; /* Never go negative on quota usage */
855 qd
->qd_qb
.qb_value
= q
.qu_value
;
857 if (fdq
->d_fieldmask
& QC_SPC_SOFT
) {
858 q
.qu_warn
= cpu_to_be64(fdq
->d_spc_softlimit
>> sdp
->sd_sb
.sb_bsize_shift
);
859 qd
->qd_qb
.qb_warn
= q
.qu_warn
;
861 if (fdq
->d_fieldmask
& QC_SPC_HARD
) {
862 q
.qu_limit
= cpu_to_be64(fdq
->d_spc_hardlimit
>> sdp
->sd_sb
.sb_bsize_shift
);
863 qd
->qd_qb
.qb_limit
= q
.qu_limit
;
865 if (fdq
->d_fieldmask
& QC_SPACE
) {
866 q
.qu_value
= cpu_to_be64(fdq
->d_space
>> sdp
->sd_sb
.sb_bsize_shift
);
867 qd
->qd_qb
.qb_value
= q
.qu_value
;
871 err
= gfs2_write_disk_quota(ip
, &q
, loc
);
873 size
= loc
+ sizeof(struct gfs2_quota
);
874 if (size
> inode
->i_size
)
875 i_size_write(inode
, size
);
876 inode
->i_mtime
= inode
->i_atime
= current_time(inode
);
877 mark_inode_dirty(inode
);
878 set_bit(QDF_REFRESH
, &qd
->qd_flags
);
884 static int do_sync(unsigned int num_qd
, struct gfs2_quota_data
**qda
)
886 struct gfs2_sbd
*sdp
= (*qda
)->qd_gl
->gl_name
.ln_sbd
;
887 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_quota_inode
);
888 struct gfs2_alloc_parms ap
= { .aflags
= 0, };
889 unsigned int data_blocks
, ind_blocks
;
890 struct gfs2_holder
*ghs
, i_gh
;
892 struct gfs2_quota_data
*qd
;
895 unsigned int nalloc
= 0, blocks
;
898 error
= gfs2_qa_get(ip
);
902 gfs2_write_calc_reserv(ip
, sizeof(struct gfs2_quota
),
903 &data_blocks
, &ind_blocks
);
905 ghs
= kmalloc_array(num_qd
, sizeof(struct gfs2_holder
), GFP_NOFS
);
911 sort(qda
, num_qd
, sizeof(struct gfs2_quota_data
*), sort_qd
, NULL
);
912 inode_lock(&ip
->i_inode
);
913 for (qx
= 0; qx
< num_qd
; qx
++) {
914 error
= gfs2_glock_nq_init(qda
[qx
]->qd_gl
, LM_ST_EXCLUSIVE
,
915 GL_NOCACHE
, &ghs
[qx
]);
920 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, &i_gh
);
924 for (x
= 0; x
< num_qd
; x
++) {
925 offset
= qd2offset(qda
[x
]);
926 if (gfs2_write_alloc_required(ip
, offset
,
927 sizeof(struct gfs2_quota
)))
932 * 1 blk for unstuffing inode if stuffed. We add this extra
933 * block to the reservation unconditionally. If the inode
934 * doesn't need unstuffing, the block will be released to the
935 * rgrp since it won't be allocated during the transaction
937 /* +3 in the end for unstuffing block, inode size update block
938 * and another block in case quota straddles page boundary and
939 * two blocks need to be updated instead of 1 */
940 blocks
= num_qd
* data_blocks
+ RES_DINODE
+ num_qd
+ 3;
942 reserved
= 1 + (nalloc
* (data_blocks
+ ind_blocks
));
943 ap
.target
= reserved
;
944 error
= gfs2_inplace_reserve(ip
, &ap
);
949 blocks
+= gfs2_rg_blocks(ip
, reserved
) + nalloc
* ind_blocks
+ RES_STATFS
;
951 error
= gfs2_trans_begin(sdp
, blocks
, 0);
955 for (x
= 0; x
< num_qd
; x
++) {
957 offset
= qd2offset(qd
);
958 error
= gfs2_adjust_quota(ip
, offset
, qd
->qd_change_sync
, qd
, NULL
);
962 do_qc(qd
, -qd
->qd_change_sync
);
963 set_bit(QDF_REFRESH
, &qd
->qd_flags
);
971 gfs2_inplace_release(ip
);
973 gfs2_glock_dq_uninit(&i_gh
);
976 gfs2_glock_dq_uninit(&ghs
[qx
]);
977 inode_unlock(&ip
->i_inode
);
979 gfs2_log_flush(ip
->i_gl
->gl_name
.ln_sbd
, ip
->i_gl
,
980 GFS2_LOG_HEAD_FLUSH_NORMAL
| GFS2_LFC_DO_SYNC
);
986 static int update_qd(struct gfs2_sbd
*sdp
, struct gfs2_quota_data
*qd
)
988 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_quota_inode
);
990 struct gfs2_quota_lvb
*qlvb
;
994 memset(&q
, 0, sizeof(struct gfs2_quota
));
996 error
= gfs2_internal_read(ip
, (char *)&q
, &pos
, sizeof(q
));
1000 qlvb
= (struct gfs2_quota_lvb
*)qd
->qd_gl
->gl_lksb
.sb_lvbptr
;
1001 qlvb
->qb_magic
= cpu_to_be32(GFS2_MAGIC
);
1003 qlvb
->qb_limit
= q
.qu_limit
;
1004 qlvb
->qb_warn
= q
.qu_warn
;
1005 qlvb
->qb_value
= q
.qu_value
;
1011 static int do_glock(struct gfs2_quota_data
*qd
, int force_refresh
,
1012 struct gfs2_holder
*q_gh
)
1014 struct gfs2_sbd
*sdp
= qd
->qd_gl
->gl_name
.ln_sbd
;
1015 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_quota_inode
);
1016 struct gfs2_holder i_gh
;
1020 error
= gfs2_glock_nq_init(qd
->qd_gl
, LM_ST_SHARED
, 0, q_gh
);
1024 if (test_and_clear_bit(QDF_REFRESH
, &qd
->qd_flags
))
1025 force_refresh
= FORCE
;
1027 qd
->qd_qb
= *(struct gfs2_quota_lvb
*)qd
->qd_gl
->gl_lksb
.sb_lvbptr
;
1029 if (force_refresh
|| qd
->qd_qb
.qb_magic
!= cpu_to_be32(GFS2_MAGIC
)) {
1030 gfs2_glock_dq_uninit(q_gh
);
1031 error
= gfs2_glock_nq_init(qd
->qd_gl
, LM_ST_EXCLUSIVE
,
1036 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, 0, &i_gh
);
1040 error
= update_qd(sdp
, qd
);
1044 gfs2_glock_dq_uninit(&i_gh
);
1045 gfs2_glock_dq_uninit(q_gh
);
1053 gfs2_glock_dq_uninit(&i_gh
);
1055 gfs2_glock_dq_uninit(q_gh
);
1059 int gfs2_quota_lock(struct gfs2_inode
*ip
, kuid_t uid
, kgid_t gid
)
1061 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1062 struct gfs2_quota_data
*qd
;
1066 if (sdp
->sd_args
.ar_quota
!= GFS2_QUOTA_ON
)
1069 error
= gfs2_quota_hold(ip
, uid
, gid
);
1073 sort(ip
->i_qadata
->qa_qd
, ip
->i_qadata
->qa_qd_num
,
1074 sizeof(struct gfs2_quota_data
*), sort_qd
, NULL
);
1076 for (x
= 0; x
< ip
->i_qadata
->qa_qd_num
; x
++) {
1077 qd
= ip
->i_qadata
->qa_qd
[x
];
1078 error
= do_glock(qd
, NO_FORCE
, &ip
->i_qadata
->qa_qd_ghs
[x
]);
1084 set_bit(GIF_QD_LOCKED
, &ip
->i_flags
);
1087 gfs2_glock_dq_uninit(&ip
->i_qadata
->qa_qd_ghs
[x
]);
1088 gfs2_quota_unhold(ip
);
1094 static int need_sync(struct gfs2_quota_data
*qd
)
1096 struct gfs2_sbd
*sdp
= qd
->qd_gl
->gl_name
.ln_sbd
;
1097 struct gfs2_tune
*gt
= &sdp
->sd_tune
;
1099 unsigned int num
, den
;
1102 if (!qd
->qd_qb
.qb_limit
)
1105 spin_lock(&qd_lock
);
1106 value
= qd
->qd_change
;
1107 spin_unlock(&qd_lock
);
1109 spin_lock(>
->gt_spin
);
1110 num
= gt
->gt_quota_scale_num
;
1111 den
= gt
->gt_quota_scale_den
;
1112 spin_unlock(>
->gt_spin
);
1116 else if ((s64
)be64_to_cpu(qd
->qd_qb
.qb_value
) >=
1117 (s64
)be64_to_cpu(qd
->qd_qb
.qb_limit
))
1120 value
*= gfs2_jindex_size(sdp
) * num
;
1121 value
= div_s64(value
, den
);
1122 value
+= (s64
)be64_to_cpu(qd
->qd_qb
.qb_value
);
1123 if (value
< (s64
)be64_to_cpu(qd
->qd_qb
.qb_limit
))
1130 void gfs2_quota_unlock(struct gfs2_inode
*ip
)
1132 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1133 struct gfs2_quota_data
*qda
[4];
1134 unsigned int count
= 0;
1138 if (!test_and_clear_bit(GIF_QD_LOCKED
, &ip
->i_flags
))
1141 for (x
= 0; x
< ip
->i_qadata
->qa_qd_num
; x
++) {
1142 struct gfs2_quota_data
*qd
;
1145 qd
= ip
->i_qadata
->qa_qd
[x
];
1146 sync
= need_sync(qd
);
1148 gfs2_glock_dq_uninit(&ip
->i_qadata
->qa_qd_ghs
[x
]);
1152 spin_lock(&qd_lock
);
1153 found
= qd_check_sync(sdp
, qd
, NULL
);
1154 spin_unlock(&qd_lock
);
1159 gfs2_assert_warn(sdp
, qd
->qd_change_sync
);
1161 clear_bit(QDF_LOCKED
, &qd
->qd_flags
);
1171 do_sync(count
, qda
);
1172 for (x
= 0; x
< count
; x
++)
1176 gfs2_quota_unhold(ip
);
1179 #define MAX_LINE 256
1181 static int print_message(struct gfs2_quota_data
*qd
, char *type
)
1183 struct gfs2_sbd
*sdp
= qd
->qd_gl
->gl_name
.ln_sbd
;
1185 fs_info(sdp
, "quota %s for %s %u\n",
1187 (qd
->qd_id
.type
== USRQUOTA
) ? "user" : "group",
1188 from_kqid(&init_user_ns
, qd
->qd_id
));
1194 * gfs2_quota_check - check if allocating new blocks will exceed quota
1195 * @ip: The inode for which this check is being performed
1196 * @uid: The uid to check against
1197 * @gid: The gid to check against
1198 * @ap: The allocation parameters. ap->target contains the requested
1199 * blocks. ap->min_target, if set, contains the minimum blks
1202 * Returns: 0 on success.
1203 * min_req = ap->min_target ? ap->min_target : ap->target;
1204 * quota must allow at least min_req blks for success and
1205 * ap->allowed is set to the number of blocks allowed
1207 * -EDQUOT otherwise, quota violation. ap->allowed is set to number
1208 * of blocks available.
1210 int gfs2_quota_check(struct gfs2_inode
*ip
, kuid_t uid
, kgid_t gid
,
1211 struct gfs2_alloc_parms
*ap
)
1213 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1214 struct gfs2_quota_data
*qd
;
1215 s64 value
, warn
, limit
;
1219 ap
->allowed
= UINT_MAX
; /* Assume we are permitted a whole lot */
1220 if (!test_bit(GIF_QD_LOCKED
, &ip
->i_flags
))
1223 for (x
= 0; x
< ip
->i_qadata
->qa_qd_num
; x
++) {
1224 qd
= ip
->i_qadata
->qa_qd
[x
];
1226 if (!(qid_eq(qd
->qd_id
, make_kqid_uid(uid
)) ||
1227 qid_eq(qd
->qd_id
, make_kqid_gid(gid
))))
1230 warn
= (s64
)be64_to_cpu(qd
->qd_qb
.qb_warn
);
1231 limit
= (s64
)be64_to_cpu(qd
->qd_qb
.qb_limit
);
1232 value
= (s64
)be64_to_cpu(qd
->qd_qb
.qb_value
);
1233 spin_lock(&qd_lock
);
1234 value
+= qd
->qd_change
;
1235 spin_unlock(&qd_lock
);
1237 if (limit
> 0 && (limit
- value
) < ap
->allowed
)
1238 ap
->allowed
= limit
- value
;
1239 /* If we can't meet the target */
1240 if (limit
&& limit
< (value
+ (s64
)ap
->target
)) {
1241 /* If no min_target specified or we don't meet
1242 * min_target, return -EDQUOT */
1243 if (!ap
->min_target
|| ap
->min_target
> ap
->allowed
) {
1244 if (!test_and_set_bit(QDF_QMSG_QUIET
,
1246 print_message(qd
, "exceeded");
1247 quota_send_warning(qd
->qd_id
,
1249 QUOTA_NL_BHARDWARN
);
1254 } else if (warn
&& warn
< value
&&
1255 time_after_eq(jiffies
, qd
->qd_last_warn
+
1256 gfs2_tune_get(sdp
, gt_quota_warn_period
)
1258 quota_send_warning(qd
->qd_id
,
1259 sdp
->sd_vfs
->s_dev
, QUOTA_NL_BSOFTWARN
);
1260 error
= print_message(qd
, "warning");
1261 qd
->qd_last_warn
= jiffies
;
1267 void gfs2_quota_change(struct gfs2_inode
*ip
, s64 change
,
1268 kuid_t uid
, kgid_t gid
)
1270 struct gfs2_quota_data
*qd
;
1272 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1274 if (sdp
->sd_args
.ar_quota
!= GFS2_QUOTA_ON
||
1275 gfs2_assert_warn(sdp
, change
))
1277 if (ip
->i_diskflags
& GFS2_DIF_SYSTEM
)
1280 if (gfs2_assert_withdraw(sdp
, ip
->i_qadata
&&
1281 ip
->i_qadata
->qa_ref
> 0))
1283 for (x
= 0; x
< ip
->i_qadata
->qa_qd_num
; x
++) {
1284 qd
= ip
->i_qadata
->qa_qd
[x
];
1286 if (qid_eq(qd
->qd_id
, make_kqid_uid(uid
)) ||
1287 qid_eq(qd
->qd_id
, make_kqid_gid(gid
))) {
1293 int gfs2_quota_sync(struct super_block
*sb
, int type
)
1295 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
1296 struct gfs2_quota_data
**qda
;
1297 unsigned int max_qd
= PAGE_SIZE
/ sizeof(struct gfs2_holder
);
1298 unsigned int num_qd
;
1302 qda
= kcalloc(max_qd
, sizeof(struct gfs2_quota_data
*), GFP_KERNEL
);
1306 mutex_lock(&sdp
->sd_quota_sync_mutex
);
1307 sdp
->sd_quota_sync_gen
++;
1313 error
= qd_fish(sdp
, qda
+ num_qd
);
1314 if (error
|| !qda
[num_qd
])
1316 if (++num_qd
== max_qd
)
1322 error
= do_sync(num_qd
, qda
);
1324 for (x
= 0; x
< num_qd
; x
++)
1325 qda
[x
]->qd_sync_gen
=
1326 sdp
->sd_quota_sync_gen
;
1328 for (x
= 0; x
< num_qd
; x
++)
1331 } while (!error
&& num_qd
== max_qd
);
1333 mutex_unlock(&sdp
->sd_quota_sync_mutex
);
1339 int gfs2_quota_refresh(struct gfs2_sbd
*sdp
, struct kqid qid
)
1341 struct gfs2_quota_data
*qd
;
1342 struct gfs2_holder q_gh
;
1345 error
= qd_get(sdp
, qid
, &qd
);
1349 error
= do_glock(qd
, FORCE
, &q_gh
);
1351 gfs2_glock_dq_uninit(&q_gh
);
1357 int gfs2_quota_init(struct gfs2_sbd
*sdp
)
1359 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_qc_inode
);
1360 u64 size
= i_size_read(sdp
->sd_qc_inode
);
1361 unsigned int blocks
= size
>> sdp
->sd_sb
.sb_bsize_shift
;
1362 unsigned int x
, slot
= 0;
1363 unsigned int found
= 0;
1365 unsigned int bm_size
;
1370 if (gfs2_check_internal_file_size(sdp
->sd_qc_inode
, 1, 64 << 20))
1373 sdp
->sd_quota_slots
= blocks
* sdp
->sd_qc_per_block
;
1374 bm_size
= DIV_ROUND_UP(sdp
->sd_quota_slots
, 8 * sizeof(unsigned long));
1375 bm_size
*= sizeof(unsigned long);
1377 sdp
->sd_quota_bitmap
= kzalloc(bm_size
, GFP_NOFS
| __GFP_NOWARN
);
1378 if (sdp
->sd_quota_bitmap
== NULL
)
1379 sdp
->sd_quota_bitmap
= __vmalloc(bm_size
, GFP_NOFS
|
1381 if (!sdp
->sd_quota_bitmap
)
1384 for (x
= 0; x
< blocks
; x
++) {
1385 struct buffer_head
*bh
;
1386 const struct gfs2_quota_change
*qc
;
1391 error
= gfs2_get_extent(&ip
->i_inode
, x
, &dblock
, &extlen
);
1396 bh
= gfs2_meta_ra(ip
->i_gl
, dblock
, extlen
);
1399 if (gfs2_metatype_check(sdp
, bh
, GFS2_METATYPE_QC
)) {
1404 qc
= (const struct gfs2_quota_change
*)(bh
->b_data
+ sizeof(struct gfs2_meta_header
));
1405 for (y
= 0; y
< sdp
->sd_qc_per_block
&& slot
< sdp
->sd_quota_slots
;
1407 struct gfs2_quota_data
*qd
;
1408 s64 qc_change
= be64_to_cpu(qc
->qc_change
);
1409 u32 qc_flags
= be32_to_cpu(qc
->qc_flags
);
1410 enum quota_type qtype
= (qc_flags
& GFS2_QCF_USER
) ?
1411 USRQUOTA
: GRPQUOTA
;
1412 struct kqid qc_id
= make_kqid(&init_user_ns
, qtype
,
1413 be32_to_cpu(qc
->qc_id
));
1418 hash
= gfs2_qd_hash(sdp
, qc_id
);
1419 qd
= qd_alloc(hash
, sdp
, qc_id
);
1425 set_bit(QDF_CHANGE
, &qd
->qd_flags
);
1426 qd
->qd_change
= qc_change
;
1428 qd
->qd_slot_count
= 1;
1430 spin_lock(&qd_lock
);
1431 BUG_ON(test_and_set_bit(slot
, sdp
->sd_quota_bitmap
));
1432 list_add(&qd
->qd_list
, &sdp
->sd_quota_list
);
1433 atomic_inc(&sdp
->sd_quota_count
);
1434 spin_unlock(&qd_lock
);
1436 spin_lock_bucket(hash
);
1437 hlist_bl_add_head_rcu(&qd
->qd_hlist
, &qd_hash_table
[hash
]);
1438 spin_unlock_bucket(hash
);
1449 fs_info(sdp
, "found %u quota changes\n", found
);
1454 gfs2_quota_cleanup(sdp
);
1458 void gfs2_quota_cleanup(struct gfs2_sbd
*sdp
)
1460 struct list_head
*head
= &sdp
->sd_quota_list
;
1461 struct gfs2_quota_data
*qd
;
1463 spin_lock(&qd_lock
);
1464 while (!list_empty(head
)) {
1465 qd
= list_last_entry(head
, struct gfs2_quota_data
, qd_list
);
1467 list_del(&qd
->qd_list
);
1469 /* Also remove if this qd exists in the reclaim list */
1470 list_lru_del(&gfs2_qd_lru
, &qd
->qd_lru
);
1471 atomic_dec(&sdp
->sd_quota_count
);
1472 spin_unlock(&qd_lock
);
1474 spin_lock_bucket(qd
->qd_hash
);
1475 hlist_bl_del_rcu(&qd
->qd_hlist
);
1476 spin_unlock_bucket(qd
->qd_hash
);
1478 gfs2_assert_warn(sdp
, !qd
->qd_change
);
1479 gfs2_assert_warn(sdp
, !qd
->qd_slot_count
);
1480 gfs2_assert_warn(sdp
, !qd
->qd_bh_count
);
1482 gfs2_glock_put(qd
->qd_gl
);
1483 call_rcu(&qd
->qd_rcu
, gfs2_qd_dealloc
);
1485 spin_lock(&qd_lock
);
1487 spin_unlock(&qd_lock
);
1489 gfs2_assert_warn(sdp
, !atomic_read(&sdp
->sd_quota_count
));
1491 kvfree(sdp
->sd_quota_bitmap
);
1492 sdp
->sd_quota_bitmap
= NULL
;
1495 static void quotad_error(struct gfs2_sbd
*sdp
, const char *msg
, int error
)
1497 if (error
== 0 || error
== -EROFS
)
1499 if (!gfs2_withdrawn(sdp
)) {
1500 if (!cmpxchg(&sdp
->sd_log_error
, 0, error
))
1501 fs_err(sdp
, "gfs2_quotad: %s error %d\n", msg
, error
);
1502 wake_up(&sdp
->sd_logd_waitq
);
1506 static void quotad_check_timeo(struct gfs2_sbd
*sdp
, const char *msg
,
1507 int (*fxn
)(struct super_block
*sb
, int type
),
1508 unsigned long t
, unsigned long *timeo
,
1509 unsigned int *new_timeo
)
1512 int error
= fxn(sdp
->sd_vfs
, 0);
1513 quotad_error(sdp
, msg
, error
);
1514 *timeo
= gfs2_tune_get_i(&sdp
->sd_tune
, new_timeo
) * HZ
;
1520 void gfs2_wake_up_statfs(struct gfs2_sbd
*sdp
) {
1521 if (!sdp
->sd_statfs_force_sync
) {
1522 sdp
->sd_statfs_force_sync
= 1;
1523 wake_up(&sdp
->sd_quota_wait
);
1529 * gfs2_quotad - Write cached quota changes into the quota file
1530 * @data: Pointer to GFS2 superblock
1534 int gfs2_quotad(void *data
)
1536 struct gfs2_sbd
*sdp
= data
;
1537 struct gfs2_tune
*tune
= &sdp
->sd_tune
;
1538 unsigned long statfs_timeo
= 0;
1539 unsigned long quotad_timeo
= 0;
1540 unsigned long t
= 0;
1543 while (!kthread_should_stop()) {
1545 if (gfs2_withdrawn(sdp
))
1547 /* Update the master statfs file */
1548 if (sdp
->sd_statfs_force_sync
) {
1549 int error
= gfs2_statfs_sync(sdp
->sd_vfs
, 0);
1550 quotad_error(sdp
, "statfs", error
);
1551 statfs_timeo
= gfs2_tune_get(sdp
, gt_statfs_quantum
) * HZ
;
1554 quotad_check_timeo(sdp
, "statfs", gfs2_statfs_sync
, t
,
1556 &tune
->gt_statfs_quantum
);
1558 /* Update quota file */
1559 quotad_check_timeo(sdp
, "sync", gfs2_quota_sync
, t
,
1560 "ad_timeo
, &tune
->gt_quota_quantum
);
1565 t
= min(quotad_timeo
, statfs_timeo
);
1567 prepare_to_wait(&sdp
->sd_quota_wait
, &wait
, TASK_INTERRUPTIBLE
);
1568 if (!sdp
->sd_statfs_force_sync
)
1569 t
-= schedule_timeout(t
);
1572 finish_wait(&sdp
->sd_quota_wait
, &wait
);
1578 static int gfs2_quota_get_state(struct super_block
*sb
, struct qc_state
*state
)
1580 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
1582 memset(state
, 0, sizeof(*state
));
1584 switch (sdp
->sd_args
.ar_quota
) {
1586 state
->s_state
[USRQUOTA
].flags
|= QCI_LIMITS_ENFORCED
;
1587 state
->s_state
[GRPQUOTA
].flags
|= QCI_LIMITS_ENFORCED
;
1589 case GFS2_QUOTA_ACCOUNT
:
1590 state
->s_state
[USRQUOTA
].flags
|= QCI_ACCT_ENABLED
|
1592 state
->s_state
[GRPQUOTA
].flags
|= QCI_ACCT_ENABLED
|
1595 case GFS2_QUOTA_OFF
:
1598 if (sdp
->sd_quota_inode
) {
1599 state
->s_state
[USRQUOTA
].ino
=
1600 GFS2_I(sdp
->sd_quota_inode
)->i_no_addr
;
1601 state
->s_state
[USRQUOTA
].blocks
= sdp
->sd_quota_inode
->i_blocks
;
1603 state
->s_state
[USRQUOTA
].nextents
= 1; /* unsupported */
1604 state
->s_state
[GRPQUOTA
] = state
->s_state
[USRQUOTA
];
1605 state
->s_incoredqs
= list_lru_count(&gfs2_qd_lru
);
1609 static int gfs2_get_dqblk(struct super_block
*sb
, struct kqid qid
,
1610 struct qc_dqblk
*fdq
)
1612 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
1613 struct gfs2_quota_lvb
*qlvb
;
1614 struct gfs2_quota_data
*qd
;
1615 struct gfs2_holder q_gh
;
1618 memset(fdq
, 0, sizeof(*fdq
));
1620 if (sdp
->sd_args
.ar_quota
== GFS2_QUOTA_OFF
)
1621 return -ESRCH
; /* Crazy XFS error code */
1623 if ((qid
.type
!= USRQUOTA
) &&
1624 (qid
.type
!= GRPQUOTA
))
1627 error
= qd_get(sdp
, qid
, &qd
);
1630 error
= do_glock(qd
, FORCE
, &q_gh
);
1634 qlvb
= (struct gfs2_quota_lvb
*)qd
->qd_gl
->gl_lksb
.sb_lvbptr
;
1635 fdq
->d_spc_hardlimit
= be64_to_cpu(qlvb
->qb_limit
) << sdp
->sd_sb
.sb_bsize_shift
;
1636 fdq
->d_spc_softlimit
= be64_to_cpu(qlvb
->qb_warn
) << sdp
->sd_sb
.sb_bsize_shift
;
1637 fdq
->d_space
= be64_to_cpu(qlvb
->qb_value
) << sdp
->sd_sb
.sb_bsize_shift
;
1639 gfs2_glock_dq_uninit(&q_gh
);
1645 /* GFS2 only supports a subset of the XFS fields */
1646 #define GFS2_FIELDMASK (QC_SPC_SOFT|QC_SPC_HARD|QC_SPACE)
1648 static int gfs2_set_dqblk(struct super_block
*sb
, struct kqid qid
,
1649 struct qc_dqblk
*fdq
)
1651 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
1652 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_quota_inode
);
1653 struct gfs2_quota_data
*qd
;
1654 struct gfs2_holder q_gh
, i_gh
;
1655 unsigned int data_blocks
, ind_blocks
;
1656 unsigned int blocks
= 0;
1661 if (sdp
->sd_args
.ar_quota
== GFS2_QUOTA_OFF
)
1662 return -ESRCH
; /* Crazy XFS error code */
1664 if ((qid
.type
!= USRQUOTA
) &&
1665 (qid
.type
!= GRPQUOTA
))
1668 if (fdq
->d_fieldmask
& ~GFS2_FIELDMASK
)
1671 error
= qd_get(sdp
, qid
, &qd
);
1675 error
= gfs2_qa_get(ip
);
1679 inode_lock(&ip
->i_inode
);
1680 error
= gfs2_glock_nq_init(qd
->qd_gl
, LM_ST_EXCLUSIVE
, 0, &q_gh
);
1683 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, &i_gh
);
1687 /* Check for existing entry, if none then alloc new blocks */
1688 error
= update_qd(sdp
, qd
);
1692 /* If nothing has changed, this is a no-op */
1693 if ((fdq
->d_fieldmask
& QC_SPC_SOFT
) &&
1694 ((fdq
->d_spc_softlimit
>> sdp
->sd_sb
.sb_bsize_shift
) == be64_to_cpu(qd
->qd_qb
.qb_warn
)))
1695 fdq
->d_fieldmask
^= QC_SPC_SOFT
;
1697 if ((fdq
->d_fieldmask
& QC_SPC_HARD
) &&
1698 ((fdq
->d_spc_hardlimit
>> sdp
->sd_sb
.sb_bsize_shift
) == be64_to_cpu(qd
->qd_qb
.qb_limit
)))
1699 fdq
->d_fieldmask
^= QC_SPC_HARD
;
1701 if ((fdq
->d_fieldmask
& QC_SPACE
) &&
1702 ((fdq
->d_space
>> sdp
->sd_sb
.sb_bsize_shift
) == be64_to_cpu(qd
->qd_qb
.qb_value
)))
1703 fdq
->d_fieldmask
^= QC_SPACE
;
1705 if (fdq
->d_fieldmask
== 0)
1708 offset
= qd2offset(qd
);
1709 alloc_required
= gfs2_write_alloc_required(ip
, offset
, sizeof(struct gfs2_quota
));
1710 if (gfs2_is_stuffed(ip
))
1712 if (alloc_required
) {
1713 struct gfs2_alloc_parms ap
= { .aflags
= 0, };
1714 gfs2_write_calc_reserv(ip
, sizeof(struct gfs2_quota
),
1715 &data_blocks
, &ind_blocks
);
1716 blocks
= 1 + data_blocks
+ ind_blocks
;
1718 error
= gfs2_inplace_reserve(ip
, &ap
);
1721 blocks
+= gfs2_rg_blocks(ip
, blocks
);
1724 /* Some quotas span block boundaries and can update two blocks,
1725 adding an extra block to the transaction to handle such quotas */
1726 error
= gfs2_trans_begin(sdp
, blocks
+ RES_DINODE
+ 2, 0);
1731 error
= gfs2_adjust_quota(ip
, offset
, 0, qd
, fdq
);
1733 clear_bit(QDF_QMSG_QUIET
, &qd
->qd_flags
);
1735 gfs2_trans_end(sdp
);
1738 gfs2_inplace_release(ip
);
1740 gfs2_glock_dq_uninit(&i_gh
);
1742 gfs2_glock_dq_uninit(&q_gh
);
1745 inode_unlock(&ip
->i_inode
);
1751 const struct quotactl_ops gfs2_quotactl_ops
= {
1752 .quota_sync
= gfs2_quota_sync
,
1753 .get_state
= gfs2_quota_get_state
,
1754 .get_dqblk
= gfs2_get_dqblk
,
1755 .set_dqblk
= gfs2_set_dqblk
,
1758 void __init
gfs2_quota_hash_init(void)
1762 for(i
= 0; i
< GFS2_QD_HASH_SIZE
; i
++)
1763 INIT_HLIST_BL_HEAD(&qd_hash_table
[i
]);