quotaops.h 9.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355
  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. #include <linux/fs.h>
  10. #define DQUOT_SPACE_WARN 0x1
  11. #define DQUOT_SPACE_RESERVE 0x2
  12. #define DQUOT_SPACE_NOFAIL 0x4
  13. static inline struct quota_info *sb_dqopt(struct super_block *sb)
  14. {
  15. return &sb->s_dquot;
  16. }
  17. /* i_mutex must being held */
  18. static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
  19. {
  20. return (ia->ia_valid & ATTR_SIZE && ia->ia_size != inode->i_size) ||
  21. (ia->ia_valid & ATTR_UID && ia->ia_uid != inode->i_uid) ||
  22. (ia->ia_valid & ATTR_GID && ia->ia_gid != inode->i_gid);
  23. }
  24. #if defined(CONFIG_QUOTA)
  25. #define quota_error(sb, fmt, args...) \
  26. __quota_error((sb), __func__, fmt , ## args)
  27. extern void __quota_error(struct super_block *sb, const char *func,
  28. const char *fmt, ...);
  29. /*
  30. * declaration of quota_function calls in kernel.
  31. */
  32. void inode_add_rsv_space(struct inode *inode, qsize_t number);
  33. void inode_claim_rsv_space(struct inode *inode, qsize_t number);
  34. void inode_sub_rsv_space(struct inode *inode, qsize_t number);
  35. void dquot_initialize(struct inode *inode);
  36. void dquot_drop(struct inode *inode);
  37. struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
  38. void dqput(struct dquot *dquot);
  39. int dquot_scan_active(struct super_block *sb,
  40. int (*fn)(struct dquot *dquot, unsigned long priv),
  41. unsigned long priv);
  42. struct dquot *dquot_alloc(struct super_block *sb, int type);
  43. void dquot_destroy(struct dquot *dquot);
  44. int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
  45. void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
  46. int dquot_alloc_inode(const struct inode *inode);
  47. int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
  48. void dquot_free_inode(const struct inode *inode);
  49. int dquot_disable(struct super_block *sb, int type, unsigned int flags);
  50. /* Suspend quotas on remount RO */
  51. static inline int dquot_suspend(struct super_block *sb, int type)
  52. {
  53. return dquot_disable(sb, type, DQUOT_SUSPENDED);
  54. }
  55. int dquot_resume(struct super_block *sb, int type);
  56. int dquot_commit(struct dquot *dquot);
  57. int dquot_acquire(struct dquot *dquot);
  58. int dquot_release(struct dquot *dquot);
  59. int dquot_commit_info(struct super_block *sb, int type);
  60. int dquot_mark_dquot_dirty(struct dquot *dquot);
  61. int dquot_file_open(struct inode *inode, struct file *file);
  62. int dquot_quota_on(struct super_block *sb, int type, int format_id,
  63. char *path);
  64. int dquot_enable(struct inode *inode, int type, int format_id,
  65. unsigned int flags);
  66. int dquot_quota_on_path(struct super_block *sb, int type, int format_id,
  67. struct path *path);
  68. int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
  69. int format_id, int type);
  70. int dquot_quota_off(struct super_block *sb, int type);
  71. int dquot_quota_sync(struct super_block *sb, int type, int wait);
  72. int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  73. int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  74. int dquot_get_dqblk(struct super_block *sb, int type, qid_t id,
  75. struct fs_disk_quota *di);
  76. int dquot_set_dqblk(struct super_block *sb, int type, qid_t id,
  77. struct fs_disk_quota *di);
  78. int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
  79. int dquot_transfer(struct inode *inode, struct iattr *iattr);
  80. static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
  81. {
  82. return sb_dqopt(sb)->info + type;
  83. }
  84. /*
  85. * Functions for checking status of quota
  86. */
  87. static inline bool 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. static inline bool 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. static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
  98. {
  99. return sb_dqopt(sb)->flags &
  100. dquot_state_flag(DQUOT_SUSPENDED, type);
  101. }
  102. static inline unsigned sb_any_quota_suspended(struct super_block *sb)
  103. {
  104. unsigned type, tmsk = 0;
  105. for (type = 0; type < MAXQUOTAS; type++)
  106. tmsk |= sb_has_quota_suspended(sb, type) << type;
  107. return tmsk;
  108. }
  109. /* Does kernel know about any quota information for given sb + type? */
  110. static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
  111. {
  112. /* Currently if anything is on, then quota usage is on as well */
  113. return sb_has_quota_usage_enabled(sb, type);
  114. }
  115. static inline unsigned sb_any_quota_loaded(struct super_block *sb)
  116. {
  117. unsigned type, tmsk = 0;
  118. for (type = 0; type < MAXQUOTAS; type++)
  119. tmsk |= sb_has_quota_loaded(sb, type) << type;
  120. return tmsk;
  121. }
  122. static inline bool sb_has_quota_active(struct super_block *sb, int type)
  123. {
  124. return sb_has_quota_loaded(sb, type) &&
  125. !sb_has_quota_suspended(sb, type);
  126. }
  127. /*
  128. * Operations supported for diskquotas.
  129. */
  130. extern const struct dquot_operations dquot_operations;
  131. extern const struct quotactl_ops dquot_quotactl_ops;
  132. #else
  133. static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
  134. {
  135. return 0;
  136. }
  137. static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
  138. {
  139. return 0;
  140. }
  141. static inline int sb_has_quota_suspended(struct super_block *sb, int type)
  142. {
  143. return 0;
  144. }
  145. static inline int sb_any_quota_suspended(struct super_block *sb)
  146. {
  147. return 0;
  148. }
  149. /* Does kernel know about any quota information for given sb + type? */
  150. static inline int sb_has_quota_loaded(struct super_block *sb, int type)
  151. {
  152. return 0;
  153. }
  154. static inline int sb_any_quota_loaded(struct super_block *sb)
  155. {
  156. return 0;
  157. }
  158. static inline int sb_has_quota_active(struct super_block *sb, int type)
  159. {
  160. return 0;
  161. }
  162. static inline void dquot_initialize(struct inode *inode)
  163. {
  164. }
  165. static inline void dquot_drop(struct inode *inode)
  166. {
  167. }
  168. static inline int dquot_alloc_inode(const struct inode *inode)
  169. {
  170. return 0;
  171. }
  172. static inline void dquot_free_inode(const struct inode *inode)
  173. {
  174. }
  175. static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
  176. {
  177. return 0;
  178. }
  179. static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
  180. int flags)
  181. {
  182. if (!(flags & DQUOT_SPACE_RESERVE))
  183. inode_add_bytes(inode, number);
  184. return 0;
  185. }
  186. static inline void __dquot_free_space(struct inode *inode, qsize_t number,
  187. int flags)
  188. {
  189. if (!(flags & DQUOT_SPACE_RESERVE))
  190. inode_sub_bytes(inode, number);
  191. }
  192. static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
  193. {
  194. inode_add_bytes(inode, number);
  195. return 0;
  196. }
  197. static inline int dquot_disable(struct super_block *sb, int type,
  198. unsigned int flags)
  199. {
  200. return 0;
  201. }
  202. static inline int dquot_suspend(struct super_block *sb, int type)
  203. {
  204. return 0;
  205. }
  206. static inline int dquot_resume(struct super_block *sb, int type)
  207. {
  208. return 0;
  209. }
  210. #define dquot_file_open generic_file_open
  211. #endif /* CONFIG_QUOTA */
  212. static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
  213. {
  214. return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
  215. }
  216. static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
  217. {
  218. __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
  219. mark_inode_dirty_sync(inode);
  220. }
  221. static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
  222. {
  223. int ret;
  224. ret = dquot_alloc_space_nodirty(inode, nr);
  225. if (!ret)
  226. mark_inode_dirty_sync(inode);
  227. return ret;
  228. }
  229. static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
  230. {
  231. return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
  232. }
  233. static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
  234. {
  235. dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
  236. }
  237. static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
  238. {
  239. return dquot_alloc_space(inode, nr << inode->i_blkbits);
  240. }
  241. static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
  242. {
  243. return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
  244. }
  245. static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
  246. {
  247. int ret;
  248. ret = dquot_prealloc_block_nodirty(inode, nr);
  249. if (!ret)
  250. mark_inode_dirty_sync(inode);
  251. return ret;
  252. }
  253. static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
  254. {
  255. return __dquot_alloc_space(inode, nr << inode->i_blkbits,
  256. DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
  257. }
  258. static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
  259. {
  260. int ret;
  261. ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
  262. if (!ret)
  263. mark_inode_dirty_sync(inode);
  264. return ret;
  265. }
  266. static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
  267. {
  268. __dquot_free_space(inode, nr, 0);
  269. }
  270. static inline void dquot_free_space(struct inode *inode, qsize_t nr)
  271. {
  272. dquot_free_space_nodirty(inode, nr);
  273. mark_inode_dirty_sync(inode);
  274. }
  275. static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
  276. {
  277. dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
  278. }
  279. static inline void dquot_free_block(struct inode *inode, qsize_t nr)
  280. {
  281. dquot_free_space(inode, nr << inode->i_blkbits);
  282. }
  283. static inline void dquot_release_reservation_block(struct inode *inode,
  284. qsize_t nr)
  285. {
  286. __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
  287. }
  288. #endif /* _LINUX_QUOTAOPS_ */