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/fs.h>
  11
  12#define DQUOT_SPACE_WARN        0x1
  13#define DQUOT_SPACE_RESERVE     0x2
  14#define DQUOT_SPACE_NOFAIL      0x4
  15
  16static inline struct quota_info *sb_dqopt(struct super_block *sb)
  17{
  18        return &sb->s_dquot;
  19}
  20
  21/* i_mutex must being held */
  22static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
  23{
  24        return (ia->ia_valid & ATTR_SIZE && ia->ia_size != inode->i_size) ||
  25                (ia->ia_valid & ATTR_UID && !uid_eq(ia->ia_uid, inode->i_uid)) ||
  26                (ia->ia_valid & ATTR_GID && !gid_eq(ia->ia_gid, inode->i_gid));
  27}
  28
  29#if defined(CONFIG_QUOTA)
  30
  31#define quota_error(sb, fmt, args...) \
  32        __quota_error((sb), __func__, fmt , ## args)
  33
  34extern __printf(3, 4)
  35void __quota_error(struct super_block *sb, const char *func,
  36                   const char *fmt, ...);
  37
  38/*
  39 * declaration of quota_function calls in kernel.
  40 */
  41void inode_add_rsv_space(struct inode *inode, qsize_t number);
  42void inode_claim_rsv_space(struct inode *inode, qsize_t number);
  43void inode_sub_rsv_space(struct inode *inode, qsize_t number);
  44
  45void dquot_initialize(struct inode *inode);
  46void dquot_drop(struct inode *inode);
  47struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
  48void dqput(struct dquot *dquot);
  49int dquot_scan_active(struct super_block *sb,
  50                      int (*fn)(struct dquot *dquot, unsigned long priv),
  51                      unsigned long priv);
  52struct dquot *dquot_alloc(struct super_block *sb, int type);
  53void dquot_destroy(struct dquot *dquot);
  54
  55int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
  56void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
  57
  58int dquot_alloc_inode(const struct inode *inode);
  59
  60int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
  61void dquot_free_inode(const struct inode *inode);
  62
  63int dquot_disable(struct super_block *sb, int type, unsigned int flags);
  64/* Suspend quotas on remount RO */
  65static inline int dquot_suspend(struct super_block *sb, int type)
  66{
  67        return dquot_disable(sb, type, DQUOT_SUSPENDED);
  68}
  69int dquot_resume(struct super_block *sb, int type);
  70
  71int dquot_commit(struct dquot *dquot);
  72int dquot_acquire(struct dquot *dquot);
  73int dquot_release(struct dquot *dquot);
  74int dquot_commit_info(struct super_block *sb, int type);
  75int dquot_mark_dquot_dirty(struct dquot *dquot);
  76
  77int dquot_file_open(struct inode *inode, struct file *file);
  78
  79int dquot_enable(struct inode *inode, int type, int format_id,
  80        unsigned int flags);
  81int dquot_quota_on(struct super_block *sb, int type, int format_id,
  82        struct path *path);
  83int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
  84        int format_id, int type);
  85int dquot_quota_off(struct super_block *sb, int type);
  86int dquot_writeback_dquots(struct super_block *sb, int type);
  87int dquot_quota_sync(struct super_block *sb, int type);
  88int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  89int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  90int dquot_get_dqblk(struct super_block *sb, int type, qid_t id,
  91                struct fs_disk_quota *di);
  92int dquot_set_dqblk(struct super_block *sb, int type, qid_t id,
  93                struct fs_disk_quota *di);
  94
  95int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
  96int dquot_transfer(struct inode *inode, struct iattr *iattr);
  97
  98static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
  99{
 100        return sb_dqopt(sb)->info + type;
 101}
 102
 103/*
 104 * Functions for checking status of quota
 105 */
 106
 107static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
 108{
 109        return sb_dqopt(sb)->flags &
 110                                dquot_state_flag(DQUOT_USAGE_ENABLED, type);
 111}
 112
 113static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
 114{
 115        return sb_dqopt(sb)->flags &
 116                                dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
 117}
 118
 119static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
 120{
 121        return sb_dqopt(sb)->flags &
 122                                dquot_state_flag(DQUOT_SUSPENDED, type);
 123}
 124
 125static inline unsigned sb_any_quota_suspended(struct super_block *sb)
 126{
 127        unsigned type, tmsk = 0;
 128        for (type = 0; type < MAXQUOTAS; type++)
 129                tmsk |= sb_has_quota_suspended(sb, type) << type;
 130        return tmsk;
 131}
 132
 133/* Does kernel know about any quota information for given sb + type? */
 134static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
 135{
 136        /* Currently if anything is on, then quota usage is on as well */
 137        return sb_has_quota_usage_enabled(sb, type);
 138}
 139
 140static inline unsigned sb_any_quota_loaded(struct super_block *sb)
 141{
 142        unsigned type, tmsk = 0;
 143        for (type = 0; type < MAXQUOTAS; type++)
 144                tmsk |= sb_has_quota_loaded(sb, type) << type;
 145        return  tmsk;
 146}
 147
 148static inline bool sb_has_quota_active(struct super_block *sb, int type)
 149{
 150        return sb_has_quota_loaded(sb, type) &&
 151               !sb_has_quota_suspended(sb, type);
 152}
 153
 154/*
 155 * Operations supported for diskquotas.
 156 */
 157extern const struct dquot_operations dquot_operations;
 158extern const struct quotactl_ops dquot_quotactl_ops;
 159
 160#else
 161
 162static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
 163{
 164        return 0;
 165}
 166
 167static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
 168{
 169        return 0;
 170}
 171
 172static inline int sb_has_quota_suspended(struct super_block *sb, int type)
 173{
 174        return 0;
 175}
 176
 177static 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? */
 183static inline int sb_has_quota_loaded(struct super_block *sb, int type)
 184{
 185        return 0;
 186}
 187
 188static inline int sb_any_quota_loaded(struct super_block *sb)
 189{
 190        return 0;
 191}
 192
 193static inline int sb_has_quota_active(struct super_block *sb, int type)
 194{
 195        return 0;
 196}
 197
 198static inline void dquot_initialize(struct inode *inode)
 199{
 200}
 201
 202static inline void dquot_drop(struct inode *inode)
 203{
 204}
 205
 206static inline int dquot_alloc_inode(const struct inode *inode)
 207{
 208        return 0;
 209}
 210
 211static inline void dquot_free_inode(const struct inode *inode)
 212{
 213}
 214
 215static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
 216{
 217        return 0;
 218}
 219
 220static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
 221                int flags)
 222{
 223        if (!(flags & DQUOT_SPACE_RESERVE))
 224                inode_add_bytes(inode, number);
 225        return 0;
 226}
 227
 228static inline void __dquot_free_space(struct inode *inode, qsize_t number,
 229                int flags)
 230{
 231        if (!(flags & DQUOT_SPACE_RESERVE))
 232                inode_sub_bytes(inode, number);
 233}
 234
 235static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
 236{
 237        inode_add_bytes(inode, number);
 238        return 0;
 239}
 240
 241static inline int dquot_disable(struct super_block *sb, int type,
 242                unsigned int flags)
 243{
 244        return 0;
 245}
 246
 247static inline int dquot_suspend(struct super_block *sb, int type)
 248{
 249        return 0;
 250}
 251
 252static inline int dquot_resume(struct super_block *sb, int type)
 253{
 254        return 0;
 255}
 256
 257#define dquot_file_open         generic_file_open
 258
 259static inline int dquot_writeback_dquots(struct super_block *sb, int type)
 260{
 261        return 0;
 262}
 263
 264#endif /* CONFIG_QUOTA */
 265
 266static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
 267{
 268        return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
 269}
 270
 271static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
 272{
 273        __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
 274        mark_inode_dirty_sync(inode);
 275}
 276
 277static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
 278{
 279        int ret;
 280
 281        ret = dquot_alloc_space_nodirty(inode, nr);
 282        if (!ret) {
 283                /*
 284                 * Mark inode fully dirty. Since we are allocating blocks, inode
 285                 * would become fully dirty soon anyway and it reportedly
 286                 * reduces lock contention.
 287                 */
 288                mark_inode_dirty(inode);
 289        }
 290        return ret;
 291}
 292
 293static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
 294{
 295        return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
 296}
 297
 298static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
 299{
 300        dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
 301}
 302
 303static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
 304{
 305        return dquot_alloc_space(inode, nr << inode->i_blkbits);
 306}
 307
 308static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
 309{
 310        return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
 311}
 312
 313static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
 314{
 315        int ret;
 316
 317        ret = dquot_prealloc_block_nodirty(inode, nr);
 318        if (!ret)
 319                mark_inode_dirty_sync(inode);
 320        return ret;
 321}
 322
 323static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
 324{
 325        return __dquot_alloc_space(inode, nr << inode->i_blkbits,
 326                                DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
 327}
 328
 329static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
 330{
 331        int ret;
 332
 333        ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
 334        if (!ret)
 335                mark_inode_dirty_sync(inode);
 336        return ret;
 337}
 338
 339static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
 340{
 341        __dquot_free_space(inode, nr, 0);
 342}
 343
 344static inline void dquot_free_space(struct inode *inode, qsize_t nr)
 345{
 346        dquot_free_space_nodirty(inode, nr);
 347        mark_inode_dirty_sync(inode);
 348}
 349
 350static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
 351{
 352        dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
 353}
 354
 355static inline void dquot_free_block(struct inode *inode, qsize_t nr)
 356{
 357        dquot_free_space(inode, nr << inode->i_blkbits);
 358}
 359
 360static inline void dquot_release_reservation_block(struct inode *inode,
 361                qsize_t nr)
 362{
 363        __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
 364}
 365
 366#endif /* _LINUX_QUOTAOPS_ */
 367
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.