include/linux/quotaops.h

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