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