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