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