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