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