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