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