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