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 #define DQUOT_SPACE_WARN        0x1
  13 #define DQUOT_SPACE_RESERVE     0x2
  14 #define DQUOT_SPACE_NOFAIL      0x4
  15
  16 static inline struct quota_info *sb_dqopt(struct super_block *sb)
  17 {
  18         return &sb->s_dquot;
  19 }
  20
  21 /* i_mutex must being held */
  22 static 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 && ia->ia_uid != inode->i_uid) ||
  26                 (ia->ia_valid & ATTR_GID && ia->ia_gid != inode->i_gid);
  27 }
  28
  29 #if defined(CONFIG_QUOTA)
  30
  31 /*
  32  * declaration of quota_function calls in kernel.
  33  */
  34 void inode_add_rsv_space(struct inode *inode, qsize_t number);
  35 void inode_claim_rsv_space(struct inode *inode, qsize_t number);
  36 void inode_sub_rsv_space(struct inode *inode, qsize_t number);
  37
  38 void dquot_initialize(struct inode *inode);
  39 void dquot_drop(struct inode *inode);
  40 struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
  41 void dqput(struct dquot *dquot);
  42 int dquot_scan_active(struct super_block *sb,
  43                       int (*fn)(struct dquot *dquot, unsigned long priv),
  44                       unsigned long priv);
  45 struct dquot *dquot_alloc(struct super_block *sb, int type);
  46 void dquot_destroy(struct dquot *dquot);
  47
  48 int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
  49 void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
  50
  51 int dquot_alloc_inode(const struct inode *inode);
  52
  53 int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
  54 void dquot_free_inode(const struct inode *inode);
  55
  56 int dquot_commit(struct dquot *dquot);
  57 int dquot_acquire(struct dquot *dquot);
  58 int dquot_release(struct dquot *dquot);
  59 int dquot_commit_info(struct super_block *sb, int type);
  60 int dquot_mark_dquot_dirty(struct dquot *dquot);
  61
  62 int dquot_file_open(struct inode *inode, struct file *file);
  63
  64 int vfs_quota_on(struct super_block *sb, int type, int format_id,
  65         char *path, int remount);
  66 int vfs_quota_enable(struct inode *inode, int type, int format_id,
  67         unsigned int flags);
  68 int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
  69         struct path *path);
  70 int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
  71         int format_id, int type);
  72 int vfs_quota_off(struct super_block *sb, int type, int remount);
  73 int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags);
  74 int vfs_quota_sync(struct super_block *sb, int type, int wait);
  75 int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  76 int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  77 int vfs_get_dqblk(struct super_block *sb, int type, qid_t id,
  78                 struct fs_disk_quota *di);
  79 int vfs_set_dqblk(struct super_block *sb, int type, qid_t id,
  80                 struct fs_disk_quota *di);
  81
  82 int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
  83 int dquot_transfer(struct inode *inode, struct iattr *iattr);
  84 int vfs_dq_quota_on_remount(struct super_block *sb);
  85
  86 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
  87 {
  88         return sb_dqopt(sb)->info + type;
  89 }
  90
  91 /*
  92  * Functions for checking status of quota
  93  */
  94
  95 static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
  96 {
  97         return sb_dqopt(sb)->flags &
  98                                 dquot_state_flag(DQUOT_USAGE_ENABLED, type);
  99 }
 100
 101 static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
 102 {
 103         return sb_dqopt(sb)->flags &
 104                                 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
 105 }
 106
 107 static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
 108 {
 109         return sb_dqopt(sb)->flags &
 110                                 dquot_state_flag(DQUOT_SUSPENDED, type);
 111 }
 112
 113 static inline unsigned sb_any_quota_suspended(struct super_block *sb)
 114 {
 115         unsigned type, tmsk = 0;
 116         for (type = 0; type < MAXQUOTAS; type++)
 117                 tmsk |= sb_has_quota_suspended(sb, type) << type;
 118         return tmsk;
 119 }
 120
 121 /* Does kernel know about any quota information for given sb + type? */
 122 static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
 123 {
 124         /* Currently if anything is on, then quota usage is on as well */
 125         return sb_has_quota_usage_enabled(sb, type);
 126 }
 127
 128 static inline unsigned sb_any_quota_loaded(struct super_block *sb)
 129 {
 130         unsigned type, tmsk = 0;
 131         for (type = 0; type < MAXQUOTAS; type++)
 132                 tmsk |= sb_has_quota_loaded(sb, type) << type;
 133         return  tmsk;
 134 }
 135
 136 static inline bool sb_has_quota_active(struct super_block *sb, int type)
 137 {
 138         return sb_has_quota_loaded(sb, type) &&
 139                !sb_has_quota_suspended(sb, type);
 140 }
 141
 142 static inline unsigned sb_any_quota_active(struct super_block *sb)
 143 {
 144         return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
 145 }
 146
 147 /*
 148  * Operations supported for diskquotas.
 149  */
 150 extern const struct dquot_operations dquot_operations;
 151 extern const struct quotactl_ops vfs_quotactl_ops;
 152
 153 #define sb_dquot_ops (&dquot_operations)
 154 #define sb_quotactl_ops (&vfs_quotactl_ops)
 155
 156 /* Cannot be called inside a transaction */
 157 static inline int vfs_dq_off(struct super_block *sb, int remount)
 158 {
 159         int ret = -ENOSYS;
 160
 161         if (sb->s_qcop && sb->s_qcop->quota_off)
 162                 ret = sb->s_qcop->quota_off(sb, -1, remount);
 163         return ret;
 164 }
 165
 166 #else
 167
 168 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
 169 {
 170         return 0;
 171 }
 172
 173 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
 174 {
 175         return 0;
 176 }
 177
 178 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
 179 {
 180         return 0;
 181 }
 182
 183 static inline int sb_any_quota_suspended(struct super_block *sb)
 184 {
 185         return 0;
 186 }
 187
 188 /* Does kernel know about any quota information for given sb + type? */
 189 static inline int sb_has_quota_loaded(struct super_block *sb, int type)
 190 {
 191         return 0;
 192 }
 193
 194 static inline int sb_any_quota_loaded(struct super_block *sb)
 195 {
 196         return 0;
 197 }
 198
 199 static inline int sb_has_quota_active(struct super_block *sb, int type)
 200 {
 201         return 0;
 202 }
 203
 204 static inline int sb_any_quota_active(struct super_block *sb)
 205 {
 206         return 0;
 207 }
 208
 209 /*
 210  * NO-OP when quota not configured.
 211  */
 212 #define sb_dquot_ops                            (NULL)
 213 #define sb_quotactl_ops                         (NULL)
 214
 215 static inline void dquot_initialize(struct inode *inode)
 216 {
 217 }
 218
 219 static inline void dquot_drop(struct inode *inode)
 220 {
 221 }
 222
 223 static inline int dquot_alloc_inode(const struct inode *inode)
 224 {
 225         return 0;
 226 }
 227
 228 static inline void dquot_free_inode(const struct inode *inode)
 229 {
 230 }
 231
 232 static inline int vfs_dq_off(struct super_block *sb, int remount)
 233 {
 234         return 0;
 235 }
 236
 237 static inline int vfs_dq_quota_on_remount(struct super_block *sb)
 238 {
 239         return 0;
 240 }
 241
 242 static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
 243 {
 244         return 0;
 245 }
 246
 247 static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
 248                 int flags)
 249 {
 250         if (!(flags & DQUOT_SPACE_RESERVE))
 251                 inode_add_bytes(inode, number);
 252         return 0;
 253 }
 254
 255 static inline void __dquot_free_space(struct inode *inode, qsize_t number,
 256                 int flags)
 257 {
 258         if (!(flags & DQUOT_SPACE_RESERVE))
 259                 inode_sub_bytes(inode, number);
 260 }
 261
 262 static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
 263 {
 264         inode_add_bytes(inode, number);
 265         return 0;
 266 }
 267
 268 #define dquot_file_open         generic_file_open
 269
 270 #endif /* CONFIG_QUOTA */
 271
 272 static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
 273 {
 274         return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
 275 }
 276
 277 static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
 278 {
 279         __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
 280         mark_inode_dirty(inode);
 281 }
 282
 283 static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
 284 {
 285         int ret;
 286
 287         ret = dquot_alloc_space_nodirty(inode, nr);
 288         if (!ret)
 289                 mark_inode_dirty(inode);
 290         return ret;
 291 }
 292
 293 static 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
 298 static 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
 303 static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
 304 {
 305         return dquot_alloc_space(inode, nr << inode->i_blkbits);
 306 }
 307
 308 static 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
 313 static 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(inode);
 320         return ret;
 321 }
 322
 323 static 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
 329 static 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(inode);
 336         return ret;
 337 }
 338
 339 static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
 340 {
 341         __dquot_free_space(inode, nr, 0);
 342 }
 343
 344 static inline void dquot_free_space(struct inode *inode, qsize_t nr)
 345 {
 346         dquot_free_space_nodirty(inode, nr);
 347         mark_inode_dirty(inode);
 348 }
 349
 350 static 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
 355 static inline void dquot_free_block(struct inode *inode, qsize_t nr)
 356 {
 357         dquot_free_space(inode, nr << inode->i_blkbits);
 358 }
 359
 360 static 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_ */