[linux-2.6] / include / linux / ext3_jbd.h

/*
 * linux/include/linux/ext3_jbd.h
 *
 * Written by Stephen C. Tweedie <sct@redhat.com>, 1999
 *
 * Copyright 1998--1999 Red Hat corp --- All Rights Reserved
 *
 * This file is part of the Linux kernel and is made available under
 * the terms of the GNU General Public License, version 2, or at your
 * option, any later version, incorporated herein by reference.
 *
 * Ext3-specific journaling extensions.
 */

#ifndef _LINUX_EXT3_JBD_H
#define _LINUX_EXT3_JBD_H

#include <linux/fs.h>
#include <linux/jbd.h>
#include <linux/ext3_fs.h>

#define EXT3_JOURNAL(inode)	(EXT3_SB((inode)->i_sb)->s_journal)

/* Define the number of blocks we need to account to a transaction to
 * modify one block of data.
 * 
 * We may have to touch one inode, one bitmap buffer, up to three
 * indirection blocks, the group and superblock summaries, and the data
 * block to complete the transaction.  */

#define EXT3_SINGLEDATA_TRANS_BLOCKS	8U

/* Extended attribute operations touch at most two data buffers,
 * two bitmap buffers, and two group summaries, in addition to the inode
 * and the superblock, which are already accounted for. */

#define EXT3_XATTR_TRANS_BLOCKS		6U

/* Define the minimum size for a transaction which modifies data.  This
 * needs to take into account the fact that we may end up modifying two
 * quota files too (one for the group, one for the user quota).  The
 * superblock only gets updated once, of course, so don't bother
 * counting that again for the quota updates. */

#define EXT3_DATA_TRANS_BLOCKS		(EXT3_SINGLEDATA_TRANS_BLOCKS + \
					 EXT3_XATTR_TRANS_BLOCKS - 2 + \
					 2*EXT3_QUOTA_TRANS_BLOCKS)

/* Delete operations potentially hit one directory's namespace plus an
 * entire inode, plus arbitrary amounts of bitmap/indirection data.  Be
 * generous.  We can grow the delete transaction later if necessary. */

#define EXT3_DELETE_TRANS_BLOCKS	(2 * EXT3_DATA_TRANS_BLOCKS + 64)

/* Define an arbitrary limit for the amount of data we will anticipate
 * writing to any given transaction.  For unbounded transactions such as
 * write(2) and truncate(2) we can write more than this, but we always
 * start off at the maximum transaction size and grow the transaction
 * optimistically as we go. */

#define EXT3_MAX_TRANS_DATA		64U

/* We break up a large truncate or write transaction once the handle's
 * buffer credits gets this low, we need either to extend the
 * transaction or to start a new one.  Reserve enough space here for
 * inode, bitmap, superblock, group and indirection updates for at least
 * one block, plus two quota updates.  Quota allocations are not
 * needed. */

#define EXT3_RESERVE_TRANS_BLOCKS	12U

#define EXT3_INDEX_EXTRA_TRANS_BLOCKS	8

#ifdef CONFIG_QUOTA
/* Amount of blocks needed for quota update - we know that the structure was
 * allocated so we need to update only inode+data */
#define EXT3_QUOTA_TRANS_BLOCKS 2
/* Amount of blocks needed for quota insert/delete - we do some block writes
 * but inode, sb and group updates are done only once */
#define EXT3_QUOTA_INIT_BLOCKS (DQUOT_MAX_WRITES*\
				(EXT3_SINGLEDATA_TRANS_BLOCKS-3)+3)
#else
#define EXT3_QUOTA_TRANS_BLOCKS 0
#define EXT3_QUOTA_INIT_BLOCKS 0
#endif

int
ext3_mark_iloc_dirty(handle_t *handle, 
		     struct inode *inode,
		     struct ext3_iloc *iloc);

/* 
 * On success, We end up with an outstanding reference count against
 * iloc->bh.  This _must_ be cleaned up later. 
 */

int ext3_reserve_inode_write(handle_t *handle, struct inode *inode, 
			struct ext3_iloc *iloc);

int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode);

/*
 * Wrapper functions with which ext3 calls into JBD.  The intent here is
 * to allow these to be turned into appropriate stubs so ext3 can control
 * ext2 filesystems, so ext2+ext3 systems only nee one fs.  This work hasn't
 * been done yet.
 */

void ext3_journal_abort_handle(const char *caller, const char *err_fn,
		struct buffer_head *bh, handle_t *handle, int err);

static inline int
__ext3_journal_get_undo_access(const char *where, handle_t *handle,
				struct buffer_head *bh)
{
	int err = journal_get_undo_access(handle, bh);
	if (err)
		ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
	return err;
}

static inline int
__ext3_journal_get_write_access(const char *where, handle_t *handle,
				struct buffer_head *bh)
{
	int err = journal_get_write_access(handle, bh);
	if (err)
		ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
	return err;
}

static inline void
ext3_journal_release_buffer(handle_t *handle, struct buffer_head *bh)
{
	journal_release_buffer(handle, bh);
}

static inline int
__ext3_journal_forget(const char *where, handle_t *handle, struct buffer_head *bh)
{
	int err = journal_forget(handle, bh);
	if (err)
		ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
	return err;
}

static inline int
__ext3_journal_revoke(const char *where, handle_t *handle,
		      unsigned long blocknr, struct buffer_head *bh)
{
	int err = journal_revoke(handle, blocknr, bh);
	if (err)
		ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
	return err;
}

static inline int
__ext3_journal_get_create_access(const char *where,
				 handle_t *handle, struct buffer_head *bh)
{
	int err = journal_get_create_access(handle, bh);
	if (err)
		ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
	return err;
}

static inline int
__ext3_journal_dirty_metadata(const char *where,
			      handle_t *handle, struct buffer_head *bh)
{
	int err = journal_dirty_metadata(handle, bh);
	if (err)
		ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
	return err;
}


#define ext3_journal_get_undo_access(handle, bh) \
	__ext3_journal_get_undo_access(__FUNCTION__, (handle), (bh))
#define ext3_journal_get_write_access(handle, bh) \
	__ext3_journal_get_write_access(__FUNCTION__, (handle), (bh))
#define ext3_journal_revoke(handle, blocknr, bh) \
	__ext3_journal_revoke(__FUNCTION__, (handle), (blocknr), (bh))
#define ext3_journal_get_create_access(handle, bh) \
	__ext3_journal_get_create_access(__FUNCTION__, (handle), (bh))
#define ext3_journal_dirty_metadata(handle, bh) \
	__ext3_journal_dirty_metadata(__FUNCTION__, (handle), (bh))
#define ext3_journal_forget(handle, bh) \
	__ext3_journal_forget(__FUNCTION__, (handle), (bh))

int ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh);

handle_t *ext3_journal_start_sb(struct super_block *sb, int nblocks);
int __ext3_journal_stop(const char *where, handle_t *handle);

static inline handle_t *ext3_journal_start(struct inode *inode, int nblocks)
{
	return ext3_journal_start_sb(inode->i_sb, nblocks);
}

#define ext3_journal_stop(handle) \
	__ext3_journal_stop(__FUNCTION__, (handle))

static inline handle_t *ext3_journal_current_handle(void)
{
	return journal_current_handle();
}

static inline int ext3_journal_extend(handle_t *handle, int nblocks)
{
	return journal_extend(handle, nblocks);
}

static inline int ext3_journal_restart(handle_t *handle, int nblocks)
{
	return journal_restart(handle, nblocks);
}

static inline int ext3_journal_blocks_per_page(struct inode *inode)
{
	return journal_blocks_per_page(inode);
}

static inline int ext3_journal_force_commit(journal_t *journal)
{
	return journal_force_commit(journal);
}

/* super.c */
int ext3_force_commit(struct super_block *sb);

static inline int ext3_should_journal_data(struct inode *inode)
{
	if (!S_ISREG(inode->i_mode))
		return 1;
	if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA)
		return 1;
	if (EXT3_I(inode)->i_flags & EXT3_JOURNAL_DATA_FL)
		return 1;
	return 0;
}

static inline int ext3_should_order_data(struct inode *inode)
{
	if (!S_ISREG(inode->i_mode))
		return 0;
	if (EXT3_I(inode)->i_flags & EXT3_JOURNAL_DATA_FL)
		return 0;
	if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_ORDERED_DATA)
		return 1;
	return 0;
}

static inline int ext3_should_writeback_data(struct inode *inode)
{
	if (!S_ISREG(inode->i_mode))
		return 0;
	if (EXT3_I(inode)->i_flags & EXT3_JOURNAL_DATA_FL)
		return 0;
	if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_WRITEBACK_DATA)
		return 1;
	return 0;
}

#endif	/* _LINUX_EXT3_JBD_H */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/include/linux/ext3_jbd.h
	3	*
	4	* Written by Stephen C. Tweedie <sct@redhat.com>, 1999
	5	*
	6	* Copyright 1998--1999 Red Hat corp --- All Rights Reserved
	7	*
	8	* This file is part of the Linux kernel and is made available under
	9	* the terms of the GNU General Public License, version 2, or at your
	10	* option, any later version, incorporated herein by reference.
	11	*
	12	* Ext3-specific journaling extensions.
	13	*/
	14
	15	#ifndef _LINUX_EXT3_JBD_H
	16	#define _LINUX_EXT3_JBD_H
	17
	18	#include <linux/fs.h>
	19	#include <linux/jbd.h>
	20	#include <linux/ext3_fs.h>
	21
	22	#define EXT3_JOURNAL(inode) (EXT3_SB((inode)->i_sb)->s_journal)
	23
	24	/* Define the number of blocks we need to account to a transaction to
	25	* modify one block of data.
	26	*
	27	* We may have to touch one inode, one bitmap buffer, up to three
	28	* indirection blocks, the group and superblock summaries, and the data
	29	* block to complete the transaction. */
	30
	31	#define EXT3_SINGLEDATA_TRANS_BLOCKS 8U
	32
	33	/* Extended attribute operations touch at most two data buffers,
	34	* two bitmap buffers, and two group summaries, in addition to the inode
	35	* and the superblock, which are already accounted for. */
	36
	37	#define EXT3_XATTR_TRANS_BLOCKS 6U
	38
	39	/* Define the minimum size for a transaction which modifies data. This
	40	* needs to take into account the fact that we may end up modifying two
	41	* quota files too (one for the group, one for the user quota). The
	42	* superblock only gets updated once, of course, so don't bother
	43	* counting that again for the quota updates. */
	44
	45	#define EXT3_DATA_TRANS_BLOCKS (EXT3_SINGLEDATA_TRANS_BLOCKS + \
	46	EXT3_XATTR_TRANS_BLOCKS - 2 + \
	47	2*EXT3_QUOTA_TRANS_BLOCKS)
	48
	49	/* Delete operations potentially hit one directory's namespace plus an
	50	* entire inode, plus arbitrary amounts of bitmap/indirection data. Be
	51	* generous. We can grow the delete transaction later if necessary. */
	52
	53	#define EXT3_DELETE_TRANS_BLOCKS (2 * EXT3_DATA_TRANS_BLOCKS + 64)
	54
	55	/* Define an arbitrary limit for the amount of data we will anticipate
	56	* writing to any given transaction. For unbounded transactions such as
	57	* write(2) and truncate(2) we can write more than this, but we always
	58	* start off at the maximum transaction size and grow the transaction
	59	* optimistically as we go. */
	60
	61	#define EXT3_MAX_TRANS_DATA 64U
	62
	63	/* We break up a large truncate or write transaction once the handle's
	64	* buffer credits gets this low, we need either to extend the
65	* transaction or to start a new one. Reserve enough space here for
66	* inode, bitmap, superblock, group and indirection updates for at least
67	* one block, plus two quota updates. Quota allocations are not
68	* needed. */
69
70	#define EXT3_RESERVE_TRANS_BLOCKS 12U
71
72	#define EXT3_INDEX_EXTRA_TRANS_BLOCKS 8
73
74	#ifdef CONFIG_QUOTA
75	/* Amount of blocks needed for quota update - we know that the structure was
76	* allocated so we need to update only inode+data */
77	#define EXT3_QUOTA_TRANS_BLOCKS 2
78	/* Amount of blocks needed for quota insert/delete - we do some block writes
79	* but inode, sb and group updates are done only once */
80	#define EXT3_QUOTA_INIT_BLOCKS (DQUOT_MAX_WRITES*\
81	(EXT3_SINGLEDATA_TRANS_BLOCKS-3)+3)
82	#else
83	#define EXT3_QUOTA_TRANS_BLOCKS 0
84	#define EXT3_QUOTA_INIT_BLOCKS 0
85	#endif
86
87	int
88	ext3_mark_iloc_dirty(handle_t *handle,
89	struct inode *inode,
90	struct ext3_iloc *iloc);
91
92	/*
93	* On success, We end up with an outstanding reference count against
94	* iloc->bh. This _must_ be cleaned up later.
95	*/
96
97	int ext3_reserve_inode_write(handle_t handle, struct inode inode,
98	struct ext3_iloc *iloc);
99
100	int ext3_mark_inode_dirty(handle_t handle, struct inode inode);
101
102	/*
103	* Wrapper functions with which ext3 calls into JBD. The intent here is
104	* to allow these to be turned into appropriate stubs so ext3 can control
105	* ext2 filesystems, so ext2+ext3 systems only nee one fs. This work hasn't
106	* been done yet.
107	*/
108
109	void ext3_journal_abort_handle(const char caller, const char err_fn,
110	struct buffer_head bh, handle_t handle, int err);
111
112	static inline int
113	__ext3_journal_get_undo_access(const char where, handle_t handle,
114	struct buffer_head *bh)
115	{
116	int err = journal_get_undo_access(handle, bh);
117	if (err)
118	ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
119	return err;
120	}
121
122	static inline int
123	__ext3_journal_get_write_access(const char where, handle_t handle,
124	struct buffer_head *bh)
125	{
126	int err = journal_get_write_access(handle, bh);
127	if (err)
128	ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
129	return err;
130	}
131
132	static inline void
133	ext3_journal_release_buffer(handle_t handle, struct buffer_head bh)
134	{
135	journal_release_buffer(handle, bh);
136	}
137
138	static inline int
139	__ext3_journal_forget(const char where, handle_t handle, struct buffer_head *bh)
140	{
141	int err = journal_forget(handle, bh);
142	if (err)
143	ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
144	return err;
145	}
146
147	static inline int
148	__ext3_journal_revoke(const char where, handle_t handle,
149	unsigned long blocknr, struct buffer_head *bh)
150	{
151	int err = journal_revoke(handle, blocknr, bh);
152	if (err)
153	ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
154	return err;
155	}
156
157	static inline int
158	__ext3_journal_get_create_access(const char *where,
159	handle_t handle, struct buffer_head bh)
160	{
161	int err = journal_get_create_access(handle, bh);
162	if (err)
163	ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
164	return err;
165	}
166
167	static inline int
168	__ext3_journal_dirty_metadata(const char *where,
169	handle_t handle, struct buffer_head bh)
170	{
171	int err = journal_dirty_metadata(handle, bh);
172	if (err)
173	ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
174	return err;
175	}
176
177
178	#define ext3_journal_get_undo_access(handle, bh) \
179	__ext3_journal_get_undo_access(__FUNCTION__, (handle), (bh))
180	#define ext3_journal_get_write_access(handle, bh) \
181	__ext3_journal_get_write_access(__FUNCTION__, (handle), (bh))
182	#define ext3_journal_revoke(handle, blocknr, bh) \
183	__ext3_journal_revoke(__FUNCTION__, (handle), (blocknr), (bh))
184	#define ext3_journal_get_create_access(handle, bh) \
185	__ext3_journal_get_create_access(__FUNCTION__, (handle), (bh))
186	#define ext3_journal_dirty_metadata(handle, bh) \
187	__ext3_journal_dirty_metadata(__FUNCTION__, (handle), (bh))
188	#define ext3_journal_forget(handle, bh) \
189	__ext3_journal_forget(__FUNCTION__, (handle), (bh))
190
191	int ext3_journal_dirty_data(handle_t handle, struct buffer_head bh);
192
193	handle_t ext3_journal_start_sb(struct super_block sb, int nblocks);
194	int __ext3_journal_stop(const char where, handle_t handle);
195
196	static inline handle_t ext3_journal_start(struct inode inode, int nblocks)
197	{
198	return ext3_journal_start_sb(inode->i_sb, nblocks);
199	}
200
201	#define ext3_journal_stop(handle) \
202	__ext3_journal_stop(__FUNCTION__, (handle))
203
204	static inline handle_t *ext3_journal_current_handle(void)
205	{
206	return journal_current_handle();
207	}
208
209	static inline int ext3_journal_extend(handle_t *handle, int nblocks)
210	{
211	return journal_extend(handle, nblocks);
212	}
213
214	static inline int ext3_journal_restart(handle_t *handle, int nblocks)
215	{
216	return journal_restart(handle, nblocks);
217	}
218
219	static inline int ext3_journal_blocks_per_page(struct inode *inode)
220	{
221	return journal_blocks_per_page(inode);
222	}
223
224	static inline int ext3_journal_force_commit(journal_t *journal)
225	{
226	return journal_force_commit(journal);
227	}
228
229	/* super.c */
230	int ext3_force_commit(struct super_block *sb);
231
232	static inline int ext3_should_journal_data(struct inode *inode)
233	{
234	if (!S_ISREG(inode->i_mode))
235	return 1;
236	if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA)
237	return 1;
238	if (EXT3_I(inode)->i_flags & EXT3_JOURNAL_DATA_FL)
239	return 1;
240	return 0;
241	}
242
243	static inline int ext3_should_order_data(struct inode *inode)
244	{
245	if (!S_ISREG(inode->i_mode))
246	return 0;
247	if (EXT3_I(inode)->i_flags & EXT3_JOURNAL_DATA_FL)
248	return 0;
249	if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_ORDERED_DATA)
250	return 1;
251	return 0;
252	}
253
254	static inline int ext3_should_writeback_data(struct inode *inode)
255	{
256	if (!S_ISREG(inode->i_mode))
257	return 0;
258	if (EXT3_I(inode)->i_flags & EXT3_JOURNAL_DATA_FL)
259	return 0;
260	if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_WRITEBACK_DATA)
261	return 1;
262	return 0;
263	}
264
265	#endif /* _LINUX_EXT3_JBD_H */