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