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