blob: 17b977304a09f8208dad924dc475676bd4a6f5f9 [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);
44
Christoph Hellwig871a2932010-03-03 09:05:07 -050045void dquot_initialize(struct inode *inode);
Christoph Hellwig9f754752010-03-03 09:05:05 -050046void dquot_drop(struct inode *inode);
Jan Kara3d9ea252008-10-10 16:12:23 +020047struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
48void dqput(struct dquot *dquot);
Jan Kara12c77522008-10-20 17:05:00 +020049int dquot_scan_active(struct super_block *sb,
50 int (*fn)(struct dquot *dquot, unsigned long priv),
51 unsigned long priv);
Jan Kara7d9056b2008-11-25 15:31:32 +010052struct dquot *dquot_alloc(struct super_block *sb, int type);
53void dquot_destroy(struct dquot *dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Eric Sandeen56246f92010-05-16 09:00:00 -040055int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
56void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
Christoph Hellwig5dd40562010-03-03 09:05:00 -050057
Christoph Hellwig63936dd2010-03-03 09:05:01 -050058int dquot_alloc_inode(const struct inode *inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
Christoph Hellwig5dd40562010-03-03 09:05:00 -050060int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
Christoph Hellwig63936dd2010-03-03 09:05:01 -050061void dquot_free_inode(const struct inode *inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
Christoph Hellwig0f0dd622010-05-19 07:16:41 -040063int dquot_disable(struct super_block *sb, int type, unsigned int flags);
64/* Suspend quotas on remount RO */
65static inline int dquot_suspend(struct super_block *sb, int type)
66{
67 return dquot_disable(sb, type, DQUOT_SUSPENDED);
68}
69int dquot_resume(struct super_block *sb, int type);
70
Jan Karab85f4b82008-07-25 01:46:50 -070071int dquot_commit(struct dquot *dquot);
72int dquot_acquire(struct dquot *dquot);
73int dquot_release(struct dquot *dquot);
74int dquot_commit_info(struct super_block *sb, int type);
75int dquot_mark_dquot_dirty(struct dquot *dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Christoph Hellwig907f4552010-03-03 09:05:06 -050077int dquot_file_open(struct inode *inode, struct file *file);
78
Christoph Hellwig287a8092010-05-19 07:16:45 -040079int dquot_enable(struct inode *inode, int type, int format_id,
Jan Karaf55abc02008-08-20 17:50:32 +020080 unsigned int flags);
Jan Karaf00c9e42010-09-15 17:38:58 +020081int dquot_quota_on(struct super_block *sb, int type, int format_id,
Al Viro77e69da2008-08-01 04:29:18 -040082 struct path *path);
Christoph Hellwig287a8092010-05-19 07:16:45 -040083int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
Jan Karab85f4b82008-07-25 01:46:50 -070084 int format_id, int type);
Christoph Hellwig287a8092010-05-19 07:16:45 -040085int dquot_quota_off(struct super_block *sb, int type);
86int dquot_quota_sync(struct super_block *sb, int type, int wait);
87int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
88int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
89int dquot_get_dqblk(struct super_block *sb, int type, qid_t id,
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -040090 struct fs_disk_quota *di);
Christoph Hellwig287a8092010-05-19 07:16:45 -040091int dquot_set_dqblk(struct super_block *sb, int type, qid_t id,
Christoph Hellwigc472b432010-05-06 17:05:17 -040092 struct fs_disk_quota *di);
Jan Karab85f4b82008-07-25 01:46:50 -070093
Jan Karabc8e5f02010-05-13 19:58:50 +020094int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
Christoph Hellwigb43fa822010-03-03 09:05:03 -050095int dquot_transfer(struct inode *inode, struct iattr *iattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Jan Kara03b06342008-07-25 01:46:52 -070097static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
98{
99 return sb_dqopt(sb)->info + type;
100}
Jan Kara74abb982008-07-25 01:46:51 -0700101
102/*
103 * Functions for checking status of quota
104 */
105
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300106static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700107{
Jan Karaf55abc02008-08-20 17:50:32 +0200108 return sb_dqopt(sb)->flags &
109 dquot_state_flag(DQUOT_USAGE_ENABLED, type);
Jan Kara03b06342008-07-25 01:46:52 -0700110}
Jan Kara74abb982008-07-25 01:46:51 -0700111
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300112static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700113{
Jan Karaf55abc02008-08-20 17:50:32 +0200114 return sb_dqopt(sb)->flags &
115 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
Jan Kara03b06342008-07-25 01:46:52 -0700116}
Jan Kara74abb982008-07-25 01:46:51 -0700117
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300118static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700119{
Jan Karaf55abc02008-08-20 17:50:32 +0200120 return sb_dqopt(sb)->flags &
121 dquot_state_flag(DQUOT_SUSPENDED, type);
Jan Kara03b06342008-07-25 01:46:52 -0700122}
Jan Kara74abb982008-07-25 01:46:51 -0700123
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300124static inline unsigned sb_any_quota_suspended(struct super_block *sb)
Jan Kara03b06342008-07-25 01:46:52 -0700125{
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300126 unsigned type, tmsk = 0;
127 for (type = 0; type < MAXQUOTAS; type++)
128 tmsk |= sb_has_quota_suspended(sb, type) << type;
129 return tmsk;
Jan Kara03b06342008-07-25 01:46:52 -0700130}
Jan Kara74abb982008-07-25 01:46:51 -0700131
Jan Karaf55abc02008-08-20 17:50:32 +0200132/* Does kernel know about any quota information for given sb + type? */
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300133static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
Jan Karaf55abc02008-08-20 17:50:32 +0200134{
135 /* Currently if anything is on, then quota usage is on as well */
136 return sb_has_quota_usage_enabled(sb, type);
137}
138
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300139static inline unsigned sb_any_quota_loaded(struct super_block *sb)
Jan Karaf55abc02008-08-20 17:50:32 +0200140{
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300141 unsigned type, tmsk = 0;
142 for (type = 0; type < MAXQUOTAS; type++)
143 tmsk |= sb_has_quota_loaded(sb, type) << type;
144 return tmsk;
Jan Karaf55abc02008-08-20 17:50:32 +0200145}
146
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +0300147static inline bool sb_has_quota_active(struct super_block *sb, int type)
Jan Karaf55abc02008-08-20 17:50:32 +0200148{
149 return sb_has_quota_loaded(sb, type) &&
150 !sb_has_quota_suspended(sb, type);
151}
152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153/*
154 * Operations supported for diskquotas.
155 */
Alexey Dobriyan61e225d2009-09-21 17:01:08 -0700156extern const struct dquot_operations dquot_operations;
Christoph Hellwig287a8092010-05-19 07:16:45 -0400157extern const struct quotactl_ops dquot_quotactl_ops;
Jan Kara0ff5af82008-04-28 02:14:33 -0700158
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159#else
160
Jan Karaf55abc02008-08-20 17:50:32 +0200161static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700162{
163 return 0;
164}
165
Jan Karaf55abc02008-08-20 17:50:32 +0200166static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700167{
168 return 0;
169}
170
171static inline int sb_has_quota_suspended(struct super_block *sb, int type)
172{
173 return 0;
174}
175
176static inline int sb_any_quota_suspended(struct super_block *sb)
177{
178 return 0;
179}
Jan Kara74abb982008-07-25 01:46:51 -0700180
Jan Karaf55abc02008-08-20 17:50:32 +0200181/* Does kernel know about any quota information for given sb + type? */
182static inline int sb_has_quota_loaded(struct super_block *sb, int type)
183{
184 return 0;
185}
186
187static inline int sb_any_quota_loaded(struct super_block *sb)
188{
189 return 0;
190}
191
192static inline int sb_has_quota_active(struct super_block *sb, int type)
193{
194 return 0;
195}
196
Christoph Hellwig871a2932010-03-03 09:05:07 -0500197static inline void dquot_initialize(struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700198{
199}
200
Christoph Hellwig9f754752010-03-03 09:05:05 -0500201static inline void dquot_drop(struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700202{
203}
204
Christoph Hellwig63936dd2010-03-03 09:05:01 -0500205static inline int dquot_alloc_inode(const struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700206{
207 return 0;
208}
209
Christoph Hellwig63936dd2010-03-03 09:05:01 -0500210static inline void dquot_free_inode(const struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700211{
212}
213
Christoph Hellwigb43fa822010-03-03 09:05:03 -0500214static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
Andrew Morton50f8c372008-04-28 02:14:35 -0700215{
216 return 0;
217}
218
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500219static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
Eric Sandeen56246f92010-05-16 09:00:00 -0400220 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221{
Eric Sandeen56246f92010-05-16 09:00:00 -0400222 if (!(flags & DQUOT_SPACE_RESERVE))
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500223 inode_add_bytes(inode, number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 return 0;
225}
226
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500227static inline void __dquot_free_space(struct inode *inode, qsize_t number,
Eric Sandeen56246f92010-05-16 09:00:00 -0400228 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229{
Eric Sandeen56246f92010-05-16 09:00:00 -0400230 if (!(flags & DQUOT_SPACE_RESERVE))
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500231 inode_sub_bytes(inode, number);
232}
233
234static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
235{
236 inode_add_bytes(inode, number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 return 0;
238}
239
Christoph Hellwig0f0dd622010-05-19 07:16:41 -0400240static inline int dquot_disable(struct super_block *sb, int type,
241 unsigned int flags)
242{
243 return 0;
244}
245
246static inline int dquot_suspend(struct super_block *sb, int type)
247{
248 return 0;
249}
250
251static inline int dquot_resume(struct super_block *sb, int type)
252{
253 return 0;
254}
255
Christoph Hellwig871a2932010-03-03 09:05:07 -0500256#define dquot_file_open generic_file_open
257
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258#endif /* CONFIG_QUOTA */
259
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500260static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700261{
Eric Sandeen56246f92010-05-16 09:00:00 -0400262 return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
Jan Kara03f6e922008-04-28 02:14:32 -0700263}
264
Eric Sandeen0e058422010-05-16 10:00:00 -0400265static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
266{
267 __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
Jan Kara43d29322010-07-21 14:22:21 +0200268 mark_inode_dirty_sync(inode);
Jan Kara03f6e922008-04-28 02:14:32 -0700269}
270
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500271static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700272{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500273 int ret;
274
275 ret = dquot_alloc_space_nodirty(inode, nr);
Shaohua Lid5301482010-08-20 16:49:43 +0800276 if (!ret) {
277 /*
278 * Mark inode fully dirty. Since we are allocating blocks, inode
279 * would become fully dirty soon anyway and it reportedly
Dave Chinner250df6e2011-03-22 22:23:36 +1100280 * reduces lock contention.
Shaohua Lid5301482010-08-20 16:49:43 +0800281 */
282 mark_inode_dirty(inode);
283 }
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500284 return ret;
Jan Kara03f6e922008-04-28 02:14:32 -0700285}
286
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500287static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700288{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500289 return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
Jan Kara03f6e922008-04-28 02:14:32 -0700290}
291
Eric Sandeen0e058422010-05-16 10:00:00 -0400292static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
293{
294 dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
295}
296
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500297static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700298{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500299 return dquot_alloc_space(inode, nr << inode->i_blkbits);
Jan Kara03f6e922008-04-28 02:14:32 -0700300}
301
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500302static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
Mingming Caof18df222009-01-13 16:43:09 +0100303{
Eric Sandeen56246f92010-05-16 09:00:00 -0400304 return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
Mingming Caof18df222009-01-13 16:43:09 +0100305}
306
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500307static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
Mingming Cao740d9dc2009-01-13 16:43:14 +0100308{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500309 int ret;
310
311 ret = dquot_prealloc_block_nodirty(inode, nr);
312 if (!ret)
Jan Kara43d29322010-07-21 14:22:21 +0200313 mark_inode_dirty_sync(inode);
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500314 return ret;
Mingming Cao740d9dc2009-01-13 16:43:14 +0100315}
316
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500317static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
Mingming Cao740d9dc2009-01-13 16:43:14 +0100318{
Eric Sandeen56246f92010-05-16 09:00:00 -0400319 return __dquot_alloc_space(inode, nr << inode->i_blkbits,
320 DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
Mingming Cao740d9dc2009-01-13 16:43:14 +0100321}
322
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500323static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700324{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500325 int ret;
326
327 ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
328 if (!ret)
Jan Kara43d29322010-07-21 14:22:21 +0200329 mark_inode_dirty_sync(inode);
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500330 return ret;
Jan Kara03f6e922008-04-28 02:14:32 -0700331}
332
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500333static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700334{
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500335 __dquot_free_space(inode, nr, 0);
336}
337
338static inline void dquot_free_space(struct inode *inode, qsize_t nr)
339{
340 dquot_free_space_nodirty(inode, nr);
Jan Kara43d29322010-07-21 14:22:21 +0200341 mark_inode_dirty_sync(inode);
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500342}
343
344static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
345{
346 dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
347}
348
349static inline void dquot_free_block(struct inode *inode, qsize_t nr)
350{
351 dquot_free_space(inode, nr << inode->i_blkbits);
352}
353
354static inline void dquot_release_reservation_block(struct inode *inode,
355 qsize_t nr)
356{
Eric Sandeen56246f92010-05-16 09:00:00 -0400357 __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
Jan Kara03f6e922008-04-28 02:14:32 -0700358}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360#endif /* _LINUX_QUOTAOPS_ */