quotaops.h 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403
  1. /* SPDX-License-Identifier: GPL-2.0 */
  2. /*
  3. * Definitions for diskquota-operations. When diskquota is configured these
  4. * macros expand to the right source-code.
  5. *
  6. * Author: Marco van Wieringen <mvw@planets.elm.net>
  7. */
  8. #ifndef _LINUX_QUOTAOPS_
  9. #define _LINUX_QUOTAOPS_
  10. #include <linux/fs.h>
  11. #define DQUOT_SPACE_WARN 0x1
  12. #define DQUOT_SPACE_RESERVE 0x2
  13. #define DQUOT_SPACE_NOFAIL 0x4
  14. static inline struct quota_info *sb_dqopt(struct super_block *sb)
  15. {
  16. return &sb->s_dquot;
  17. }
  18. /* i_mutex must being held */
  19. static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
  20. {
  21. return (ia->ia_valid & ATTR_SIZE) ||
  22. (ia->ia_valid & ATTR_UID && !uid_eq(ia->ia_uid, inode->i_uid)) ||
  23. (ia->ia_valid & ATTR_GID && !gid_eq(ia->ia_gid, inode->i_gid));
  24. }
  25. #if defined(CONFIG_QUOTA)
  26. #define quota_error(sb, fmt, args...) \
  27. __quota_error((sb), __func__, fmt , ## args)
  28. extern __printf(3, 4)
  29. void __quota_error(struct super_block *sb, const char *func,
  30. const char *fmt, ...);
  31. /*
  32. * declaration of quota_function calls in kernel.
  33. */
  34. int dquot_initialize(struct inode *inode);
  35. bool dquot_initialize_needed(struct inode *inode);
  36. void dquot_drop(struct inode *inode);
  37. struct dquot *dqget(struct super_block *sb, struct kqid qid);
  38. static inline struct dquot *dqgrab(struct dquot *dquot)
  39. {
  40. /* Make sure someone else has active reference to dquot */
  41. WARN_ON_ONCE(!atomic_read(&dquot->dq_count));
  42. WARN_ON_ONCE(!test_bit(DQ_ACTIVE_B, &dquot->dq_flags));
  43. atomic_inc(&dquot->dq_count);
  44. return dquot;
  45. }
  46. static inline bool dquot_is_busy(struct dquot *dquot)
  47. {
  48. if (test_bit(DQ_MOD_B, &dquot->dq_flags))
  49. return true;
  50. if (atomic_read(&dquot->dq_count) > 1)
  51. return true;
  52. return false;
  53. }
  54. void dqput(struct dquot *dquot);
  55. int dquot_scan_active(struct super_block *sb,
  56. int (*fn)(struct dquot *dquot, unsigned long priv),
  57. unsigned long priv);
  58. struct dquot *dquot_alloc(struct super_block *sb, int type);
  59. void dquot_destroy(struct dquot *dquot);
  60. int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
  61. void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
  62. int dquot_alloc_inode(struct inode *inode);
  63. int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
  64. void dquot_free_inode(struct inode *inode);
  65. void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number);
  66. int dquot_disable(struct super_block *sb, int type, unsigned int flags);
  67. /* Suspend quotas on remount RO */
  68. static inline int dquot_suspend(struct super_block *sb, int type)
  69. {
  70. return dquot_disable(sb, type, DQUOT_SUSPENDED);
  71. }
  72. int dquot_resume(struct super_block *sb, int type);
  73. int dquot_commit(struct dquot *dquot);
  74. int dquot_acquire(struct dquot *dquot);
  75. int dquot_release(struct dquot *dquot);
  76. int dquot_commit_info(struct super_block *sb, int type);
  77. int dquot_get_next_id(struct super_block *sb, struct kqid *qid);
  78. int dquot_mark_dquot_dirty(struct dquot *dquot);
  79. int dquot_file_open(struct inode *inode, struct file *file);
  80. int dquot_load_quota_sb(struct super_block *sb, int type, int format_id,
  81. unsigned int flags);
  82. int dquot_load_quota_inode(struct inode *inode, int type, int format_id,
  83. unsigned int flags);
  84. int dquot_quota_on(struct super_block *sb, int type, int format_id,
  85. const struct path *path);
  86. int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
  87. int format_id, int type);
  88. int dquot_quota_off(struct super_block *sb, int type);
  89. int dquot_writeback_dquots(struct super_block *sb, int type);
  90. int dquot_quota_sync(struct super_block *sb, int type);
  91. int dquot_get_state(struct super_block *sb, struct qc_state *state);
  92. int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii);
  93. int dquot_get_dqblk(struct super_block *sb, struct kqid id,
  94. struct qc_dqblk *di);
  95. int dquot_get_next_dqblk(struct super_block *sb, struct kqid *id,
  96. struct qc_dqblk *di);
  97. int dquot_set_dqblk(struct super_block *sb, struct kqid id,
  98. struct qc_dqblk *di);
  99. int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
  100. int dquot_transfer(struct inode *inode, struct iattr *iattr);
  101. static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
  102. {
  103. return sb_dqopt(sb)->info + type;
  104. }
  105. /*
  106. * Functions for checking status of quota
  107. */
  108. static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
  109. {
  110. return sb_dqopt(sb)->flags &
  111. dquot_state_flag(DQUOT_USAGE_ENABLED, type);
  112. }
  113. static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
  114. {
  115. return sb_dqopt(sb)->flags &
  116. dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
  117. }
  118. static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
  119. {
  120. return sb_dqopt(sb)->flags &
  121. dquot_state_flag(DQUOT_SUSPENDED, type);
  122. }
  123. static inline unsigned sb_any_quota_suspended(struct super_block *sb)
  124. {
  125. return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_SUSPENDED);
  126. }
  127. /* Does kernel know about any quota information for given sb + type? */
  128. static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
  129. {
  130. /* Currently if anything is on, then quota usage is on as well */
  131. return sb_has_quota_usage_enabled(sb, type);
  132. }
  133. static inline unsigned sb_any_quota_loaded(struct super_block *sb)
  134. {
  135. return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_USAGE_ENABLED);
  136. }
  137. static inline bool sb_has_quota_active(struct super_block *sb, int type)
  138. {
  139. return sb_has_quota_loaded(sb, type) &&
  140. !sb_has_quota_suspended(sb, type);
  141. }
  142. /*
  143. * Operations supported for diskquotas.
  144. */
  145. extern const struct dquot_operations dquot_operations;
  146. extern const struct quotactl_ops dquot_quotactl_sysfile_ops;
  147. #else
  148. static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
  149. {
  150. return 0;
  151. }
  152. static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
  153. {
  154. return 0;
  155. }
  156. static inline int sb_has_quota_suspended(struct super_block *sb, int type)
  157. {
  158. return 0;
  159. }
  160. static inline int sb_any_quota_suspended(struct super_block *sb)
  161. {
  162. return 0;
  163. }
  164. /* Does kernel know about any quota information for given sb + type? */
  165. static inline int sb_has_quota_loaded(struct super_block *sb, int type)
  166. {
  167. return 0;
  168. }
  169. static inline int sb_any_quota_loaded(struct super_block *sb)
  170. {
  171. return 0;
  172. }
  173. static inline int sb_has_quota_active(struct super_block *sb, int type)
  174. {
  175. return 0;
  176. }
  177. static inline int dquot_initialize(struct inode *inode)
  178. {
  179. return 0;
  180. }
  181. static inline bool dquot_initialize_needed(struct inode *inode)
  182. {
  183. return false;
  184. }
  185. static inline void dquot_drop(struct inode *inode)
  186. {
  187. }
  188. static inline int dquot_alloc_inode(struct inode *inode)
  189. {
  190. return 0;
  191. }
  192. static inline void dquot_free_inode(struct inode *inode)
  193. {
  194. }
  195. static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
  196. {
  197. return 0;
  198. }
  199. static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
  200. int flags)
  201. {
  202. if (!(flags & DQUOT_SPACE_RESERVE))
  203. inode_add_bytes(inode, number);
  204. return 0;
  205. }
  206. static inline void __dquot_free_space(struct inode *inode, qsize_t number,
  207. int flags)
  208. {
  209. if (!(flags & DQUOT_SPACE_RESERVE))
  210. inode_sub_bytes(inode, number);
  211. }
  212. static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
  213. {
  214. inode_add_bytes(inode, number);
  215. return 0;
  216. }
  217. static inline int dquot_reclaim_space_nodirty(struct inode *inode,
  218. qsize_t number)
  219. {
  220. inode_sub_bytes(inode, number);
  221. return 0;
  222. }
  223. static inline int dquot_disable(struct super_block *sb, int type,
  224. unsigned int flags)
  225. {
  226. return 0;
  227. }
  228. static inline int dquot_suspend(struct super_block *sb, int type)
  229. {
  230. return 0;
  231. }
  232. static inline int dquot_resume(struct super_block *sb, int type)
  233. {
  234. return 0;
  235. }
  236. #define dquot_file_open generic_file_open
  237. static inline int dquot_writeback_dquots(struct super_block *sb, int type)
  238. {
  239. return 0;
  240. }
  241. #endif /* CONFIG_QUOTA */
  242. static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
  243. {
  244. return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
  245. }
  246. static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
  247. {
  248. __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
  249. mark_inode_dirty_sync(inode);
  250. }
  251. static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
  252. {
  253. int ret;
  254. ret = dquot_alloc_space_nodirty(inode, nr);
  255. if (!ret) {
  256. /*
  257. * Mark inode fully dirty. Since we are allocating blocks, inode
  258. * would become fully dirty soon anyway and it reportedly
  259. * reduces lock contention.
  260. */
  261. mark_inode_dirty(inode);
  262. }
  263. return ret;
  264. }
  265. static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
  266. {
  267. return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
  268. }
  269. static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
  270. {
  271. dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
  272. }
  273. static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
  274. {
  275. return dquot_alloc_space(inode, nr << inode->i_blkbits);
  276. }
  277. static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
  278. {
  279. return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
  280. }
  281. static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
  282. {
  283. int ret;
  284. ret = dquot_prealloc_block_nodirty(inode, nr);
  285. if (!ret)
  286. mark_inode_dirty_sync(inode);
  287. return ret;
  288. }
  289. static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
  290. {
  291. return __dquot_alloc_space(inode, nr << inode->i_blkbits,
  292. DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
  293. }
  294. static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
  295. {
  296. int ret;
  297. ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
  298. if (!ret)
  299. mark_inode_dirty_sync(inode);
  300. return ret;
  301. }
  302. static inline void dquot_reclaim_block(struct inode *inode, qsize_t nr)
  303. {
  304. dquot_reclaim_space_nodirty(inode, nr << inode->i_blkbits);
  305. mark_inode_dirty_sync(inode);
  306. }
  307. static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
  308. {
  309. __dquot_free_space(inode, nr, 0);
  310. }
  311. static inline void dquot_free_space(struct inode *inode, qsize_t nr)
  312. {
  313. dquot_free_space_nodirty(inode, nr);
  314. mark_inode_dirty_sync(inode);
  315. }
  316. static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
  317. {
  318. dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
  319. }
  320. static inline void dquot_free_block(struct inode *inode, qsize_t nr)
  321. {
  322. dquot_free_space(inode, nr << inode->i_blkbits);
  323. }
  324. static inline void dquot_release_reservation_block(struct inode *inode,
  325. qsize_t nr)
  326. {
  327. __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
  328. }
  329. unsigned int qtype_enforce_flag(int type);
  330. #endif /* _LINUX_QUOTAOPS_ */