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