LXR linux/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/smp_lock.h>
  11#include <linux/fs.h>
  12
  13static inline struct quota_info *sb_dqopt(struct super_block *sb)
  14{
  15        return &sb->s_dquot;
  16}
  17
  18#if defined(CONFIG_QUOTA)
  19
  20/*
  21 * declaration of quota_function calls in kernel.
  22 */
  23void sync_dquots(struct super_block *sb, int type);
  24
  25int dquot_initialize(struct inode *inode, int type);
  26int dquot_drop(struct inode *inode);
  27
  28int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
  29int dquot_alloc_inode(const struct inode *inode, unsigned long number);
  30
  31int dquot_free_space(struct inode *inode, qsize_t number);
  32int dquot_free_inode(const struct inode *inode, unsigned long number);
  33
  34int dquot_transfer(struct inode *inode, struct iattr *iattr);
  35int dquot_commit(struct dquot *dquot);
  36int dquot_acquire(struct dquot *dquot);
  37int dquot_release(struct dquot *dquot);
  38int dquot_commit_info(struct super_block *sb, int type);
  39int dquot_mark_dquot_dirty(struct dquot *dquot);
  40
  41int vfs_quota_on(struct super_block *sb, int type, int format_id,
  42        char *path, int remount);
  43int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
  44        struct path *path);
  45int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
  46        int format_id, int type);
  47int vfs_quota_off(struct super_block *sb, int type, int remount);
  48int vfs_quota_sync(struct super_block *sb, int type);
  49int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  50int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  51int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
  52int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
  53
  54void vfs_dq_drop(struct inode *inode);
  55int vfs_dq_transfer(struct inode *inode, struct iattr *iattr);
  56int vfs_dq_quota_on_remount(struct super_block *sb);
  57
  58static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
  59{
  60        return sb_dqopt(sb)->info + type;
  61}
  62
  63/*
  64 * Functions for checking status of quota
  65 */
  66
  67static inline int sb_has_quota_enabled(struct super_block *sb, int type)
  68{
  69        if (type == USRQUOTA)
  70                return sb_dqopt(sb)->flags & DQUOT_USR_ENABLED;
  71        return sb_dqopt(sb)->flags & DQUOT_GRP_ENABLED;
  72}
  73
  74static inline int sb_any_quota_enabled(struct super_block *sb)
  75{
  76        return sb_has_quota_enabled(sb, USRQUOTA) ||
  77                sb_has_quota_enabled(sb, GRPQUOTA);
  78}
  79
  80static inline int sb_has_quota_suspended(struct super_block *sb, int type)
  81{
  82        if (type == USRQUOTA)
  83                return sb_dqopt(sb)->flags & DQUOT_USR_SUSPENDED;
  84        return sb_dqopt(sb)->flags & DQUOT_GRP_SUSPENDED;
  85}
  86
  87static inline int sb_any_quota_suspended(struct super_block *sb)
  88{
  89        return sb_has_quota_suspended(sb, USRQUOTA) ||
  90                sb_has_quota_suspended(sb, GRPQUOTA);
  91}
  92
  93/*
  94 * Operations supported for diskquotas.
  95 */
  96extern struct dquot_operations dquot_operations;
  97extern struct quotactl_ops vfs_quotactl_ops;
  98
  99#define sb_dquot_ops (&dquot_operations)
 100#define sb_quotactl_ops (&vfs_quotactl_ops)
 101
 102/* It is better to call this function outside of any transaction as it might
 103 * need a lot of space in journal for dquot structure allocation. */
 104static inline void vfs_dq_init(struct inode *inode)
 105{
 106        BUG_ON(!inode->i_sb);
 107        if (sb_any_quota_enabled(inode->i_sb) && !IS_NOQUOTA(inode))
 108                inode->i_sb->dq_op->initialize(inode, -1);
 109}
 110
 111/* The following allocation/freeing/transfer functions *must* be called inside
 112 * a transaction (deadlocks possible otherwise) */
 113static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
 114{
 115        if (sb_any_quota_enabled(inode->i_sb)) {
 116                /* Used space is updated in alloc_space() */
 117                if (inode->i_sb->dq_op->alloc_space(inode, nr, 1) == NO_QUOTA)
 118                        return 1;
 119        }
 120        else
 121                inode_add_bytes(inode, nr);
 122        return 0;
 123}
 124
 125static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
 126{
 127        int ret;
 128        if (!(ret =  vfs_dq_prealloc_space_nodirty(inode, nr)))
 129                mark_inode_dirty(inode);
 130        return ret;
 131}
 132
 133static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
 134{
 135        if (sb_any_quota_enabled(inode->i_sb)) {
 136                /* Used space is updated in alloc_space() */
 137                if (inode->i_sb->dq_op->alloc_space(inode, nr, 0) == NO_QUOTA)
 138                        return 1;
 139        }
 140        else
 141                inode_add_bytes(inode, nr);
 142        return 0;
 143}
 144
 145static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
 146{
 147        int ret;
 148        if (!(ret = vfs_dq_alloc_space_nodirty(inode, nr)))
 149                mark_inode_dirty(inode);
 150        return ret;
 151}
 152
 153static inline int vfs_dq_alloc_inode(struct inode *inode)
 154{
 155        if (sb_any_quota_enabled(inode->i_sb)) {
 156                vfs_dq_init(inode);
 157                if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
 158                        return 1;
 159        }
 160        return 0;
 161}
 162
 163static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
 164{
 165        if (sb_any_quota_enabled(inode->i_sb))
 166                inode->i_sb->dq_op->free_space(inode, nr);
 167        else
 168                inode_sub_bytes(inode, nr);
 169}
 170
 171static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
 172{
 173        vfs_dq_free_space_nodirty(inode, nr);
 174        mark_inode_dirty(inode);
 175}
 176
 177static inline void vfs_dq_free_inode(struct inode *inode)
 178{
 179        if (sb_any_quota_enabled(inode->i_sb))
 180                inode->i_sb->dq_op->free_inode(inode, 1);
 181}
 182
 183/* The following two functions cannot be called inside a transaction */
 184static inline void vfs_dq_sync(struct super_block *sb)
 185{
 186        sync_dquots(sb, -1);
 187}
 188
 189static inline int vfs_dq_off(struct super_block *sb, int remount)
 190{
 191        int ret = -ENOSYS;
 192
 193        if (sb->s_qcop && sb->s_qcop->quota_off)
 194                ret = sb->s_qcop->quota_off(sb, -1, remount);
 195        return ret;
 196}
 197
 198#else
 199
 200static inline int sb_has_quota_enabled(struct super_block *sb, int type)
 201{
 202        return 0;
 203}
 204
 205static inline int sb_any_quota_enabled(struct super_block *sb)
 206{
 207        return 0;
 208}
 209
 210static inline int sb_has_quota_suspended(struct super_block *sb, int type)
 211{
 212        return 0;
 213}
 214
 215static inline int sb_any_quota_suspended(struct super_block *sb)
 216{
 217        return 0;
 218}
 219
 220/*
 221 * NO-OP when quota not configured.
 222 */
 223#define sb_dquot_ops                            (NULL)
 224#define sb_quotactl_ops                         (NULL)
 225
 226static inline void vfs_dq_init(struct inode *inode)
 227{
 228}
 229
 230static inline void vfs_dq_drop(struct inode *inode)
 231{
 232}
 233
 234static inline int vfs_dq_alloc_inode(struct inode *inode)
 235{
 236        return 0;
 237}
 238
 239static inline void vfs_dq_free_inode(struct inode *inode)
 240{
 241}
 242
 243static inline void vfs_dq_sync(struct super_block *sb)
 244{
 245}
 246
 247static inline int vfs_dq_off(struct super_block *sb, int remount)
 248{
 249        return 0;
 250}
 251
 252static inline int vfs_dq_quota_on_remount(struct super_block *sb)
 253{
 254        return 0;
 255}
 256
 257static inline int vfs_dq_transfer(struct inode *inode, struct iattr *iattr)
 258{
 259        return 0;
 260}
 261
 262static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
 263{
 264        inode_add_bytes(inode, nr);
 265        return 0;
 266}
 267
 268static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
 269{
 270        vfs_dq_prealloc_space_nodirty(inode, nr);
 271        mark_inode_dirty(inode);
 272        return 0;
 273}
 274
 275static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
 276{
 277        inode_add_bytes(inode, nr);
 278        return 0;
 279}
 280
 281static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
 282{
 283        vfs_dq_alloc_space_nodirty(inode, nr);
 284        mark_inode_dirty(inode);
 285        return 0;
 286}
 287
 288static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
 289{
 290        inode_sub_bytes(inode, nr);
 291}
 292
 293static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
 294{
 295        vfs_dq_free_space_nodirty(inode, nr);
 296        mark_inode_dirty(inode);
 297}       
 298
 299#endif /* CONFIG_QUOTA */
 300
 301static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
 302{
 303        return vfs_dq_prealloc_space_nodirty(inode,
 304                        nr << inode->i_sb->s_blocksize_bits);
 305}
 306
 307static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
 308{
 309        return vfs_dq_prealloc_space(inode,
 310                        nr << inode->i_sb->s_blocksize_bits);
 311}
 312
 313static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
 314{
 315        return vfs_dq_alloc_space_nodirty(inode,
 316                        nr << inode->i_sb->s_blocksize_bits);
 317}
 318
 319static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
 320{
 321        return vfs_dq_alloc_space(inode,
 322                        nr << inode->i_sb->s_blocksize_bits);
 323}
 324
 325static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
 326{
 327        vfs_dq_free_space_nodirty(inode, nr << inode->i_sb->s_blocksize_bits);
 328}
 329
 330static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
 331{
 332        vfs_dq_free_space(inode, nr << inode->i_sb->s_blocksize_bits);
 333}
 334
 335/*
 336 * Define uppercase equivalents for compatibility with old function names
 337 * Can go away when we think all users have been converted (15/04/2008)
 338 */
 339#define DQUOT_INIT(inode) vfs_dq_init(inode)
 340#define DQUOT_DROP(inode) vfs_dq_drop(inode)
 341#define DQUOT_PREALLOC_SPACE_NODIRTY(inode, nr) \
 342                                vfs_dq_prealloc_space_nodirty(inode, nr)
 343#define DQUOT_PREALLOC_SPACE(inode, nr) vfs_dq_prealloc_space(inode, nr)
 344#define DQUOT_ALLOC_SPACE_NODIRTY(inode, nr) \
 345                                vfs_dq_alloc_space_nodirty(inode, nr)
 346#define DQUOT_ALLOC_SPACE(inode, nr) vfs_dq_alloc_space(inode, nr)
 347#define DQUOT_PREALLOC_BLOCK_NODIRTY(inode, nr) \
 348                                vfs_dq_prealloc_block_nodirty(inode, nr)
 349#define DQUOT_PREALLOC_BLOCK(inode, nr) vfs_dq_prealloc_block(inode, nr)
 350#define DQUOT_ALLOC_BLOCK_NODIRTY(inode, nr) \
 351                                vfs_dq_alloc_block_nodirty(inode, nr)
 352#define DQUOT_ALLOC_BLOCK(inode, nr) vfs_dq_alloc_block(inode, nr)
 353#define DQUOT_ALLOC_INODE(inode) vfs_dq_alloc_inode(inode)
 354#define DQUOT_FREE_SPACE_NODIRTY(inode, nr) \
 355                                vfs_dq_free_space_nodirty(inode, nr)
 356#define DQUOT_FREE_SPACE(inode, nr) vfs_dq_free_space(inode, nr)
 357#define DQUOT_FREE_BLOCK_NODIRTY(inode, nr) \
 358                                vfs_dq_free_block_nodirty(inode, nr)
 359#define DQUOT_FREE_BLOCK(inode, nr) vfs_dq_free_block(inode, nr)
 360#define DQUOT_FREE_INODE(inode) vfs_dq_free_inode(inode)
 361#define DQUOT_TRANSFER(inode, iattr) vfs_dq_transfer(inode, iattr)
 362#define DQUOT_SYNC(sb) vfs_dq_sync(sb)
 363#define DQUOT_OFF(sb, remount) vfs_dq_off(sb, remount)
 364#define DQUOT_ON_REMOUNT(sb) vfs_dq_quota_on_remount(sb)
 365
 366#endif /* _LINUX_QUOTAOPS_ */
 367