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 static inline struct quota_info *sb_dqopt(struct super_block *sb)
  13 {
  14         return &sb->s_dquot;
  15 }
  16
  17 #if defined(CONFIG_QUOTA)
  18
  19 /*
  20  * declaration of quota_function calls in kernel.
  21  */
  22 void inode_add_rsv_space(struct inode *inode, qsize_t number);
  23 void inode_claim_rsv_space(struct inode *inode, qsize_t number);
  24 void inode_sub_rsv_space(struct inode *inode, qsize_t number);
  25
  26 int dquot_initialize(struct inode *inode, int type);
  27 int dquot_drop(struct inode *inode);
  28 struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
  29 void dqput(struct dquot *dquot);
  30 int dquot_scan_active(struct super_block *sb,
  31                       int (*fn)(struct dquot *dquot, unsigned long priv),
  32                       unsigned long priv);
  33 struct dquot *dquot_alloc(struct super_block *sb, int type);
  34 void dquot_destroy(struct dquot *dquot);
  35
  36 int __dquot_alloc_space(struct inode *inode, qsize_t number,
  37                 int warn, int reserve);
  38 void __dquot_free_space(struct inode *inode, qsize_t number, int reserve);
  39
  40 int dquot_alloc_inode(const struct inode *inode);
  41
  42 int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
  43 void dquot_free_inode(const struct inode *inode);
  44
  45 int dquot_transfer(struct inode *inode, qid_t *chid, unsigned long mask);
  46 int dquot_commit(struct dquot *dquot);
  47 int dquot_acquire(struct dquot *dquot);
  48 int dquot_release(struct dquot *dquot);
  49 int dquot_commit_info(struct super_block *sb, int type);
  50 int dquot_mark_dquot_dirty(struct dquot *dquot);
  51
  52 int vfs_quota_on(struct super_block *sb, int type, int format_id,
  53         char *path, int remount);
  54 int vfs_quota_enable(struct inode *inode, int type, int format_id,
  55         unsigned int flags);
  56 int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
  57         struct path *path);
  58 int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
  59         int format_id, int type);
  60 int vfs_quota_off(struct super_block *sb, int type, int remount);
  61 int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags);
  62 int vfs_quota_sync(struct super_block *sb, int type, int wait);
  63 int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  64 int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  65 int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
  66 int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
  67
  68 void vfs_dq_drop(struct inode *inode);
  69 int vfs_dq_transfer(struct inode *inode, struct iattr *iattr);
  70 int vfs_dq_quota_on_remount(struct super_block *sb);
  71
  72 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
  73 {
  74         return sb_dqopt(sb)->info + type;
  75 }
  76
  77 /*
  78  * Functions for checking status of quota
  79  */
  80
  81 static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
  82 {
  83         return sb_dqopt(sb)->flags &
  84                                 dquot_state_flag(DQUOT_USAGE_ENABLED, type);
  85 }
  86
  87 static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
  88 {
  89         return sb_dqopt(sb)->flags &
  90                                 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
  91 }
  92
  93 static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
  94 {
  95         return sb_dqopt(sb)->flags &
  96                                 dquot_state_flag(DQUOT_SUSPENDED, type);
  97 }
  98
  99 static inline unsigned sb_any_quota_suspended(struct super_block *sb)
 100 {
 101         unsigned type, tmsk = 0;
 102         for (type = 0; type < MAXQUOTAS; type++)
 103                 tmsk |= sb_has_quota_suspended(sb, type) << type;
 104         return tmsk;
 105 }
 106
 107 /* Does kernel know about any quota information for given sb + type? */
 108 static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
 109 {
 110         /* Currently if anything is on, then quota usage is on as well */
 111         return sb_has_quota_usage_enabled(sb, type);
 112 }
 113
 114 static inline unsigned sb_any_quota_loaded(struct super_block *sb)
 115 {
 116         unsigned type, tmsk = 0;
 117         for (type = 0; type < MAXQUOTAS; type++)
 118                 tmsk |= sb_has_quota_loaded(sb, type) << type;
 119         return  tmsk;
 120 }
 121
 122 static inline bool sb_has_quota_active(struct super_block *sb, int type)
 123 {
 124         return sb_has_quota_loaded(sb, type) &&
 125                !sb_has_quota_suspended(sb, type);
 126 }
 127
 128 static inline unsigned sb_any_quota_active(struct super_block *sb)
 129 {
 130         return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
 131 }
 132
 133 /*
 134  * Operations supported for diskquotas.
 135  */
 136 extern const struct dquot_operations dquot_operations;
 137 extern const struct quotactl_ops vfs_quotactl_ops;
 138
 139 #define sb_dquot_ops (&dquot_operations)
 140 #define sb_quotactl_ops (&vfs_quotactl_ops)
 141
 142 /* It is better to call this function outside of any transaction as it might
 143  * need a lot of space in journal for dquot structure allocation. */
 144 static inline void vfs_dq_init(struct inode *inode)
 145 {
 146         BUG_ON(!inode->i_sb);
 147         if (sb_any_quota_active(inode->i_sb) && !IS_NOQUOTA(inode))
 148                 inode->i_sb->dq_op->initialize(inode, -1);
 149 }
 150
 151 /* Cannot be called inside a transaction */
 152 static inline int vfs_dq_off(struct super_block *sb, int remount)
 153 {
 154         int ret = -ENOSYS;
 155
 156         if (sb->s_qcop && sb->s_qcop->quota_off)
 157                 ret = sb->s_qcop->quota_off(sb, -1, remount);
 158         return ret;
 159 }
 160
 161 #else
 162
 163 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
 164 {
 165         return 0;
 166 }
 167
 168 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
 169 {
 170         return 0;
 171 }
 172
 173 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
 174 {
 175         return 0;
 176 }
 177
 178 static inline int sb_any_quota_suspended(struct super_block *sb)
 179 {
 180         return 0;
 181 }
 182
 183 /* Does kernel know about any quota information for given sb + type? */
 184 static inline int sb_has_quota_loaded(struct super_block *sb, int type)
 185 {
 186         return 0;
 187 }
 188
 189 static inline int sb_any_quota_loaded(struct super_block *sb)
 190 {
 191         return 0;
 192 }
 193
 194 static inline int sb_has_quota_active(struct super_block *sb, int type)
 195 {
 196         return 0;
 197 }
 198
 199 static inline int sb_any_quota_active(struct super_block *sb)
 200 {
 201         return 0;
 202 }
 203
 204 /*
 205  * NO-OP when quota not configured.
 206  */
 207 #define sb_dquot_ops                            (NULL)
 208 #define sb_quotactl_ops                         (NULL)
 209
 210 static inline void vfs_dq_init(struct inode *inode)
 211 {
 212 }
 213
 214 static inline void vfs_dq_drop(struct inode *inode)
 215 {
 216 }
 217
 218 static inline int dquot_alloc_inode(const struct inode *inode)
 219 {
 220         return 0;
 221 }
 222
 223 static inline void dquot_free_inode(const struct inode *inode)
 224 {
 225 }
 226
 227 static inline int vfs_dq_off(struct super_block *sb, int remount)
 228 {
 229         return 0;
 230 }
 231
 232 static inline int vfs_dq_quota_on_remount(struct super_block *sb)
 233 {
 234         return 0;
 235 }
 236
 237 static inline int vfs_dq_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 warn, int reserve)
 244 {
 245         if (!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 reserve)
 252 {
 253         if (!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 #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, 1, 0);
 268 }
 269
 270 static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
 271 {
 272         int ret;
 273
 274         ret = dquot_alloc_space_nodirty(inode, nr);
 275         if (!ret)
 276                 mark_inode_dirty(inode);
 277         return ret;
 278 }
 279
 280 static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
 281 {
 282         return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
 283 }
 284
 285 static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
 286 {
 287         return dquot_alloc_space(inode, nr << inode->i_blkbits);
 288 }
 289
 290 static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
 291 {
 292         return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0, 0);
 293 }
 294
 295 static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
 296 {
 297         int ret;
 298
 299         ret = dquot_prealloc_block_nodirty(inode, nr);
 300         if (!ret)
 301                 mark_inode_dirty(inode);
 302         return ret;
 303 }
 304
 305 static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
 306 {
 307         return __dquot_alloc_space(inode, nr << inode->i_blkbits, 1, 1);
 308 }
 309
 310 static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
 311 {
 312         int ret;
 313
 314         ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
 315         if (!ret)
 316                 mark_inode_dirty(inode);
 317         return ret;
 318 }
 319
 320 static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
 321 {
 322         __dquot_free_space(inode, nr, 0);
 323 }
 324
 325 static inline void dquot_free_space(struct inode *inode, qsize_t nr)
 326 {
 327         dquot_free_space_nodirty(inode, nr);
 328         mark_inode_dirty(inode);
 329 }
 330
 331 static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
 332 {
 333         dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
 334 }
 335
 336 static inline void dquot_free_block(struct inode *inode, qsize_t nr)
 337 {
 338         dquot_free_space(inode, nr << inode->i_blkbits);
 339 }
 340
 341 static inline void dquot_release_reservation_block(struct inode *inode,
 342                 qsize_t nr)
 343 {
 344         __dquot_free_space(inode, nr << inode->i_blkbits, 1);
 345 }
 346
 347 #endif /* _LINUX_QUOTAOPS_ */