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