[apple/xnu.git] / bsd / vfs / vfs_journal.h


/*
 * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * This header contains the structures and function prototypes
 * for the vfs journaling code.  The data types are not meant
 * to be modified by user code.  Just use the functions and do
 * not mess around with the structs.
 */ 
#ifndef _SYS_VFS_JOURNAL_H_
#define _SYS_VFS_JOURNAL_H_

#include <sys/appleapiopts.h>
#include <sys/cdefs.h>

#ifdef __APPLE_API_UNSTABLE

#include <sys/types.h>
#include <kern/locks.h>

typedef struct _blk_info {
    int32_t    bsize;
    union {
	int32_t    cksum;
	uint32_t   sequence_num;
    } b;
} _blk_info;

typedef struct block_info {
    off_t       bnum;                // block # on the file system device
    union {
	_blk_info   bi;
	struct buf *bp;
    } u;
} __attribute__((__packed__)) block_info;

typedef struct block_list_header {
    u_int16_t   max_blocks;          // max number of blocks in this chunk
    u_int16_t   num_blocks;          // number of valid block numbers in block_nums
    int32_t     bytes_used;          // how many bytes of this tbuffer are used
    int32_t     checksum;            // on-disk: checksum of this header and binfo[0]
    int32_t     flags;               // check-checksums, initial blhdr, etc
    block_info  binfo[1];            // so we can reference them by name
} block_list_header;

#define BLHDR_CHECK_CHECKSUMS   0x0001
#define BLHDR_FIRST_HEADER      0x0002


struct journal;

typedef struct transaction {
    int                 tbuffer_size;  // in bytes
    char               *tbuffer;       // memory copy of the transaction
    block_list_header  *blhdr;         // points to the first byte of tbuffer
    int                 num_blhdrs;    // how many buffers we've allocated
    int                 total_bytes;   // total # of bytes in transaction
    int                 num_flushed;   // how many bytes have been flushed
    int                 num_killed;    // how many bytes were "killed"
    off_t               journal_start; // where in the journal this transaction starts
    off_t               journal_end;   // where in the journal this transaction ends
    struct journal     *jnl;           // ptr back to the journal structure
    struct transaction *next;          // list of tr's (either completed or to be free'd)
    uint32_t            sequence_num;
} transaction;


/*
 * This is written to block zero of the journal and it
 * maintains overall state about the journal.
 */
typedef struct journal_header {
    int32_t        magic;
    int32_t        endian;
    volatile off_t start;         // zero-based byte offset of the start of the first transaction
    volatile off_t end;           // zero-based byte offset of where free space begins
    off_t          size;          // size in bytes of the entire journal
    int32_t        blhdr_size;    // size in bytes of each block_list_header in the journal
    int32_t        checksum;
    int32_t        jhdr_size;     // block size (in bytes) of the journal header
    uint32_t       sequence_num;  // NEW FIELD: a monotonically increasing value assigned to all txn's
} journal_header;

#define JOURNAL_HEADER_MAGIC  0x4a4e4c78   // 'JNLx'
#define ENDIAN_MAGIC          0x12345678

//
// we only checksum the original size of the journal_header to remain
// backwards compatible.  the size of the original journal_heade is
// everything up to the the sequence_num field, hence we use the
// offsetof macro to calculate the size.
//
#define JOURNAL_HEADER_CKSUM_SIZE  (offsetof(struct journal_header, sequence_num))

#define OLD_JOURNAL_HEADER_MAGIC  0x4a484452   // 'JHDR'


/*
 * In memory structure about the journal.
 */
typedef struct journal {
    lck_mtx_t           jlock;             // protects the struct journal data

    struct vnode       *jdev;              // vnode of the device where the journal lives
    off_t               jdev_offset;       // byte offset to the start of the journal
    const char         *jdev_name;

    struct vnode       *fsdev;             // vnode of the file system device
    
    void              (*flush)(void *arg); // fs callback to flush meta data blocks
    void               *flush_arg;         // arg that's passed to flush()

    int32_t             flags;
    int32_t             tbuffer_size;      // default transaction buffer size

    char               *header_buf;        // in-memory copy of the journal header
    int32_t             header_buf_size;
    journal_header     *jhdr;              // points to the first byte of header_buf

    off_t               max_read_size;
    off_t               max_write_size;

    transaction        *cur_tr;            // for group-commit
    transaction        *completed_trs;     // out-of-order transactions that completed
    transaction        *active_tr;         // for nested transactions
    int32_t             nested_count;      // for nested transactions
    void               *owner;             // a ptr that's unique to the calling process

    transaction        *tr_freeme;         // transaction structs that need to be free'd

    volatile off_t      active_start;      // the active start that we only keep in memory
    lck_mtx_t           old_start_lock;    // protects the old_start
    volatile off_t      old_start[16];     // this is how we do lazy start update

    int                 last_flush_err;    // last error from flushing the cache
} journal;

/* internal-only journal flags (top 16 bits) */
#define JOURNAL_CLOSE_PENDING     0x00010000
#define JOURNAL_INVALID           0x00020000
#define JOURNAL_FLUSHCACHE_ERR    0x00040000   // means we already printed this err
#define JOURNAL_NEED_SWAP         0x00080000   // swap any data read from disk
#define JOURNAL_DO_FUA_WRITES     0x00100000   // do force-unit-access writes

/* journal_open/create options are always in the low-16 bits */
#define JOURNAL_OPTION_FLAGS_MASK 0x0000ffff

__BEGIN_DECLS
/*
 * Prototypes.
 */

/*
 * Call journal_init() to initialize the journaling code (sets up lock attributes)
 */
void      journal_init(void) __attribute__((section("__TEXT, initcode")));

/*
 * Call journal_create() to create a new journal.  You only
 * call this once, typically at file system creation time.
 *
 * The "jvp" argument is the vnode where the journal is written.
 * The journal starts at "offset" and is "journal_size" bytes long.
 *
 * The "fsvp" argument is the vnode of your file system.  It may be
 * the same as "jvp".
 *
 * The "min_fs_block_size" argument is the minimum block size
 * (in bytes) that the file system will ever write.  Typically
 * this is the block size of the file system (1k, 4k, etc) but
 * on HFS+ it is the minimum block size of the underlying device.
 *
 * The flags argument lets you disable group commit if you
 * want tighter guarantees on transactions (in exchange for
 * lower performance).
 *
 * The tbuffer_size is the size of the transaction buffer
 * used by the journal. If you specify zero, the journal code
 * will use a reasonable defaults.  The tbuffer_size should 
 * be an integer multiple of the min_fs_block_size.
 *
 * Returns a valid journal pointer or NULL if one could not
 * be created.
 */
journal *journal_create(struct vnode *jvp,
						off_t         offset,
						off_t         journal_size,
						struct vnode *fsvp,
						size_t        min_fs_block_size,
						int32_t       flags,
						int32_t       tbuffer_size,
						void        (*flush)(void *arg),
						void         *arg);

/*
 * Call journal_open() when mounting an existing file system
 * that has a previously created journal.  It will take care
 * of validating the journal and replaying it if necessary.
 *
 * See journal_create() for a description of the arguments.
 *
 * Returns a valid journal pointer of NULL if it runs into
 * trouble reading/playing back the journal.
 */
journal  *journal_open(struct vnode *jvp,
					   off_t         offset,
					   off_t         journal_size,
					   struct vnode *fsvp,
					   size_t        min_fs_block_size,
					   int32_t       flags,
					   int32_t       tbuffer_size,
					   void        (*flush)(void *arg),
					   void         *arg);

/*
 * Test whether the journal is clean or not.  This is intended
 * to be used when you're mounting read-only.  If the journal
 * is not clean for some reason then you should not mount the
 * volume as your data structures may be in an unknown state.
 */
int journal_is_clean(struct vnode *jvp,
		     off_t         offset,
		     off_t         journal_size,
		     struct vnode *fsvp,
                     size_t        min_fs_block_size);


/*
 * Call journal_close() just before your file system is unmounted.
 * It flushes any outstanding transactions and makes sure the
 * journal is in a consistent state.
 */
void      journal_close(journal *journalp);

/*
 * flags for journal_create/open.  only can use 
 * the low 16 bits for flags because internal 
 * bits go in the high 16.
 */
#define JOURNAL_NO_GROUP_COMMIT   0x00000001
#define JOURNAL_RESET             0x00000002

/*
 * Transaction related functions.
 *
 * Before you start modifying file system meta data, you
 * should call journal_start_transaction().  Then before
 * you modify each block, call journal_modify_block_start()
 * and when you're done, journal_modify_block_end().  When
 * you've modified the last block as part of a transaction,
 * call journal_end_transaction() to commit the changes.
 *
 * If you decide to abort the modifications to a block you
 * should call journal_modify_block_abort().
 *
 * If as part of a transaction you need want to throw out
 * any previous copies of a block (because it got deleted)
 * then call journal_kill_block().  This will mark it so
 * that the journal does not play it back (effectively
 * dropping it).
 */
int   journal_start_transaction(journal *jnl);
int   journal_modify_block_start(journal *jnl, struct buf *bp);
int   journal_modify_block_abort(journal *jnl, struct buf *bp);
int   journal_modify_block_end(journal *jnl, struct buf *bp, void (*func)(struct buf *bp, void *arg), void *arg);
int   journal_kill_block(journal *jnl, struct buf *bp);
int   journal_end_transaction(journal *jnl);

int   journal_active(journal *jnl);
int   journal_flush(journal *jnl);
void *journal_owner(journal *jnl);    // compare against current_thread()
int   journal_uses_fua(journal *jnl);


/*
 * Relocate the journal.
 * 
 * You provide the new starting offset and size for the journal. You may
 * optionally provide a new tbuffer_size; passing zero defaults to not
 * changing the tbuffer size except as needed to fit within the new journal
 * size.
 * 
 * You must have already started a transaction. The transaction may contain
 * modified blocks (such as those needed to deallocate the old journal,
 * allocate the new journal, and update the location and size of the journal
 * in filesystem-private structures). Any transactions prior to the active
 * transaction will be flushed to the old journal. The new journal will be
 * initialized, and the blocks from the active transaction will be written to
 * the new journal. The caller will need to update the structures that
 * identify the location and size of the journal from the callback routine.
 */
int journal_relocate(journal *jnl, off_t offset, off_t journal_size, int32_t tbuffer_size,
	errno_t (*callback)(void *), void *callback_arg);

__END_DECLS

#endif /* __APPLE_API_UNSTABLE */
#endif /* !_SYS_VFS_JOURNAL_H_ */
Commit	Line	Data
b4c24cb9 A	1
b4c24cb9 A	2	/*
2d21ac55	3	* Copyright (c) 2000-2007 Apple Inc. All rights reserved.
5d5c5d0d	4	*
2d21ac55	5	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
b4c24cb9	6	*
2d21ac55 A	7	* This file contains Original Code and/or Modifications of Original Code
	8	* as defined in and that are subject to the Apple Public Source License
	9	* Version 2.0 (the 'License'). You may not use this file except in
	10	* compliance with the License. The rights granted to you under the License
	11	* may not be used to create, or enable the creation or redistribution of,
	12	* unlawful or unlicensed copies of an Apple operating system, or to
	13	* circumvent, violate, or enable the circumvention or violation of, any
	14	* terms of an Apple operating system software license agreement.
8f6c56a5	15	*
2d21ac55 A	16	* Please obtain a copy of the License at
	17	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	18	*
	19	* The Original Code and all software distributed under the License are
	20	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
8f6c56a5 A	21	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	22	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	23	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	24	* Please see the License for the specific language governing rights and
	25	* limitations under the License.
8f6c56a5	26	*
2d21ac55	27	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
b4c24cb9 A	28	*/
	29	/*
	30	* This header contains the structures and function prototypes
	31	* for the vfs journaling code. The data types are not meant
	32	* to be modified by user code. Just use the functions and do
	33	* not mess around with the structs.
	34	*/
	35	#ifndef _SYS_VFS_JOURNAL_H_
	36	#define _SYS_VFS_JOURNAL_H_
	37
	38	#include <sys/appleapiopts.h>
91447636	39	#include <sys/cdefs.h>
b4c24cb9 A	40
	41	#ifdef __APPLE_API_UNSTABLE
	42
	43	#include <sys/types.h>
91447636	44	#include <kern/locks.h>
b4c24cb9	45
b0d623f7 A	46	typedef struct _blk_info {
	47	int32_t bsize;
	48	union {
	49	int32_t cksum;
	50	uint32_t sequence_num;
	51	} b;
	52	} _blk_info;
	53
b4c24cb9 A	54	typedef struct block_info {
b4c24cb9 A	55	off_t bnum; // block # on the file system device
2d21ac55	56	union {
b0d623f7	57	_blk_info bi;
2d21ac55	58	struct buf *bp;
b0d623f7 A	59	} u;
b0d623f7 A	60	} __attribute__((__packed__)) block_info;
b4c24cb9 A	61
	62	typedef struct block_list_header {
	63	u_int16_t max_blocks; // max number of blocks in this chunk
	64	u_int16_t num_blocks; // number of valid block numbers in block_nums
	65	int32_t bytes_used; // how many bytes of this tbuffer are used
	66	int32_t checksum; // on-disk: checksum of this header and binfo[0]
2d21ac55	67	int32_t flags; // check-checksums, initial blhdr, etc
b4c24cb9 A	68	block_info binfo[1]; // so we can reference them by name
	69	} block_list_header;
	70
2d21ac55 A	71	#define BLHDR_CHECK_CHECKSUMS 0x0001
	72	#define BLHDR_FIRST_HEADER 0x0002
	73
b4c24cb9 A	74
	75	struct journal;
	76
	77	typedef struct transaction {
	78	int tbuffer_size; // in bytes
	79	char *tbuffer; // memory copy of the transaction
	80	block_list_header *blhdr; // points to the first byte of tbuffer
	81	int num_blhdrs; // how many buffers we've allocated
	82	int total_bytes; // total # of bytes in transaction
	83	int num_flushed; // how many bytes have been flushed
	84	int num_killed; // how many bytes were "killed"
	85	off_t journal_start; // where in the journal this transaction starts
	86	off_t journal_end; // where in the journal this transaction ends
	87	struct journal *jnl; // ptr back to the journal structure
	88	struct transaction *next; // list of tr's (either completed or to be free'd)
2d21ac55	89	uint32_t sequence_num;
b4c24cb9 A	90	} transaction;
	91
	92
	93	/*
	94	* This is written to block zero of the journal and it
	95	* maintains overall state about the journal.
	96	*/
	97	typedef struct journal_header {
	98	int32_t magic;
	99	int32_t endian;
	100	volatile off_t start; // zero-based byte offset of the start of the first transaction
	101	volatile off_t end; // zero-based byte offset of where free space begins
	102	off_t size; // size in bytes of the entire journal
	103	int32_t blhdr_size; // size in bytes of each block_list_header in the journal
	104	int32_t checksum;
	105	int32_t jhdr_size; // block size (in bytes) of the journal header
2d21ac55	106	uint32_t sequence_num; // NEW FIELD: a monotonically increasing value assigned to all txn's
b4c24cb9 A	107	} journal_header;
	108
	109	#define JOURNAL_HEADER_MAGIC 0x4a4e4c78 // 'JNLx'
	110	#define ENDIAN_MAGIC 0x12345678
	111
2d21ac55 A	112	//
	113	// we only checksum the original size of the journal_header to remain
	114	// backwards compatible. the size of the original journal_heade is
	115	// everything up to the the sequence_num field, hence we use the
	116	// offsetof macro to calculate the size.
	117	//
	118	#define JOURNAL_HEADER_CKSUM_SIZE (offsetof(struct journal_header, sequence_num))
	119
b4c24cb9 A	120	#define OLD_JOURNAL_HEADER_MAGIC 0x4a484452 // 'JHDR'
	121
	122
	123	/*
	124	* In memory structure about the journal.
	125	*/
	126	typedef struct journal {
91447636	127	lck_mtx_t jlock; // protects the struct journal data
55e303ae	128
b4c24cb9 A	129	struct vnode *jdev; // vnode of the device where the journal lives
b4c24cb9 A	130	off_t jdev_offset; // byte offset to the start of the journal
2d21ac55	131	const char *jdev_name;
b4c24cb9 A	132
	133	struct vnode *fsdev; // vnode of the file system device
	134
	135	void (flush)(void arg); // fs callback to flush meta data blocks
	136	void *flush_arg; // arg that's passed to flush()
	137
	138	int32_t flags;
	139	int32_t tbuffer_size; // default transaction buffer size
	140
	141	char *header_buf; // in-memory copy of the journal header
b0d623f7	142	int32_t header_buf_size;
b4c24cb9 A	143	journal_header *jhdr; // points to the first byte of header_buf
b4c24cb9 A	144
2d21ac55 A	145	off_t max_read_size;
	146	off_t max_write_size;
	147
b4c24cb9 A	148	transaction *cur_tr; // for group-commit
	149	transaction *completed_trs; // out-of-order transactions that completed
	150	transaction *active_tr; // for nested transactions
	151	int32_t nested_count; // for nested transactions
	152	void *owner; // a ptr that's unique to the calling process
	153
	154	transaction *tr_freeme; // transaction structs that need to be free'd
	155
91447636 A	156	volatile off_t active_start; // the active start that we only keep in memory
	157	lck_mtx_t old_start_lock; // protects the old_start
	158	volatile off_t old_start[16]; // this is how we do lazy start update
b4c24cb9	159
91447636	160	int last_flush_err; // last error from flushing the cache
b4c24cb9 A	161	} journal;
	162
	163	/* internal-only journal flags (top 16 bits) */
	164	#define JOURNAL_CLOSE_PENDING 0x00010000
	165	#define JOURNAL_INVALID 0x00020000
55e303ae A	166	#define JOURNAL_FLUSHCACHE_ERR 0x00040000 // means we already printed this err
55e303ae A	167	#define JOURNAL_NEED_SWAP 0x00080000 // swap any data read from disk
2d21ac55	168	#define JOURNAL_DO_FUA_WRITES 0x00100000 // do force-unit-access writes
b4c24cb9 A	169
	170	/* journal_open/create options are always in the low-16 bits */
	171	#define JOURNAL_OPTION_FLAGS_MASK 0x0000ffff
	172
91447636	173	__BEGIN_DECLS
b4c24cb9 A	174	/*
	175	* Prototypes.
	176	*/
	177
91447636 A	178	/*
	179	* Call journal_init() to initialize the journaling code (sets up lock attributes)
	180	*/
2d21ac55	181	void journal_init(void) __attribute__((section("__TEXT, initcode")));
91447636	182
b4c24cb9 A	183	/*
	184	* Call journal_create() to create a new journal. You only
	185	* call this once, typically at file system creation time.
	186	*
	187	* The "jvp" argument is the vnode where the journal is written.
	188	* The journal starts at "offset" and is "journal_size" bytes long.
	189	*
	190	* The "fsvp" argument is the vnode of your file system. It may be
	191	* the same as "jvp".
	192	*
	193	* The "min_fs_block_size" argument is the minimum block size
	194	* (in bytes) that the file system will ever write. Typically
	195	* this is the block size of the file system (1k, 4k, etc) but
	196	* on HFS+ it is the minimum block size of the underlying device.
	197	*
	198	* The flags argument lets you disable group commit if you
	199	* want tighter guarantees on transactions (in exchange for
	200	* lower performance).
	201	*
	202	* The tbuffer_size is the size of the transaction buffer
	203	* used by the journal. If you specify zero, the journal code
	204	* will use a reasonable defaults. The tbuffer_size should
	205	* be an integer multiple of the min_fs_block_size.
	206	*
	207	* Returns a valid journal pointer or NULL if one could not
	208	* be created.
	209	*/
	210	journal journal_create(struct vnode jvp,
	211	off_t offset,
	212	off_t journal_size,
	213	struct vnode *fsvp,
	214	size_t min_fs_block_size,
	215	int32_t flags,
	216	int32_t tbuffer_size,
	217	void (flush)(void arg),
	218	void *arg);
	219
	220	/*
	221	* Call journal_open() when mounting an existing file system
	222	* that has a previously created journal. It will take care
	223	* of validating the journal and replaying it if necessary.
	224	*
	225	* See journal_create() for a description of the arguments.
	226	*
	227	* Returns a valid journal pointer of NULL if it runs into
	228	* trouble reading/playing back the journal.
	229	*/
	230	journal journal_open(struct vnode jvp,
	231	off_t offset,
	232	off_t journal_size,
	233	struct vnode *fsvp,
	234	size_t min_fs_block_size,
	235	int32_t flags,
	236	int32_t tbuffer_size,
	237	void (flush)(void arg),
	238	void *arg);
	239
743b1565 A	240	/*
	241	* Test whether the journal is clean or not. This is intended
	242	* to be used when you're mounting read-only. If the journal
	243	* is not clean for some reason then you should not mount the
	244	* volume as your data structures may be in an unknown state.
	245	*/
	246	int journal_is_clean(struct vnode *jvp,
	247	off_t offset,
	248	off_t journal_size,
	249	struct vnode *fsvp,
	250	size_t min_fs_block_size);
	251
	252
b4c24cb9 A	253	/*
	254	* Call journal_close() just before your file system is unmounted.
	255	* It flushes any outstanding transactions and makes sure the
	256	* journal is in a consistent state.
	257	*/
91447636	258	void journal_close(journal *journalp);
b4c24cb9 A	259
	260	/*
	261	* flags for journal_create/open. only can use
	262	* the low 16 bits for flags because internal
	263	* bits go in the high 16.
	264	*/
	265	#define JOURNAL_NO_GROUP_COMMIT 0x00000001
	266	#define JOURNAL_RESET 0x00000002
	267
	268	/*
	269	* Transaction related functions.
	270	*
	271	* Before you start modifying file system meta data, you
	272	* should call journal_start_transaction(). Then before
	273	* you modify each block, call journal_modify_block_start()
	274	* and when you're done, journal_modify_block_end(). When
	275	* you've modified the last block as part of a transaction,
	276	* call journal_end_transaction() to commit the changes.
	277	*
	278	* If you decide to abort the modifications to a block you
	279	* should call journal_modify_block_abort().
	280	*
	281	* If as part of a transaction you need want to throw out
	282	* any previous copies of a block (because it got deleted)
	283	* then call journal_kill_block(). This will mark it so
	284	* that the journal does not play it back (effectively
	285	* dropping it).
	286	*/
	287	int journal_start_transaction(journal *jnl);
	288	int journal_modify_block_start(journal jnl, struct buf bp);
	289	int journal_modify_block_abort(journal jnl, struct buf bp);
2d21ac55	290	int journal_modify_block_end(journal jnl, struct buf bp, void (func)(struct buf bp, void arg), void arg);
b4c24cb9 A	291	int journal_kill_block(journal jnl, struct buf bp);
	292	int journal_end_transaction(journal *jnl);
	293
	294	int journal_active(journal *jnl);
	295	int journal_flush(journal *jnl);
91447636	296	void journal_owner(journal jnl); // compare against current_thread()
2d21ac55 A	297	int journal_uses_fua(journal *jnl);
	298
	299
	300	/*
	301	* Relocate the journal.
	302	*
	303	* You provide the new starting offset and size for the journal. You may
	304	* optionally provide a new tbuffer_size; passing zero defaults to not
	305	* changing the tbuffer size except as needed to fit within the new journal
	306	* size.
	307	*
	308	* You must have already started a transaction. The transaction may contain
	309	* modified blocks (such as those needed to deallocate the old journal,
	310	* allocate the new journal, and update the location and size of the journal
	311	* in filesystem-private structures). Any transactions prior to the active
	312	* transaction will be flushed to the old journal. The new journal will be
	313	* initialized, and the blocks from the active transaction will be written to
	314	* the new journal. The caller will need to update the structures that
	315	* identify the location and size of the journal from the callback routine.
	316	*/
	317	int journal_relocate(journal *jnl, off_t offset, off_t journal_size, int32_t tbuffer_size,
	318	errno_t (callback)(void ), void *callback_arg);
91447636 A	319
91447636 A	320	__END_DECLS
b4c24cb9 A	321
	322	#endif /* __APPLE_API_UNSTABLE */
	323	#endif /* !_SYS_VFS_JOURNAL_H_ */