include/linux/quotaops.h

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