blob: 7a57c28eb5e708d0346760818533d7b6f8665096 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Definitions for diskquota-operations. When diskquota is configured these
3 * macros expand to the right source-code.
4 *
5 * Author: Marco van Wieringen <mvw@planets.elm.net>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 */
7#ifndef _LINUX_QUOTAOPS_
8#define _LINUX_QUOTAOPS_
9
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/fs.h>
11
Eric Sandeen56246f92010-05-16 09:00:00 -040012#define DQUOT_SPACE_WARN 0x1
13#define DQUOT_SPACE_RESERVE 0x2
Eric Sandeen0e058422010-05-16 10:00:00 -040014#define DQUOT_SPACE_NOFAIL 0x4
Eric Sandeen56246f92010-05-16 09:00:00 -040015
Jan Kara03b06342008-07-25 01:46:52 -070016static inline struct quota_info *sb_dqopt(struct super_block *sb)
17{
18 return &sb->s_dquot;
19}
Jan Kara74abb982008-07-25 01:46:51 -070020
Dmitry Monakhov12755622010-04-08 22:04:20 +040021/* i_mutex must being held */
22static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
23{
24 return (ia->ia_valid & ATTR_SIZE && ia->ia_size != inode->i_size) ||
Eric W. Biederman8e96e3b2012-03-03 21:17:15 -080025 (ia->ia_valid & ATTR_UID && !uid_eq(ia->ia_uid, inode->i_uid)) ||
26 (ia->ia_valid & ATTR_GID && !gid_eq(ia->ia_gid, inode->i_gid));
Dmitry Monakhov12755622010-04-08 22:04:20 +040027}
28
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#if defined(CONFIG_QUOTA)
30
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +020031#define quota_error(sb, fmt, args...) \
32 __quota_error((sb), __func__, fmt , ## args)
33
Joe Perchesb9075fa2011-10-31 17:11:33 -070034extern __printf(3, 4)
Joe Perches055adcb2010-11-23 18:49:54 -080035void __quota_error(struct super_block *sb, const char *func,
36 const char *fmt, ...);
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +020037
Linus Torvalds1da177e2005-04-16 15:20:36 -070038/*
39 * declaration of quota_function calls in kernel.
40 */
Dmitry Monakhovc4690702010-02-09 17:53:36 +010041void inode_add_rsv_space(struct inode *inode, qsize_t number);
42void inode_claim_rsv_space(struct inode *inode, qsize_t number);
43void inode_sub_rsv_space(struct inode *inode, qsize_t number);
Jan Kara1c8924e2013-08-17 09:32:32 -040044void inode_reclaim_rsv_space(struct inode *inode, qsize_t number);
Dmitry Monakhovc4690702010-02-09 17:53:36 +010045
Jan Kara6184fc02015-06-24 18:07:02 +020046int dquot_initialize(struct inode *inode);
Christoph Hellwig9f754752010-03-03 09:05:05 -050047void dquot_drop(struct inode *inode);
Eric W. Biedermanaca645a2012-09-16 03:11:50 -070048struct dquot *dqget(struct super_block *sb, struct kqid qid);
Jan Kara9f985cb2014-04-03 14:46:55 -070049static inline struct dquot *dqgrab(struct dquot *dquot)
50{
51 /* Make sure someone else has active reference to dquot */
52 WARN_ON_ONCE(!atomic_read(&dquot->dq_count));
53 WARN_ON_ONCE(!test_bit(DQ_ACTIVE_B, &dquot->dq_flags));
54 atomic_inc(&dquot->dq_count);
55 return dquot;
56}
Jan Kara3d9ea252008-10-10 16:12:23 +020057void dqput(struct dquot *dquot);
Jan Kara12c77522008-10-20 17:05:00 +020058int dquot_scan_active(struct super_block *sb,
59 int (*fn)(struct dquot *dquot, unsigned long priv),
60 unsigned long priv);
Jan Kara7d9056b2008-11-25 15:31:32 +010061struct dquot *dquot_alloc(struct super_block *sb, int type);
62void dquot_destroy(struct dquot *dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
Eric Sandeen56246f92010-05-16 09:00:00 -040064int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
65void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
Christoph Hellwig5dd40562010-03-03 09:05:00 -050066
Jan Kara6bab3592014-10-20 16:01:33 +020067int dquot_alloc_inode(struct inode *inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
Christoph Hellwig5dd40562010-03-03 09:05:00 -050069int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
Jan Kara6bab3592014-10-20 16:01:33 +020070void dquot_free_inode(struct inode *inode);
Jan Kara1c8924e2013-08-17 09:32:32 -040071void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
Christoph Hellwig0f0dd622010-05-19 07:16:41 -040073int dquot_disable(struct super_block *sb, int type, unsigned int flags);
74/* Suspend quotas on remount RO */
75static inline int dquot_suspend(struct super_block *sb, int type)
76{
77 return dquot_disable(sb, type, DQUOT_SUSPENDED);
78}
79int dquot_resume(struct super_block *sb, int type);
80
Jan Karab85f4b82008-07-25 01:46:50 -070081int dquot_commit(struct dquot *dquot);
82int dquot_acquire(struct dquot *dquot);
83int dquot_release(struct dquot *dquot);
84int dquot_commit_info(struct super_block *sb, int type);
85int dquot_mark_dquot_dirty(struct dquot *dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
Christoph Hellwig907f4552010-03-03 09:05:06 -050087int dquot_file_open(struct inode *inode, struct file *file);
88
Christoph Hellwig287a8092010-05-19 07:16:45 -040089int dquot_enable(struct inode *inode, int type, int format_id,
Jan Karaf55abc02008-08-20 17:50:32 +020090 unsigned int flags);
Jan Karaf00c9e42010-09-15 17:38:58 +020091int dquot_quota_on(struct super_block *sb, int type, int format_id,
Al Viro77e69da2008-08-01 04:29:18 -040092 struct path *path);
Christoph Hellwig287a8092010-05-19 07:16:45 -040093int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
Jan Karab85f4b82008-07-25 01:46:50 -070094 int format_id, int type);
Christoph Hellwig287a8092010-05-19 07:16:45 -040095int dquot_quota_off(struct super_block *sb, int type);
Jan Karaceed1722012-07-03 16:45:28 +020096int dquot_writeback_dquots(struct super_block *sb, int type);
97int dquot_quota_sync(struct super_block *sb, int type);
Jan Kara0a2403392014-11-19 00:42:09 +010098int dquot_get_state(struct super_block *sb, struct qc_state *state);
Jan Kara5eacb2a2014-12-16 12:03:51 +010099int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii);
Eric W. Biederman74a8a102012-09-16 02:07:49 -0700100int dquot_get_dqblk(struct super_block *sb, struct kqid id,
Jan Kara14bf61f2014-10-09 16:03:13 +0200101 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;
Christoph Hellwig287a8092010-05-19 07:16:45 -0400162extern const struct quotactl_ops dquot_quotactl_ops;
Jan Kara3e2af672014-10-06 18:40:51 +0200163extern const struct quotactl_ops dquot_quotactl_sysfile_ops;
Jan Kara0ff5af82008-04-28 02:14:33 -0700164
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165#else
166
Jan Karaf55abc02008-08-20 17:50:32 +0200167static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700168{
169 return 0;
170}
171
Jan Karaf55abc02008-08-20 17:50:32 +0200172static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700173{
174 return 0;
175}
176
177static inline int sb_has_quota_suspended(struct super_block *sb, int type)
178{
179 return 0;
180}
181
182static inline int sb_any_quota_suspended(struct super_block *sb)
183{
184 return 0;
185}
Jan Kara74abb982008-07-25 01:46:51 -0700186
Jan Karaf55abc02008-08-20 17:50:32 +0200187/* Does kernel know about any quota information for given sb + type? */
188static inline int sb_has_quota_loaded(struct super_block *sb, int type)
189{
190 return 0;
191}
192
193static inline int sb_any_quota_loaded(struct super_block *sb)
194{
195 return 0;
196}
197
198static inline int sb_has_quota_active(struct super_block *sb, int type)
199{
200 return 0;
201}
202
Jan Kara6184fc02015-06-24 18:07:02 +0200203static inline int dquot_initialize(struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700204{
Jan Kara6184fc02015-06-24 18:07:02 +0200205 return 0;
Andrew Morton50f8c372008-04-28 02:14:35 -0700206}
207
Christoph Hellwig9f754752010-03-03 09:05:05 -0500208static inline void dquot_drop(struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700209{
210}
211
Jan Kara6bab3592014-10-20 16:01:33 +0200212static inline int dquot_alloc_inode(struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700213{
214 return 0;
215}
216
Jan Kara6bab3592014-10-20 16:01:33 +0200217static inline void dquot_free_inode(struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700218{
219}
220
Christoph Hellwigb43fa822010-03-03 09:05:03 -0500221static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
Andrew Morton50f8c372008-04-28 02:14:35 -0700222{
223 return 0;
224}
225
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500226static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
Eric Sandeen56246f92010-05-16 09:00:00 -0400227 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228{
Eric Sandeen56246f92010-05-16 09:00:00 -0400229 if (!(flags & DQUOT_SPACE_RESERVE))
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500230 inode_add_bytes(inode, number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 return 0;
232}
233
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500234static inline void __dquot_free_space(struct inode *inode, qsize_t number,
Eric Sandeen56246f92010-05-16 09:00:00 -0400235 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236{
Eric Sandeen56246f92010-05-16 09:00:00 -0400237 if (!(flags & DQUOT_SPACE_RESERVE))
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500238 inode_sub_bytes(inode, number);
239}
240
241static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
242{
243 inode_add_bytes(inode, number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 return 0;
245}
246
Jan Kara1c8924e2013-08-17 09:32:32 -0400247static inline int dquot_reclaim_space_nodirty(struct inode *inode,
248 qsize_t number)
249{
250 inode_sub_bytes(inode, number);
251 return 0;
252}
253
Christoph Hellwig0f0dd622010-05-19 07:16:41 -0400254static inline int dquot_disable(struct super_block *sb, int type,
255 unsigned int flags)
256{
257 return 0;
258}
259
260static inline int dquot_suspend(struct super_block *sb, int type)
261{
262 return 0;
263}
264
265static inline int dquot_resume(struct super_block *sb, int type)
266{
267 return 0;
268}
269
Christoph Hellwig871a2932010-03-03 09:05:07 -0500270#define dquot_file_open generic_file_open
271
Jan Karaceed1722012-07-03 16:45:28 +0200272static inline int dquot_writeback_dquots(struct super_block *sb, int type)
273{
274 return 0;
275}
276
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277#endif /* CONFIG_QUOTA */
278
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500279static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700280{
Eric Sandeen56246f92010-05-16 09:00:00 -0400281 return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
Jan Kara03f6e922008-04-28 02:14:32 -0700282}
283
Eric Sandeen0e058422010-05-16 10:00:00 -0400284static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
285{
286 __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
Jan Kara43d29322010-07-21 14:22:21 +0200287 mark_inode_dirty_sync(inode);
Jan Kara03f6e922008-04-28 02:14:32 -0700288}
289
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500290static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700291{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500292 int ret;
293
294 ret = dquot_alloc_space_nodirty(inode, nr);
Shaohua Lid5301482010-08-20 16:49:43 +0800295 if (!ret) {
296 /*
297 * Mark inode fully dirty. Since we are allocating blocks, inode
298 * would become fully dirty soon anyway and it reportedly
Dave Chinner250df6e2011-03-22 22:23:36 +1100299 * reduces lock contention.
Shaohua Lid5301482010-08-20 16:49:43 +0800300 */
301 mark_inode_dirty(inode);
302 }
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500303 return ret;
Jan Kara03f6e922008-04-28 02:14:32 -0700304}
305
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500306static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700307{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500308 return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
Jan Kara03f6e922008-04-28 02:14:32 -0700309}
310
Eric Sandeen0e058422010-05-16 10:00:00 -0400311static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
312{
313 dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
314}
315
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500316static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700317{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500318 return dquot_alloc_space(inode, nr << inode->i_blkbits);
Jan Kara03f6e922008-04-28 02:14:32 -0700319}
320
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500321static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
Mingming Caof18df222009-01-13 16:43:09 +0100322{
Eric Sandeen56246f92010-05-16 09:00:00 -0400323 return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
Mingming Caof18df222009-01-13 16:43:09 +0100324}
325
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500326static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
Mingming Cao740d9dc2009-01-13 16:43:14 +0100327{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500328 int ret;
329
330 ret = dquot_prealloc_block_nodirty(inode, nr);
331 if (!ret)
Jan Kara43d29322010-07-21 14:22:21 +0200332 mark_inode_dirty_sync(inode);
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500333 return ret;
Mingming Cao740d9dc2009-01-13 16:43:14 +0100334}
335
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500336static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
Mingming Cao740d9dc2009-01-13 16:43:14 +0100337{
Eric Sandeen56246f92010-05-16 09:00:00 -0400338 return __dquot_alloc_space(inode, nr << inode->i_blkbits,
339 DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
Mingming Cao740d9dc2009-01-13 16:43:14 +0100340}
341
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500342static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700343{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500344 int ret;
345
346 ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
347 if (!ret)
Jan Kara43d29322010-07-21 14:22:21 +0200348 mark_inode_dirty_sync(inode);
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500349 return ret;
Jan Kara03f6e922008-04-28 02:14:32 -0700350}
351
Jan Kara1c8924e2013-08-17 09:32:32 -0400352static inline void dquot_reclaim_block(struct inode *inode, qsize_t nr)
353{
354 dquot_reclaim_space_nodirty(inode, nr << inode->i_blkbits);
355 mark_inode_dirty_sync(inode);
356}
357
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500358static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700359{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500360 __dquot_free_space(inode, nr, 0);
361}
362
363static inline void dquot_free_space(struct inode *inode, qsize_t nr)
364{
365 dquot_free_space_nodirty(inode, nr);
Jan Kara43d29322010-07-21 14:22:21 +0200366 mark_inode_dirty_sync(inode);
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500367}
368
369static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
370{
371 dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
372}
373
374static inline void dquot_free_block(struct inode *inode, qsize_t nr)
375{
376 dquot_free_space(inode, nr << inode->i_blkbits);
377}
378
379static inline void dquot_release_reservation_block(struct inode *inode,
380 qsize_t nr)
381{
Eric Sandeen56246f92010-05-16 09:00:00 -0400382 __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
Jan Kara03f6e922008-04-28 02:14:32 -0700383}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
Jan Karad3b86322014-10-08 16:07:12 +0200385unsigned int qtype_enforce_flag(int type);
386
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387#endif /* _LINUX_QUOTAOPS_ */