This source file includes following definitions.
- sb_dqopt
- is_quota_modification
- __printf
- dquot_is_busy
- dquot_suspend
- sb_dqinfo
- sb_has_quota_usage_enabled
- sb_has_quota_limits_enabled
- sb_has_quota_suspended
- sb_any_quota_suspended
- sb_has_quota_loaded
- sb_any_quota_loaded
- sb_has_quota_active
- sb_has_quota_usage_enabled
- sb_has_quota_limits_enabled
- sb_has_quota_suspended
- sb_any_quota_suspended
- sb_has_quota_loaded
- sb_any_quota_loaded
- sb_has_quota_active
- dquot_initialize
- dquot_initialize_needed
- dquot_drop
- dquot_alloc_inode
- dquot_free_inode
- dquot_transfer
- __dquot_alloc_space
- __dquot_free_space
- dquot_claim_space_nodirty
- dquot_reclaim_space_nodirty
- dquot_disable
- dquot_suspend
- dquot_resume
- dquot_writeback_dquots
- dquot_alloc_space_nodirty
- dquot_alloc_space_nofail
- dquot_alloc_space
- dquot_alloc_block_nodirty
- dquot_alloc_block_nofail
- dquot_alloc_block
- dquot_prealloc_block_nodirty
- dquot_prealloc_block
- dquot_reserve_block
- dquot_claim_block
- dquot_reclaim_block
- dquot_free_space_nodirty
- dquot_free_space
- dquot_free_block_nodirty
- dquot_free_block
- dquot_release_reservation_block
1
2
3
4
5
6
7
8 #ifndef _LINUX_QUOTAOPS_
9 #define _LINUX_QUOTAOPS_
10
11 #include <linux/fs.h>
12
13 #define DQUOT_SPACE_WARN 0x1
14 #define DQUOT_SPACE_RESERVE 0x2
15 #define DQUOT_SPACE_NOFAIL 0x4
16
17 static inline struct quota_info *sb_dqopt(struct super_block *sb)
18 {
19 return &sb->s_dquot;
20 }
21
22
23 static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
24 {
25 return (ia->ia_valid & ATTR_SIZE) ||
26 (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));
28 }
29
30 int kernel_quotactl(unsigned int cmd, const char __user *special,
31 qid_t id, void __user *addr);
32
33 #if defined(CONFIG_QUOTA)
34
35 #define quota_error(sb, fmt, args...) \
36 __quota_error((sb), __func__, fmt , ## args)
37
38 extern __printf(3, 4)
39 void __quota_error(struct super_block *sb, const char *func,
40 const char *fmt, ...);
41
42
43
44
45 int dquot_initialize(struct inode *inode);
46 bool dquot_initialize_needed(struct inode *inode);
47 void dquot_drop(struct inode *inode);
48 struct dquot *dqget(struct super_block *sb, struct kqid qid);
49 static inline struct dquot *dqgrab(struct dquot *dquot)
50 {
51
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 }
57
58 static inline bool dquot_is_busy(struct dquot *dquot)
59 {
60 if (test_bit(DQ_MOD_B, &dquot->dq_flags))
61 return true;
62 if (atomic_read(&dquot->dq_count) > 1)
63 return true;
64 return false;
65 }
66
67 void dqput(struct dquot *dquot);
68 int dquot_scan_active(struct super_block *sb,
69 int (*fn)(struct dquot *dquot, unsigned long priv),
70 unsigned long priv);
71 struct dquot *dquot_alloc(struct super_block *sb, int type);
72 void dquot_destroy(struct dquot *dquot);
73
74 int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
75 void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
76
77 int dquot_alloc_inode(struct inode *inode);
78
79 int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
80 void dquot_free_inode(struct inode *inode);
81 void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number);
82
83 int dquot_disable(struct super_block *sb, int type, unsigned int flags);
84
85 static inline int dquot_suspend(struct super_block *sb, int type)
86 {
87 return dquot_disable(sb, type, DQUOT_SUSPENDED);
88 }
89 int dquot_resume(struct super_block *sb, int type);
90
91 int dquot_commit(struct dquot *dquot);
92 int dquot_acquire(struct dquot *dquot);
93 int dquot_release(struct dquot *dquot);
94 int dquot_commit_info(struct super_block *sb, int type);
95 int dquot_get_next_id(struct super_block *sb, struct kqid *qid);
96 int dquot_mark_dquot_dirty(struct dquot *dquot);
97
98 int dquot_file_open(struct inode *inode, struct file *file);
99
100 int dquot_enable(struct inode *inode, int type, int format_id,
101 unsigned int flags);
102 int dquot_quota_on(struct super_block *sb, int type, int format_id,
103 const struct path *path);
104 int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
105 int format_id, int type);
106 int dquot_quota_off(struct super_block *sb, int type);
107 int dquot_writeback_dquots(struct super_block *sb, int type);
108 int dquot_quota_sync(struct super_block *sb, int type);
109 int dquot_get_state(struct super_block *sb, struct qc_state *state);
110 int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii);
111 int dquot_get_dqblk(struct super_block *sb, struct kqid id,
112 struct qc_dqblk *di);
113 int dquot_get_next_dqblk(struct super_block *sb, struct kqid *id,
114 struct qc_dqblk *di);
115 int dquot_set_dqblk(struct super_block *sb, struct kqid id,
116 struct qc_dqblk *di);
117
118 int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
119 int dquot_transfer(struct inode *inode, struct iattr *iattr);
120
121 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
122 {
123 return sb_dqopt(sb)->info + type;
124 }
125
126
127
128
129
130 static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
131 {
132 return sb_dqopt(sb)->flags &
133 dquot_state_flag(DQUOT_USAGE_ENABLED, type);
134 }
135
136 static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
137 {
138 return sb_dqopt(sb)->flags &
139 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
140 }
141
142 static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
143 {
144 return sb_dqopt(sb)->flags &
145 dquot_state_flag(DQUOT_SUSPENDED, type);
146 }
147
148 static inline unsigned sb_any_quota_suspended(struct super_block *sb)
149 {
150 return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_SUSPENDED);
151 }
152
153
154 static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
155 {
156
157 return sb_has_quota_usage_enabled(sb, type);
158 }
159
160 static inline unsigned sb_any_quota_loaded(struct super_block *sb)
161 {
162 return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_USAGE_ENABLED);
163 }
164
165 static inline bool sb_has_quota_active(struct super_block *sb, int type)
166 {
167 return sb_has_quota_loaded(sb, type) &&
168 !sb_has_quota_suspended(sb, type);
169 }
170
171
172
173
174 extern const struct dquot_operations dquot_operations;
175 extern const struct quotactl_ops dquot_quotactl_sysfile_ops;
176
177 #else
178
179 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
180 {
181 return 0;
182 }
183
184 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
185 {
186 return 0;
187 }
188
189 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
190 {
191 return 0;
192 }
193
194 static inline int sb_any_quota_suspended(struct super_block *sb)
195 {
196 return 0;
197 }
198
199
200 static inline int sb_has_quota_loaded(struct super_block *sb, int type)
201 {
202 return 0;
203 }
204
205 static inline int sb_any_quota_loaded(struct super_block *sb)
206 {
207 return 0;
208 }
209
210 static inline int sb_has_quota_active(struct super_block *sb, int type)
211 {
212 return 0;
213 }
214
215 static inline int dquot_initialize(struct inode *inode)
216 {
217 return 0;
218 }
219
220 static inline bool dquot_initialize_needed(struct inode *inode)
221 {
222 return false;
223 }
224
225 static inline void dquot_drop(struct inode *inode)
226 {
227 }
228
229 static inline int dquot_alloc_inode(struct inode *inode)
230 {
231 return 0;
232 }
233
234 static inline void dquot_free_inode(struct inode *inode)
235 {
236 }
237
238 static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
239 {
240 return 0;
241 }
242
243 static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
244 int flags)
245 {
246 if (!(flags & DQUOT_SPACE_RESERVE))
247 inode_add_bytes(inode, number);
248 return 0;
249 }
250
251 static inline void __dquot_free_space(struct inode *inode, qsize_t number,
252 int flags)
253 {
254 if (!(flags & DQUOT_SPACE_RESERVE))
255 inode_sub_bytes(inode, number);
256 }
257
258 static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
259 {
260 inode_add_bytes(inode, number);
261 return 0;
262 }
263
264 static inline int dquot_reclaim_space_nodirty(struct inode *inode,
265 qsize_t number)
266 {
267 inode_sub_bytes(inode, number);
268 return 0;
269 }
270
271 static inline int dquot_disable(struct super_block *sb, int type,
272 unsigned int flags)
273 {
274 return 0;
275 }
276
277 static inline int dquot_suspend(struct super_block *sb, int type)
278 {
279 return 0;
280 }
281
282 static inline int dquot_resume(struct super_block *sb, int type)
283 {
284 return 0;
285 }
286
287 #define dquot_file_open generic_file_open
288
289 static inline int dquot_writeback_dquots(struct super_block *sb, int type)
290 {
291 return 0;
292 }
293
294 #endif
295
296 static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
297 {
298 return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
299 }
300
301 static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
302 {
303 __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
304 mark_inode_dirty_sync(inode);
305 }
306
307 static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
308 {
309 int ret;
310
311 ret = dquot_alloc_space_nodirty(inode, nr);
312 if (!ret) {
313
314
315
316
317
318 mark_inode_dirty(inode);
319 }
320 return ret;
321 }
322
323 static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
324 {
325 return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
326 }
327
328 static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
329 {
330 dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
331 }
332
333 static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
334 {
335 return dquot_alloc_space(inode, nr << inode->i_blkbits);
336 }
337
338 static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
339 {
340 return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
341 }
342
343 static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
344 {
345 int ret;
346
347 ret = dquot_prealloc_block_nodirty(inode, nr);
348 if (!ret)
349 mark_inode_dirty_sync(inode);
350 return ret;
351 }
352
353 static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
354 {
355 return __dquot_alloc_space(inode, nr << inode->i_blkbits,
356 DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
357 }
358
359 static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
360 {
361 int ret;
362
363 ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
364 if (!ret)
365 mark_inode_dirty_sync(inode);
366 return ret;
367 }
368
369 static inline void dquot_reclaim_block(struct inode *inode, qsize_t nr)
370 {
371 dquot_reclaim_space_nodirty(inode, nr << inode->i_blkbits);
372 mark_inode_dirty_sync(inode);
373 }
374
375 static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
376 {
377 __dquot_free_space(inode, nr, 0);
378 }
379
380 static inline void dquot_free_space(struct inode *inode, qsize_t nr)
381 {
382 dquot_free_space_nodirty(inode, nr);
383 mark_inode_dirty_sync(inode);
384 }
385
386 static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
387 {
388 dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
389 }
390
391 static inline void dquot_free_block(struct inode *inode, qsize_t nr)
392 {
393 dquot_free_space(inode, nr << inode->i_blkbits);
394 }
395
396 static inline void dquot_release_reservation_block(struct inode *inode,
397 qsize_t nr)
398 {
399 __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
400 }
401
402 unsigned int qtype_enforce_flag(int type);
403
404 #endif