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/smp_lock.h>
  11 #include <linux/fs.h>
  12
  13 static inline struct quota_info *sb_dqopt(struct super_block *sb)
  14 {
  15         return &sb->s_dquot;
  16 }
  17
  18 #if defined(CONFIG_QUOTA)
  19
  20 /*
  21  * declaration of quota_function calls in kernel.
  22  */
  23 void sync_dquots(struct super_block *sb, int type);
  24
  25 int dquot_initialize(struct inode *inode, int type);
  26 int dquot_drop(struct inode *inode);
  27
  28 int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
  29 int dquot_alloc_inode(const struct inode *inode, unsigned long number);
  30
  31 int dquot_free_space(struct inode *inode, qsize_t number);
  32 int dquot_free_inode(const struct inode *inode, unsigned long number);
  33
  34 int dquot_transfer(struct inode *inode, struct iattr *iattr);
  35 int dquot_commit(struct dquot *dquot);
  36 int dquot_acquire(struct dquot *dquot);
  37 int dquot_release(struct dquot *dquot);
  38 int dquot_commit_info(struct super_block *sb, int type);
  39 int dquot_mark_dquot_dirty(struct dquot *dquot);
  40
  41 int vfs_quota_on(struct super_block *sb, int type, int format_id,
  42         char *path, int remount);
  43 int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
  44         struct path *path);
  45 int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
  46         int format_id, int type);
  47 int vfs_quota_off(struct super_block *sb, int type, int remount);
  48 int vfs_quota_sync(struct super_block *sb, int type);
  49 int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  50 int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  51 int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
  52 int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
  53
  54 void vfs_dq_drop(struct inode *inode);
  55 int vfs_dq_transfer(struct inode *inode, struct iattr *iattr);
  56 int vfs_dq_quota_on_remount(struct super_block *sb);
  57
  58 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
  59 {
  60         return sb_dqopt(sb)->info + type;
  61 }
  62
  63 /*
  64  * Functions for checking status of quota
  65  */
  66
  67 static inline int sb_has_quota_enabled(struct super_block *sb, int type)
  68 {
  69         if (type == USRQUOTA)
  70                 return sb_dqopt(sb)->flags & DQUOT_USR_ENABLED;
  71         return sb_dqopt(sb)->flags & DQUOT_GRP_ENABLED;
  72 }
  73
  74 static inline int sb_any_quota_enabled(struct super_block *sb)
  75 {
  76         return sb_has_quota_enabled(sb, USRQUOTA) ||
  77                 sb_has_quota_enabled(sb, GRPQUOTA);
  78 }
  79
  80 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
  81 {
  82         if (type == USRQUOTA)
  83                 return sb_dqopt(sb)->flags & DQUOT_USR_SUSPENDED;
  84         return sb_dqopt(sb)->flags & DQUOT_GRP_SUSPENDED;
  85 }
  86
  87 static inline int sb_any_quota_suspended(struct super_block *sb)
  88 {
  89         return sb_has_quota_suspended(sb, USRQUOTA) ||
  90                 sb_has_quota_suspended(sb, GRPQUOTA);
  91 }
  92
  93 /*
  94  * Operations supported for diskquotas.
  95  */
  96 extern struct dquot_operations dquot_operations;
  97 extern struct quotactl_ops vfs_quotactl_ops;
  98
  99 #define sb_dquot_ops (&dquot_operations)
 100 #define sb_quotactl_ops (&vfs_quotactl_ops)
 101
 102 /* It is better to call this function outside of any transaction as it might
 103  * need a lot of space in journal for dquot structure allocation. */
 104 static inline void vfs_dq_init(struct inode *inode)
 105 {
 106         BUG_ON(!inode->i_sb);
 107         if (sb_any_quota_enabled(inode->i_sb) && !IS_NOQUOTA(inode))
 108                 inode->i_sb->dq_op->initialize(inode, -1);
 109 }
 110
 111 /* The following allocation/freeing/transfer functions *must* be called inside
 112  * a transaction (deadlocks possible otherwise) */
 113 static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
 114 {
 115         if (sb_any_quota_enabled(inode->i_sb)) {
 116                 /* Used space is updated in alloc_space() */
 117                 if (inode->i_sb->dq_op->alloc_space(inode, nr, 1) == NO_QUOTA)
 118                         return 1;
 119         }
 120         else
 121                 inode_add_bytes(inode, nr);
 122         return 0;
 123 }
 124
 125 static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
 126 {
 127         int ret;
 128         if (!(ret =  vfs_dq_prealloc_space_nodirty(inode, nr)))
 129                 mark_inode_dirty(inode);
 130         return ret;
 131 }
 132
 133 static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
 134 {
 135         if (sb_any_quota_enabled(inode->i_sb)) {
 136                 /* Used space is updated in alloc_space() */
 137                 if (inode->i_sb->dq_op->alloc_space(inode, nr, 0) == NO_QUOTA)
 138                         return 1;
 139         }
 140         else
 141                 inode_add_bytes(inode, nr);
 142         return 0;
 143 }
 144
 145 static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
 146 {
 147         int ret;
 148         if (!(ret = vfs_dq_alloc_space_nodirty(inode, nr)))
 149                 mark_inode_dirty(inode);
 150         return ret;
 151 }
 152
 153 static inline int vfs_dq_alloc_inode(struct inode *inode)
 154 {
 155         if (sb_any_quota_enabled(inode->i_sb)) {
 156                 vfs_dq_init(inode);
 157                 if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
 158                         return 1;
 159         }
 160         return 0;
 161 }
 162
 163 static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
 164 {
 165         if (sb_any_quota_enabled(inode->i_sb))
 166                 inode->i_sb->dq_op->free_space(inode, nr);
 167         else
 168                 inode_sub_bytes(inode, nr);
 169 }
 170
 171 static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
 172 {
 173         vfs_dq_free_space_nodirty(inode, nr);
 174         mark_inode_dirty(inode);
 175 }
 176
 177 static inline void vfs_dq_free_inode(struct inode *inode)
 178 {
 179         if (sb_any_quota_enabled(inode->i_sb))
 180                 inode->i_sb->dq_op->free_inode(inode, 1);
 181 }
 182
 183 /* The following two functions cannot be called inside a transaction */
 184 static inline void vfs_dq_sync(struct super_block *sb)
 185 {
 186         sync_dquots(sb, -1);
 187 }
 188
 189 static inline int vfs_dq_off(struct super_block *sb, int remount)
 190 {
 191         int ret = -ENOSYS;
 192
 193         if (sb->s_qcop && sb->s_qcop->quota_off)
 194                 ret = sb->s_qcop->quota_off(sb, -1, remount);
 195         return ret;
 196 }
 197
 198 #else
 199
 200 static inline int sb_has_quota_enabled(struct super_block *sb, int type)
 201 {
 202         return 0;
 203 }
 204
 205 static inline int sb_any_quota_enabled(struct super_block *sb)
 206 {
 207         return 0;
 208 }
 209
 210 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
 211 {
 212         return 0;
 213 }
 214
 215 static inline int sb_any_quota_suspended(struct super_block *sb)
 216 {
 217         return 0;
 218 }
 219
 220 /*
 221  * NO-OP when quota not configured.
 222  */
 223 #define sb_dquot_ops                            (NULL)
 224 #define sb_quotactl_ops                         (NULL)
 225
 226 static inline void vfs_dq_init(struct inode *inode)
 227 {
 228 }
 229
 230 static inline void vfs_dq_drop(struct inode *inode)
 231 {
 232 }
 233
 234 static inline int vfs_dq_alloc_inode(struct inode *inode)
 235 {
 236         return 0;
 237 }
 238
 239 static inline void vfs_dq_free_inode(struct inode *inode)
 240 {
 241 }
 242
 243 static inline void vfs_dq_sync(struct super_block *sb)
 244 {
 245 }
 246
 247 static inline int vfs_dq_off(struct super_block *sb, int remount)
 248 {
 249         return 0;
 250 }
 251
 252 static inline int vfs_dq_quota_on_remount(struct super_block *sb)
 253 {
 254         return 0;
 255 }
 256
 257 static inline int vfs_dq_transfer(struct inode *inode, struct iattr *iattr)
 258 {
 259         return 0;
 260 }
 261
 262 static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
 263 {
 264         inode_add_bytes(inode, nr);
 265         return 0;
 266 }
 267
 268 static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
 269 {
 270         vfs_dq_prealloc_space_nodirty(inode, nr);
 271         mark_inode_dirty(inode);
 272         return 0;
 273 }
 274
 275 static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
 276 {
 277         inode_add_bytes(inode, nr);
 278         return 0;
 279 }
 280
 281 static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
 282 {
 283         vfs_dq_alloc_space_nodirty(inode, nr);
 284         mark_inode_dirty(inode);
 285         return 0;
 286 }
 287
 288 static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
 289 {
 290         inode_sub_bytes(inode, nr);
 291 }
 292
 293 static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
 294 {
 295         vfs_dq_free_space_nodirty(inode, nr);
 296         mark_inode_dirty(inode);
 297 }
 298
 299 #endif /* CONFIG_QUOTA */
 300
 301 static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
 302 {
 303         return vfs_dq_prealloc_space_nodirty(inode,
 304                         nr << inode->i_sb->s_blocksize_bits);
 305 }
 306
 307 static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
 308 {
 309         return vfs_dq_prealloc_space(inode,
 310                         nr << inode->i_sb->s_blocksize_bits);
 311 }
 312
 313 static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
 314 {
 315         return vfs_dq_alloc_space_nodirty(inode,
 316                         nr << inode->i_sb->s_blocksize_bits);
 317 }
 318
 319 static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
 320 {
 321         return vfs_dq_alloc_space(inode,
 322                         nr << inode->i_sb->s_blocksize_bits);
 323 }
 324
 325 static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
 326 {
 327         vfs_dq_free_space_nodirty(inode, nr << inode->i_sb->s_blocksize_bits);
 328 }
 329
 330 static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
 331 {
 332         vfs_dq_free_space(inode, nr << inode->i_sb->s_blocksize_bits);
 333 }
 334
 335 /*
 336  * Define uppercase equivalents for compatibility with old function names
 337  * Can go away when we think all users have been converted (15/04/2008)
 338  */
 339 #define DQUOT_INIT(inode) vfs_dq_init(inode)
 340 #define DQUOT_DROP(inode) vfs_dq_drop(inode)
 341 #define DQUOT_PREALLOC_SPACE_NODIRTY(inode, nr) \
 342                                 vfs_dq_prealloc_space_nodirty(inode, nr)
 343 #define DQUOT_PREALLOC_SPACE(inode, nr) vfs_dq_prealloc_space(inode, nr)
 344 #define DQUOT_ALLOC_SPACE_NODIRTY(inode, nr) \
 345                                 vfs_dq_alloc_space_nodirty(inode, nr)
 346 #define DQUOT_ALLOC_SPACE(inode, nr) vfs_dq_alloc_space(inode, nr)
 347 #define DQUOT_PREALLOC_BLOCK_NODIRTY(inode, nr) \
 348                                 vfs_dq_prealloc_block_nodirty(inode, nr)
 349 #define DQUOT_PREALLOC_BLOCK(inode, nr) vfs_dq_prealloc_block(inode, nr)
 350 #define DQUOT_ALLOC_BLOCK_NODIRTY(inode, nr) \
 351                                 vfs_dq_alloc_block_nodirty(inode, nr)
 352 #define DQUOT_ALLOC_BLOCK(inode, nr) vfs_dq_alloc_block(inode, nr)
 353 #define DQUOT_ALLOC_INODE(inode) vfs_dq_alloc_inode(inode)
 354 #define DQUOT_FREE_SPACE_NODIRTY(inode, nr) \
 355                                 vfs_dq_free_space_nodirty(inode, nr)
 356 #define DQUOT_FREE_SPACE(inode, nr) vfs_dq_free_space(inode, nr)
 357 #define DQUOT_FREE_BLOCK_NODIRTY(inode, nr) \
 358                                 vfs_dq_free_block_nodirty(inode, nr)
 359 #define DQUOT_FREE_BLOCK(inode, nr) vfs_dq_free_block(inode, nr)
 360 #define DQUOT_FREE_INODE(inode) vfs_dq_free_inode(inode)
 361 #define DQUOT_TRANSFER(inode, iattr) vfs_dq_transfer(inode, iattr)
 362 #define DQUOT_SYNC(sb) vfs_dq_sync(sb)
 363 #define DQUOT_OFF(sb, remount) vfs_dq_off(sb, remount)
 364 #define DQUOT_ON_REMOUNT(sb) vfs_dq_quota_on_remount(sb)
 365
 366 #endif /* _LINUX_QUOTAOPS_ */