release/src-rt-6.x.4708/linux/linux-2.6.36/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 #define quota_error(sb, fmt, args...) \
  32         __quota_error((sb), __func__, fmt , ## args)
  33
  34 extern void __quota_error(struct super_block *sb, const char *func,
  35                          const char *fmt, ...);
  36
  37 /*
  38  * declaration of quota_function calls in kernel.
  39  */
  40 void inode_add_rsv_space(struct inode *inode, qsize_t number);
  41 void inode_claim_rsv_space(struct inode *inode, qsize_t number);
  42 void inode_sub_rsv_space(struct inode *inode, qsize_t number);
  43
  44 void dquot_initialize(struct inode *inode);
  45 void dquot_drop(struct inode *inode);
  46 struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
  47 void dqput(struct dquot *dquot);
  48 int dquot_scan_active(struct super_block *sb,
  49                       int (*fn)(struct dquot *dquot, unsigned long priv),
  50                       unsigned long priv);
  51 struct dquot *dquot_alloc(struct super_block *sb, int type);
  52 void dquot_destroy(struct dquot *dquot);
  53
  54 int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
  55 void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
  56
  57 int dquot_alloc_inode(const struct inode *inode);
  58
  59 int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
  60 void dquot_free_inode(const struct inode *inode);
  61
  62 int dquot_disable(struct super_block *sb, int type, unsigned int flags);
  63 /* Suspend quotas on remount RO */
  64 static inline int dquot_suspend(struct super_block *sb, int type)
  65 {
  66         return dquot_disable(sb, type, DQUOT_SUSPENDED);
  67 }
  68 int dquot_resume(struct super_block *sb, int type);
  69
  70 int dquot_commit(struct dquot *dquot);
  71 int dquot_acquire(struct dquot *dquot);
  72 int dquot_release(struct dquot *dquot);
  73 int dquot_commit_info(struct super_block *sb, int type);
  74 int dquot_mark_dquot_dirty(struct dquot *dquot);
  75
  76 int dquot_file_open(struct inode *inode, struct file *file);
  77
  78 int dquot_quota_on(struct super_block *sb, int type, int format_id,
  79         char *path);
  80 int dquot_enable(struct inode *inode, int type, int format_id,
  81         unsigned int flags);
  82 int dquot_quota_on_path(struct super_block *sb, int type, int format_id,
  83         struct path *path);
  84 int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
  85         int format_id, int type);
  86 int dquot_quota_off(struct super_block *sb, int type);
  87 int dquot_quota_sync(struct super_block *sb, int type, int wait);
  88 int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  89 int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  90 int dquot_get_dqblk(struct super_block *sb, int type, qid_t id,
  91                 struct fs_disk_quota *di);
  92 int dquot_set_dqblk(struct super_block *sb, int type, qid_t id,
  93                 struct fs_disk_quota *di);
  94
  95 int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
  96 int dquot_transfer(struct inode *inode, struct iattr *iattr);
  97
  98 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
  99 {
 100         return sb_dqopt(sb)->info + type;
 101 }
 102
 103 /*
 104  * Functions for checking status of quota
 105  */
 106
 107 static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
 108 {
 109         return sb_dqopt(sb)->flags &
 110                                 dquot_state_flag(DQUOT_USAGE_ENABLED, type);
 111 }
 112
 113 static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
 114 {
 115         return sb_dqopt(sb)->flags &
 116                                 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
 117 }
 118
 119 static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
 120 {
 121         return sb_dqopt(sb)->flags &
 122                                 dquot_state_flag(DQUOT_SUSPENDED, type);
 123 }
 124
 125 static inline unsigned sb_any_quota_suspended(struct super_block *sb)
 126 {
 127         unsigned type, tmsk = 0;
 128         for (type = 0; type < MAXQUOTAS; type++)
 129                 tmsk |= sb_has_quota_suspended(sb, type) << type;
 130         return tmsk;
 131 }
 132
 133 /* Does kernel know about any quota information for given sb + type? */
 134 static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
 135 {
 136         /* Currently if anything is on, then quota usage is on as well */
 137         return sb_has_quota_usage_enabled(sb, type);
 138 }
 139
 140 static inline unsigned sb_any_quota_loaded(struct super_block *sb)
 141 {
 142         unsigned type, tmsk = 0;
 143         for (type = 0; type < MAXQUOTAS; type++)
 144                 tmsk |= sb_has_quota_loaded(sb, type) << type;
 145         return  tmsk;
 146 }
 147
 148 static inline bool sb_has_quota_active(struct super_block *sb, int type)
 149 {
 150         return sb_has_quota_loaded(sb, type) &&
 151                !sb_has_quota_suspended(sb, type);
 152 }
 153
 154 /*
 155  * Operations supported for diskquotas.
 156  */
 157 extern const struct dquot_operations dquot_operations;
 158 extern const struct quotactl_ops dquot_quotactl_ops;
 159
 160 #else
 161
 162 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
 163 {
 164         return 0;
 165 }
 166
 167 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
 168 {
 169         return 0;
 170 }
 171
 172 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
 173 {
 174         return 0;
 175 }
 176
 177 static inline int sb_any_quota_suspended(struct super_block *sb)
 178 {
 179         return 0;
 180 }
 181
 182 /* Does kernel know about any quota information for given sb + type? */
 183 static inline int sb_has_quota_loaded(struct super_block *sb, int type)
 184 {
 185         return 0;
 186 }
 187
 188 static inline int sb_any_quota_loaded(struct super_block *sb)
 189 {
 190         return 0;
 191 }
 192
 193 static inline int sb_has_quota_active(struct super_block *sb, int type)
 194 {
 195         return 0;
 196 }
 197
 198 static inline void dquot_initialize(struct inode *inode)
 199 {
 200 }
 201
 202 static inline void dquot_drop(struct inode *inode)
 203 {
 204 }
 205
 206 static inline int dquot_alloc_inode(const struct inode *inode)
 207 {
 208         return 0;
 209 }
 210
 211 static inline void dquot_free_inode(const struct inode *inode)
 212 {
 213 }
 214
 215 static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
 216 {
 217         return 0;
 218 }
 219
 220 static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
 221                 int flags)
 222 {
 223         if (!(flags & DQUOT_SPACE_RESERVE))
 224                 inode_add_bytes(inode, number);
 225         return 0;
 226 }
 227
 228 static inline void __dquot_free_space(struct inode *inode, qsize_t number,
 229                 int flags)
 230 {
 231         if (!(flags & DQUOT_SPACE_RESERVE))
 232                 inode_sub_bytes(inode, number);
 233 }
 234
 235 static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
 236 {
 237         inode_add_bytes(inode, number);
 238         return 0;
 239 }
 240
 241 static inline int dquot_disable(struct super_block *sb, int type,
 242                 unsigned int flags)
 243 {
 244         return 0;
 245 }
 246
 247 static inline int dquot_suspend(struct super_block *sb, int type)
 248 {
 249         return 0;
 250 }
 251
 252 static inline int dquot_resume(struct super_block *sb, int type)
 253 {
 254         return 0;
 255 }
 256
 257 #define dquot_file_open         generic_file_open
 258
 259 #endif /* CONFIG_QUOTA */
 260
 261 static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
 262 {
 263         return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
 264 }
 265
 266 static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
 267 {
 268         __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
 269         mark_inode_dirty_sync(inode);
 270 }
 271
 272 static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
 273 {
 274         int ret;
 275
 276         ret = dquot_alloc_space_nodirty(inode, nr);
 277         if (!ret) {
 278                 /*
 279                  * Mark inode fully dirty. Since we are allocating blocks, inode
 280                  * would become fully dirty soon anyway and it reportedly
 281                  * reduces inode_lock contention.
 282                  */
 283                 mark_inode_dirty(inode);
 284         }
 285         return ret;
 286 }
 287
 288 static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
 289 {
 290         return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
 291 }
 292
 293 static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
 294 {
 295         dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
 296 }
 297
 298 static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
 299 {
 300         return dquot_alloc_space(inode, nr << inode->i_blkbits);
 301 }
 302
 303 static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
 304 {
 305         return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
 306 }
 307
 308 static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
 309 {
 310         int ret;
 311
 312         ret = dquot_prealloc_block_nodirty(inode, nr);
 313         if (!ret)
 314                 mark_inode_dirty_sync(inode);
 315         return ret;
 316 }
 317
 318 static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
 319 {
 320         return __dquot_alloc_space(inode, nr << inode->i_blkbits,
 321                                 DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
 322 }
 323
 324 static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
 325 {
 326         int ret;
 327
 328         ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
 329         if (!ret)
 330                 mark_inode_dirty_sync(inode);
 331         return ret;
 332 }
 333
 334 static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
 335 {
 336         __dquot_free_space(inode, nr, 0);
 337 }
 338
 339 static inline void dquot_free_space(struct inode *inode, qsize_t nr)
 340 {
 341         dquot_free_space_nodirty(inode, nr);
 342         mark_inode_dirty_sync(inode);
 343 }
 344
 345 static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
 346 {
 347         dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
 348 }
 349
 350 static inline void dquot_free_block(struct inode *inode, qsize_t nr)
 351 {
 352         dquot_free_space(inode, nr << inode->i_blkbits);
 353 }
 354
 355 static inline void dquot_release_reservation_block(struct inode *inode,
 356                 qsize_t nr)
 357 {
 358         __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
 359 }
 360
 361 #endif /* _LINUX_QUOTAOPS_ */