blob: d1a9193960f17601d4637bfae03f3c9a3ac5bc83 [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) ||
25 (ia->ia_valid & ATTR_UID && ia->ia_uid != inode->i_uid) ||
26 (ia->ia_valid & ATTR_GID && ia->ia_gid != inode->i_gid);
27}
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
34extern void __quota_error(struct super_block *sb, const char *func,
35 const char *fmt, ...);
36
Linus Torvalds1da177e2005-04-16 15:20:36 -070037/*
38 * declaration of quota_function calls in kernel.
39 */
Dmitry Monakhovc4690702010-02-09 17:53:36 +010040void inode_add_rsv_space(struct inode *inode, qsize_t number);
41void inode_claim_rsv_space(struct inode *inode, qsize_t number);
42void inode_sub_rsv_space(struct inode *inode, qsize_t number);
43
Christoph Hellwig871a2932010-03-03 09:05:07 -050044void dquot_initialize(struct inode *inode);
Christoph Hellwig9f754752010-03-03 09:05:05 -050045void dquot_drop(struct inode *inode);
Jan Kara3d9ea252008-10-10 16:12:23 +020046struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
47void dqput(struct dquot *dquot);
Jan Kara12c77522008-10-20 17:05:00 +020048int dquot_scan_active(struct super_block *sb,
49 int (*fn)(struct dquot *dquot, unsigned long priv),
50 unsigned long priv);
Jan Kara7d9056b2008-11-25 15:31:32 +010051struct dquot *dquot_alloc(struct super_block *sb, int type);
52void dquot_destroy(struct dquot *dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Eric Sandeen56246f92010-05-16 09:00:00 -040054int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
55void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
Christoph Hellwig5dd40562010-03-03 09:05:00 -050056
Christoph Hellwig63936dd2010-03-03 09:05:01 -050057int dquot_alloc_inode(const struct inode *inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Christoph Hellwig5dd40562010-03-03 09:05:00 -050059int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
Christoph Hellwig63936dd2010-03-03 09:05:01 -050060void dquot_free_inode(const struct inode *inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
Christoph Hellwig0f0dd622010-05-19 07:16:41 -040062int dquot_disable(struct super_block *sb, int type, unsigned int flags);
63/* Suspend quotas on remount RO */
64static inline int dquot_suspend(struct super_block *sb, int type)
65{
66 return dquot_disable(sb, type, DQUOT_SUSPENDED);
67}
68int dquot_resume(struct super_block *sb, int type);
69
Jan Karab85f4b82008-07-25 01:46:50 -070070int dquot_commit(struct dquot *dquot);
71int dquot_acquire(struct dquot *dquot);
72int dquot_release(struct dquot *dquot);
73int dquot_commit_info(struct super_block *sb, int type);
74int dquot_mark_dquot_dirty(struct dquot *dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
Christoph Hellwig907f4552010-03-03 09:05:06 -050076int dquot_file_open(struct inode *inode, struct file *file);
77
Christoph Hellwig287a8092010-05-19 07:16:45 -040078int dquot_quota_on(struct super_block *sb, int type, int format_id,
Christoph Hellwig307ae182010-05-19 07:16:43 -040079 char *path);
Christoph Hellwig287a8092010-05-19 07:16:45 -040080int dquot_enable(struct inode *inode, int type, int format_id,
Jan Karaf55abc02008-08-20 17:50:32 +020081 unsigned int flags);
Christoph Hellwig287a8092010-05-19 07:16:45 -040082int dquot_quota_on_path(struct super_block *sb, int type, int format_id,
Al Viro77e69da2008-08-01 04:29:18 -040083 struct path *path);
Christoph Hellwig287a8092010-05-19 07:16:45 -040084int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
Jan Karab85f4b82008-07-25 01:46:50 -070085 int format_id, int type);
Christoph Hellwig287a8092010-05-19 07:16:45 -040086int dquot_quota_off(struct super_block *sb, int type);
87int dquot_quota_sync(struct super_block *sb, int type, int wait);
88int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
89int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
90int dquot_get_dqblk(struct super_block *sb, int type, qid_t id,
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -040091 struct fs_disk_quota *di);
Christoph Hellwig287a8092010-05-19 07:16:45 -040092int dquot_set_dqblk(struct super_block *sb, int type, qid_t id,
Christoph Hellwigc472b432010-05-06 17:05:17 -040093 struct fs_disk_quota *di);
Jan Karab85f4b82008-07-25 01:46:50 -070094
Jan Karabc8e5f02010-05-13 19:58:50 +020095int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
Christoph Hellwigb43fa822010-03-03 09:05:03 -050096int dquot_transfer(struct inode *inode, struct iattr *iattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
Jan Kara03b06342008-07-25 01:46:52 -070098static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
99{
100 return sb_dqopt(sb)->info + type;
101}
Jan Kara74abb982008-07-25 01:46:51 -0700102
103/*
104 * Functions for checking status of quota
105 */
106
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300107static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700108{
Jan Karaf55abc02008-08-20 17:50:32 +0200109 return sb_dqopt(sb)->flags &
110 dquot_state_flag(DQUOT_USAGE_ENABLED, type);
Jan Kara03b06342008-07-25 01:46:52 -0700111}
Jan Kara74abb982008-07-25 01:46:51 -0700112
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300113static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700114{
Jan Karaf55abc02008-08-20 17:50:32 +0200115 return sb_dqopt(sb)->flags &
116 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
Jan Kara03b06342008-07-25 01:46:52 -0700117}
Jan Kara74abb982008-07-25 01:46:51 -0700118
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300119static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700120{
Jan Karaf55abc02008-08-20 17:50:32 +0200121 return sb_dqopt(sb)->flags &
122 dquot_state_flag(DQUOT_SUSPENDED, type);
Jan Kara03b06342008-07-25 01:46:52 -0700123}
Jan Kara74abb982008-07-25 01:46:51 -0700124
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300125static inline unsigned sb_any_quota_suspended(struct super_block *sb)
Jan Kara03b06342008-07-25 01:46:52 -0700126{
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300127 unsigned type, tmsk = 0;
128 for (type = 0; type < MAXQUOTAS; type++)
129 tmsk |= sb_has_quota_suspended(sb, type) << type;
130 return tmsk;
Jan Kara03b06342008-07-25 01:46:52 -0700131}
Jan Kara74abb982008-07-25 01:46:51 -0700132
Jan Karaf55abc02008-08-20 17:50:32 +0200133/* Does kernel know about any quota information for given sb + type? */
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300134static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
Jan Karaf55abc02008-08-20 17:50:32 +0200135{
136 /* Currently if anything is on, then quota usage is on as well */
137 return sb_has_quota_usage_enabled(sb, type);
138}
139
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300140static inline unsigned sb_any_quota_loaded(struct super_block *sb)
Jan Karaf55abc02008-08-20 17:50:32 +0200141{
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300142 unsigned type, tmsk = 0;
143 for (type = 0; type < MAXQUOTAS; type++)
144 tmsk |= sb_has_quota_loaded(sb, type) << type;
145 return tmsk;
Jan Karaf55abc02008-08-20 17:50:32 +0200146}
147
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300148static inline bool sb_has_quota_active(struct super_block *sb, int type)
Jan Karaf55abc02008-08-20 17:50:32 +0200149{
150 return sb_has_quota_loaded(sb, type) &&
151 !sb_has_quota_suspended(sb, type);
152}
153
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154/*
155 * Operations supported for diskquotas.
156 */
Alexey Dobriyan61e225d2009-09-21 17:01:08 -0700157extern const struct dquot_operations dquot_operations;
Christoph Hellwig287a8092010-05-19 07:16:45 -0400158extern const struct quotactl_ops dquot_quotactl_ops;
Jan Kara0ff5af82008-04-28 02:14:33 -0700159
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160#else
161
Jan Karaf55abc02008-08-20 17:50:32 +0200162static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700163{
164 return 0;
165}
166
Jan Karaf55abc02008-08-20 17:50:32 +0200167static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700168{
169 return 0;
170}
171
172static inline int sb_has_quota_suspended(struct super_block *sb, int type)
173{
174 return 0;
175}
176
177static inline int sb_any_quota_suspended(struct super_block *sb)
178{
179 return 0;
180}
Jan Kara74abb982008-07-25 01:46:51 -0700181
Jan Karaf55abc02008-08-20 17:50:32 +0200182/* Does kernel know about any quota information for given sb + type? */
183static inline int sb_has_quota_loaded(struct super_block *sb, int type)
184{
185 return 0;
186}
187
188static inline int sb_any_quota_loaded(struct super_block *sb)
189{
190 return 0;
191}
192
193static inline int sb_has_quota_active(struct super_block *sb, int type)
194{
195 return 0;
196}
197
Christoph Hellwig871a2932010-03-03 09:05:07 -0500198static inline void dquot_initialize(struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700199{
200}
201
Christoph Hellwig9f754752010-03-03 09:05:05 -0500202static inline void dquot_drop(struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700203{
204}
205
Christoph Hellwig63936dd2010-03-03 09:05:01 -0500206static inline int dquot_alloc_inode(const struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700207{
208 return 0;
209}
210
Christoph Hellwig63936dd2010-03-03 09:05:01 -0500211static inline void dquot_free_inode(const struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700212{
213}
214
Christoph Hellwigb43fa822010-03-03 09:05:03 -0500215static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
Andrew Morton50f8c372008-04-28 02:14:35 -0700216{
217 return 0;
218}
219
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500220static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
Eric Sandeen56246f92010-05-16 09:00:00 -0400221 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222{
Eric Sandeen56246f92010-05-16 09:00:00 -0400223 if (!(flags & DQUOT_SPACE_RESERVE))
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500224 inode_add_bytes(inode, number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 return 0;
226}
227
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500228static inline void __dquot_free_space(struct inode *inode, qsize_t number,
Eric Sandeen56246f92010-05-16 09:00:00 -0400229 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230{
Eric Sandeen56246f92010-05-16 09:00:00 -0400231 if (!(flags & DQUOT_SPACE_RESERVE))
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500232 inode_sub_bytes(inode, number);
233}
234
235static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
236{
237 inode_add_bytes(inode, number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 return 0;
239}
240
Christoph Hellwig0f0dd622010-05-19 07:16:41 -0400241static inline int dquot_disable(struct super_block *sb, int type,
242 unsigned int flags)
243{
244 return 0;
245}
246
247static inline int dquot_suspend(struct super_block *sb, int type)
248{
249 return 0;
250}
251
252static inline int dquot_resume(struct super_block *sb, int type)
253{
254 return 0;
255}
256
Christoph Hellwig871a2932010-03-03 09:05:07 -0500257#define dquot_file_open generic_file_open
258
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259#endif /* CONFIG_QUOTA */
260
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500261static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700262{
Eric Sandeen56246f92010-05-16 09:00:00 -0400263 return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
Jan Kara03f6e922008-04-28 02:14:32 -0700264}
265
Eric Sandeen0e058422010-05-16 10:00:00 -0400266static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
267{
268 __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
Jan Kara43d29322010-07-21 14:22:21 +0200269 mark_inode_dirty_sync(inode);
Jan Kara03f6e922008-04-28 02:14:32 -0700270}
271
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500272static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700273{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500274 int ret;
275
276 ret = dquot_alloc_space_nodirty(inode, nr);
Shaohua Lid5301482010-08-20 16:49:43 +0800277 if (!ret) {
278 /*
279 * Mark inode fully dirty. Since we are allocating blocks, inode
280 * would become fully dirty soon anyway and it reportedly
281 * reduces inode_lock contention.
282 */
283 mark_inode_dirty(inode);
284 }
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500285 return ret;
Jan Kara03f6e922008-04-28 02:14:32 -0700286}
287
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500288static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700289{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500290 return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
Jan Kara03f6e922008-04-28 02:14:32 -0700291}
292
Eric Sandeen0e058422010-05-16 10:00:00 -0400293static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
294{
295 dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
296}
297
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500298static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700299{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500300 return dquot_alloc_space(inode, nr << inode->i_blkbits);
Jan Kara03f6e922008-04-28 02:14:32 -0700301}
302
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500303static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
Mingming Caof18df222009-01-13 16:43:09 +0100304{
Eric Sandeen56246f92010-05-16 09:00:00 -0400305 return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
Mingming Caof18df222009-01-13 16:43:09 +0100306}
307
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500308static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
Mingming Cao740d9dc2009-01-13 16:43:14 +0100309{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500310 int ret;
311
312 ret = dquot_prealloc_block_nodirty(inode, nr);
313 if (!ret)
Jan Kara43d29322010-07-21 14:22:21 +0200314 mark_inode_dirty_sync(inode);
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500315 return ret;
Mingming Cao740d9dc2009-01-13 16:43:14 +0100316}
317
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500318static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
Mingming Cao740d9dc2009-01-13 16:43:14 +0100319{
Eric Sandeen56246f92010-05-16 09:00:00 -0400320 return __dquot_alloc_space(inode, nr << inode->i_blkbits,
321 DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
Mingming Cao740d9dc2009-01-13 16:43:14 +0100322}
323
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500324static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700325{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500326 int ret;
327
328 ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
329 if (!ret)
Jan Kara43d29322010-07-21 14:22:21 +0200330 mark_inode_dirty_sync(inode);
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500331 return ret;
Jan Kara03f6e922008-04-28 02:14:32 -0700332}
333
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500334static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700335{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500336 __dquot_free_space(inode, nr, 0);
337}
338
339static inline void dquot_free_space(struct inode *inode, qsize_t nr)
340{
341 dquot_free_space_nodirty(inode, nr);
Jan Kara43d29322010-07-21 14:22:21 +0200342 mark_inode_dirty_sync(inode);
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500343}
344
345static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
346{
347 dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
348}
349
350static inline void dquot_free_block(struct inode *inode, qsize_t nr)
351{
352 dquot_free_space(inode, nr << inode->i_blkbits);
353}
354
355static inline void dquot_release_reservation_block(struct inode *inode,
356 qsize_t nr)
357{
Eric Sandeen56246f92010-05-16 09:00:00 -0400358 __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
Jan Kara03f6e922008-04-28 02:14:32 -0700359}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361#endif /* _LINUX_QUOTAOPS_ */