1/* 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> 6 */ 7#ifndef _LINUX_QUOTAOPS_ 8#define _LINUX_QUOTAOPS_ 9 10#include <linux/fs.h> 11 12#define DQUOT_SPACE_WARN 0x1 13#define DQUOT_SPACE_RESERVE 0x2 14#define DQUOT_SPACE_NOFAIL 0x4 15 16static inline struct quota_info *sb_dqopt(struct super_block *sb) 17{ 18 return &sb->s_dquot; 19} 20 21/* 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 && !uid_eq(ia->ia_uid, inode->i_uid)) || 26 (ia->ia_valid & ATTR_GID && !gid_eq(ia->ia_gid, inode->i_gid)); 27} 28 29#if defined(CONFIG_QUOTA) 30 31#define quota_error(sb, fmt, args...) \ 32 __quota_error((sb), __func__, fmt , ## args) 33 34extern __printf(3, 4) 35void __quota_error(struct super_block *sb, const char *func, 36 const char *fmt, ...); 37 38/* 39 * declaration of quota_function calls in kernel. 40 */ 41void 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); 44void inode_reclaim_rsv_space(struct inode *inode, qsize_t number); 45 46void dquot_initialize(struct inode *inode); 47void dquot_drop(struct inode *inode); 48struct dquot *dqget(struct super_block *sb, struct kqid qid); 49static 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} 57void dqput(struct dquot *dquot); 58int dquot_scan_active(struct super_block *sb, 59 int (*fn)(struct dquot *dquot, unsigned long priv), 60 unsigned long priv); 61struct dquot *dquot_alloc(struct super_block *sb, int type); 62void dquot_destroy(struct dquot *dquot); 63 64int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags); 65void __dquot_free_space(struct inode *inode, qsize_t number, int flags); 66 67int dquot_alloc_inode(struct inode *inode); 68 69int dquot_claim_space_nodirty(struct inode *inode, qsize_t number); 70void dquot_free_inode(struct inode *inode); 71void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number); 72 73int 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 81int 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); 86 87int dquot_file_open(struct inode *inode, struct file *file); 88 89int dquot_enable(struct inode *inode, int type, int format_id, 90 unsigned int flags); 91int dquot_quota_on(struct super_block *sb, int type, int format_id, 92 struct path *path); 93int dquot_quota_on_mount(struct super_block *sb, char *qf_name, 94 int format_id, int type); 95int dquot_quota_off(struct super_block *sb, int type); 96int dquot_writeback_dquots(struct super_block *sb, int type); 97int dquot_quota_sync(struct super_block *sb, int type); 98int dquot_get_state(struct super_block *sb, struct qc_state *state); 99int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii); 100int dquot_get_dqblk(struct super_block *sb, struct kqid id, 101 struct qc_dqblk *di); 102int dquot_set_dqblk(struct super_block *sb, struct kqid id, 103 struct qc_dqblk *di); 104 105int __dquot_transfer(struct inode *inode, struct dquot **transfer_to); 106int dquot_transfer(struct inode *inode, struct iattr *iattr); 107 108static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type) 109{ 110 return sb_dqopt(sb)->info + type; 111} 112 113/* 114 * Functions for checking status of quota 115 */ 116 117static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type) 118{ 119 return sb_dqopt(sb)->flags & 120 dquot_state_flag(DQUOT_USAGE_ENABLED, type); 121} 122 123static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type) 124{ 125 return sb_dqopt(sb)->flags & 126 dquot_state_flag(DQUOT_LIMITS_ENABLED, type); 127} 128 129static inline bool sb_has_quota_suspended(struct super_block *sb, int type) 130{ 131 return sb_dqopt(sb)->flags & 132 dquot_state_flag(DQUOT_SUSPENDED, type); 133} 134 135static inline unsigned sb_any_quota_suspended(struct super_block *sb) 136{ 137 return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_SUSPENDED); 138} 139 140/* Does kernel know about any quota information for given sb + type? */ 141static inline bool sb_has_quota_loaded(struct super_block *sb, int type) 142{ 143 /* Currently if anything is on, then quota usage is on as well */ 144 return sb_has_quota_usage_enabled(sb, type); 145} 146 147static inline unsigned sb_any_quota_loaded(struct super_block *sb) 148{ 149 return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_USAGE_ENABLED); 150} 151 152static inline bool sb_has_quota_active(struct super_block *sb, int type) 153{ 154 return sb_has_quota_loaded(sb, type) && 155 !sb_has_quota_suspended(sb, type); 156} 157 158/* 159 * Operations supported for diskquotas. 160 */ 161extern const struct dquot_operations dquot_operations; 162extern const struct quotactl_ops dquot_quotactl_ops; 163extern const struct quotactl_ops dquot_quotactl_sysfile_ops; 164 165#else 166 167static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type) 168{ 169 return 0; 170} 171 172static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type) 173{ 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} 186 187/* 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 203static inline void dquot_initialize(struct inode *inode) 204{ 205} 206 207static inline void dquot_drop(struct inode *inode) 208{ 209} 210 211static inline int dquot_alloc_inode(struct inode *inode) 212{ 213 return 0; 214} 215 216static inline void dquot_free_inode(struct inode *inode) 217{ 218} 219 220static inline int dquot_transfer(struct inode *inode, struct iattr *iattr) 221{ 222 return 0; 223} 224 225static inline int __dquot_alloc_space(struct inode *inode, qsize_t number, 226 int flags) 227{ 228 if (!(flags & DQUOT_SPACE_RESERVE)) 229 inode_add_bytes(inode, number); 230 return 0; 231} 232 233static inline void __dquot_free_space(struct inode *inode, qsize_t number, 234 int flags) 235{ 236 if (!(flags & DQUOT_SPACE_RESERVE)) 237 inode_sub_bytes(inode, number); 238} 239 240static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number) 241{ 242 inode_add_bytes(inode, number); 243 return 0; 244} 245 246static inline int dquot_reclaim_space_nodirty(struct inode *inode, 247 qsize_t number) 248{ 249 inode_sub_bytes(inode, number); 250 return 0; 251} 252 253static inline int dquot_disable(struct super_block *sb, int type, 254 unsigned int flags) 255{ 256 return 0; 257} 258 259static inline int dquot_suspend(struct super_block *sb, int type) 260{ 261 return 0; 262} 263 264static inline int dquot_resume(struct super_block *sb, int type) 265{ 266 return 0; 267} 268 269#define dquot_file_open generic_file_open 270 271static inline int dquot_writeback_dquots(struct super_block *sb, int type) 272{ 273 return 0; 274} 275 276#endif /* CONFIG_QUOTA */ 277 278static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr) 279{ 280 return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN); 281} 282 283static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr) 284{ 285 __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL); 286 mark_inode_dirty_sync(inode); 287} 288 289static inline int dquot_alloc_space(struct inode *inode, qsize_t nr) 290{ 291 int ret; 292 293 ret = dquot_alloc_space_nodirty(inode, nr); 294 if (!ret) { 295 /* 296 * Mark inode fully dirty. Since we are allocating blocks, inode 297 * would become fully dirty soon anyway and it reportedly 298 * reduces lock contention. 299 */ 300 mark_inode_dirty(inode); 301 } 302 return ret; 303} 304 305static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr) 306{ 307 return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits); 308} 309 310static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr) 311{ 312 dquot_alloc_space_nofail(inode, nr << inode->i_blkbits); 313} 314 315static inline int dquot_alloc_block(struct inode *inode, qsize_t nr) 316{ 317 return dquot_alloc_space(inode, nr << inode->i_blkbits); 318} 319 320static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr) 321{ 322 return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0); 323} 324 325static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr) 326{ 327 int ret; 328 329 ret = dquot_prealloc_block_nodirty(inode, nr); 330 if (!ret) 331 mark_inode_dirty_sync(inode); 332 return ret; 333} 334 335static inline int dquot_reserve_block(struct inode *inode, qsize_t nr) 336{ 337 return __dquot_alloc_space(inode, nr << inode->i_blkbits, 338 DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE); 339} 340 341static inline int dquot_claim_block(struct inode *inode, qsize_t nr) 342{ 343 int ret; 344 345 ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits); 346 if (!ret) 347 mark_inode_dirty_sync(inode); 348 return ret; 349} 350 351static inline void dquot_reclaim_block(struct inode *inode, qsize_t nr) 352{ 353 dquot_reclaim_space_nodirty(inode, nr << inode->i_blkbits); 354 mark_inode_dirty_sync(inode); 355} 356 357static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr) 358{ 359 __dquot_free_space(inode, nr, 0); 360} 361 362static inline void dquot_free_space(struct inode *inode, qsize_t nr) 363{ 364 dquot_free_space_nodirty(inode, nr); 365 mark_inode_dirty_sync(inode); 366} 367 368static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr) 369{ 370 dquot_free_space_nodirty(inode, nr << inode->i_blkbits); 371} 372 373static inline void dquot_free_block(struct inode *inode, qsize_t nr) 374{ 375 dquot_free_space(inode, nr << inode->i_blkbits); 376} 377 378static inline void dquot_release_reservation_block(struct inode *inode, 379 qsize_t nr) 380{ 381 __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE); 382} 383 384unsigned int qtype_enforce_flag(int type); 385 386#endif /* _LINUX_QUOTAOPS_ */ 387