Linux Audio

Check our new training course

Loading...
v3.15
 
  1/*
  2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
  3 * All Rights Reserved.
  4 *
  5 * This program is free software; you can redistribute it and/or
  6 * modify it under the terms of the GNU General Public License as
  7 * published by the Free Software Foundation.
  8 *
  9 * This program is distributed in the hope that it would be useful,
 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 * GNU General Public License for more details.
 13 *
 14 * You should have received a copy of the GNU General Public License
 15 * along with this program; if not, write the Free Software Foundation,
 16 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 17 */
 18#ifndef __XFS_QUOTA_H__
 19#define __XFS_QUOTA_H__
 20
 21#include "xfs_quota_defs.h"
 22
 23/*
 24 * Kernel only quota definitions and functions
 25 */
 26
 27struct xfs_trans;
 
 28
 29/*
 30 * This check is done typically without holding the inode lock;
 31 * that may seem racy, but it is harmless in the context that it is used.
 32 * The inode cannot go inactive as long a reference is kept, and
 33 * therefore if dquot(s) were attached, they'll stay consistent.
 34 * If, for example, the ownership of the inode changes while
 35 * we didn't have the inode locked, the appropriate dquot(s) will be
 36 * attached atomically.
 37 */
 38#define XFS_NOT_DQATTACHED(mp, ip) \
 39	((XFS_IS_UQUOTA_ON(mp) && (ip)->i_udquot == NULL) || \
 40	 (XFS_IS_GQUOTA_ON(mp) && (ip)->i_gdquot == NULL) || \
 41	 (XFS_IS_PQUOTA_ON(mp) && (ip)->i_pdquot == NULL))
 42
 
 
 
 
 
 43#define XFS_QM_NEED_QUOTACHECK(mp) \
 44	((XFS_IS_UQUOTA_ON(mp) && \
 45		(mp->m_sb.sb_qflags & XFS_UQUOTA_CHKD) == 0) || \
 46	 (XFS_IS_GQUOTA_ON(mp) && \
 47		(mp->m_sb.sb_qflags & XFS_GQUOTA_CHKD) == 0) || \
 48	 (XFS_IS_PQUOTA_ON(mp) && \
 49		(mp->m_sb.sb_qflags & XFS_PQUOTA_CHKD) == 0))
 50
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 51/*
 52 * The structure kept inside the xfs_trans_t keep track of dquot changes
 53 * within a transaction and apply them later.
 54 */
 55typedef struct xfs_dqtrx {
 56	struct xfs_dquot *qt_dquot;	  /* the dquot this refers to */
 57	ulong		qt_blk_res;	  /* blks reserved on a dquot */
 58	ulong		qt_blk_res_used;  /* blks used from the reservation */
 59	ulong		qt_ino_res;	  /* inode reserved on a dquot */
 60	ulong		qt_ino_res_used;  /* inodes used from the reservation */
 61	long		qt_bcount_delta;  /* dquot blk count changes */
 62	long		qt_delbcnt_delta; /* delayed dquot blk count changes */
 63	long		qt_icount_delta;  /* dquot inode count changes */
 64	ulong		qt_rtblk_res;	  /* # blks reserved on a dquot */
 65	ulong		qt_rtblk_res_used;/* # blks used from reservation */
 66	long		qt_rtbcount_delta;/* dquot realtime blk changes */
 67	long		qt_delrtb_delta;  /* delayed RT blk count changes */
 68} xfs_dqtrx_t;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 69
 70#ifdef CONFIG_XFS_QUOTA
 71extern void xfs_trans_dup_dqinfo(struct xfs_trans *, struct xfs_trans *);
 72extern void xfs_trans_free_dqinfo(struct xfs_trans *);
 73extern void xfs_trans_mod_dquot_byino(struct xfs_trans *, struct xfs_inode *,
 74		uint, long);
 75extern void xfs_trans_apply_dquot_deltas(struct xfs_trans *);
 76extern void xfs_trans_unreserve_and_mod_dquots(struct xfs_trans *);
 77extern int xfs_trans_reserve_quota_nblks(struct xfs_trans *,
 78		struct xfs_inode *, long, long, uint);
 
 79extern int xfs_trans_reserve_quota_bydquots(struct xfs_trans *,
 80		struct xfs_mount *, struct xfs_dquot *,
 81		struct xfs_dquot *, struct xfs_dquot *, long, long, uint);
 
 
 
 82
 83extern int xfs_qm_vop_dqalloc(struct xfs_inode *, xfs_dqid_t, xfs_dqid_t,
 84		prid_t, uint, struct xfs_dquot **, struct xfs_dquot **,
 85		struct xfs_dquot **);
 86extern void xfs_qm_vop_create_dqattach(struct xfs_trans *, struct xfs_inode *,
 87		struct xfs_dquot *, struct xfs_dquot *, struct xfs_dquot *);
 88extern int xfs_qm_vop_rename_dqattach(struct xfs_inode **);
 89extern struct xfs_dquot *xfs_qm_vop_chown(struct xfs_trans *,
 90		struct xfs_inode *, struct xfs_dquot **, struct xfs_dquot *);
 91extern int xfs_qm_vop_chown_reserve(struct xfs_trans *, struct xfs_inode *,
 92		struct xfs_dquot *, struct xfs_dquot *,
 93		struct xfs_dquot *, uint);
 94extern int xfs_qm_dqattach(struct xfs_inode *, uint);
 95extern int xfs_qm_dqattach_locked(struct xfs_inode *, uint);
 96extern void xfs_qm_dqdetach(struct xfs_inode *);
 97extern void xfs_qm_dqrele(struct xfs_dquot *);
 98extern void xfs_qm_statvfs(struct xfs_inode *, struct kstatfs *);
 99extern int xfs_qm_newmount(struct xfs_mount *, uint *, uint *);
 
100extern void xfs_qm_mount_quotas(struct xfs_mount *);
101extern void xfs_qm_unmount(struct xfs_mount *);
102extern void xfs_qm_unmount_quotas(struct xfs_mount *);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
103
104#else
105static inline int
106xfs_qm_vop_dqalloc(struct xfs_inode *ip, xfs_dqid_t uid, xfs_dqid_t gid,
107		prid_t prid, uint flags, struct xfs_dquot **udqp,
108		struct xfs_dquot **gdqp, struct xfs_dquot **pdqp)
109{
110	*udqp = NULL;
111	*gdqp = NULL;
112	*pdqp = NULL;
113	return 0;
114}
115#define xfs_trans_dup_dqinfo(tp, tp2)
116#define xfs_trans_free_dqinfo(tp)
117#define xfs_trans_mod_dquot_byino(tp, ip, fields, delta)
 
 
 
118#define xfs_trans_apply_dquot_deltas(tp)
119#define xfs_trans_unreserve_and_mod_dquots(tp)
120static inline int xfs_trans_reserve_quota_nblks(struct xfs_trans *tp,
121		struct xfs_inode *ip, long nblks, long ninos, uint flags)
 
122{
123	return 0;
124}
125static inline int xfs_trans_reserve_quota_bydquots(struct xfs_trans *tp,
126		struct xfs_mount *mp, struct xfs_dquot *udqp,
127		struct xfs_dquot *gdqp, struct xfs_dquot *pdqp,
128		long nblks, long nions, uint flags)
129{
130	return 0;
131}
 
 
 
 
 
 
 
 
132#define xfs_qm_vop_create_dqattach(tp, ip, u, g, p)
133#define xfs_qm_vop_rename_dqattach(it)					(0)
134#define xfs_qm_vop_chown(tp, ip, old, new)				(NULL)
135#define xfs_qm_vop_chown_reserve(tp, ip, u, g, p, fl)			(0)
136#define xfs_qm_dqattach(ip, fl)						(0)
137#define xfs_qm_dqattach_locked(ip, fl)					(0)
138#define xfs_qm_dqdetach(ip)
139#define xfs_qm_dqrele(d)
140#define xfs_qm_statvfs(ip, s)
141#define xfs_qm_newmount(mp, a, b)					(0)
 
142#define xfs_qm_mount_quotas(mp)
143#define xfs_qm_unmount(mp)
144#define xfs_qm_unmount_quotas(mp)
 
 
 
 
 
 
 
 
 
 
 
 
145#endif /* CONFIG_XFS_QUOTA */
146
147#define xfs_trans_unreserve_quota_nblks(tp, ip, nblks, ninos, flags) \
148	xfs_trans_reserve_quota_nblks(tp, ip, -(nblks), -(ninos), flags)
149#define xfs_trans_reserve_quota(tp, mp, ud, gd, pd, nb, ni, f) \
150	xfs_trans_reserve_quota_bydquots(tp, mp, ud, gd, pd, nb, ni, \
151				f | XFS_QMOPT_RES_REGBLKS)
 
152
153extern int xfs_mount_reset_sbqflags(struct xfs_mount *);
154
155#endif	/* __XFS_QUOTA_H__ */
v6.13.7
  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
  4 * All Rights Reserved.
 
 
 
 
 
 
 
 
 
 
 
 
 
  5 */
  6#ifndef __XFS_QUOTA_H__
  7#define __XFS_QUOTA_H__
  8
  9#include "xfs_quota_defs.h"
 10
 11/*
 12 * Kernel only quota definitions and functions
 13 */
 14
 15struct xfs_trans;
 16struct xfs_buf;
 17
 18/*
 19 * This check is done typically without holding the inode lock;
 20 * that may seem racy, but it is harmless in the context that it is used.
 21 * The inode cannot go inactive as long a reference is kept, and
 22 * therefore if dquot(s) were attached, they'll stay consistent.
 23 * If, for example, the ownership of the inode changes while
 24 * we didn't have the inode locked, the appropriate dquot(s) will be
 25 * attached atomically.
 26 */
 27#define XFS_NOT_DQATTACHED(mp, ip) \
 28	((XFS_IS_UQUOTA_ON(mp) && (ip)->i_udquot == NULL) || \
 29	 (XFS_IS_GQUOTA_ON(mp) && (ip)->i_gdquot == NULL) || \
 30	 (XFS_IS_PQUOTA_ON(mp) && (ip)->i_pdquot == NULL))
 31
 32#define XFS_IS_DQDETACHED(ip) \
 33	((ip)->i_udquot == NULL && \
 34	 (ip)->i_gdquot == NULL && \
 35	 (ip)->i_pdquot == NULL)
 36
 37#define XFS_QM_NEED_QUOTACHECK(mp) \
 38	((XFS_IS_UQUOTA_ON(mp) && \
 39		(mp->m_sb.sb_qflags & XFS_UQUOTA_CHKD) == 0) || \
 40	 (XFS_IS_GQUOTA_ON(mp) && \
 41		(mp->m_sb.sb_qflags & XFS_GQUOTA_CHKD) == 0) || \
 42	 (XFS_IS_PQUOTA_ON(mp) && \
 43		(mp->m_sb.sb_qflags & XFS_PQUOTA_CHKD) == 0))
 44
 45static inline uint
 46xfs_quota_chkd_flag(
 47	xfs_dqtype_t		type)
 48{
 49	switch (type) {
 50	case XFS_DQTYPE_USER:
 51		return XFS_UQUOTA_CHKD;
 52	case XFS_DQTYPE_GROUP:
 53		return XFS_GQUOTA_CHKD;
 54	case XFS_DQTYPE_PROJ:
 55		return XFS_PQUOTA_CHKD;
 56	default:
 57		return 0;
 58	}
 59}
 60
 61/*
 62 * The structure kept inside the xfs_trans_t keep track of dquot changes
 63 * within a transaction and apply them later.
 64 */
 65struct xfs_dqtrx {
 66	struct xfs_dquot *qt_dquot;	  /* the dquot this refers to */
 67
 68	uint64_t	qt_blk_res;	  /* blks reserved on a dquot */
 69	int64_t		qt_bcount_delta;  /* dquot blk count changes */
 70	int64_t		qt_delbcnt_delta; /* delayed dquot blk count changes */
 71
 72	uint64_t	qt_rtblk_res;	  /* # blks reserved on a dquot */
 73	uint64_t	qt_rtblk_res_used;/* # blks used from reservation */
 74	int64_t		qt_rtbcount_delta;/* dquot realtime blk changes */
 75	int64_t		qt_delrtb_delta;  /* delayed RT blk count changes */
 76
 77	uint64_t	qt_ino_res;	  /* inode reserved on a dquot */
 78	uint64_t	qt_ino_res_used;  /* inodes used from the reservation */
 79	int64_t		qt_icount_delta;  /* dquot inode count changes */
 80};
 81
 82enum xfs_apply_dqtrx_type {
 83	XFS_APPLY_DQTRX_COMMIT = 0,
 84	XFS_APPLY_DQTRX_UNRESERVE,
 85};
 86
 87/*
 88 * Parameters for applying dqtrx changes to a dquot.  The hook function arg
 89 * parameter is enum xfs_apply_dqtrx_type.
 90 */
 91struct xfs_apply_dqtrx_params {
 92	uintptr_t		tx_id;
 93	xfs_ino_t		ino;
 94	xfs_dqtype_t		q_type;
 95	xfs_dqid_t		q_id;
 96};
 97
 98#ifdef CONFIG_XFS_QUOTA
 99extern void xfs_trans_dup_dqinfo(struct xfs_trans *, struct xfs_trans *);
100extern void xfs_trans_free_dqinfo(struct xfs_trans *);
101extern void xfs_trans_mod_dquot_byino(struct xfs_trans *, struct xfs_inode *,
102		uint, int64_t);
103extern void xfs_trans_apply_dquot_deltas(struct xfs_trans *);
104void xfs_trans_unreserve_and_mod_dquots(struct xfs_trans *tp,
105		bool already_locked);
106int xfs_trans_reserve_quota_nblks(struct xfs_trans *tp, struct xfs_inode *ip,
107		int64_t dblocks, int64_t rblocks, bool force);
108extern int xfs_trans_reserve_quota_bydquots(struct xfs_trans *,
109		struct xfs_mount *, struct xfs_dquot *,
110		struct xfs_dquot *, struct xfs_dquot *, int64_t, long, uint);
111int xfs_trans_reserve_quota_icreate(struct xfs_trans *tp,
112		struct xfs_dquot *udqp, struct xfs_dquot *gdqp,
113		struct xfs_dquot *pdqp, int64_t dblocks);
114
115extern int xfs_qm_vop_dqalloc(struct xfs_inode *, kuid_t, kgid_t,
116		prid_t, uint, struct xfs_dquot **, struct xfs_dquot **,
117		struct xfs_dquot **);
118extern void xfs_qm_vop_create_dqattach(struct xfs_trans *, struct xfs_inode *,
119		struct xfs_dquot *, struct xfs_dquot *, struct xfs_dquot *);
120extern int xfs_qm_vop_rename_dqattach(struct xfs_inode **);
121extern struct xfs_dquot *xfs_qm_vop_chown(struct xfs_trans *,
122		struct xfs_inode *, struct xfs_dquot **, struct xfs_dquot *);
123extern int xfs_qm_dqattach(struct xfs_inode *);
124extern int xfs_qm_dqattach_locked(struct xfs_inode *ip, bool doalloc);
 
 
 
125extern void xfs_qm_dqdetach(struct xfs_inode *);
126extern void xfs_qm_dqrele(struct xfs_dquot *);
127extern void xfs_qm_statvfs(struct xfs_inode *, struct kstatfs *);
128extern int xfs_qm_newmount(struct xfs_mount *, uint *, uint *);
129void xfs_qm_resume_quotaon(struct xfs_mount *mp);
130extern void xfs_qm_mount_quotas(struct xfs_mount *);
131extern void xfs_qm_unmount(struct xfs_mount *);
132extern void xfs_qm_unmount_quotas(struct xfs_mount *);
133bool xfs_inode_near_dquot_enforcement(struct xfs_inode *ip, xfs_dqtype_t type);
134int xfs_quota_reserve_blkres(struct xfs_inode *ip, int64_t blocks);
135
136# ifdef CONFIG_XFS_LIVE_HOOKS
137void xfs_trans_mod_ino_dquot(struct xfs_trans *tp, struct xfs_inode *ip,
138		struct xfs_dquot *dqp, unsigned int field, int64_t delta);
139
140struct xfs_quotainfo;
141
142struct xfs_dqtrx_hook {
143	struct xfs_hook		mod_hook;
144	struct xfs_hook		apply_hook;
145};
146
147void xfs_dqtrx_hook_disable(void);
148void xfs_dqtrx_hook_enable(void);
149
150int xfs_dqtrx_hook_add(struct xfs_quotainfo *qi, struct xfs_dqtrx_hook *hook);
151void xfs_dqtrx_hook_del(struct xfs_quotainfo *qi, struct xfs_dqtrx_hook *hook);
152void xfs_dqtrx_hook_setup(struct xfs_dqtrx_hook *hook, notifier_fn_t mod_fn,
153		notifier_fn_t apply_fn);
154# else
155#  define xfs_trans_mod_ino_dquot(tp, ip, dqp, field, delta) \
156		xfs_trans_mod_dquot((tp), (dqp), (field), (delta))
157# endif /* CONFIG_XFS_LIVE_HOOKS */
158
159#else
160static inline int
161xfs_qm_vop_dqalloc(struct xfs_inode *ip, kuid_t kuid, kgid_t kgid,
162		prid_t prid, uint flags, struct xfs_dquot **udqp,
163		struct xfs_dquot **gdqp, struct xfs_dquot **pdqp)
164{
165	*udqp = NULL;
166	*gdqp = NULL;
167	*pdqp = NULL;
168	return 0;
169}
170#define xfs_trans_dup_dqinfo(tp, tp2)
171#define xfs_trans_free_dqinfo(tp)
172static inline void xfs_trans_mod_dquot_byino(struct xfs_trans *tp,
173		struct xfs_inode *ip, uint field, int64_t delta)
174{
175}
176#define xfs_trans_apply_dquot_deltas(tp)
177#define xfs_trans_unreserve_and_mod_dquots(tp, a)
178static inline int xfs_trans_reserve_quota_nblks(struct xfs_trans *tp,
179		struct xfs_inode *ip, int64_t dblocks, int64_t rblocks,
180		bool force)
181{
182	return 0;
183}
184static inline int xfs_trans_reserve_quota_bydquots(struct xfs_trans *tp,
185		struct xfs_mount *mp, struct xfs_dquot *udqp,
186		struct xfs_dquot *gdqp, struct xfs_dquot *pdqp,
187		int64_t nblks, long nions, uint flags)
188{
189	return 0;
190}
191
192static inline int
193xfs_trans_reserve_quota_icreate(struct xfs_trans *tp, struct xfs_dquot *udqp,
194		struct xfs_dquot *gdqp, struct xfs_dquot *pdqp, int64_t dblocks)
195{
196	return 0;
197}
198
199#define xfs_qm_vop_create_dqattach(tp, ip, u, g, p)
200#define xfs_qm_vop_rename_dqattach(it)					(0)
201#define xfs_qm_vop_chown(tp, ip, old, new)				(NULL)
202#define xfs_qm_dqattach(ip)						(0)
 
203#define xfs_qm_dqattach_locked(ip, fl)					(0)
204#define xfs_qm_dqdetach(ip)
205#define xfs_qm_dqrele(d)			do { (d) = (d); } while(0)
206#define xfs_qm_statvfs(ip, s)			do { } while(0)
207#define xfs_qm_newmount(mp, a, b)					(0)
208#define xfs_qm_resume_quotaon(mp)		((void)0)
209#define xfs_qm_mount_quotas(mp)
210#define xfs_qm_unmount(mp)
211#define xfs_qm_unmount_quotas(mp)
212#define xfs_inode_near_dquot_enforcement(ip, type)			(false)
213
214static inline int xfs_quota_reserve_blkres(struct xfs_inode *ip, int64_t blocks)
215{
216	return 0;
217}
218
219# ifdef CONFIG_XFS_LIVE_HOOKS
220#  define xfs_dqtrx_hook_enable()		((void)0)
221#  define xfs_dqtrx_hook_disable()		((void)0)
222# endif /* CONFIG_XFS_LIVE_HOOKS */
223
224#endif /* CONFIG_XFS_QUOTA */
225
226static inline void
227xfs_quota_unreserve_blkres(struct xfs_inode *ip, uint64_t blocks)
228{
229	/* don't return an error as unreserving quotas can't fail */
230	xfs_quota_reserve_blkres(ip, -(int64_t)blocks);
231}
232
233extern int xfs_mount_reset_sbqflags(struct xfs_mount *);
234
235#endif	/* __XFS_QUOTA_H__ */