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 #if defined(CONFIG_QUOTA)
  18
  19 /*
  20  * declaration of quota_function calls in kernel.
  21  */
  22 void inode_add_rsv_space(struct inode *inode, qsize_t number);
  23 void inode_claim_rsv_space(struct inode *inode, qsize_t number);
  24 void inode_sub_rsv_space(struct inode *inode, qsize_t number);
  25
  26 int dquot_initialize(struct inode *inode, int type);
  27 int dquot_drop(struct inode *inode);
  28 struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
  29 void dqput(struct dquot *dquot);
  30 int dquot_scan_active(struct super_block *sb,
  31                       int (*fn)(struct dquot *dquot, unsigned long priv),
  32                       unsigned long priv);
  33 struct dquot *dquot_alloc(struct super_block *sb, int type);
  34 void dquot_destroy(struct dquot *dquot);
  35
  36 int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
  37 int dquot_alloc_inode(const struct inode *inode, qsize_t number);
  38
  39 int dquot_reserve_space(struct inode *inode, qsize_t number, int prealloc);
  40 int dquot_claim_space(struct inode *inode, qsize_t number);
  41 void dquot_release_reserved_space(struct inode *inode, qsize_t number);
  42
  43 int dquot_free_space(struct inode *inode, qsize_t number);
  44 int dquot_free_inode(const struct inode *inode, qsize_t number);
  45
  46 int dquot_transfer(struct inode *inode, struct iattr *iattr);
  47 int dquot_commit(struct dquot *dquot);
  48 int dquot_acquire(struct dquot *dquot);
  49 int dquot_release(struct dquot *dquot);
  50 int dquot_commit_info(struct super_block *sb, int type);
  51 int dquot_mark_dquot_dirty(struct dquot *dquot);
  52
  53 int vfs_quota_on(struct super_block *sb, int type, int format_id,
  54         char *path, int remount);
  55 int vfs_quota_enable(struct inode *inode, int type, int format_id,
  56         unsigned int flags);
  57 int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
  58         struct path *path);
  59 int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
  60         int format_id, int type);
  61 int vfs_quota_off(struct super_block *sb, int type, int remount);
  62 int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags);
  63 int vfs_quota_sync(struct super_block *sb, int type, int wait);
  64 int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  65 int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  66 int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
  67 int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
  68
  69 void vfs_dq_drop(struct inode *inode);
  70 int vfs_dq_transfer(struct inode *inode, struct iattr *iattr);
  71 int vfs_dq_quota_on_remount(struct super_block *sb);
  72
  73 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
  74 {
  75         return sb_dqopt(sb)->info + type;
  76 }
  77
  78 /*
  79  * Functions for checking status of quota
  80  */
  81
  82 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
  83 {
  84         return sb_dqopt(sb)->flags &
  85                                 dquot_state_flag(DQUOT_USAGE_ENABLED, type);
  86 }
  87
  88 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
  89 {
  90         return sb_dqopt(sb)->flags &
  91                                 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
  92 }
  93
  94 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
  95 {
  96         return sb_dqopt(sb)->flags &
  97                                 dquot_state_flag(DQUOT_SUSPENDED, type);
  98 }
  99
 100 static inline int sb_any_quota_suspended(struct super_block *sb)
 101 {
 102         return sb_has_quota_suspended(sb, USRQUOTA) ||
 103                 sb_has_quota_suspended(sb, GRPQUOTA);
 104 }
 105
 106 /* Does kernel know about any quota information for given sb + type? */
 107 static inline int sb_has_quota_loaded(struct super_block *sb, int type)
 108 {
 109         /* Currently if anything is on, then quota usage is on as well */
 110         return sb_has_quota_usage_enabled(sb, type);
 111 }
 112
 113 static inline int sb_any_quota_loaded(struct super_block *sb)
 114 {
 115         return sb_has_quota_loaded(sb, USRQUOTA) ||
 116                 sb_has_quota_loaded(sb, GRPQUOTA);
 117 }
 118
 119 static inline int sb_has_quota_active(struct super_block *sb, int type)
 120 {
 121         return sb_has_quota_loaded(sb, type) &&
 122                !sb_has_quota_suspended(sb, type);
 123 }
 124
 125 static inline int sb_any_quota_active(struct super_block *sb)
 126 {
 127         return sb_has_quota_active(sb, USRQUOTA) ||
 128                sb_has_quota_active(sb, GRPQUOTA);
 129 }
 130
 131 /*
 132  * Operations supported for diskquotas.
 133  */
 134 extern const struct dquot_operations dquot_operations;
 135 extern const struct quotactl_ops vfs_quotactl_ops;
 136
 137 #define sb_dquot_ops (&dquot_operations)
 138 #define sb_quotactl_ops (&vfs_quotactl_ops)
 139
 140 /* It is better to call this function outside of any transaction as it might
 141  * need a lot of space in journal for dquot structure allocation. */
 142 static inline void vfs_dq_init(struct inode *inode)
 143 {
 144         BUG_ON(!inode->i_sb);
 145         if (sb_any_quota_active(inode->i_sb) && !IS_NOQUOTA(inode))
 146                 inode->i_sb->dq_op->initialize(inode, -1);
 147 }
 148
 149 /* The following allocation/freeing/transfer functions *must* be called inside
 150  * a transaction (deadlocks possible otherwise) */
 151 static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
 152 {
 153         if (sb_any_quota_active(inode->i_sb)) {
 154                 /* Used space is updated in alloc_space() */
 155                 if (inode->i_sb->dq_op->alloc_space(inode, nr, 1) == NO_QUOTA)
 156                         return 1;
 157         }
 158         else
 159                 inode_add_bytes(inode, nr);
 160         return 0;
 161 }
 162
 163 static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
 164 {
 165         int ret;
 166         if (!(ret =  vfs_dq_prealloc_space_nodirty(inode, nr)))
 167                 mark_inode_dirty(inode);
 168         return ret;
 169 }
 170
 171 static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
 172 {
 173         if (sb_any_quota_active(inode->i_sb)) {
 174                 /* Used space is updated in alloc_space() */
 175                 if (inode->i_sb->dq_op->alloc_space(inode, nr, 0) == NO_QUOTA)
 176                         return 1;
 177         }
 178         else
 179                 inode_add_bytes(inode, nr);
 180         return 0;
 181 }
 182
 183 static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
 184 {
 185         int ret;
 186         if (!(ret = vfs_dq_alloc_space_nodirty(inode, nr)))
 187                 mark_inode_dirty(inode);
 188         return ret;
 189 }
 190
 191 static inline int vfs_dq_reserve_space(struct inode *inode, qsize_t nr)
 192 {
 193         if (sb_any_quota_active(inode->i_sb)) {
 194                 /* Used space is updated in alloc_space() */
 195                 if (inode->i_sb->dq_op->reserve_space(inode, nr, 0) == NO_QUOTA)
 196                         return 1;
 197         }
 198         else
 199                 inode_add_rsv_space(inode, nr);
 200         return 0;
 201 }
 202
 203 static inline int vfs_dq_alloc_inode(struct inode *inode)
 204 {
 205         if (sb_any_quota_active(inode->i_sb)) {
 206                 vfs_dq_init(inode);
 207                 if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
 208                         return 1;
 209         }
 210         return 0;
 211 }
 212
 213 /*
 214  * Convert in-memory reserved quotas to real consumed quotas
 215  */
 216 static inline int vfs_dq_claim_space(struct inode *inode, qsize_t nr)
 217 {
 218         if (sb_any_quota_active(inode->i_sb)) {
 219                 if (inode->i_sb->dq_op->claim_space(inode, nr) == NO_QUOTA)
 220                         return 1;
 221         } else
 222                 inode_claim_rsv_space(inode, nr);
 223
 224         mark_inode_dirty(inode);
 225         return 0;
 226 }
 227
 228 /*
 229  * Release reserved (in-memory) quotas
 230  */
 231 static inline
 232 void vfs_dq_release_reservation_space(struct inode *inode, qsize_t nr)
 233 {
 234         if (sb_any_quota_active(inode->i_sb))
 235                 inode->i_sb->dq_op->release_rsv(inode, nr);
 236         else
 237                 inode_sub_rsv_space(inode, nr);
 238 }
 239
 240 static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
 241 {
 242         if (sb_any_quota_active(inode->i_sb))
 243                 inode->i_sb->dq_op->free_space(inode, nr);
 244         else
 245                 inode_sub_bytes(inode, nr);
 246 }
 247
 248 static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
 249 {
 250         vfs_dq_free_space_nodirty(inode, nr);
 251         mark_inode_dirty(inode);
 252 }
 253
 254 static inline void vfs_dq_free_inode(struct inode *inode)
 255 {
 256         if (sb_any_quota_active(inode->i_sb))
 257                 inode->i_sb->dq_op->free_inode(inode, 1);
 258 }
 259
 260 /* Cannot be called inside a transaction */
 261 static inline int vfs_dq_off(struct super_block *sb, int remount)
 262 {
 263         int ret = -ENOSYS;
 264
 265         if (sb->s_qcop && sb->s_qcop->quota_off)
 266                 ret = sb->s_qcop->quota_off(sb, -1, remount);
 267         return ret;
 268 }
 269
 270 #else
 271
 272 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
 273 {
 274         return 0;
 275 }
 276
 277 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
 278 {
 279         return 0;
 280 }
 281
 282 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
 283 {
 284         return 0;
 285 }
 286
 287 static inline int sb_any_quota_suspended(struct super_block *sb)
 288 {
 289         return 0;
 290 }
 291
 292 /* Does kernel know about any quota information for given sb + type? */
 293 static inline int sb_has_quota_loaded(struct super_block *sb, int type)
 294 {
 295         return 0;
 296 }
 297
 298 static inline int sb_any_quota_loaded(struct super_block *sb)
 299 {
 300         return 0;
 301 }
 302
 303 static inline int sb_has_quota_active(struct super_block *sb, int type)
 304 {
 305         return 0;
 306 }
 307
 308 static inline int sb_any_quota_active(struct super_block *sb)
 309 {
 310         return 0;
 311 }
 312
 313 /*
 314  * NO-OP when quota not configured.
 315  */
 316 #define sb_dquot_ops                            (NULL)
 317 #define sb_quotactl_ops                         (NULL)
 318
 319 static inline void vfs_dq_init(struct inode *inode)
 320 {
 321 }
 322
 323 static inline void vfs_dq_drop(struct inode *inode)
 324 {
 325 }
 326
 327 static inline int vfs_dq_alloc_inode(struct inode *inode)
 328 {
 329         return 0;
 330 }
 331
 332 static inline void vfs_dq_free_inode(struct inode *inode)
 333 {
 334 }
 335
 336 static inline int vfs_dq_off(struct super_block *sb, int remount)
 337 {
 338         return 0;
 339 }
 340
 341 static inline int vfs_dq_quota_on_remount(struct super_block *sb)
 342 {
 343         return 0;
 344 }
 345
 346 static inline int vfs_dq_transfer(struct inode *inode, struct iattr *iattr)
 347 {
 348         return 0;
 349 }
 350
 351 static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
 352 {
 353         inode_add_bytes(inode, nr);
 354         return 0;
 355 }
 356
 357 static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
 358 {
 359         vfs_dq_prealloc_space_nodirty(inode, nr);
 360         mark_inode_dirty(inode);
 361         return 0;
 362 }
 363
 364 static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
 365 {
 366         inode_add_bytes(inode, nr);
 367         return 0;
 368 }
 369
 370 static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
 371 {
 372         vfs_dq_alloc_space_nodirty(inode, nr);
 373         mark_inode_dirty(inode);
 374         return 0;
 375 }
 376
 377 static inline int vfs_dq_reserve_space(struct inode *inode, qsize_t nr)
 378 {
 379         return 0;
 380 }
 381
 382 static inline int vfs_dq_claim_space(struct inode *inode, qsize_t nr)
 383 {
 384         return vfs_dq_alloc_space(inode, nr);
 385 }
 386
 387 static inline
 388 int vfs_dq_release_reservation_space(struct inode *inode, qsize_t nr)
 389 {
 390         return 0;
 391 }
 392
 393 static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
 394 {
 395         inode_sub_bytes(inode, nr);
 396 }
 397
 398 static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
 399 {
 400         vfs_dq_free_space_nodirty(inode, nr);
 401         mark_inode_dirty(inode);
 402 }
 403
 404 #endif /* CONFIG_QUOTA */
 405
 406 static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
 407 {
 408         return vfs_dq_prealloc_space_nodirty(inode, nr << inode->i_blkbits);
 409 }
 410
 411 static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
 412 {
 413         return vfs_dq_prealloc_space(inode, nr << inode->i_blkbits);
 414 }
 415
 416 static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
 417 {
 418         return vfs_dq_alloc_space_nodirty(inode, nr << inode->i_blkbits);
 419 }
 420
 421 static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
 422 {
 423         return vfs_dq_alloc_space(inode, nr << inode->i_blkbits);
 424 }
 425
 426 static inline int vfs_dq_reserve_block(struct inode *inode, qsize_t nr)
 427 {
 428         return vfs_dq_reserve_space(inode, nr << inode->i_blkbits);
 429 }
 430
 431 static inline int vfs_dq_claim_block(struct inode *inode, qsize_t nr)
 432 {
 433         return vfs_dq_claim_space(inode, nr << inode->i_blkbits);
 434 }
 435
 436 static inline
 437 void vfs_dq_release_reservation_block(struct inode *inode, qsize_t nr)
 438 {
 439         vfs_dq_release_reservation_space(inode, nr << inode->i_blkbits);
 440 }
 441
 442 static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
 443 {
 444         vfs_dq_free_space_nodirty(inode, nr << inode->i_blkbits);
 445 }
 446
 447 static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
 448 {
 449         vfs_dq_free_space(inode, nr << inode->i_blkbits);
 450 }
 451
 452 #endif /* _LINUX_QUOTAOPS_ */