blob: 2fb6fb11132efb1a967796cfed3e633c73ccd587 [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001/* SPDX-License-Identifier: GPL-2.0 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
3 * Definitions for diskquota-operations. When diskquota is configured these
4 * macros expand to the right source-code.
5 *
6 * Author: Marco van Wieringen <mvw@planets.elm.net>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 */
8#ifndef _LINUX_QUOTAOPS_
9#define _LINUX_QUOTAOPS_
10
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/fs.h>
12
Eric Sandeen56246f92010-05-16 09:00:00 -040013#define DQUOT_SPACE_WARN 0x1
14#define DQUOT_SPACE_RESERVE 0x2
Eric Sandeen0e058422010-05-16 10:00:00 -040015#define DQUOT_SPACE_NOFAIL 0x4
Eric Sandeen56246f92010-05-16 09:00:00 -040016
Jan Kara03b06342008-07-25 01:46:52 -070017static inline struct quota_info *sb_dqopt(struct super_block *sb)
18{
19 return &sb->s_dquot;
20}
Jan Kara74abb982008-07-25 01:46:51 -070021
Dmitry Monakhov12755622010-04-08 22:04:20 +040022/* i_mutex must being held */
23static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
24{
25 return (ia->ia_valid & ATTR_SIZE && ia->ia_size != inode->i_size) ||
Eric W. Biederman8e96e3b2012-03-03 21:17:15 -080026 (ia->ia_valid & ATTR_UID && !uid_eq(ia->ia_uid, inode->i_uid)) ||
27 (ia->ia_valid & ATTR_GID && !gid_eq(ia->ia_gid, inode->i_gid));
Dmitry Monakhov12755622010-04-08 22:04:20 +040028}
29
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#if defined(CONFIG_QUOTA)
31
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +020032#define quota_error(sb, fmt, args...) \
33 __quota_error((sb), __func__, fmt , ## args)
34
Joe Perchesb9075fa2011-10-31 17:11:33 -070035extern __printf(3, 4)
Joe Perches055adcb2010-11-23 18:49:54 -080036void __quota_error(struct super_block *sb, const char *func,
37 const char *fmt, ...);
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +020038
Linus Torvalds1da177e2005-04-16 15:20:36 -070039/*
40 * declaration of quota_function calls in kernel.
41 */
Jan Kara6184fc02015-06-24 18:07:02 +020042int dquot_initialize(struct inode *inode);
Tahsin Erdoganb8cb5a52017-05-24 18:24:07 -040043bool dquot_initialize_needed(struct inode *inode);
Christoph Hellwig9f754752010-03-03 09:05:05 -050044void dquot_drop(struct inode *inode);
Eric W. Biedermanaca645a2012-09-16 03:11:50 -070045struct dquot *dqget(struct super_block *sb, struct kqid qid);
Jan Kara9f985cb2014-04-03 14:46:55 -070046static inline struct dquot *dqgrab(struct dquot *dquot)
47{
48 /* Make sure someone else has active reference to dquot */
49 WARN_ON_ONCE(!atomic_read(&dquot->dq_count));
50 WARN_ON_ONCE(!test_bit(DQ_ACTIVE_B, &dquot->dq_flags));
51 atomic_inc(&dquot->dq_count);
52 return dquot;
53}
Jan Kara3d9ea252008-10-10 16:12:23 +020054void dqput(struct dquot *dquot);
Jan Kara12c77522008-10-20 17:05:00 +020055int dquot_scan_active(struct super_block *sb,
56 int (*fn)(struct dquot *dquot, unsigned long priv),
57 unsigned long priv);
Jan Kara7d9056b2008-11-25 15:31:32 +010058struct dquot *dquot_alloc(struct super_block *sb, int type);
59void dquot_destroy(struct dquot *dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Eric Sandeen56246f92010-05-16 09:00:00 -040061int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
62void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
Christoph Hellwig5dd40562010-03-03 09:05:00 -050063
Jan Kara6bab3592014-10-20 16:01:33 +020064int dquot_alloc_inode(struct inode *inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Christoph Hellwig5dd40562010-03-03 09:05:00 -050066int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
Jan Kara6bab3592014-10-20 16:01:33 +020067void dquot_free_inode(struct inode *inode);
Jan Kara1c8924e2013-08-17 09:32:32 -040068void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
Christoph Hellwig0f0dd622010-05-19 07:16:41 -040070int dquot_disable(struct super_block *sb, int type, unsigned int flags);
71/* Suspend quotas on remount RO */
72static inline int dquot_suspend(struct super_block *sb, int type)
73{
74 return dquot_disable(sb, type, DQUOT_SUSPENDED);
75}
76int dquot_resume(struct super_block *sb, int type);
77
Jan Karab85f4b82008-07-25 01:46:50 -070078int dquot_commit(struct dquot *dquot);
79int dquot_acquire(struct dquot *dquot);
80int dquot_release(struct dquot *dquot);
81int dquot_commit_info(struct super_block *sb, int type);
Jan Karabe6257b2016-01-25 19:24:50 +010082int dquot_get_next_id(struct super_block *sb, struct kqid *qid);
Jan Karab85f4b82008-07-25 01:46:50 -070083int dquot_mark_dquot_dirty(struct dquot *dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
Christoph Hellwig907f4552010-03-03 09:05:06 -050085int dquot_file_open(struct inode *inode, struct file *file);
86
Christoph Hellwig287a8092010-05-19 07:16:45 -040087int dquot_enable(struct inode *inode, int type, int format_id,
Jan Karaf55abc02008-08-20 17:50:32 +020088 unsigned int flags);
Jan Karaf00c9e42010-09-15 17:38:58 +020089int dquot_quota_on(struct super_block *sb, int type, int format_id,
Al Viro8c54ca92016-11-20 19:49:34 -050090 const struct path *path);
Christoph Hellwig287a8092010-05-19 07:16:45 -040091int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
Jan Karab85f4b82008-07-25 01:46:50 -070092 int format_id, int type);
Christoph Hellwig287a8092010-05-19 07:16:45 -040093int dquot_quota_off(struct super_block *sb, int type);
Jan Karaceed1722012-07-03 16:45:28 +020094int dquot_writeback_dquots(struct super_block *sb, int type);
95int dquot_quota_sync(struct super_block *sb, int type);
Jan Kara0a2403392014-11-19 00:42:09 +010096int dquot_get_state(struct super_block *sb, struct qc_state *state);
Jan Kara5eacb2a2014-12-16 12:03:51 +010097int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii);
Eric W. Biederman74a8a102012-09-16 02:07:49 -070098int dquot_get_dqblk(struct super_block *sb, struct kqid id,
Jan Kara14bf61f2014-10-09 16:03:13 +020099 struct qc_dqblk *di);
Jan Karabe6257b2016-01-25 19:24:50 +0100100int dquot_get_next_dqblk(struct super_block *sb, struct kqid *id,
101 struct qc_dqblk *di);
Eric W. Biederman74a8a102012-09-16 02:07:49 -0700102int dquot_set_dqblk(struct super_block *sb, struct kqid id,
Jan Kara14bf61f2014-10-09 16:03:13 +0200103 struct qc_dqblk *di);
Jan Karab85f4b82008-07-25 01:46:50 -0700104
Jan Karabc8e5f02010-05-13 19:58:50 +0200105int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
Christoph Hellwigb43fa822010-03-03 09:05:03 -0500106int dquot_transfer(struct inode *inode, struct iattr *iattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
Jan Kara03b06342008-07-25 01:46:52 -0700108static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
109{
110 return sb_dqopt(sb)->info + type;
111}
Jan Kara74abb982008-07-25 01:46:51 -0700112
113/*
114 * Functions for checking status of quota
115 */
116
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300117static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700118{
Jan Karaf55abc02008-08-20 17:50:32 +0200119 return sb_dqopt(sb)->flags &
120 dquot_state_flag(DQUOT_USAGE_ENABLED, type);
Jan Kara03b06342008-07-25 01:46:52 -0700121}
Jan Kara74abb982008-07-25 01:46:51 -0700122
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300123static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700124{
Jan Karaf55abc02008-08-20 17:50:32 +0200125 return sb_dqopt(sb)->flags &
126 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
Jan Kara03b06342008-07-25 01:46:52 -0700127}
Jan Kara74abb982008-07-25 01:46:51 -0700128
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300129static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700130{
Jan Karaf55abc02008-08-20 17:50:32 +0200131 return sb_dqopt(sb)->flags &
132 dquot_state_flag(DQUOT_SUSPENDED, type);
Jan Kara03b06342008-07-25 01:46:52 -0700133}
Jan Kara74abb982008-07-25 01:46:51 -0700134
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300135static inline unsigned sb_any_quota_suspended(struct super_block *sb)
Jan Kara03b06342008-07-25 01:46:52 -0700136{
Konstantin Khlebnikov78197022015-02-12 19:08:16 +0300137 return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_SUSPENDED);
Jan Kara03b06342008-07-25 01:46:52 -0700138}
Jan Kara74abb982008-07-25 01:46:51 -0700139
Jan Karaf55abc02008-08-20 17:50:32 +0200140/* Does kernel know about any quota information for given sb + type? */
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300141static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
Jan Karaf55abc02008-08-20 17:50:32 +0200142{
143 /* Currently if anything is on, then quota usage is on as well */
144 return sb_has_quota_usage_enabled(sb, type);
145}
146
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300147static inline unsigned sb_any_quota_loaded(struct super_block *sb)
Jan Karaf55abc02008-08-20 17:50:32 +0200148{
Konstantin Khlebnikov78197022015-02-12 19:08:16 +0300149 return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_USAGE_ENABLED);
Jan Karaf55abc02008-08-20 17:50:32 +0200150}
151
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300152static inline bool sb_has_quota_active(struct super_block *sb, int type)
Jan Karaf55abc02008-08-20 17:50:32 +0200153{
154 return sb_has_quota_loaded(sb, type) &&
155 !sb_has_quota_suspended(sb, type);
156}
157
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158/*
159 * Operations supported for diskquotas.
160 */
Alexey Dobriyan61e225d2009-09-21 17:01:08 -0700161extern const struct dquot_operations dquot_operations;
Jan Kara3e2af672014-10-06 18:40:51 +0200162extern const struct quotactl_ops dquot_quotactl_sysfile_ops;
Jan Kara0ff5af82008-04-28 02:14:33 -0700163
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164#else
165
Jan Karaf55abc02008-08-20 17:50:32 +0200166static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700167{
168 return 0;
169}
170
Jan Karaf55abc02008-08-20 17:50:32 +0200171static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700172{
173 return 0;
174}
175
176static inline int sb_has_quota_suspended(struct super_block *sb, int type)
177{
178 return 0;
179}
180
181static inline int sb_any_quota_suspended(struct super_block *sb)
182{
183 return 0;
184}
Jan Kara74abb982008-07-25 01:46:51 -0700185
Jan Karaf55abc02008-08-20 17:50:32 +0200186/* Does kernel know about any quota information for given sb + type? */
187static inline int sb_has_quota_loaded(struct super_block *sb, int type)
188{
189 return 0;
190}
191
192static inline int sb_any_quota_loaded(struct super_block *sb)
193{
194 return 0;
195}
196
197static inline int sb_has_quota_active(struct super_block *sb, int type)
198{
199 return 0;
200}
201
Jan Kara6184fc02015-06-24 18:07:02 +0200202static inline int dquot_initialize(struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700203{
Jan Kara6184fc02015-06-24 18:07:02 +0200204 return 0;
Andrew Morton50f8c372008-04-28 02:14:35 -0700205}
206
Tahsin Erdoganb8cb5a52017-05-24 18:24:07 -0400207static inline bool dquot_initialize_needed(struct inode *inode)
208{
209 return false;
210}
211
Christoph Hellwig9f754752010-03-03 09:05:05 -0500212static inline void dquot_drop(struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700213{
214}
215
Jan Kara6bab3592014-10-20 16:01:33 +0200216static inline int dquot_alloc_inode(struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700217{
218 return 0;
219}
220
Jan Kara6bab3592014-10-20 16:01:33 +0200221static inline void dquot_free_inode(struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700222{
223}
224
Christoph Hellwigb43fa822010-03-03 09:05:03 -0500225static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
Andrew Morton50f8c372008-04-28 02:14:35 -0700226{
227 return 0;
228}
229
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500230static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
Eric Sandeen56246f92010-05-16 09:00:00 -0400231 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232{
Eric Sandeen56246f92010-05-16 09:00:00 -0400233 if (!(flags & DQUOT_SPACE_RESERVE))
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500234 inode_add_bytes(inode, number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 return 0;
236}
237
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500238static inline void __dquot_free_space(struct inode *inode, qsize_t number,
Eric Sandeen56246f92010-05-16 09:00:00 -0400239 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240{
Eric Sandeen56246f92010-05-16 09:00:00 -0400241 if (!(flags & DQUOT_SPACE_RESERVE))
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500242 inode_sub_bytes(inode, number);
243}
244
245static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
246{
247 inode_add_bytes(inode, number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 return 0;
249}
250
Jan Kara1c8924e2013-08-17 09:32:32 -0400251static inline int dquot_reclaim_space_nodirty(struct inode *inode,
252 qsize_t number)
253{
254 inode_sub_bytes(inode, number);
255 return 0;
256}
257
Christoph Hellwig0f0dd622010-05-19 07:16:41 -0400258static inline int dquot_disable(struct super_block *sb, int type,
259 unsigned int flags)
260{
261 return 0;
262}
263
264static inline int dquot_suspend(struct super_block *sb, int type)
265{
266 return 0;
267}
268
269static inline int dquot_resume(struct super_block *sb, int type)
270{
271 return 0;
272}
273
Christoph Hellwig871a2932010-03-03 09:05:07 -0500274#define dquot_file_open generic_file_open
275
Jan Karaceed1722012-07-03 16:45:28 +0200276static inline int dquot_writeback_dquots(struct super_block *sb, int type)
277{
278 return 0;
279}
280
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281#endif /* CONFIG_QUOTA */
282
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500283static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700284{
Eric Sandeen56246f92010-05-16 09:00:00 -0400285 return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
Jan Kara03f6e922008-04-28 02:14:32 -0700286}
287
Eric Sandeen0e058422010-05-16 10:00:00 -0400288static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
289{
290 __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
Jan Kara43d29322010-07-21 14:22:21 +0200291 mark_inode_dirty_sync(inode);
Jan Kara03f6e922008-04-28 02:14:32 -0700292}
293
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500294static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700295{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500296 int ret;
297
298 ret = dquot_alloc_space_nodirty(inode, nr);
Shaohua Lid5301482010-08-20 16:49:43 +0800299 if (!ret) {
300 /*
301 * Mark inode fully dirty. Since we are allocating blocks, inode
302 * would become fully dirty soon anyway and it reportedly
Dave Chinner250df6e2011-03-22 22:23:36 +1100303 * reduces lock contention.
Shaohua Lid5301482010-08-20 16:49:43 +0800304 */
305 mark_inode_dirty(inode);
306 }
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500307 return ret;
Jan Kara03f6e922008-04-28 02:14:32 -0700308}
309
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500310static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700311{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500312 return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
Jan Kara03f6e922008-04-28 02:14:32 -0700313}
314
Eric Sandeen0e058422010-05-16 10:00:00 -0400315static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
316{
317 dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
318}
319
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500320static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700321{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500322 return dquot_alloc_space(inode, nr << inode->i_blkbits);
Jan Kara03f6e922008-04-28 02:14:32 -0700323}
324
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500325static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
Mingming Caof18df222009-01-13 16:43:09 +0100326{
Eric Sandeen56246f92010-05-16 09:00:00 -0400327 return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
Mingming Caof18df222009-01-13 16:43:09 +0100328}
329
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500330static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
Mingming Cao740d9dc2009-01-13 16:43:14 +0100331{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500332 int ret;
333
334 ret = dquot_prealloc_block_nodirty(inode, nr);
335 if (!ret)
Jan Kara43d29322010-07-21 14:22:21 +0200336 mark_inode_dirty_sync(inode);
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500337 return ret;
Mingming Cao740d9dc2009-01-13 16:43:14 +0100338}
339
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500340static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
Mingming Cao740d9dc2009-01-13 16:43:14 +0100341{
Eric Sandeen56246f92010-05-16 09:00:00 -0400342 return __dquot_alloc_space(inode, nr << inode->i_blkbits,
343 DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
Mingming Cao740d9dc2009-01-13 16:43:14 +0100344}
345
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500346static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700347{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500348 int ret;
349
350 ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
351 if (!ret)
Jan Kara43d29322010-07-21 14:22:21 +0200352 mark_inode_dirty_sync(inode);
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500353 return ret;
Jan Kara03f6e922008-04-28 02:14:32 -0700354}
355
Jan Kara1c8924e2013-08-17 09:32:32 -0400356static inline void dquot_reclaim_block(struct inode *inode, qsize_t nr)
357{
358 dquot_reclaim_space_nodirty(inode, nr << inode->i_blkbits);
359 mark_inode_dirty_sync(inode);
360}
361
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500362static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700363{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500364 __dquot_free_space(inode, nr, 0);
365}
366
367static inline void dquot_free_space(struct inode *inode, qsize_t nr)
368{
369 dquot_free_space_nodirty(inode, nr);
Jan Kara43d29322010-07-21 14:22:21 +0200370 mark_inode_dirty_sync(inode);
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500371}
372
373static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
374{
375 dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
376}
377
378static inline void dquot_free_block(struct inode *inode, qsize_t nr)
379{
380 dquot_free_space(inode, nr << inode->i_blkbits);
381}
382
383static inline void dquot_release_reservation_block(struct inode *inode,
384 qsize_t nr)
385{
Eric Sandeen56246f92010-05-16 09:00:00 -0400386 __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
Jan Kara03f6e922008-04-28 02:14:32 -0700387}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
Jan Karad3b86322014-10-08 16:07:12 +0200389unsigned int qtype_enforce_flag(int type);
390
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391#endif /* _LINUX_QUOTAOPS_ */