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_commit(struct dquot *dquot);
  46 int dquot_acquire(struct dquot *dquot);
  47 int dquot_release(struct dquot *dquot);
  48 int dquot_commit_info(struct super_block *sb, int type);
  49 int dquot_mark_dquot_dirty(struct dquot *dquot);
  50
  51 int vfs_quota_on(struct super_block *sb, int type, int format_id,
  52         char *path, int remount);
  53 int vfs_quota_enable(struct inode *inode, int type, int format_id,
  54         unsigned int flags);
  55 int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
  56         struct path *path);
  57 int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
  58         int format_id, int type);
  59 int vfs_quota_off(struct super_block *sb, int type, int remount);
  60 int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags);
  61 int vfs_quota_sync(struct super_block *sb, int type, int wait);
  62 int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  63 int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  64 int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
  65 int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
  66
  67 void vfs_dq_drop(struct inode *inode);
  68 int dquot_transfer(struct inode *inode, struct iattr *iattr);
  69 int vfs_dq_quota_on_remount(struct super_block *sb);
  70
  71 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
  72 {
  73         return sb_dqopt(sb)->info + type;
  74 }
  75
  76 /*
  77  * Functions for checking status of quota
  78  */
  79
  80 static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
  81 {
  82         return sb_dqopt(sb)->flags &
  83                                 dquot_state_flag(DQUOT_USAGE_ENABLED, type);
  84 }
  85
  86 static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
  87 {
  88         return sb_dqopt(sb)->flags &
  89                                 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
  90 }
  91
  92 static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
  93 {
  94         return sb_dqopt(sb)->flags &
  95                                 dquot_state_flag(DQUOT_SUSPENDED, type);
  96 }
  97
  98 static inline unsigned sb_any_quota_suspended(struct super_block *sb)
  99 {
 100         unsigned type, tmsk = 0;
 101         for (type = 0; type < MAXQUOTAS; type++)
 102                 tmsk |= sb_has_quota_suspended(sb, type) << type;
 103         return tmsk;
 104 }
 105
 106 /* Does kernel know about any quota information for given sb + type? */
 107 static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
 108 {
 109         /* Currently if anything is on, then quota usage is on as well */
 110         return sb_has_quota_usage_enabled(sb, type);
 111 }
 112
 113 static inline unsigned sb_any_quota_loaded(struct super_block *sb)
 114 {
 115         unsigned type, tmsk = 0;
 116         for (type = 0; type < MAXQUOTAS; type++)
 117                 tmsk |= sb_has_quota_loaded(sb, type) << type;
 118         return  tmsk;
 119 }
 120
 121 static inline bool sb_has_quota_active(struct super_block *sb, int type)
 122 {
 123         return sb_has_quota_loaded(sb, type) &&
 124                !sb_has_quota_suspended(sb, type);
 125 }
 126
 127 static inline unsigned sb_any_quota_active(struct super_block *sb)
 128 {
 129         return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
 130 }
 131
 132 /*
 133  * Operations supported for diskquotas.
 134  */
 135 extern const struct dquot_operations dquot_operations;
 136 extern const struct quotactl_ops vfs_quotactl_ops;
 137
 138 #define sb_dquot_ops (&dquot_operations)
 139 #define sb_quotactl_ops (&vfs_quotactl_ops)
 140
 141 /* It is better to call this function outside of any transaction as it might
 142  * need a lot of space in journal for dquot structure allocation. */
 143 static inline void vfs_dq_init(struct inode *inode)
 144 {
 145         BUG_ON(!inode->i_sb);
 146         if (sb_any_quota_active(inode->i_sb) && !IS_NOQUOTA(inode))
 147                 inode->i_sb->dq_op->initialize(inode, -1);
 148 }
 149
 150 /* Cannot be called inside a transaction */
 151 static inline int vfs_dq_off(struct super_block *sb, int remount)
 152 {
 153         int ret = -ENOSYS;
 154
 155         if (sb->s_qcop && sb->s_qcop->quota_off)
 156                 ret = sb->s_qcop->quota_off(sb, -1, remount);
 157         return ret;
 158 }
 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 int sb_any_quota_active(struct super_block *sb)
 199 {
 200         return 0;
 201 }
 202
 203 /*
 204  * NO-OP when quota not configured.
 205  */
 206 #define sb_dquot_ops                            (NULL)
 207 #define sb_quotactl_ops                         (NULL)
 208
 209 static inline void vfs_dq_init(struct inode *inode)
 210 {
 211 }
 212
 213 static inline void vfs_dq_drop(struct inode *inode)
 214 {
 215 }
 216
 217 static inline int dquot_alloc_inode(const struct inode *inode)
 218 {
 219         return 0;
 220 }
 221
 222 static inline void dquot_free_inode(const struct inode *inode)
 223 {
 224 }
 225
 226 static inline int vfs_dq_off(struct super_block *sb, int remount)
 227 {
 228         return 0;
 229 }
 230
 231 static inline int vfs_dq_quota_on_remount(struct super_block *sb)
 232 {
 233         return 0;
 234 }
 235
 236 static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
 237 {
 238         return 0;
 239 }
 240
 241 static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
 242                 int warn, int reserve)
 243 {
 244         if (!reserve)
 245                 inode_add_bytes(inode, number);
 246         return 0;
 247 }
 248
 249 static inline void __dquot_free_space(struct inode *inode, qsize_t number,
 250                 int reserve)
 251 {
 252         if (!reserve)
 253                 inode_sub_bytes(inode, number);
 254 }
 255
 256 static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
 257 {
 258         inode_add_bytes(inode, number);
 259         return 0;
 260 }
 261
 262 #endif /* CONFIG_QUOTA */
 263
 264 static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
 265 {
 266         return __dquot_alloc_space(inode, nr, 1, 0);
 267 }
 268
 269 static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
 270 {
 271         int ret;
 272
 273         ret = dquot_alloc_space_nodirty(inode, nr);
 274         if (!ret)
 275                 mark_inode_dirty(inode);
 276         return ret;
 277 }
 278
 279 static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
 280 {
 281         return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
 282 }
 283
 284 static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
 285 {
 286         return dquot_alloc_space(inode, nr << inode->i_blkbits);
 287 }
 288
 289 static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
 290 {
 291         return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0, 0);
 292 }
 293
 294 static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
 295 {
 296         int ret;
 297
 298         ret = dquot_prealloc_block_nodirty(inode, nr);
 299         if (!ret)
 300                 mark_inode_dirty(inode);
 301         return ret;
 302 }
 303
 304 static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
 305 {
 306         return __dquot_alloc_space(inode, nr << inode->i_blkbits, 1, 1);
 307 }
 308
 309 static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
 310 {
 311         int ret;
 312
 313         ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
 314         if (!ret)
 315                 mark_inode_dirty(inode);
 316         return ret;
 317 }
 318
 319 static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
 320 {
 321         __dquot_free_space(inode, nr, 0);
 322 }
 323
 324 static inline void dquot_free_space(struct inode *inode, qsize_t nr)
 325 {
 326         dquot_free_space_nodirty(inode, nr);
 327         mark_inode_dirty(inode);
 328 }
 329
 330 static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
 331 {
 332         dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
 333 }
 334
 335 static inline void dquot_free_block(struct inode *inode, qsize_t nr)
 336 {
 337         dquot_free_space(inode, nr << inode->i_blkbits);
 338 }
 339
 340 static inline void dquot_release_reservation_block(struct inode *inode,
 341                 qsize_t nr)
 342 {
 343         __dquot_free_space(inode, nr << inode->i_blkbits, 1);
 344 }
 345
 346 #endif /* _LINUX_QUOTAOPS_ */