Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 847fff5ca881670ca8ec617afeb943950f0c804b

Authored by Barry Naujok 2008-10-30 14:05:38 +0800

Committed by Lachlan McIlroy 2008-10-30 14:05:38 +0800

Exists in master and in 7 other branches

[XFS] Sync up kernel and user-space headers

SGI-PV: 986558

SGI-Modid: xfs-linux-melb:xfs-kern:32231a

Signed-off-by: Barry Naujok <bnaujok@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>

Showing 14 changed files with 383 additions and 389 deletions Inline Diff

fs/xfs/xfs_ag.h
fs/xfs/xfs_alloc.h
fs/xfs/xfs_arch.h
fs/xfs/xfs_bit.h
fs/xfs/xfs_bmap.h
fs/xfs/xfs_bmap_btree.h
fs/xfs/xfs_btree.h
fs/xfs/xfs_da_btree.h
fs/xfs/xfs_ialloc.h
fs/xfs/xfs_imap.h
fs/xfs/xfs_inode.h
fs/xfs/xfs_inode_item.h
fs/xfs/xfs_mount.h
fs/xfs/xfs_trans.h

fs/xfs/xfs_ag.h

Diff comments View file @ 847fff5

fs/xfs/xfs_alloc.h

Diff comments View file @ 847fff5

 /*
  * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef __XFS_ALLOC_H__
 #define	__XFS_ALLOC_H__
 struct xfs_buf;
 struct xfs_mount;
 struct xfs_perag;
 struct xfs_trans;
 /*
  * Freespace allocation types.  Argument to xfs_alloc_[v]extent.
  */
 typedef enum xfs_alloctype
 {
 	XFS_ALLOCTYPE_ANY_AG,		/* allocate anywhere, use rotor */
 	XFS_ALLOCTYPE_FIRST_AG,		/* ... start at ag 0 */
 	XFS_ALLOCTYPE_START_AG,		/* anywhere, start in this a.g. */
 	XFS_ALLOCTYPE_THIS_AG,		/* anywhere in this a.g. */
 	XFS_ALLOCTYPE_START_BNO,	/* near this block else anywhere */
 	XFS_ALLOCTYPE_NEAR_BNO,		/* in this a.g. and near this block */
 	XFS_ALLOCTYPE_THIS_BNO		/* at exactly this block */
 } xfs_alloctype_t;
 /*
  * Flags for xfs_alloc_fix_freelist.
  */
 #define	XFS_ALLOC_FLAG_TRYLOCK	0x00000001  /* use trylock for buffer locking */
 #define	XFS_ALLOC_FLAG_FREEING	0x00000002  /* indicate caller is freeing extents*/
 /*
  * In order to avoid ENOSPC-related deadlock caused by
  * out-of-order locking of AGF buffer (PV 947395), we place
  * constraints on the relationship among actual allocations for
  * data blocks, freelist blocks, and potential file data bmap
  * btree blocks. However, these restrictions may result in no
  * actual space allocated for a delayed extent, for example, a data
  * block in a certain AG is allocated but there is no additional
  * block for the additional bmap btree block due to a split of the
  * bmap btree of the file. The result of this may lead to an
  * infinite loop in xfssyncd when the file gets flushed to disk and
  * all delayed extents need to be actually allocated. To get around
  * this, we explicitly set aside a few blocks which will not be
  * reserved in delayed allocation. Considering the minimum number of
  * needed freelist blocks is 4 fsbs _per AG_, a potential split of file's bmap
  * btree requires 1 fsb, so we set the number of set-aside blocks
  * to 4 + 4*agcount.
  */
 #define XFS_ALLOC_SET_ASIDE(mp)  (4 + ((mp)->m_sb.sb_agcount * 4))
 /*
  * Argument structure for xfs_alloc routines.
  * This is turned into a structure to avoid having 20 arguments passed
  * down several levels of the stack.
  */
 typedef struct xfs_alloc_arg {
 	struct xfs_trans *tp;		/* transaction pointer */
 	struct xfs_mount *mp;		/* file system mount point */
 	struct xfs_buf	*agbp;		/* buffer for a.g. freelist header */
 	struct xfs_perag *pag;		/* per-ag struct for this agno */
 	xfs_fsblock_t	fsbno;		/* file system block number */
 	xfs_agnumber_t	agno;		/* allocation group number */
 	xfs_agblock_t	agbno;		/* allocation group-relative block # */
 	xfs_extlen_t	minlen;		/* minimum size of extent */
 	xfs_extlen_t	maxlen;		/* maximum size of extent */
 	xfs_extlen_t	mod;		/* mod value for extent size */
 	xfs_extlen_t	prod;		/* prod value for extent size */
 	xfs_extlen_t	minleft;	/* min blocks must be left after us */
 	xfs_extlen_t	total;		/* total blocks needed in xaction */
 	xfs_extlen_t	alignment;	/* align answer to multiple of this */
 	xfs_extlen_t	minalignslop;	/* slop for minlen+alignment calcs */
 	xfs_extlen_t	len;		/* output: actual size of extent */
 	xfs_alloctype_t	type;		/* allocation type XFS_ALLOCTYPE_... */
 	xfs_alloctype_t	otype;		/* original allocation type */
 	char		wasdel;		/* set if allocation was prev delayed */
 	char		wasfromfl;	/* set if allocation is from freelist */
 	char		isfl;		/* set if is freelist blocks - !acctg */
 	char		userdata;	/* set if this is user data */
 	xfs_fsblock_t	firstblock;	/* io first block allocated */
 } xfs_alloc_arg_t;
 /*
  * Defines for userdata
  */
 #define XFS_ALLOC_USERDATA		1	/* allocation is for user data*/
 #define XFS_ALLOC_INITIAL_USER_DATA	2	/* special case start of file */
 #ifdef __KERNEL__
 #if defined(XFS_ALLOC_TRACE)
 /*
  * Allocation tracing buffer size.
  */
 #define	XFS_ALLOC_TRACE_SIZE	4096
 extern ktrace_t *xfs_alloc_trace_buf;
 /*
  * Types for alloc tracing.
  */
 #define	XFS_ALLOC_KTRACE_ALLOC	1
 #define	XFS_ALLOC_KTRACE_FREE	2
 #define	XFS_ALLOC_KTRACE_MODAGF	3
 #define	XFS_ALLOC_KTRACE_BUSY	4
 #define	XFS_ALLOC_KTRACE_UNBUSY	5
 #define	XFS_ALLOC_KTRACE_BUSYSEARCH	6
 #endif
+void
+xfs_alloc_mark_busy(xfs_trans_t *tp,
+		xfs_agnumber_t agno,
+		xfs_agblock_t bno,
+		xfs_extlen_t len);
+void
+xfs_alloc_clear_busy(xfs_trans_t *tp,
+		xfs_agnumber_t ag,
+		int idx);
+#endif	/* __KERNEL__ */
 /*
  * Compute and fill in value of m_ag_maxlevels.
  */
 void
 xfs_alloc_compute_maxlevels(
 	struct xfs_mount	*mp);	/* file system mount structure */
 /*
  * Get a block from the freelist.
  * Returns with the buffer for the block gotten.
  */
 int				/* error */
 xfs_alloc_get_freelist(
 	struct xfs_trans *tp,	/* transaction pointer */
 	struct xfs_buf	*agbp,	/* buffer containing the agf structure */
 	xfs_agblock_t	*bnop,	/* block address retrieved from freelist */
 	int		btreeblk); /* destination is a AGF btree */
 /*
  * Log the given fields from the agf structure.
  */
 void
 xfs_alloc_log_agf(
 	struct xfs_trans *tp,	/* transaction pointer */
 	struct xfs_buf	*bp,	/* buffer for a.g. freelist header */
 	int		fields);/* mask of fields to be logged (XFS_AGF_...) */
 /*
  * Interface for inode allocation to force the pag data to be initialized.
  */
 int				/* error */
 xfs_alloc_pagf_init(
 	struct xfs_mount *mp,	/* file system mount structure */
 	struct xfs_trans *tp,	/* transaction pointer */
 	xfs_agnumber_t	agno,	/* allocation group number */
 	int		flags);	/* XFS_ALLOC_FLAGS_... */
 /*
  * Put the block on the freelist for the allocation group.
  */
 int				/* error */
 xfs_alloc_put_freelist(
 	struct xfs_trans *tp,	/* transaction pointer */
 	struct xfs_buf	*agbp,	/* buffer for a.g. freelist header */
 	struct xfs_buf	*agflbp,/* buffer for a.g. free block array */
 	xfs_agblock_t	bno,	/* block being freed */
 	int		btreeblk); /* owner was a AGF btree */
 /*
  * Read in the allocation group header (free/alloc section).
  */
 int					/* error  */
 xfs_alloc_read_agf(
 	struct xfs_mount *mp,		/* mount point structure */
 	struct xfs_trans *tp,		/* transaction pointer */
 	xfs_agnumber_t	agno,		/* allocation group number */
 	int		flags,		/* XFS_ALLOC_FLAG_... */
 	struct xfs_buf	**bpp);		/* buffer for the ag freelist header */
 /*
  * Allocate an extent (variable-size).
  */
 int				/* error */
 xfs_alloc_vextent(
 	xfs_alloc_arg_t	*args);	/* allocation argument structure */
 /*
  * Free an extent.
  */
 int				/* error */
 xfs_free_extent(
 	struct xfs_trans *tp,	/* transaction pointer */
 	xfs_fsblock_t	bno,	/* starting block number of extent */
 	xfs_extlen_t	len);	/* length of extent */
-void
-xfs_alloc_mark_busy(xfs_trans_t *tp,
-		xfs_agnumber_t agno,

fs/xfs/xfs_arch.h

Diff comments View file @ 847fff5

 /*
  * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef __XFS_ARCH_H__
 #define __XFS_ARCH_H__
 #ifndef XFS_BIG_INUMS
 # error XFS_BIG_INUMS must be defined true or false
 #endif
 #ifdef __KERNEL__
 #include <asm/byteorder.h>
 #ifdef __BIG_ENDIAN
 #define	XFS_NATIVE_HOST	1
 #else
 #undef XFS_NATIVE_HOST
 #endif
 #else /* __KERNEL__ */
 #if __BYTE_ORDER == __BIG_ENDIAN
 #define	XFS_NATIVE_HOST	1
 #else
 #undef XFS_NATIVE_HOST
 #endif
 #ifdef XFS_NATIVE_HOST
-#define cpu_to_be16(val)	((__be16)(val))
+#define cpu_to_be16(val)	((__force __be16)(__u16)(val))
-#define cpu_to_be32(val)	((__be32)(val))
+#define cpu_to_be32(val)	((__force __be32)(__u32)(val))
-#define cpu_to_be64(val)	((__be64)(val))
+#define cpu_to_be64(val)	((__force __be64)(__u64)(val))
-#define be16_to_cpu(val)	((__uint16_t)(val))
+#define be16_to_cpu(val)	((__force __u16)(__be16)(val))
-#define be32_to_cpu(val)	((__uint32_t)(val))
+#define be32_to_cpu(val)	((__force __u32)(__be32)(val))
-#define be64_to_cpu(val)	((__uint64_t)(val))
+#define be64_to_cpu(val)	((__force __u64)(__be64)(val))
 #else
-#define cpu_to_be16(val)	(__swab16((__uint16_t)(val)))
+#define cpu_to_be16(val)	((__force __be16)__swab16((__u16)(val)))
-#define cpu_to_be32(val)	(__swab32((__uint32_t)(val)))
+#define cpu_to_be32(val)	((__force __be32)__swab32((__u32)(val)))
-#define cpu_to_be64(val)	(__swab64((__uint64_t)(val)))
+#define cpu_to_be64(val)	((__force __be64)__swab64((__u64)(val)))
-#define be16_to_cpu(val)	(__swab16((__be16)(val)))
+#define be16_to_cpu(val)	(__swab16((__force __u16)(__be16)(val)))
-#define be32_to_cpu(val)	(__swab32((__be32)(val)))
+#define be32_to_cpu(val)	(__swab32((__force __u32)(__be32)(val)))
-#define be64_to_cpu(val)	(__swab64((__be64)(val)))
+#define be64_to_cpu(val)	(__swab64((__force __u64)(__be64)(val)))
 #endif
+static inline void be16_add_cpu(__be16 *a, __s16 b)
+{
+	*a = cpu_to_be16(be16_to_cpu(*a) + b);
+}
+static inline void be32_add_cpu(__be32 *a, __s32 b)
+{
+	*a = cpu_to_be32(be32_to_cpu(*a) + b);
+}
+static inline void be64_add_cpu(__be64 *a, __s64 b)
+{
+	*a = cpu_to_be64(be64_to_cpu(*a) + b);
+}
 #endif	/* __KERNEL__ */
 /* do we need conversion? */
 #define ARCH_NOCONVERT 1
 #ifdef XFS_NATIVE_HOST
 # define ARCH_CONVERT	ARCH_NOCONVERT
 #else
 # define ARCH_CONVERT	0
 #endif
 /* generic swapping macros */
 #ifndef HAVE_SWABMACROS
 #define INT_SWAP16(type,var) ((typeof(type))(__swab16((__u16)(var))))
 #define INT_SWAP32(type,var) ((typeof(type))(__swab32((__u32)(var))))
 #define INT_SWAP64(type,var) ((typeof(type))(__swab64((__u64)(var))))
 #endif
 #define INT_SWAP(type, var) \
     ((sizeof(type) == 8) ? INT_SWAP64(type,var) : \
     ((sizeof(type) == 4) ? INT_SWAP32(type,var) : \
     ((sizeof(type) == 2) ? INT_SWAP16(type,var) : \
     (var))))
 /*
  * get and set integers from potentially unaligned locations
  */
 #define INT_GET_UNALIGNED_16_BE(pointer) \
    ((__u16)((((__u8*)(pointer))[0] << 8) | (((__u8*)(pointer))[1])))
 #define INT_SET_UNALIGNED_16_BE(pointer,value) \
     { \
 	((__u8*)(pointer))[0] = (((value) >> 8) & 0xff); \
 	((__u8*)(pointer))[1] = (((value)     ) & 0xff); \
     }
 /* does not return a value */
 #define INT_SET(reference,arch,valueref) \
     (__builtin_constant_p(valueref) ? \
 	(void)( (reference) = ( ((arch) != ARCH_NOCONVERT) ? (INT_SWAP((reference),(valueref))) : (valueref)) ) : \
 	(void)( \
 	    ((reference) = (valueref)), \
 	    ( ((arch) != ARCH_NOCONVERT) ? (reference) = INT_SWAP((reference),(reference)) : 0 ) \
 	) \
     )
 /*
  * In directories inode numbers are stored as unaligned arrays of unsigned
  * 8bit integers on disk.
  *
  * For v1 directories or v2 directories that contain inode numbers that
  * do not fit into 32bit the array has eight members, but the first member
  * is always zero:
  *
  *  |unused|48-55|40-47|32-39|24-31|16-23| 8-15| 0- 7|
  *
  * For v2 directories that only contain entries with inode numbers that fit
  * into 32bits a four-member array is used:
  *
  *  |24-31|16-23| 8-15| 0- 7|
  */
 #define XFS_GET_DIR_INO4(di) \
 	(((__u32)(di).i[0] << 24) | ((di).i[1] << 16) | ((di).i[2] << 8) | ((di).i[3]))
 #define XFS_PUT_DIR_INO4(from, di) \
 do { \
 	(di).i[0] = (((from) & 0xff000000ULL) >> 24); \
 	(di).i[1] = (((from) & 0x00ff0000ULL) >> 16); \
 	(di).i[2] = (((from) & 0x0000ff00ULL) >> 8); \
 	(di).i[3] = ((from) & 0x000000ffULL); \
 } while (0)
 #define XFS_DI_HI(di) \
 	(((__u32)(di).i[1] << 16) | ((di).i[2] << 8) | ((di).i[3]))
 #define XFS_DI_LO(di) \
 	(((__u32)(di).i[4] << 24) | ((di).i[5] << 16) | ((di).i[6] << 8) | ((di).i[7]))
 #define XFS_GET_DIR_INO8(di)        \
 	(((xfs_ino_t)XFS_DI_LO(di) & 0xffffffffULL) | \
 	 ((xfs_ino_t)XFS_DI_HI(di) << 32))
 #define XFS_PUT_DIR_INO8(from, di) \
 do { \
 	(di).i[0] = 0; \
 	(di).i[1] = (((from) & 0x00ff000000000000ULL) >> 48); \
 	(di).i[2] = (((from) & 0x0000ff0000000000ULL) >> 40); \
 	(di).i[3] = (((from) & 0x000000ff00000000ULL) >> 32); \
 	(di).i[4] = (((from) & 0x00000000ff000000ULL) >> 24); \
 	(di).i[5] = (((from) & 0x0000000000ff0000ULL) >> 16); \
 	(di).i[6] = (((from) & 0x000000000000ff00ULL) >> 8); \
 	(di).i[7] = ((from) & 0x00000000000000ffULL); \
 } while (0)
 #endif	/* __XFS_ARCH_H__ */

fs/xfs/xfs_bit.h

Diff comments View file @ 847fff5

 /*
  * Copyright (c) 2000,2002,2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef __XFS_BIT_H__
 #define	__XFS_BIT_H__
 /*
  * XFS bit manipulation routines.
  */
 /*
  * masks with n high/low bits set, 32-bit values & 64-bit values
  */
 #define	XFS_MASK32HI(n)		xfs_mask32hi(n)
 static inline __uint32_t xfs_mask32hi(int n)
 {
 	return (__uint32_t)-1 << (32 - (n));
 }
 #define	XFS_MASK64HI(n)		xfs_mask64hi(n)
 static inline __uint64_t xfs_mask64hi(int n)
 {
 	return (__uint64_t)-1 << (64 - (n));
 }
 #define	XFS_MASK32LO(n)		xfs_mask32lo(n)
 static inline __uint32_t xfs_mask32lo(int n)
 {
 	return ((__uint32_t)1 << (n)) - 1;
 }
 #define	XFS_MASK64LO(n)		xfs_mask64lo(n)
 static inline __uint64_t xfs_mask64lo(int n)
 {
 	return ((__uint64_t)1 << (n)) - 1;
 }
 /* Get high bit set out of 32-bit argument, -1 if none set */
 static inline int xfs_highbit32(__uint32_t v)
 {
 	return fls(v) - 1;
 }
 /* Get high bit set out of 64-bit argument, -1 if none set */
 static inline int xfs_highbit64(__uint64_t v)
 {
 	return fls64(v) - 1;
 }
 /* Get low bit set out of 32-bit argument, -1 if none set */
 static inline int xfs_lowbit32(__uint32_t v)
 {
-	unsigned long	t = v;
+	return ffs(v) - 1;
-	return (v) ? find_first_bit(&t, 32) : -1;
 }
 /* Get low bit set out of 64-bit argument, -1 if none set */
 static inline int xfs_lowbit64(__uint64_t v)
 {
 	__uint32_t	w = (__uint32_t)v;
 	int		n = 0;
 	if (w) {	/* lower bits */
 		n = ffs(w);
 	} else {	/* upper bits */
 		w = (__uint32_t)(v >> 32);
 		if (w && (n = ffs(w)))
 		n += 32;
 	}
 	return n - 1;
 }
 /* Return whether bitmap is empty (1 == empty) */
 extern int xfs_bitmap_empty(uint *map, uint size);
 /* Count continuous one bits in map starting with start_bit */
 extern int xfs_contig_bits(uint *map, uint size, uint start_bit);
 /* Find next set bit in map */
 extern int xfs_next_bit(uint *map, uint size, uint start_bit);
 #endif	/* __XFS_BIT_H__ */

fs/xfs/xfs_bmap.h

Diff comments View file @ 847fff5

fs/xfs/xfs_bmap_btree.h

Diff comments View file @ 847fff5

 /*
  * Copyright (c) 2000,2002-2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef __XFS_BMAP_BTREE_H__
 #define __XFS_BMAP_BTREE_H__
 #define XFS_BMAP_MAGIC	0x424d4150	/* 'BMAP' */
 struct xfs_btree_cur;
 struct xfs_btree_lblock;
 struct xfs_mount;
 struct xfs_inode;
 struct xfs_trans;
 /*
  * Bmap root header, on-disk form only.
  */
 typedef struct xfs_bmdr_block {
 	__be16		bb_level;	/* 0 is a leaf */
 	__be16		bb_numrecs;	/* current # of data records */
 } xfs_bmdr_block_t;
 /*
  * Bmap btree record and extent descriptor.
  *  l0:63 is an extent flag (value 1 indicates non-normal).
  *  l0:9-62 are startoff.
  *  l0:0-8 and l1:21-63 are startblock.
  *  l1:0-20 are blockcount.
  */
 #define BMBT_EXNTFLAG_BITLEN	1
 #define BMBT_STARTOFF_BITLEN	54
 #define BMBT_STARTBLOCK_BITLEN	52
 #define BMBT_BLOCKCOUNT_BITLEN	21
 #define BMBT_USE_64	1
 typedef struct xfs_bmbt_rec_32
 {
 	__uint32_t		l0, l1, l2, l3;
 } xfs_bmbt_rec_32_t;
 typedef struct xfs_bmbt_rec_64
 {
 	__be64			l0, l1;
 } xfs_bmbt_rec_64_t;
 typedef __uint64_t	xfs_bmbt_rec_base_t;	/* use this for casts */
 typedef xfs_bmbt_rec_64_t xfs_bmbt_rec_t, xfs_bmdr_rec_t;
 typedef struct xfs_bmbt_rec_host {
 	__uint64_t		l0, l1;
 } xfs_bmbt_rec_host_t;
 /*
  * Values and macros for delayed-allocation startblock fields.
  */
 #define STARTBLOCKVALBITS	17
 #define STARTBLOCKMASKBITS	(15 + XFS_BIG_BLKNOS * 20)
 #define DSTARTBLOCKMASKBITS	(15 + 20)
 #define STARTBLOCKMASK		\
 	(((((xfs_fsblock_t)1) << STARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
 #define DSTARTBLOCKMASK		\
 	(((((xfs_dfsbno_t)1) << DSTARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
 #define ISNULLSTARTBLOCK(x)	isnullstartblock(x)
 static inline int isnullstartblock(xfs_fsblock_t x)
 {
 	return ((x) & STARTBLOCKMASK) == STARTBLOCKMASK;
 }
 #define ISNULLDSTARTBLOCK(x)	isnulldstartblock(x)
 static inline int isnulldstartblock(xfs_dfsbno_t x)
 {
 	return ((x) & DSTARTBLOCKMASK) == DSTARTBLOCKMASK;
 }
 #define NULLSTARTBLOCK(k)	nullstartblock(k)
 static inline xfs_fsblock_t nullstartblock(int k)
 {
 	ASSERT(k < (1 << STARTBLOCKVALBITS));
 	return STARTBLOCKMASK | (k);
 }
 #define STARTBLOCKVAL(x)	startblockval(x)
 static inline xfs_filblks_t startblockval(xfs_fsblock_t x)
 {
 	return (xfs_filblks_t)((x) & ~STARTBLOCKMASK);
 }
 /*
  * Possible extent formats.
  */
 typedef enum {
 	XFS_EXTFMT_NOSTATE = 0,
 	XFS_EXTFMT_HASSTATE
 } xfs_exntfmt_t;
 /*
  * Possible extent states.
  */
 typedef enum {
 	XFS_EXT_NORM, XFS_EXT_UNWRITTEN,
 	XFS_EXT_DMAPI_OFFLINE, XFS_EXT_INVALID
 } xfs_exntst_t;
 /*
  * Extent state and extent format macros.
  */
 #define XFS_EXTFMT_INODE(x)	\
 	(xfs_sb_version_hasextflgbit(&((x)->i_mount->m_sb)) ? \
 		XFS_EXTFMT_HASSTATE : XFS_EXTFMT_NOSTATE)
 #define ISUNWRITTEN(x)	((x)->br_state == XFS_EXT_UNWRITTEN)
 /*
  * Incore version of above.
  */
 typedef struct xfs_bmbt_irec
 {
 	xfs_fileoff_t	br_startoff;	/* starting file offset */
 	xfs_fsblock_t	br_startblock;	/* starting block number */
 	xfs_filblks_t	br_blockcount;	/* number of blocks */
 	xfs_exntst_t	br_state;	/* extent state */
 } xfs_bmbt_irec_t;
 /*
  * Key structure for non-leaf levels of the tree.
  */
 typedef struct xfs_bmbt_key {
 	__be64		br_startoff;	/* starting file offset */
 } xfs_bmbt_key_t, xfs_bmdr_key_t;
 /* btree pointer type */
 typedef __be64 xfs_bmbt_ptr_t, xfs_bmdr_ptr_t;
 /* btree block header type */
 typedef struct xfs_btree_lblock xfs_bmbt_block_t;
 #define XFS_BUF_TO_BMBT_BLOCK(bp)	((xfs_bmbt_block_t *)XFS_BUF_PTR(bp))
 #define XFS_BMAP_RBLOCK_DSIZE(lev,cur)	((cur)->bc_private.b.forksize)
 #define XFS_BMAP_RBLOCK_ISIZE(lev,cur)	\
 	((int)XFS_IFORK_PTR((cur)->bc_private.b.ip, \
 		    (cur)->bc_private.b.whichfork)->if_broot_bytes)
 #define XFS_BMAP_BLOCK_DMAXRECS(lev,cur) \
 	(((lev) == (cur)->bc_nlevels - 1 ? \
 		XFS_BTREE_BLOCK_MAXRECS(XFS_BMAP_RBLOCK_DSIZE(lev,cur), \
 			xfs_bmdr, (lev) == 0) : \
 		((cur)->bc_mp->m_bmap_dmxr[(lev) != 0])))
 #define XFS_BMAP_BLOCK_IMAXRECS(lev,cur) \
 	(((lev) == (cur)->bc_nlevels - 1 ? \
 			XFS_BTREE_BLOCK_MAXRECS(XFS_BMAP_RBLOCK_ISIZE(lev,cur),\
 				xfs_bmbt, (lev) == 0) : \
 			((cur)->bc_mp->m_bmap_dmxr[(lev) != 0])))
 #define XFS_BMAP_BLOCK_DMINRECS(lev,cur) \
 	(((lev) == (cur)->bc_nlevels - 1 ? \
 			XFS_BTREE_BLOCK_MINRECS(XFS_BMAP_RBLOCK_DSIZE(lev,cur),\
 				xfs_bmdr, (lev) == 0) : \
 			((cur)->bc_mp->m_bmap_dmnr[(lev) != 0])))
 #define XFS_BMAP_BLOCK_IMINRECS(lev,cur) \
 	(((lev) == (cur)->bc_nlevels - 1 ? \
 			XFS_BTREE_BLOCK_MINRECS(XFS_BMAP_RBLOCK_ISIZE(lev,cur),\
 				xfs_bmbt, (lev) == 0) : \
 			((cur)->bc_mp->m_bmap_dmnr[(lev) != 0])))
 #define XFS_BMAP_REC_DADDR(bb,i,cur)	(XFS_BTREE_REC_ADDR(xfs_bmbt, bb, i))
 #define XFS_BMAP_REC_IADDR(bb,i,cur)	(XFS_BTREE_REC_ADDR(xfs_bmbt, bb, i))
 #define XFS_BMAP_KEY_DADDR(bb,i,cur)	\
 	(XFS_BTREE_KEY_ADDR(xfs_bmbt, bb, i))
 #define XFS_BMAP_KEY_IADDR(bb,i,cur)	\
 	(XFS_BTREE_KEY_ADDR(xfs_bmbt, bb, i))
 #define XFS_BMAP_PTR_DADDR(bb,i,cur)	\
 	(XFS_BTREE_PTR_ADDR(xfs_bmbt, bb, i, XFS_BMAP_BLOCK_DMAXRECS(	\
 				be16_to_cpu((bb)->bb_level), cur)))
 #define XFS_BMAP_PTR_IADDR(bb,i,cur)	\
 	(XFS_BTREE_PTR_ADDR(xfs_bmbt, bb, i, XFS_BMAP_BLOCK_IMAXRECS(	\
 				be16_to_cpu((bb)->bb_level), cur)))
 /*
  * These are to be used when we know the size of the block and
  * we don't have a cursor.
  */
 #define XFS_BMAP_BROOT_REC_ADDR(bb,i,sz) \
 	(XFS_BTREE_REC_ADDR(xfs_bmbt,bb,i))
 #define XFS_BMAP_BROOT_KEY_ADDR(bb,i,sz) \
 	(XFS_BTREE_KEY_ADDR(xfs_bmbt,bb,i))
 #define XFS_BMAP_BROOT_PTR_ADDR(bb,i,sz) \
 	(XFS_BTREE_PTR_ADDR(xfs_bmbt,bb,i,XFS_BMAP_BROOT_MAXRECS(sz)))
 #define XFS_BMAP_BROOT_NUMRECS(bb)	be16_to_cpu((bb)->bb_numrecs)
 #define XFS_BMAP_BROOT_MAXRECS(sz)	XFS_BTREE_BLOCK_MAXRECS(sz,xfs_bmbt,0)
 #define XFS_BMAP_BROOT_SPACE_CALC(nrecs) \
 	(int)(sizeof(xfs_bmbt_block_t) + \
 	       ((nrecs) * (sizeof(xfs_bmbt_key_t) + sizeof(xfs_bmbt_ptr_t))))
 #define XFS_BMAP_BROOT_SPACE(bb) \
 	(XFS_BMAP_BROOT_SPACE_CALC(be16_to_cpu((bb)->bb_numrecs)))
 #define XFS_BMDR_SPACE_CALC(nrecs) \
 	(int)(sizeof(xfs_bmdr_block_t) + \
 	       ((nrecs) * (sizeof(xfs_bmbt_key_t) + sizeof(xfs_bmbt_ptr_t))))
 /*
  * Maximum number of bmap btree levels.
  */
 #define XFS_BM_MAXLEVELS(mp,w)		((mp)->m_bm_maxlevels[(w)])
 #define XFS_BMAP_SANITY_CHECK(mp,bb,level) \
 	(be32_to_cpu((bb)->bb_magic) == XFS_BMAP_MAGIC && \
 	 be16_to_cpu((bb)->bb_level) == level && \
 	 be16_to_cpu((bb)->bb_numrecs) > 0 && \
 	 be16_to_cpu((bb)->bb_numrecs) <= (mp)->m_bmap_dmxr[(level) != 0])
-#ifdef __KERNEL__
 /*
  * Prototypes for xfs_bmap.c to call.
  */
 extern void xfs_bmdr_to_bmbt(xfs_bmdr_block_t *, int, xfs_bmbt_block_t *, int);
 extern void xfs_bmbt_get_all(xfs_bmbt_rec_host_t *r, xfs_bmbt_irec_t *s);
 extern xfs_filblks_t xfs_bmbt_get_blockcount(xfs_bmbt_rec_host_t *r);
 extern xfs_fsblock_t xfs_bmbt_get_startblock(xfs_bmbt_rec_host_t *r);
 extern xfs_fileoff_t xfs_bmbt_get_startoff(xfs_bmbt_rec_host_t *r);
 extern xfs_exntst_t xfs_bmbt_get_state(xfs_bmbt_rec_host_t *r);
 extern void xfs_bmbt_disk_get_all(xfs_bmbt_rec_t *r, xfs_bmbt_irec_t *s);
 extern xfs_filblks_t xfs_bmbt_disk_get_blockcount(xfs_bmbt_rec_t *r);
 extern xfs_fileoff_t xfs_bmbt_disk_get_startoff(xfs_bmbt_rec_t *r);
 extern void xfs_bmbt_set_all(xfs_bmbt_rec_host_t *r, xfs_bmbt_irec_t *s);
 extern void xfs_bmbt_set_allf(xfs_bmbt_rec_host_t *r, xfs_fileoff_t o,
 			xfs_fsblock_t b, xfs_filblks_t c, xfs_exntst_t v);
 extern void xfs_bmbt_set_blockcount(xfs_bmbt_rec_host_t *r, xfs_filblks_t v);
 extern void xfs_bmbt_set_startblock(xfs_bmbt_rec_host_t *r, xfs_fsblock_t v);
 extern void xfs_bmbt_set_startoff(xfs_bmbt_rec_host_t *r, xfs_fileoff_t v);
 extern void xfs_bmbt_set_state(xfs_bmbt_rec_host_t *r, xfs_exntst_t v);
 extern void xfs_bmbt_disk_set_all(xfs_bmbt_rec_t *r, xfs_bmbt_irec_t *s);
 extern void xfs_bmbt_disk_set_allf(xfs_bmbt_rec_t *r, xfs_fileoff_t o,
 			xfs_fsblock_t b, xfs_filblks_t c, xfs_exntst_t v);
 extern void xfs_bmbt_to_bmdr(xfs_bmbt_block_t *, int, xfs_bmdr_block_t *, int);
 extern struct xfs_btree_cur *xfs_bmbt_init_cursor(struct xfs_mount *,
 		struct xfs_trans *, struct xfs_inode *, int);
-#endif	/* __KERNEL__ */
 #endif	/* __XFS_BMAP_BTREE_H__ */

fs/xfs/xfs_btree.h

Diff comments View file @ 847fff5

 /*
  * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef __XFS_BTREE_H__
 #define	__XFS_BTREE_H__
 struct xfs_buf;
 struct xfs_bmap_free;
 struct xfs_inode;
 struct xfs_mount;
 struct xfs_trans;
 extern kmem_zone_t	*xfs_btree_cur_zone;
 /*
  * This nonsense is to make -wlint happy.
  */
 #define	XFS_LOOKUP_EQ	((xfs_lookup_t)XFS_LOOKUP_EQi)
 #define	XFS_LOOKUP_LE	((xfs_lookup_t)XFS_LOOKUP_LEi)
 #define	XFS_LOOKUP_GE	((xfs_lookup_t)XFS_LOOKUP_GEi)
 #define	XFS_BTNUM_BNO	((xfs_btnum_t)XFS_BTNUM_BNOi)
 #define	XFS_BTNUM_CNT	((xfs_btnum_t)XFS_BTNUM_CNTi)
 #define	XFS_BTNUM_BMAP	((xfs_btnum_t)XFS_BTNUM_BMAPi)
 #define	XFS_BTNUM_INO	((xfs_btnum_t)XFS_BTNUM_INOi)
 /*
  * Short form header: space allocation btrees.
  */
 typedef struct xfs_btree_sblock {
 	__be32		bb_magic;	/* magic number for block type */
 	__be16		bb_level;	/* 0 is a leaf */
 	__be16		bb_numrecs;	/* current # of data records */
 	__be32		bb_leftsib;	/* left sibling block or NULLAGBLOCK */
 	__be32		bb_rightsib;	/* right sibling block or NULLAGBLOCK */
 } xfs_btree_sblock_t;
 /*
  * Long form header: bmap btrees.
  */
 typedef struct xfs_btree_lblock {
 	__be32		bb_magic;	/* magic number for block type */
 	__be16		bb_level;	/* 0 is a leaf */
 	__be16		bb_numrecs;	/* current # of data records */
 	__be64		bb_leftsib;	/* left sibling block or NULLDFSBNO */
 	__be64		bb_rightsib;	/* right sibling block or NULLDFSBNO */
 } xfs_btree_lblock_t;
 /*
  * Combined header and structure, used by common code.
  */
 typedef struct xfs_btree_block {
 	__be32		bb_magic;	/* magic number for block type */
 	__be16		bb_level;	/* 0 is a leaf */
 	__be16		bb_numrecs;	/* current # of data records */
 	union {
 		struct {
 			__be32		bb_leftsib;
 			__be32		bb_rightsib;
 		} s;			/* short form pointers */
 		struct	{
 			__be64		bb_leftsib;
 			__be64		bb_rightsib;
 		} l;			/* long form pointers */
 	} bb_u;				/* rest */
 } xfs_btree_block_t;
 /*
  * Generic key, ptr and record wrapper structures.
  *
  * These are disk format structures, and are converted where necessary
  * by the btree specific code that needs to interpret them.
  */
 union xfs_btree_ptr {
 	__be32			s;	/* short form ptr */
 	__be64			l;	/* long form ptr */
 };
 union xfs_btree_key {
 	xfs_bmbt_key_t		bmbt;
 	xfs_bmdr_key_t		bmbr;	/* bmbt root block */
 	xfs_alloc_key_t		alloc;
 	xfs_inobt_key_t		inobt;
 };
 union xfs_btree_rec {
 	xfs_bmbt_rec_t		bmbt;
 	xfs_bmdr_rec_t		bmbr;	/* bmbt root block */
 	xfs_alloc_rec_t		alloc;
 	xfs_inobt_rec_t		inobt;
 };
 /*
  * For logging record fields.
  */
 #define	XFS_BB_MAGIC		0x01
 #define	XFS_BB_LEVEL		0x02
 #define	XFS_BB_NUMRECS		0x04
 #define	XFS_BB_LEFTSIB		0x08
 #define	XFS_BB_RIGHTSIB		0x10
 #define	XFS_BB_NUM_BITS		5
 #define	XFS_BB_ALL_BITS		((1 << XFS_BB_NUM_BITS) - 1)
 /*
  * Magic numbers for btree blocks.
  */
 extern const __uint32_t	xfs_magics[];
 /*
  * Generic stats interface
  */
 #define __XFS_BTREE_STATS_INC(type, stat) \
 	XFS_STATS_INC(xs_ ## type ## _2_ ## stat)
 #define XFS_BTREE_STATS_INC(cur, stat)  \
 do {    \
 	switch (cur->bc_btnum) {  \
 	case XFS_BTNUM_BNO: __XFS_BTREE_STATS_INC(abtb, stat); break;	\
 	case XFS_BTNUM_CNT: __XFS_BTREE_STATS_INC(abtc, stat); break;	\
 	case XFS_BTNUM_BMAP: __XFS_BTREE_STATS_INC(bmbt, stat); break;	\
 	case XFS_BTNUM_INO: __XFS_BTREE_STATS_INC(ibt, stat); break;	\
 	case XFS_BTNUM_MAX: ASSERT(0); /* fucking gcc */ ; break;	\
 	}       \
 } while (0)
 #define __XFS_BTREE_STATS_ADD(type, stat, val) \
 	XFS_STATS_ADD(xs_ ## type ## _2_ ## stat, val)
 #define XFS_BTREE_STATS_ADD(cur, stat, val)  \
 do {    \
 	switch (cur->bc_btnum) {  \
 	case XFS_BTNUM_BNO: __XFS_BTREE_STATS_ADD(abtb, stat, val); break; \
 	case XFS_BTNUM_CNT: __XFS_BTREE_STATS_ADD(abtc, stat, val); break; \
 	case XFS_BTNUM_BMAP: __XFS_BTREE_STATS_ADD(bmbt, stat, val); break; \
 	case XFS_BTNUM_INO: __XFS_BTREE_STATS_ADD(ibt, stat, val); break; \
 	case XFS_BTNUM_MAX: ASSERT(0); /* fucking gcc */ ; break;	\
 	}       \
 } while (0)
 /*
  * Maximum and minimum records in a btree block.
  * Given block size, type prefix, and leaf flag (0 or 1).
  * The divisor below is equivalent to lf ? (e1) : (e2) but that produces
  * compiler warnings.
  */
 #define	XFS_BTREE_BLOCK_MAXRECS(bsz,t,lf)	\
 	((int)(((bsz) - (uint)sizeof(t ## _block_t)) / \
 	 (((lf) * (uint)sizeof(t ## _rec_t)) + \
 	  ((1 - (lf)) * \
 	   ((uint)sizeof(t ## _key_t) + (uint)sizeof(t ## _ptr_t))))))
 #define	XFS_BTREE_BLOCK_MINRECS(bsz,t,lf)	\
 	(XFS_BTREE_BLOCK_MAXRECS(bsz,t,lf) / 2)
 /*
  * Record, key, and pointer address calculation macros.
  * Given block size, type prefix, block pointer, and index of requested entry
  * (first entry numbered 1).
  */
 #define	XFS_BTREE_REC_ADDR(t,bb,i)	\
 	((t ## _rec_t *)((char *)(bb) + sizeof(t ## _block_t) + \
 	 ((i) - 1) * sizeof(t ## _rec_t)))
 #define	XFS_BTREE_KEY_ADDR(t,bb,i)	\
 	((t ## _key_t *)((char *)(bb) + sizeof(t ## _block_t) + \
 	 ((i) - 1) * sizeof(t ## _key_t)))
 #define	XFS_BTREE_PTR_ADDR(t,bb,i,mxr)	\
 	((t ## _ptr_t *)((char *)(bb) + sizeof(t ## _block_t) + \
 	 (mxr) * sizeof(t ## _key_t) + ((i) - 1) * sizeof(t ## _ptr_t)))
 #define	XFS_BTREE_MAXLEVELS	8	/* max of all btrees */
 struct xfs_btree_ops {
 	/* size of the key and record structures */
 	size_t	key_len;
 	size_t	rec_len;
 	/* cursor operations */
 	struct xfs_btree_cur *(*dup_cursor)(struct xfs_btree_cur *);
 	void	(*update_cursor)(struct xfs_btree_cur *src,
 				 struct xfs_btree_cur *dst);
 	/* update btree root pointer */
 	void	(*set_root)(struct xfs_btree_cur *cur,
 				union xfs_btree_ptr *nptr, int level_change);
 	int	(*kill_root)(struct xfs_btree_cur *cur, struct xfs_buf *bp,
 				int level, union xfs_btree_ptr *newroot);
 	/* block allocation / freeing */
 	int	(*alloc_block)(struct xfs_btree_cur *cur,
 			       union xfs_btree_ptr *start_bno,
 			       union xfs_btree_ptr *new_bno,
 			       int length, int *stat);
 	int	(*free_block)(struct xfs_btree_cur *cur, struct xfs_buf *bp);
 	/* update last record information */
 	void	(*update_lastrec)(struct xfs_btree_cur *cur,
 				  struct xfs_btree_block *block,
 				  union xfs_btree_rec *rec,
 				  int ptr, int reason);
 	/* records in block/level */
 	int	(*get_minrecs)(struct xfs_btree_cur *cur, int level);
 	int	(*get_maxrecs)(struct xfs_btree_cur *cur, int level);
 	/* records on disk.  Matter for the root in inode case. */
 	int	(*get_dmaxrecs)(struct xfs_btree_cur *cur, int level);
 	/* init values of btree structures */
 	void	(*init_key_from_rec)(union xfs_btree_key *key,
 				     union xfs_btree_rec *rec);
 	void	(*init_rec_from_key)(union xfs_btree_key *key,
 				     union xfs_btree_rec *rec);
 	void	(*init_rec_from_cur)(struct xfs_btree_cur *cur,
 				     union xfs_btree_rec *rec);
 	void	(*init_ptr_from_cur)(struct xfs_btree_cur *cur,
 				     union xfs_btree_ptr *ptr);
 	/* difference between key value and cursor value */
 	__int64_t (*key_diff)(struct xfs_btree_cur *cur,
 			      union xfs_btree_key *key);
 #ifdef DEBUG
 	/* check that k1 is lower than k2 */
 	int	(*keys_inorder)(struct xfs_btree_cur *cur,
 				union xfs_btree_key *k1,
 				union xfs_btree_key *k2);
 	/* check that r1 is lower than r2 */
 	int	(*recs_inorder)(struct xfs_btree_cur *cur,
 				union xfs_btree_rec *r1,
 				union xfs_btree_rec *r2);
 #endif
 	/* btree tracing */
 #ifdef XFS_BTREE_TRACE
 	void		(*trace_enter)(struct xfs_btree_cur *, const char *,
 				       char *, int, int, __psunsigned_t,
 				       __psunsigned_t, __psunsigned_t,
 				       __psunsigned_t, __psunsigned_t,
 				       __psunsigned_t, __psunsigned_t,
 				       __psunsigned_t, __psunsigned_t,
 				       __psunsigned_t, __psunsigned_t);
 	void		(*trace_cursor)(struct xfs_btree_cur *, __uint32_t *,
 					__uint64_t *, __uint64_t *);
 	void		(*trace_key)(struct xfs_btree_cur *,
 				     union xfs_btree_key *, __uint64_t *,
 				     __uint64_t *);
 	void		(*trace_record)(struct xfs_btree_cur *,
 					union xfs_btree_rec *, __uint64_t *,
 					__uint64_t *, __uint64_t *);
 #endif
 };
 /*
  * Reasons for the update_lastrec method to be called.
  */
 #define LASTREC_UPDATE	0
 #define LASTREC_INSREC	1
 #define LASTREC_DELREC	2
 /*
  * Btree cursor structure.
  * This collects all information needed by the btree code in one place.
  */
 typedef struct xfs_btree_cur
 {
 	struct xfs_trans	*bc_tp;	/* transaction we're in, if any */
 	struct xfs_mount	*bc_mp;	/* file system mount struct */
 	const struct xfs_btree_ops *bc_ops;
 	uint			bc_flags; /* btree features - below */
 	union {
 		xfs_alloc_rec_incore_t	a;
 		xfs_bmbt_irec_t		b;
 		xfs_inobt_rec_incore_t	i;
 	}		bc_rec;		/* current insert/search record value */
 	struct xfs_buf	*bc_bufs[XFS_BTREE_MAXLEVELS];	/* buf ptr per level */
 	int		bc_ptrs[XFS_BTREE_MAXLEVELS];	/* key/record # */
 	__uint8_t	bc_ra[XFS_BTREE_MAXLEVELS];	/* readahead bits */
 #define	XFS_BTCUR_LEFTRA	1	/* left sibling has been read-ahead */
 #define	XFS_BTCUR_RIGHTRA	2	/* right sibling has been read-ahead */
 	__uint8_t	bc_nlevels;	/* number of levels in the tree */
 	__uint8_t	bc_blocklog;	/* log2(blocksize) of btree blocks */
 	xfs_btnum_t	bc_btnum;	/* identifies which btree type */
 	union {
 		struct {			/* needed for BNO, CNT, INO */
 			struct xfs_buf	*agbp;	/* agf/agi buffer pointer */
 			xfs_agnumber_t	agno;	/* ag number */
 		} a;
 		struct {			/* needed for BMAP */
 			struct xfs_inode *ip;	/* pointer to our inode */
 			struct xfs_bmap_free *flist;	/* list to free after */
 			xfs_fsblock_t	firstblock;	/* 1st blk allocated */
 			int		allocated;	/* count of alloced */
 			short		forksize;	/* fork's inode space */
 			char		whichfork;	/* data or attr fork */
 			char		flags;		/* flags */
 #define	XFS_BTCUR_BPRV_WASDEL	1			/* was delayed */
 		} b;
 	}		bc_private;	/* per-btree type data */
 } xfs_btree_cur_t;
 /* cursor flags */
 #define XFS_BTREE_LONG_PTRS		(1<<0)	/* pointers are 64bits long */
 #define XFS_BTREE_ROOT_IN_INODE		(1<<1)	/* root may be variable size */
 #define XFS_BTREE_LASTREC_UPDATE	(1<<2)	/* track last rec externally */
 #define	XFS_BTREE_NOERROR	0
 #define	XFS_BTREE_ERROR		1
 /*
  * Convert from buffer to btree block header.
  */
 #define	XFS_BUF_TO_BLOCK(bp)	((xfs_btree_block_t *)XFS_BUF_PTR(bp))
 #define	XFS_BUF_TO_LBLOCK(bp)	((xfs_btree_lblock_t *)XFS_BUF_PTR(bp))
 #define	XFS_BUF_TO_SBLOCK(bp)	((xfs_btree_sblock_t *)XFS_BUF_PTR(bp))
-#ifdef __KERNEL__
 /*
  * Check that long form block header is ok.
  */
 int					/* error (0 or EFSCORRUPTED) */
 xfs_btree_check_lblock(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	struct xfs_btree_lblock	*block,	/* btree long form block pointer */
 	int			level,	/* level of the btree block */
 	struct xfs_buf		*bp);	/* buffer containing block, if any */
 /*
  * Check that block header is ok.
  */
 int
 xfs_btree_check_block(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	struct xfs_btree_block	*block,	/* generic btree block pointer */
 	int			level,	/* level of the btree block */
 	struct xfs_buf		*bp);	/* buffer containing block, if any */
 /*
  * Check that (long) pointer is ok.
  */
 int					/* error (0 or EFSCORRUPTED) */
 xfs_btree_check_lptr(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	xfs_dfsbno_t		ptr,	/* btree block disk address */
 	int			level);	/* btree block level */
 /*
  * Delete the btree cursor.
  */
 void
 xfs_btree_del_cursor(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			error);	/* del because of error */
 /*
  * Duplicate the btree cursor.
  * Allocate a new one, copy the record, re-get the buffers.
  */
 int					/* error */
 xfs_btree_dup_cursor(
 	xfs_btree_cur_t		*cur,	/* input cursor */
 	xfs_btree_cur_t		**ncur);/* output cursor */
 /*
  * Get a buffer for the block, return it with no data read.
  * Long-form addressing.
  */
 struct xfs_buf *				/* buffer for fsbno */
 xfs_btree_get_bufl(
 	struct xfs_mount	*mp,	/* file system mount point */
 	struct xfs_trans	*tp,	/* transaction pointer */
 	xfs_fsblock_t		fsbno,	/* file system block number */
 	uint			lock);	/* lock flags for get_buf */
 /*
  * Get a buffer for the block, return it with no data read.
  * Short-form addressing.
  */
 struct xfs_buf *				/* buffer for agno/agbno */
 xfs_btree_get_bufs(
 	struct xfs_mount	*mp,	/* file system mount point */
 	struct xfs_trans	*tp,	/* transaction pointer */
 	xfs_agnumber_t		agno,	/* allocation group number */
 	xfs_agblock_t		agbno,	/* allocation group block number */
 	uint			lock);	/* lock flags for get_buf */
 /*
  * Check for the cursor referring to the last block at the given level.
  */
 int					/* 1=is last block, 0=not last block */
 xfs_btree_islastblock(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			level);	/* level to check */
 /*
  * Compute first and last byte offsets for the fields given.
  * Interprets the offsets table, which contains struct field offsets.
  */
 void
 xfs_btree_offsets(
 	__int64_t		fields,	/* bitmask of fields */
 	const short		*offsets,/* table of field offsets */
 	int			nbits,	/* number of bits to inspect */
 	int			*first,	/* output: first byte offset */
 	int			*last);	/* output: last byte offset */
 /*
  * Get a buffer for the block, return it read in.
  * Long-form addressing.
  */
 int					/* error */
 xfs_btree_read_bufl(
 	struct xfs_mount	*mp,	/* file system mount point */
 	struct xfs_trans	*tp,	/* transaction pointer */
 	xfs_fsblock_t		fsbno,	/* file system block number */
 	uint			lock,	/* lock flags for read_buf */
 	struct xfs_buf		**bpp,	/* buffer for fsbno */
 	int			refval);/* ref count value for buffer */
 /*
  * Get a buffer for the block, return it read in.
  * Short-form addressing.
  */
 int					/* error */
 xfs_btree_read_bufs(
 	struct xfs_mount	*mp,	/* file system mount point */
 	struct xfs_trans	*tp,	/* transaction pointer */
 	xfs_agnumber_t		agno,	/* allocation group number */
 	xfs_agblock_t		agbno,	/* allocation group block number */
 	uint			lock,	/* lock flags for read_buf */
 	struct xfs_buf		**bpp,	/* buffer for agno/agbno */
 	int			refval);/* ref count value for buffer */
 /*
  * Read-ahead the block, don't wait for it, don't return a buffer.
  * Long-form addressing.
  */
 void					/* error */
 xfs_btree_reada_bufl(
 	struct xfs_mount	*mp,	/* file system mount point */
 	xfs_fsblock_t		fsbno,	/* file system block number */
 	xfs_extlen_t		count);	/* count of filesystem blocks */
 /*
  * Read-ahead the block, don't wait for it, don't return a buffer.
  * Short-form addressing.
  */
 void					/* error */
 xfs_btree_reada_bufs(
 	struct xfs_mount	*mp,	/* file system mount point */
 	xfs_agnumber_t		agno,	/* allocation group number */
 	xfs_agblock_t		agbno,	/* allocation group block number */
 	xfs_extlen_t		count);	/* count of filesystem blocks */
 /*
  * Set the buffer for level "lev" in the cursor to bp, releasing
  * any previous buffer.
  */
 void
 xfs_btree_setbuf(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			lev,	/* level in btree */
 	struct xfs_buf		*bp);	/* new buffer to set */
 /*
  * Common btree core entry points.
  */
 int xfs_btree_increment(struct xfs_btree_cur *, int, int *);
 int xfs_btree_decrement(struct xfs_btree_cur *, int, int *);
 int xfs_btree_lookup(struct xfs_btree_cur *, xfs_lookup_t, int *);
 int xfs_btree_update(struct xfs_btree_cur *, union xfs_btree_rec *);
 int xfs_btree_new_iroot(struct xfs_btree_cur *, int *, int *);
 int xfs_btree_kill_iroot(struct xfs_btree_cur *);
 int xfs_btree_insert(struct xfs_btree_cur *, int *);
 int xfs_btree_delete(struct xfs_btree_cur *, int *);
 int xfs_btree_get_rec(struct xfs_btree_cur *, union xfs_btree_rec **, int *);
 /*
  * Internal btree helpers also used by xfs_bmap.c.
  */
 void xfs_btree_log_block(struct xfs_btree_cur *, struct xfs_buf *, int);
 void xfs_btree_log_recs(struct xfs_btree_cur *, struct xfs_buf *, int, int);
 /*
  * Helpers.
  */
 static inline int xfs_btree_get_numrecs(struct xfs_btree_block *block)
 {
 	return be16_to_cpu(block->bb_numrecs);
 }
 static inline void xfs_btree_set_numrecs(struct xfs_btree_block *block,
 		__uint16_t numrecs)
 {
 	block->bb_numrecs = cpu_to_be16(numrecs);
 }
 static inline int xfs_btree_get_level(struct xfs_btree_block *block)
 {
 	return be16_to_cpu(block->bb_level);
 }
-#endif	/* __KERNEL__ */
 /*
  * Min and max functions for extlen, agblock, fileoff, and filblks types.
  */
 #define	XFS_EXTLEN_MIN(a,b)	min_t(xfs_extlen_t, (a), (b))
 #define	XFS_EXTLEN_MAX(a,b)	max_t(xfs_extlen_t, (a), (b))
 #define	XFS_AGBLOCK_MIN(a,b)	min_t(xfs_agblock_t, (a), (b))
 #define	XFS_AGBLOCK_MAX(a,b)	max_t(xfs_agblock_t, (a), (b))
 #define	XFS_FILEOFF_MIN(a,b)	min_t(xfs_fileoff_t, (a), (b))
 #define	XFS_FILEOFF_MAX(a,b)	max_t(xfs_fileoff_t, (a), (b))
 #define	XFS_FILBLKS_MIN(a,b)	min_t(xfs_filblks_t, (a), (b))
 #define	XFS_FILBLKS_MAX(a,b)	max_t(xfs_filblks_t, (a), (b))
 #define	XFS_FSB_SANITY_CHECK(mp,fsb)	\
 	(XFS_FSB_TO_AGNO(mp, fsb) < mp->m_sb.sb_agcount && \
 		XFS_FSB_TO_AGBNO(mp, fsb) < mp->m_sb.sb_agblocks)
 #endif	/* __XFS_BTREE_H__ */

fs/xfs/xfs_da_btree.h

Diff comments View file @ 847fff5

 /*
  * Copyright (c) 2000,2002,2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef __XFS_DA_BTREE_H__
 #define	__XFS_DA_BTREE_H__
 struct xfs_buf;
 struct xfs_bmap_free;
 struct xfs_inode;
 struct xfs_mount;
 struct xfs_trans;
 struct zone;
 /*========================================================================
  * Directory Structure when greater than XFS_LBSIZE(mp) bytes.
  *========================================================================*/
 /*
  * This structure is common to both leaf nodes and non-leaf nodes in the Btree.
  *
  * Is is used to manage a doubly linked list of all blocks at the same
  * level in the Btree, and to identify which type of block this is.
  */
 #define XFS_DA_NODE_MAGIC	0xfebe	/* magic number: non-leaf blocks */
 #define XFS_ATTR_LEAF_MAGIC	0xfbee	/* magic number: attribute leaf blks */
 #define	XFS_DIR2_LEAF1_MAGIC	0xd2f1	/* magic number: v2 dirlf single blks */
 #define	XFS_DIR2_LEAFN_MAGIC	0xd2ff	/* magic number: v2 dirlf multi blks */
 typedef struct xfs_da_blkinfo {
 	__be32		forw;			/* previous block in list */
 	__be32		back;			/* following block in list */
 	__be16		magic;			/* validity check on block */
 	__be16		pad;			/* unused */
 } xfs_da_blkinfo_t;
 /*
  * This is the structure of the root and intermediate nodes in the Btree.
  * The leaf nodes are defined above.
  *
  * Entries are not packed.
  *
  * Since we have duplicate keys, use a binary search but always follow
  * all match in the block, not just the first match found.
  */
 #define	XFS_DA_NODE_MAXDEPTH	5	/* max depth of Btree */
 typedef struct xfs_da_intnode {
 	struct xfs_da_node_hdr {	/* constant-structure header block */
 		xfs_da_blkinfo_t info;	/* block type, links, etc. */
 		__be16	count;		/* count of active entries */
 		__be16	level;		/* level above leaves (leaf == 0) */
 	} hdr;
 	struct xfs_da_node_entry {
 		__be32	hashval;	/* hash value for this descendant */
 		__be32	before;		/* Btree block before this key */
 	} btree[1];			/* variable sized array of keys */
 } xfs_da_intnode_t;
 typedef struct xfs_da_node_hdr xfs_da_node_hdr_t;
 typedef struct xfs_da_node_entry xfs_da_node_entry_t;
 #define	XFS_LBSIZE(mp)	(mp)->m_sb.sb_blocksize
 /*========================================================================
  * Btree searching and modification structure definitions.
  *========================================================================*/
 /*
  * Search comparison results
  */
 enum xfs_dacmp {
 	XFS_CMP_DIFFERENT,	/* names are completely different */
 	XFS_CMP_EXACT,		/* names are exactly the same */
 	XFS_CMP_CASE		/* names are same but differ in case */
 };
 /*
  * Structure to ease passing around component names.
  */
 typedef struct xfs_da_args {
 	const uchar_t	*name;		/* string (maybe not NULL terminated) */
 	int		namelen;	/* length of string (maybe no NULL) */
 	uchar_t		*value;		/* set of bytes (maybe contain NULLs) */
 	int		valuelen;	/* length of value */
 	int		flags;		/* argument flags (eg: ATTR_NOCREATE) */
 	xfs_dahash_t	hashval;	/* hash value of name */
 	xfs_ino_t	inumber;	/* input/output inode number */
 	struct xfs_inode *dp;		/* directory inode to manipulate */
 	xfs_fsblock_t	*firstblock;	/* ptr to firstblock for bmap calls */
 	struct xfs_bmap_free *flist;	/* ptr to freelist for bmap_finish */
 	struct xfs_trans *trans;	/* current trans (changes over time) */
 	xfs_extlen_t	total;		/* total blocks needed, for 1st bmap */
 	int		whichfork;	/* data or attribute fork */
 	xfs_dablk_t	blkno;		/* blkno of attr leaf of interest */
 	int		index;		/* index of attr of interest in blk */
 	xfs_dablk_t	rmtblkno;	/* remote attr value starting blkno */
 	int		rmtblkcnt;	/* remote attr value block count */
 	xfs_dablk_t	blkno2;		/* blkno of 2nd attr leaf of interest */
 	int		index2;		/* index of 2nd attr in blk */
 	xfs_dablk_t	rmtblkno2;	/* remote attr value starting blkno */
 	int		rmtblkcnt2;	/* remote attr value block count */
 	int		op_flags;	/* operation flags */
 	enum xfs_dacmp	cmpresult;	/* name compare result for lookups */
 } xfs_da_args_t;
 /*
  * Operation flags:
  */
 #define XFS_DA_OP_JUSTCHECK	0x0001	/* check for ok with no space */
 #define XFS_DA_OP_RENAME	0x0002	/* this is an atomic rename op */
 #define XFS_DA_OP_ADDNAME	0x0004	/* this is an add operation */
 #define XFS_DA_OP_OKNOENT	0x0008	/* lookup/add op, ENOENT ok, else die */
 #define XFS_DA_OP_CILOOKUP	0x0010	/* lookup to return CI name if found */
 /*
  * Structure to describe buffer(s) for a block.
  * This is needed in the directory version 2 format case, when
  * multiple non-contiguous fsblocks might be needed to cover one
  * logical directory block.
  * If the buffer count is 1 then the data pointer points to the
  * same place as the b_addr field for the buffer, else to kmem_alloced memory.
  */
 typedef struct xfs_dabuf {
 	int		nbuf;		/* number of buffer pointers present */
 	short		dirty;		/* data needs to be copied back */
 	short		bbcount;	/* how large is data in bbs */
 	void		*data;		/* pointer for buffers' data */
 #ifdef XFS_DABUF_DEBUG
 	inst_t		*ra;		/* return address of caller to make */
 	struct xfs_dabuf *next;		/* next in global chain */
 	struct xfs_dabuf *prev;		/* previous in global chain */
 	struct xfs_buftarg *target;	/* device for buffer */
 	xfs_daddr_t	blkno;		/* daddr first in bps[0] */
 #endif
 	struct xfs_buf	*bps[1];	/* actually nbuf of these */
 } xfs_dabuf_t;
 #define	XFS_DA_BUF_SIZE(n)	\
 	(sizeof(xfs_dabuf_t) + sizeof(struct xfs_buf *) * ((n) - 1))
 #ifdef XFS_DABUF_DEBUG
 extern xfs_dabuf_t	*xfs_dabuf_global_list;
 #endif
 /*
  * Storage for holding state during Btree searches and split/join ops.
  *
  * Only need space for 5 intermediate nodes.  With a minimum of 62-way
  * fanout to the Btree, we can support over 900 million directory blocks,
  * which is slightly more than enough.
  */
 typedef struct xfs_da_state_blk {
 	xfs_dabuf_t	*bp;		/* buffer containing block */
 	xfs_dablk_t	blkno;		/* filesystem blkno of buffer */
 	xfs_daddr_t	disk_blkno;	/* on-disk blkno (in BBs) of buffer */
 	int		index;		/* relevant index into block */
 	xfs_dahash_t	hashval;	/* last hash value in block */
 	int		magic;		/* blk's magic number, ie: blk type */
 } xfs_da_state_blk_t;
 typedef struct xfs_da_state_path {
 	int			active;		/* number of active levels */
 	xfs_da_state_blk_t	blk[XFS_DA_NODE_MAXDEPTH];
 } xfs_da_state_path_t;
 typedef struct xfs_da_state {
 	xfs_da_args_t		*args;		/* filename arguments */
 	struct xfs_mount	*mp;		/* filesystem mount point */
 	unsigned int		blocksize;	/* logical block size */
 	unsigned int		node_ents;	/* how many entries in danode */
 	xfs_da_state_path_t	path;		/* search/split paths */
 	xfs_da_state_path_t	altpath;	/* alternate path for join */
 	unsigned char		inleaf;		/* insert into 1->lf, 0->splf */
 	unsigned char		extravalid;	/* T/F: extrablk is in use */
 	unsigned char		extraafter;	/* T/F: extrablk is after new */
 	xfs_da_state_blk_t	extrablk;	/* for double-splits on leafs */
 						/* for dirv2 extrablk is data */
 } xfs_da_state_t;
 /*
  * Utility macros to aid in logging changed structure fields.
  */
 #define XFS_DA_LOGOFF(BASE, ADDR)	((char *)(ADDR) - (char *)(BASE))
 #define XFS_DA_LOGRANGE(BASE, ADDR, SIZE)	\
 		(uint)(XFS_DA_LOGOFF(BASE, ADDR)), \
 		(uint)(XFS_DA_LOGOFF(BASE, ADDR)+(SIZE)-1)
 /*
  * Name ops for directory and/or attr name operations
  */
 struct xfs_nameops {
 	xfs_dahash_t	(*hashname)(struct xfs_name *);
 	enum xfs_dacmp	(*compname)(struct xfs_da_args *, const char *, int);
 };
-#ifdef __KERNEL__
 /*========================================================================
- * Function prototypes for the kernel.
+ * Function prototypes.
  *========================================================================*/
 /*
  * Routines used for growing the Btree.
  */
 int	xfs_da_node_create(xfs_da_args_t *args, xfs_dablk_t blkno, int level,
 					 xfs_dabuf_t **bpp, int whichfork);
 int	xfs_da_split(xfs_da_state_t *state);
 /*
  * Routines used for shrinking the Btree.
  */
 int	xfs_da_join(xfs_da_state_t *state);
 void	xfs_da_fixhashpath(xfs_da_state_t *state,
 					  xfs_da_state_path_t *path_to_to_fix);
 /*
  * Routines used for finding things in the Btree.
  */
 int	xfs_da_node_lookup_int(xfs_da_state_t *state, int *result);
 int	xfs_da_path_shift(xfs_da_state_t *state, xfs_da_state_path_t *path,
 					 int forward, int release, int *result);
 /*
  * Utility routines.
  */
 int	xfs_da_blk_link(xfs_da_state_t *state, xfs_da_state_blk_t *old_blk,
 				       xfs_da_state_blk_t *new_blk);
 /*
  * Utility routines.
  */
 int	xfs_da_grow_inode(xfs_da_args_t *args, xfs_dablk_t *new_blkno);
 int	xfs_da_get_buf(struct xfs_trans *trans, struct xfs_inode *dp,
 			      xfs_dablk_t bno, xfs_daddr_t mappedbno,
 			      xfs_dabuf_t **bp, int whichfork);
 int	xfs_da_read_buf(struct xfs_trans *trans, struct xfs_inode *dp,
 			       xfs_dablk_t bno, xfs_daddr_t mappedbno,
 			       xfs_dabuf_t **bpp, int whichfork);
 xfs_daddr_t	xfs_da_reada_buf(struct xfs_trans *trans, struct xfs_inode *dp,
 			xfs_dablk_t bno, int whichfork);
 int	xfs_da_shrink_inode(xfs_da_args_t *args, xfs_dablk_t dead_blkno,
 					  xfs_dabuf_t *dead_buf);
 uint xfs_da_hashname(const uchar_t *name_string, int name_length);
 enum xfs_dacmp xfs_da_compname(struct xfs_da_args *args,
 				const char *name, int len);
 xfs_da_state_t *xfs_da_state_alloc(void);
 void xfs_da_state_free(xfs_da_state_t *state);
 void xfs_da_buf_done(xfs_dabuf_t *dabuf);
 void xfs_da_log_buf(struct xfs_trans *tp, xfs_dabuf_t *dabuf, uint first,
 			   uint last);
 void xfs_da_brelse(struct xfs_trans *tp, xfs_dabuf_t *dabuf);
 void xfs_da_binval(struct xfs_trans *tp, xfs_dabuf_t *dabuf);
 xfs_daddr_t xfs_da_blkno(xfs_dabuf_t *dabuf);
 extern struct kmem_zone *xfs_da_state_zone;
 extern struct kmem_zone *xfs_dabuf_zone;
-#endif	/* __KERNEL__ */
 #endif	/* __XFS_DA_BTREE_H__ */

fs/xfs/xfs_ialloc.h

Diff comments View file @ 847fff5

 /*
  * Copyright (c) 2000,2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef __XFS_IALLOC_H__
 #define	__XFS_IALLOC_H__
 struct xfs_buf;
 struct xfs_dinode;
 struct xfs_mount;
 struct xfs_trans;
 /*
  * Allocation parameters for inode allocation.
  */
 #define	XFS_IALLOC_INODES(mp)	(mp)->m_ialloc_inos
 #define	XFS_IALLOC_BLOCKS(mp)	(mp)->m_ialloc_blks
 /*
  * Move inodes in clusters of this size.
  */
 #define	XFS_INODE_BIG_CLUSTER_SIZE	8192
 #define	XFS_INODE_CLUSTER_SIZE(mp)	(mp)->m_inode_cluster_size
 /*
  * Make an inode pointer out of the buffer/offset.
  */
 #define	XFS_MAKE_IPTR(mp,b,o)		xfs_make_iptr(mp,b,o)
 static inline struct xfs_dinode *
 xfs_make_iptr(struct xfs_mount *mp, struct xfs_buf *b, int o)
 {
 	return (xfs_dinode_t *)
 		(xfs_buf_offset(b, o << (mp)->m_sb.sb_inodelog));
 }
 /*
  * Find a free (set) bit in the inode bitmask.
  */
 #define	XFS_IALLOC_FIND_FREE(fp)	xfs_ialloc_find_free(fp)
 static inline int xfs_ialloc_find_free(xfs_inofree_t *fp)
 {
 	return xfs_lowbit64(*fp);
 }
-#ifdef __KERNEL__
 /*
  * Allocate an inode on disk.
  * Mode is used to tell whether the new inode will need space, and whether
  * it is a directory.
  *
  * To work within the constraint of one allocation per transaction,
  * xfs_dialloc() is designed to be called twice if it has to do an
  * allocation to make more free inodes.  If an inode is
  * available without an allocation, agbp would be set to the current
  * agbp and alloc_done set to false.
  * If an allocation needed to be done, agbp would be set to the
  * inode header of the allocation group and alloc_done set to true.
  * The caller should then commit the current transaction and allocate a new
  * transaction.  xfs_dialloc() should then be called again with
  * the agbp value returned from the previous call.
  *
  * Once we successfully pick an inode its number is returned and the
  * on-disk data structures are updated.  The inode itself is not read
  * in, since doing so would break ordering constraints with xfs_reclaim.
  *
  * *agbp should be set to NULL on the first call, *alloc_done set to FALSE.
  */
 int					/* error */
 xfs_dialloc(
 	struct xfs_trans *tp,		/* transaction pointer */
 	xfs_ino_t	parent,		/* parent inode (directory) */
 	mode_t		mode,		/* mode bits for new inode */
 	int		okalloc,	/* ok to allocate more space */
 	struct xfs_buf	**agbp,		/* buf for a.g. inode header */
 	boolean_t	*alloc_done,	/* an allocation was done to replenish
 					   the free inodes */
 	xfs_ino_t	*inop);		/* inode number allocated */
 /*
  * Free disk inode.  Carefully avoids touching the incore inode, all
  * manipulations incore are the caller's responsibility.
  * The on-disk inode is not changed by this operation, only the
  * btree (free inode mask) is changed.
  */
 int					/* error */
 xfs_difree(
 	struct xfs_trans *tp,		/* transaction pointer */
 	xfs_ino_t	inode,		/* inode to be freed */
 	struct xfs_bmap_free *flist,	/* extents to free */
 	int		*delete,	/* set if inode cluster was deleted */
 	xfs_ino_t	*first_ino);	/* first inode in deleted cluster */
 /*
  * Return the location of the inode in bno/len/off,
  * for mapping it into a buffer.
  */
 int
 xfs_dilocate(
 	struct xfs_mount *mp,		/* file system mount structure */
 	struct xfs_trans *tp,		/* transaction pointer */
 	xfs_ino_t	ino,		/* inode to locate */
 	xfs_fsblock_t	*bno,		/* output: block containing inode */
 	int		*len,		/* output: num blocks in cluster*/
 	int		*off,		/* output: index in block of inode */
 	uint		flags);		/* flags for inode btree lookup */
 /*
  * Compute and fill in value of m_in_maxlevels.
  */
 void
 xfs_ialloc_compute_maxlevels(
 	struct xfs_mount *mp);		/* file system mount structure */
 /*
  * Log specified fields for the ag hdr (inode section)
  */
 void
 xfs_ialloc_log_agi(
 	struct xfs_trans *tp,		/* transaction pointer */
 	struct xfs_buf	*bp,		/* allocation group header buffer */
 	int		fields);	/* bitmask of fields to log */
 /*
  * Read in the allocation group header (inode allocation section)
  */
 int					/* error */
 xfs_ialloc_read_agi(
 	struct xfs_mount *mp,		/* file system mount structure */
 	struct xfs_trans *tp,		/* transaction pointer */
 	xfs_agnumber_t	agno,		/* allocation group number */
 	struct xfs_buf	**bpp);		/* allocation group hdr buf */
 /*
  * Read in the allocation group header to initialise the per-ag data
  * in the mount structure
  */
 int
 xfs_ialloc_pagi_init(
 	struct xfs_mount *mp,		/* file system mount structure */
 	struct xfs_trans *tp,		/* transaction pointer */
         xfs_agnumber_t  agno);		/* allocation group number */
 /*
  * Lookup the first record greater than or equal to ino
  * in the btree given by cur.
  */
 int xfs_inobt_lookup_ge(struct xfs_btree_cur *cur, xfs_agino_t ino,
 		__int32_t fcnt,	xfs_inofree_t free, int *stat);
 /*
  * Lookup the first record less than or equal to ino
  * in the btree given by cur.
  */
 int xfs_inobt_lookup_le(struct xfs_btree_cur *cur, xfs_agino_t ino,
 		__int32_t fcnt,	xfs_inofree_t free, int *stat);
 /*
  * Get the data from the pointed-to record.
  */
 extern int xfs_inobt_get_rec(struct xfs_btree_cur *cur, xfs_agino_t *ino,
 			     __int32_t *fcnt, xfs_inofree_t *free, int *stat);
-#endif	/* __KERNEL__ */
 #endif	/* __XFS_IALLOC_H__ */

fs/xfs/xfs_imap.h

Diff comments View file @ 847fff5

 /*
  * Copyright (c) 2000,2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef __XFS_IMAP_H__
 #define	__XFS_IMAP_H__
 /*
  * This is the structure passed to xfs_imap() to map
  * an inode number to its on disk location.
  */
 typedef struct xfs_imap {
 	xfs_daddr_t	im_blkno;	/* starting BB of inode chunk */
 	uint		im_len;		/* length in BBs of inode chunk */
 	xfs_agblock_t	im_agblkno;	/* logical block of inode chunk in ag */
 	ushort		im_ioffset;	/* inode offset in block in "inodes" */
 	ushort		im_boffset;	/* inode offset in block in bytes */
 } xfs_imap_t;
-#ifdef __KERNEL__
 struct xfs_mount;
 struct xfs_trans;
 int	xfs_imap(struct xfs_mount *, struct xfs_trans *, xfs_ino_t,
 		 xfs_imap_t *, uint);
-#endif
 #endif	/* __XFS_IMAP_H__ */

fs/xfs/xfs_inode.h

Diff comments View file @ 847fff5

 /*
  * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef	__XFS_INODE_H__
 #define	__XFS_INODE_H__
 struct xfs_dinode;
 struct xfs_dinode_core;
+struct xfs_inode;
 /*
  * Fork identifiers.
  */
 #define	XFS_DATA_FORK	0
 #define	XFS_ATTR_FORK	1
 /*
  * The following xfs_ext_irec_t struct introduces a second (top) level
  * to the in-core extent allocation scheme. These structs are allocated
  * in a contiguous block, creating an indirection array where each entry
  * (irec) contains a pointer to a buffer of in-core extent records which
  * it manages. Each extent buffer is 4k in size, since 4k is the system
  * page size on Linux i386 and systems with larger page sizes don't seem
  * to gain much, if anything, by using their native page size as the
  * extent buffer size. Also, using 4k extent buffers everywhere provides
  * a consistent interface for CXFS across different platforms.
  *
  * There is currently no limit on the number of irec's (extent lists)
  * allowed, so heavily fragmented files may require an indirection array
  * which spans multiple system pages of memory. The number of extents
  * which would require this amount of contiguous memory is very large
  * and should not cause problems in the foreseeable future. However,
  * if the memory needed for the contiguous array ever becomes a problem,
  * it is possible that a third level of indirection may be required.
  */
 typedef struct xfs_ext_irec {
 	xfs_bmbt_rec_host_t *er_extbuf;	/* block of extent records */
 	xfs_extnum_t	er_extoff;	/* extent offset in file */
 	xfs_extnum_t	er_extcount;	/* number of extents in page/block */
 } xfs_ext_irec_t;
 /*
  * File incore extent information, present for each of data & attr forks.
  */
 #define	XFS_IEXT_BUFSZ		4096
 #define	XFS_LINEAR_EXTS		(XFS_IEXT_BUFSZ / (uint)sizeof(xfs_bmbt_rec_t))
 #define	XFS_INLINE_EXTS		2
 #define	XFS_INLINE_DATA		32
 typedef struct xfs_ifork {
 	int			if_bytes;	/* bytes in if_u1 */
 	int			if_real_bytes;	/* bytes allocated in if_u1 */
 	xfs_bmbt_block_t	*if_broot;	/* file's incore btree root */
 	short			if_broot_bytes;	/* bytes allocated for root */
 	unsigned char		if_flags;	/* per-fork flags */
 	unsigned char		if_ext_max;	/* max # of extent records */
 	xfs_extnum_t		if_lastex;	/* last if_extents used */
 	union {
 		xfs_bmbt_rec_host_t *if_extents;/* linear map file exts */
 		xfs_ext_irec_t	*if_ext_irec;	/* irec map file exts */
 		char		*if_data;	/* inline file data */
 	} if_u1;
 	union {
 		xfs_bmbt_rec_host_t if_inline_ext[XFS_INLINE_EXTS];
 						/* very small file extents */
 		char		if_inline_data[XFS_INLINE_DATA];
 						/* very small file data */
 		xfs_dev_t	if_rdev;	/* dev number if special */
 		uuid_t		if_uuid;	/* mount point value */
 	} if_u2;
 } xfs_ifork_t;
 /*
- * Flags for xfs_ichgtime().
- */
-#define	XFS_ICHGTIME_MOD	0x1	/* data fork modification timestamp */
-#define	XFS_ICHGTIME_CHG	0x2	/* inode field change timestamp */
-/*
- * Per-fork incore inode flags.
- */
-#define	XFS_IFINLINE	0x01	/* Inline data is read in */
-#define	XFS_IFEXTENTS	0x02	/* All extent pointers are read in */
-#define	XFS_IFBROOT	0x04	/* i_broot points to the bmap b-tree root */
-#define	XFS_IFEXTIREC	0x08	/* Indirection array of extent blocks */
-/*
- * Flags for xfs_itobp(), xfs_imap() and xfs_dilocate().
- */
-#define XFS_IMAP_LOOKUP		0x1
-#define XFS_IMAP_BULKSTAT	0x2
-#ifdef __KERNEL__
-struct bhv_desc;
-struct cred;
-struct ktrace;
-struct xfs_buf;
-struct xfs_bmap_free;
-struct xfs_bmbt_irec;
-struct xfs_bmbt_block;
-struct xfs_inode;
-struct xfs_inode_log_item;
-struct xfs_mount;
-struct xfs_trans;
-struct xfs_dquot;
-#if defined(XFS_ILOCK_TRACE)
-#define XFS_ILOCK_KTRACE_SIZE	32
-extern ktrace_t *xfs_ilock_trace_buf;
-extern void xfs_ilock_trace(struct xfs_inode *, int, unsigned int, inst_t *);
-#else
-#define	xfs_ilock_trace(i,n,f,ra)
-#endif
-typedef struct dm_attrs_s {
-	__uint32_t	da_dmevmask;	/* DMIG event mask */
-	__uint16_t	da_dmstate;	/* DMIG state info */
-	__uint16_t	da_pad;		/* DMIG extra padding */
-} dm_attrs_t;
-/*
  * This is the xfs in-core inode structure.
  * Most of the on-disk inode is embedded in the i_d field.
  *
  * The extent pointers/inline file space, however, are managed
  * separately.  The memory for this information is pointed to by
  * the if_u1 unions depending on the type of the data.
  * This is used to linearize the array of extents for fast in-core
  * access.  This is used until the file's number of extents
  * surpasses XFS_MAX_INCORE_EXTENTS, at which point all extent pointers
  * are accessed through the buffer cache.
  *
  * Other state kept in the in-core inode is used for identification,
  * locking, transactional updating, etc of the inode.
  *
  * Generally, we do not want to hold the i_rlock while holding the
  * i_ilock. Hierarchy is i_iolock followed by i_rlock.
  *
  * xfs_iptr_t contains all the inode fields upto and including the
  * i_mnext and i_mprev fields, it is used as a marker in the inode
  * chain off the mount structure by xfs_sync calls.
  */
 typedef struct xfs_ictimestamp {
 	__int32_t	t_sec;		/* timestamp seconds */
 	__int32_t	t_nsec;		/* timestamp nanoseconds */
 } xfs_ictimestamp_t;
 /*
  * NOTE:  This structure must be kept identical to struct xfs_dinode_core
  * 	  in xfs_dinode.h except for the endianess annotations.
  */
 typedef struct xfs_icdinode {
 	__uint16_t	di_magic;	/* inode magic # = XFS_DINODE_MAGIC */
 	__uint16_t	di_mode;	/* mode and type of file */
 	__int8_t	di_version;	/* inode version */
 	__int8_t	di_format;	/* format of di_c data */
 	__uint16_t	di_onlink;	/* old number of links to file */
 	__uint32_t	di_uid;		/* owner's user id */
 	__uint32_t	di_gid;		/* owner's group id */
 	__uint32_t	di_nlink;	/* number of links to file */
 	__uint16_t	di_projid;	/* owner's project id */
 	__uint8_t	di_pad[8];	/* unused, zeroed space */
 	__uint16_t	di_flushiter;	/* incremented on flush */
 	xfs_ictimestamp_t di_atime;	/* time last accessed */
 	xfs_ictimestamp_t di_mtime;	/* time last modified */
 	xfs_ictimestamp_t di_ctime;	/* time created/inode modified */
 	xfs_fsize_t	di_size;	/* number of bytes in file */
 	xfs_drfsbno_t	di_nblocks;	/* # of direct & btree blocks used */
 	xfs_extlen_t	di_extsize;	/* basic/minimum extent size for file */
 	xfs_extnum_t	di_nextents;	/* number of extents in data fork */
 	xfs_aextnum_t	di_anextents;	/* number of extents in attribute fork*/
 	__uint8_t	di_forkoff;	/* attr fork offs, <<3 for 64b align */
 	__int8_t	di_aformat;	/* format of attr fork's data */
 	__uint32_t	di_dmevmask;	/* DMIG event mask */
 	__uint16_t	di_dmstate;	/* DMIG state info */
 	__uint16_t	di_flags;	/* random flags, XFS_DIFLAG_... */
 	__uint32_t	di_gen;		/* generation number */
 } xfs_icdinode_t;
+/*
+ * Flags for xfs_ichgtime().
+ */
+#define	XFS_ICHGTIME_MOD	0x1	/* data fork modification timestamp */
+#define	XFS_ICHGTIME_CHG	0x2	/* inode field change timestamp */
+/*
+ * Per-fork incore inode flags.
+ */
+#define	XFS_IFINLINE	0x01	/* Inline data is read in */
+#define	XFS_IFEXTENTS	0x02	/* All extent pointers are read in */
+#define	XFS_IFBROOT	0x04	/* i_broot points to the bmap b-tree root */
+#define	XFS_IFEXTIREC	0x08	/* Indirection array of extent blocks */
+/*
+ * Flags for xfs_itobp(), xfs_imap() and xfs_dilocate().
+ */
+#define XFS_IMAP_LOOKUP		0x1
+#define XFS_IMAP_BULKSTAT	0x2
+/*
+ * Fork handling.
+ */
+#define XFS_IFORK_Q(ip)			((ip)->i_d.di_forkoff != 0)
+#define XFS_IFORK_BOFF(ip)		((int)((ip)->i_d.di_forkoff << 3))
+#define XFS_IFORK_PTR(ip,w)		\
+	((w) == XFS_DATA_FORK ? \
+		&(ip)->i_df : \
+		(ip)->i_afp)
+#define XFS_IFORK_DSIZE(ip) \
+	(XFS_IFORK_Q(ip) ? \
+		XFS_IFORK_BOFF(ip) : \
+		XFS_LITINO((ip)->i_mount))
+#define XFS_IFORK_ASIZE(ip) \
+	(XFS_IFORK_Q(ip) ? \
+		XFS_LITINO((ip)->i_mount) - XFS_IFORK_BOFF(ip) : \
+		0)
+#define XFS_IFORK_SIZE(ip,w) \
+	((w) == XFS_DATA_FORK ? \
+		XFS_IFORK_DSIZE(ip) : \
+		XFS_IFORK_ASIZE(ip))
+#define XFS_IFORK_FORMAT(ip,w) \
+	((w) == XFS_DATA_FORK ? \
+		(ip)->i_d.di_format : \
+		(ip)->i_d.di_aformat)
+#define XFS_IFORK_FMT_SET(ip,w,n) \
+	((w) == XFS_DATA_FORK ? \
+		((ip)->i_d.di_format = (n)) : \
+		((ip)->i_d.di_aformat = (n)))
+#define XFS_IFORK_NEXTENTS(ip,w) \
+	((w) == XFS_DATA_FORK ? \
+		(ip)->i_d.di_nextents : \
+		(ip)->i_d.di_anextents)
+#define XFS_IFORK_NEXT_SET(ip,w,n) \
+	((w) == XFS_DATA_FORK ? \
+		((ip)->i_d.di_nextents = (n)) : \
+		((ip)->i_d.di_anextents = (n)))
+#ifdef __KERNEL__
+struct bhv_desc;
+struct cred;
+struct ktrace;
+struct xfs_buf;
+struct xfs_bmap_free;
+struct xfs_bmbt_irec;
+struct xfs_bmbt_block;
+struct xfs_inode_log_item;
+struct xfs_mount;
+struct xfs_trans;
+struct xfs_dquot;
+#if defined(XFS_ILOCK_TRACE)
+#define XFS_ILOCK_KTRACE_SIZE	32
+extern ktrace_t *xfs_ilock_trace_buf;
+extern void xfs_ilock_trace(struct xfs_inode *, int, unsigned int, inst_t *);
+#else
+#define	xfs_ilock_trace(i,n,f,ra)
+#endif
+typedef struct dm_attrs_s {
+	__uint32_t	da_dmevmask;	/* DMIG event mask */
+	__uint16_t	da_dmstate;	/* DMIG state info */
+	__uint16_t	da_pad;		/* DMIG extra padding */
+} dm_attrs_t;
 typedef struct {
 	struct xfs_inode	*ip_mnext;	/* next inode in mount list */
 	struct xfs_inode	*ip_mprev;	/* ptr to prev inode */
 	struct xfs_mount	*ip_mount;	/* fs mount struct ptr */
 } xfs_iptr_t;
 typedef struct xfs_inode {
 	/* Inode linking and identification information. */
 	struct xfs_inode	*i_mnext;	/* next inode in mount list */
 	struct xfs_inode	*i_mprev;	/* ptr to prev inode */
 	struct xfs_mount	*i_mount;	/* fs mount struct ptr */
 	struct list_head	i_reclaim;	/* reclaim list */
 	struct inode		*i_vnode;	/* vnode backpointer */
 	struct xfs_dquot	*i_udquot;	/* user dquot */
 	struct xfs_dquot	*i_gdquot;	/* group dquot */
 	/* Inode location stuff */
 	xfs_ino_t		i_ino;		/* inode number (agno/agino)*/
 	xfs_daddr_t		i_blkno;	/* blkno of inode buffer */
 	ushort			i_len;		/* len of inode buffer */
 	ushort			i_boffset;	/* off of inode in buffer */
 	/* Extent information. */
 	xfs_ifork_t		*i_afp;		/* attribute fork pointer */
 	xfs_ifork_t		i_df;		/* data fork */
 	/* Transaction and locking information. */
 	struct xfs_trans	*i_transp;	/* ptr to owning transaction*/
 	struct xfs_inode_log_item *i_itemp;	/* logging information */
 	mrlock_t		i_lock;		/* inode lock */
 	mrlock_t		i_iolock;	/* inode IO lock */
 	struct completion	i_flush;	/* inode flush completion q */
 	atomic_t		i_pincount;	/* inode pin count */
 	wait_queue_head_t	i_ipin_wait;	/* inode pinning wait queue */
 	spinlock_t		i_flags_lock;	/* inode i_flags lock */
 	/* Miscellaneous state. */
 	unsigned short		i_flags;	/* see defined flags below */
 	unsigned char		i_update_core;	/* timestamps/size is dirty */
 	unsigned char		i_update_size;	/* di_size field is dirty */
 	unsigned int		i_gen;		/* generation count */
 	unsigned int		i_delayed_blks;	/* count of delay alloc blks */
 	xfs_icdinode_t		i_d;		/* most of ondisk inode */
 	xfs_fsize_t		i_size;		/* in-memory size */
 	xfs_fsize_t		i_new_size;	/* size when write completes */
 	atomic_t		i_iocount;	/* outstanding I/O count */
 	/* Trace buffers per inode. */
 #ifdef XFS_INODE_TRACE
 	struct ktrace		*i_trace;	/* general inode trace */
 #endif
 #ifdef XFS_BMAP_TRACE
 	struct ktrace		*i_xtrace;	/* inode extent list trace */
 #endif
 #ifdef XFS_BTREE_TRACE
 	struct ktrace		*i_btrace;	/* inode bmap btree trace */
 #endif
 #ifdef XFS_RW_TRACE
 	struct ktrace		*i_rwtrace;	/* inode read/write trace */
 #endif
 #ifdef XFS_ILOCK_TRACE
 	struct ktrace		*i_lock_trace;	/* inode lock/unlock trace */
 #endif
 #ifdef XFS_DIR2_TRACE
 	struct ktrace		*i_dir_trace;	/* inode directory trace */
 #endif
 } xfs_inode_t;
 #define XFS_ISIZE(ip)	(((ip)->i_d.di_mode & S_IFMT) == S_IFREG) ? \
 				(ip)->i_size : (ip)->i_d.di_size;
 /* Convert from vfs inode to xfs inode */
 static inline struct xfs_inode *XFS_I(struct inode *inode)
 {
 	return (struct xfs_inode *)inode->i_private;
 }
 /* convert from xfs inode to vfs inode */
 static inline struct inode *VFS_I(struct xfs_inode *ip)
 {
 	return (struct inode *)ip->i_vnode;
 }
 /*
  * i_flags helper functions
  */
 static inline void
 __xfs_iflags_set(xfs_inode_t *ip, unsigned short flags)
 {
 	ip->i_flags |= flags;
 }
 static inline void
 xfs_iflags_set(xfs_inode_t *ip, unsigned short flags)
 {
 	spin_lock(&ip->i_flags_lock);
 	__xfs_iflags_set(ip, flags);
 	spin_unlock(&ip->i_flags_lock);
 }
 static inline void
 xfs_iflags_clear(xfs_inode_t *ip, unsigned short flags)
 {
 	spin_lock(&ip->i_flags_lock);
 	ip->i_flags &= ~flags;
 	spin_unlock(&ip->i_flags_lock);
 }
 static inline int
 __xfs_iflags_test(xfs_inode_t *ip, unsigned short flags)
 {
 	return (ip->i_flags & flags);
 }
 static inline int
 xfs_iflags_test(xfs_inode_t *ip, unsigned short flags)
 {
 	int ret;
 	spin_lock(&ip->i_flags_lock);
 	ret = __xfs_iflags_test(ip, flags);
 	spin_unlock(&ip->i_flags_lock);
 	return ret;
 }
 static inline int
 xfs_iflags_test_and_clear(xfs_inode_t *ip, unsigned short flags)
 {
 	int ret;
 	spin_lock(&ip->i_flags_lock);
 	ret = ip->i_flags & flags;
 	if (ret)
 		ip->i_flags &= ~flags;
 	spin_unlock(&ip->i_flags_lock);
 	return ret;
 }
-#endif	/* __KERNEL__ */
 /*
- * Fork handling.
+ * Manage the i_flush queue embedded in the inode.  This completion
+ * queue synchronizes processes attempting to flush the in-core
+ * inode back to disk.
  */
+static inline void xfs_iflock(xfs_inode_t *ip)
+{
+	wait_for_completion(&ip->i_flush);
+}
-#define XFS_IFORK_Q(ip)			((ip)->i_d.di_forkoff != 0)
+static inline int xfs_iflock_nowait(xfs_inode_t *ip)
-#define XFS_IFORK_BOFF(ip)		((int)((ip)->i_d.di_forkoff << 3))
+{
+	return try_wait_for_completion(&ip->i_flush);
+}
-#define XFS_IFORK_PTR(ip,w)		\
+static inline void xfs_ifunlock(xfs_inode_t *ip)
-	((w) == XFS_DATA_FORK ? \
+{
-		&(ip)->i_df : \
+	complete(&ip->i_flush);
-		(ip)->i_afp)
+}
-#define XFS_IFORK_DSIZE(ip) \
-	(XFS_IFORK_Q(ip) ? \
-		XFS_IFORK_BOFF(ip) : \
-		XFS_LITINO((ip)->i_mount))
-#define XFS_IFORK_ASIZE(ip) \
-	(XFS_IFORK_Q(ip) ? \
-		XFS_LITINO((ip)->i_mount) - XFS_IFORK_BOFF(ip) : \
-		0)
-#define XFS_IFORK_SIZE(ip,w) \
-	((w) == XFS_DATA_FORK ? \
-		XFS_IFORK_DSIZE(ip) : \
-		XFS_IFORK_ASIZE(ip))
-#define XFS_IFORK_FORMAT(ip,w) \
-	((w) == XFS_DATA_FORK ? \
-		(ip)->i_d.di_format : \
-		(ip)->i_d.di_aformat)
-#define XFS_IFORK_FMT_SET(ip,w,n) \
-	((w) == XFS_DATA_FORK ? \
-		((ip)->i_d.di_format = (n)) : \
-		((ip)->i_d.di_aformat = (n)))
-#define XFS_IFORK_NEXTENTS(ip,w) \
-	((w) == XFS_DATA_FORK ? \
-		(ip)->i_d.di_nextents : \
-		(ip)->i_d.di_anextents)
-#define XFS_IFORK_NEXT_SET(ip,w,n) \
-	((w) == XFS_DATA_FORK ? \
-		((ip)->i_d.di_nextents = (n)) : \
-		((ip)->i_d.di_anextents = (n)))
-#ifdef __KERNEL__
 /*
  * In-core inode flags.
  */
 #define XFS_IGRIO	0x0001  /* inode used for guaranteed rate i/o */
 #define XFS_IUIOSZ	0x0002  /* inode i/o sizes have been explicitly set */
 #define XFS_IQUIESCE    0x0004  /* we have started quiescing for this inode */
 #define XFS_IRECLAIM    0x0008  /* we have started reclaiming this inode    */
 #define XFS_ISTALE	0x0010	/* inode has been staled */
 #define XFS_IRECLAIMABLE 0x0020 /* inode can be reclaimed */
 #define XFS_INEW	0x0040
 #define XFS_IFILESTREAM	0x0080	/* inode is in a filestream directory */
 #define XFS_IMODIFIED	0x0100	/* XFS inode state possibly differs */
 				/* to the Linux inode state. */
 #define XFS_ITRUNCATED	0x0200	/* truncated down so flush-on-close */
 /*
  * Flags for inode locking.
  * Bit ranges:	1<<1  - 1<<16-1 -- iolock/ilock modes (bitfield)
  *		1<<16 - 1<<32-1 -- lockdep annotation (integers)
  */
 #define	XFS_IOLOCK_EXCL		(1<<0)
 #define	XFS_IOLOCK_SHARED	(1<<1)
 #define	XFS_ILOCK_EXCL		(1<<2)
 #define	XFS_ILOCK_SHARED	(1<<3)
 #define	XFS_IUNLOCK_NONOTIFY	(1<<4)
 #define XFS_LOCK_MASK		(XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED \
 				| XFS_ILOCK_EXCL | XFS_ILOCK_SHARED)
 /*
  * Flags for lockdep annotations.
  *
  * XFS_I[O]LOCK_PARENT - for operations that require locking two inodes
  * (ie directory operations that require locking a directory inode and
  * an entry inode).  The first inode gets locked with this flag so it
  * gets a lockdep subclass of 1 and the second lock will have a lockdep
  * subclass of 0.
  *
  * XFS_LOCK_INUMORDER - for locking several inodes at the some time
  * with xfs_lock_inodes().  This flag is used as the starting subclass
  * and each subsequent lock acquired will increment the subclass by one.
  * So the first lock acquired will have a lockdep subclass of 2, the
  * second lock will have a lockdep subclass of 3, and so on. It is
  * the responsibility of the class builder to shift this to the correct
  * portion of the lock_mode lockdep mask.
  */
 #define XFS_LOCK_PARENT		1
 #define XFS_LOCK_INUMORDER	2
 #define XFS_IOLOCK_SHIFT	16
 #define	XFS_IOLOCK_PARENT	(XFS_LOCK_PARENT << XFS_IOLOCK_SHIFT)
 #define XFS_ILOCK_SHIFT		24
 #define	XFS_ILOCK_PARENT	(XFS_LOCK_PARENT << XFS_ILOCK_SHIFT)
 #define XFS_IOLOCK_DEP_MASK	0x00ff0000
 #define XFS_ILOCK_DEP_MASK	0xff000000
 #define XFS_LOCK_DEP_MASK	(XFS_IOLOCK_DEP_MASK | XFS_ILOCK_DEP_MASK)
 #define XFS_IOLOCK_DEP(flags)	(((flags) & XFS_IOLOCK_DEP_MASK) >> XFS_IOLOCK_SHIFT)
 #define XFS_ILOCK_DEP(flags)	(((flags) & XFS_ILOCK_DEP_MASK) >> XFS_ILOCK_SHIFT)
 /*
  * Flags for xfs_iflush()
  */
 #define	XFS_IFLUSH_DELWRI_ELSE_SYNC	1
 #define	XFS_IFLUSH_DELWRI_ELSE_ASYNC	2
 #define	XFS_IFLUSH_SYNC			3
 #define	XFS_IFLUSH_ASYNC		4
 #define	XFS_IFLUSH_DELWRI		5
 #define	XFS_IFLUSH_ASYNC_NOBLOCK	6
 /*
  * Flags for xfs_itruncate_start().
  */
 #define	XFS_ITRUNC_DEFINITE	0x1
 #define	XFS_ITRUNC_MAYBE	0x2
 /*
  * For multiple groups support: if S_ISGID bit is set in the parent
  * directory, group of new file is set to that of the parent, and
  * new subdirectory gets S_ISGID bit from parent.
  */
 #define XFS_INHERIT_GID(pip)	\
 	(((pip)->i_mount->m_flags & XFS_MOUNT_GRPID) || \
 	 ((pip)->i_d.di_mode & S_ISGID))
 /*
  * Flags for xfs_iget()
  */
 #define XFS_IGET_CREATE		0x1
 #define XFS_IGET_BULKSTAT	0x2
 /*
  * xfs_iget.c prototypes.
  */
 void		xfs_ihash_init(struct xfs_mount *);
 void		xfs_ihash_free(struct xfs_mount *);
 xfs_inode_t	*xfs_inode_incore(struct xfs_mount *, xfs_ino_t,
 				  struct xfs_trans *);
 int		xfs_iget(struct xfs_mount *, struct xfs_trans *, xfs_ino_t,
 			 uint, uint, xfs_inode_t **, xfs_daddr_t);
 void		xfs_iput(xfs_inode_t *, uint);
 void		xfs_iput_new(xfs_inode_t *, uint);
 void		xfs_ilock(xfs_inode_t *, uint);
 int		xfs_ilock_nowait(xfs_inode_t *, uint);
 void		xfs_iunlock(xfs_inode_t *, uint);
 void		xfs_ilock_demote(xfs_inode_t *, uint);
 int		xfs_isilocked(xfs_inode_t *, uint);
 uint		xfs_ilock_map_shared(xfs_inode_t *);
 void		xfs_iunlock_map_shared(xfs_inode_t *, uint);
 void		xfs_ireclaim(xfs_inode_t *);
 int		xfs_finish_reclaim(xfs_inode_t *, int, int);
 int		xfs_finish_reclaim_all(struct xfs_mount *, int);
 /*
  * xfs_inode.c prototypes.
  */
-int		xfs_itobp(struct xfs_mount *, struct xfs_trans *,
-			  xfs_inode_t *, struct xfs_dinode **, struct xfs_buf **,
-			  xfs_daddr_t, uint, uint);
 int		xfs_iread(struct xfs_mount *, struct xfs_trans *, xfs_ino_t,
 			  xfs_inode_t **, xfs_daddr_t, uint);
-int		xfs_iread_extents(struct xfs_trans *, xfs_inode_t *, int);
 int		xfs_ialloc(struct xfs_trans *, xfs_inode_t *, mode_t,
 			   xfs_nlink_t, xfs_dev_t, struct cred *, xfs_prid_t,
 			   int, struct xfs_buf **, boolean_t *, xfs_inode_t **);
-void		xfs_dinode_from_disk(struct xfs_icdinode *,
-				     struct xfs_dinode_core *);
-void		xfs_dinode_to_disk(struct xfs_dinode_core *,

fs/xfs/xfs_inode_item.h

Diff comments View file @ 847fff5

 /*
  * Copyright (c) 2000,2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef	__XFS_INODE_ITEM_H__
 #define	__XFS_INODE_ITEM_H__
 /*
  * This is the structure used to lay out an inode log item in the
  * log.  The size of the inline data/extents/b-tree root to be logged
  * (if any) is indicated in the ilf_dsize field.  Changes to this structure
  * must be added on to the end.
  */
 typedef struct xfs_inode_log_format {
 	__uint16_t		ilf_type;	/* inode log item type */
 	__uint16_t		ilf_size;	/* size of this item */
 	__uint32_t		ilf_fields;	/* flags for fields logged */
 	__uint16_t		ilf_asize;	/* size of attr d/ext/root */
 	__uint16_t		ilf_dsize;	/* size of data/ext/root */
 	__uint64_t		ilf_ino;	/* inode number */
 	union {
 		__uint32_t	ilfu_rdev;	/* rdev value for dev inode*/
 		uuid_t		ilfu_uuid;	/* mount point value */
 	} ilf_u;
 	__int64_t		ilf_blkno;	/* blkno of inode buffer */
 	__int32_t		ilf_len;	/* len of inode buffer */
 	__int32_t		ilf_boffset;	/* off of inode in buffer */
 } xfs_inode_log_format_t;
 #ifndef HAVE_FORMAT32
 typedef struct xfs_inode_log_format_32 {
 	__uint16_t		ilf_type;	/* inode log item type */
 	__uint16_t		ilf_size;	/* size of this item */
 	__uint32_t		ilf_fields;	/* flags for fields logged */
 	__uint16_t		ilf_asize;	/* size of attr d/ext/root */
 	__uint16_t		ilf_dsize;	/* size of data/ext/root */
 	__uint64_t		ilf_ino;	/* inode number */
 	union {
 		__uint32_t	ilfu_rdev;	/* rdev value for dev inode*/
 		uuid_t		ilfu_uuid;	/* mount point value */
 	} ilf_u;
 	__int64_t		ilf_blkno;	/* blkno of inode buffer */
 	__int32_t		ilf_len;	/* len of inode buffer */
 	__int32_t		ilf_boffset;	/* off of inode in buffer */
 } __attribute__((packed)) xfs_inode_log_format_32_t;
 #endif
 typedef struct xfs_inode_log_format_64 {
 	__uint16_t		ilf_type;	/* inode log item type */
 	__uint16_t		ilf_size;	/* size of this item */
 	__uint32_t		ilf_fields;	/* flags for fields logged */
 	__uint16_t		ilf_asize;	/* size of attr d/ext/root */
 	__uint16_t		ilf_dsize;	/* size of data/ext/root */
 	__uint32_t		ilf_pad;	/* pad for 64 bit boundary */
 	__uint64_t		ilf_ino;	/* inode number */
 	union {
 		__uint32_t	ilfu_rdev;	/* rdev value for dev inode*/
 		uuid_t		ilfu_uuid;	/* mount point value */
 	} ilf_u;
 	__int64_t		ilf_blkno;	/* blkno of inode buffer */
 	__int32_t		ilf_len;	/* len of inode buffer */
 	__int32_t		ilf_boffset;	/* off of inode in buffer */
 } xfs_inode_log_format_64_t;
 /*
  * Flags for xfs_trans_log_inode flags field.
  */
 #define	XFS_ILOG_CORE	0x001	/* log standard inode fields */
 #define	XFS_ILOG_DDATA	0x002	/* log i_df.if_data */
 #define	XFS_ILOG_DEXT	0x004	/* log i_df.if_extents */
 #define	XFS_ILOG_DBROOT	0x008	/* log i_df.i_broot */
 #define	XFS_ILOG_DEV	0x010	/* log the dev field */
 #define	XFS_ILOG_UUID	0x020	/* log the uuid field */
 #define	XFS_ILOG_ADATA	0x040	/* log i_af.if_data */
 #define	XFS_ILOG_AEXT	0x080	/* log i_af.if_extents */
 #define	XFS_ILOG_ABROOT	0x100	/* log i_af.i_broot */
 #define	XFS_ILOG_NONCORE	(XFS_ILOG_DDATA | XFS_ILOG_DEXT | \
 				 XFS_ILOG_DBROOT | XFS_ILOG_DEV | \
 				 XFS_ILOG_UUID | XFS_ILOG_ADATA | \
 				 XFS_ILOG_AEXT | XFS_ILOG_ABROOT)
 #define	XFS_ILOG_DFORK		(XFS_ILOG_DDATA | XFS_ILOG_DEXT | \
 				 XFS_ILOG_DBROOT)
 #define	XFS_ILOG_AFORK		(XFS_ILOG_ADATA | XFS_ILOG_AEXT | \
 				 XFS_ILOG_ABROOT)
 #define	XFS_ILOG_ALL		(XFS_ILOG_CORE | XFS_ILOG_DDATA | \
 				 XFS_ILOG_DEXT | XFS_ILOG_DBROOT | \
 				 XFS_ILOG_DEV | XFS_ILOG_UUID | \
 				 XFS_ILOG_ADATA | XFS_ILOG_AEXT | \
 				 XFS_ILOG_ABROOT)
 #define	XFS_ILI_HOLD		0x1
 #define	XFS_ILI_IOLOCKED_EXCL	0x2
 #define	XFS_ILI_IOLOCKED_SHARED	0x4
 #define	XFS_ILI_IOLOCKED_ANY   (XFS_ILI_IOLOCKED_EXCL | XFS_ILI_IOLOCKED_SHARED)
+#define	XFS_ILOG_FBROOT(w)	xfs_ilog_fbroot(w)
+static inline int xfs_ilog_fbroot(int w)
+{
+	return (w == XFS_DATA_FORK ? XFS_ILOG_DBROOT : XFS_ILOG_ABROOT);
+}
+#define	XFS_ILOG_FEXT(w)	xfs_ilog_fext(w)
+static inline int xfs_ilog_fext(int w)
+{
+	return (w == XFS_DATA_FORK ? XFS_ILOG_DEXT : XFS_ILOG_AEXT);
+}
+#define	XFS_ILOG_FDATA(w)	xfs_ilog_fdata(w)
+static inline int xfs_ilog_fdata(int w)
+{
+	return (w == XFS_DATA_FORK ? XFS_ILOG_DDATA : XFS_ILOG_ADATA);
+}
 #ifdef __KERNEL__
 struct xfs_buf;
 struct xfs_bmbt_rec_64;
 struct xfs_inode;
 struct xfs_mount;
 typedef struct xfs_inode_log_item {
 	xfs_log_item_t		ili_item;	   /* common portion */
 	struct xfs_inode	*ili_inode;	   /* inode ptr */
 	xfs_lsn_t		ili_flush_lsn;	   /* lsn at last flush */
 	xfs_lsn_t		ili_last_lsn;	   /* lsn at last transaction */
 	unsigned short		ili_ilock_recur;   /* lock recursion count */
 	unsigned short		ili_iolock_recur;  /* lock recursion count */
 	unsigned short		ili_flags;	   /* misc flags */
 	unsigned short		ili_logged;	   /* flushed logged data */
 	unsigned int		ili_last_fields;   /* fields when flushed */
 	struct xfs_bmbt_rec_64	*ili_extents_buf;  /* array of logged
 						      data exts */
 	struct xfs_bmbt_rec_64	*ili_aextents_buf; /* array of logged
 						      attr exts */
 	unsigned int            ili_pushbuf_flag;  /* one bit used in push_ail */
 #ifdef DEBUG
 	uint64_t                ili_push_owner;    /* one who sets pushbuf_flag
 						      above gets to push the buf */
 #endif
 #ifdef XFS_TRANS_DEBUG
 	int			ili_root_size;
 	char			*ili_orig_root;
 #endif
 	xfs_inode_log_format_t	ili_format;	   /* logged structure */
 } xfs_inode_log_item_t;
-#define	XFS_ILOG_FDATA(w)	xfs_ilog_fdata(w)
-static inline int xfs_ilog_fdata(int w)
-{
-	return (w == XFS_DATA_FORK ? XFS_ILOG_DDATA : XFS_ILOG_ADATA);
-}
-#endif	/* __KERNEL__ */
-#define	XFS_ILOG_FBROOT(w)	xfs_ilog_fbroot(w)
-static inline int xfs_ilog_fbroot(int w)
-{
-	return (w == XFS_DATA_FORK ? XFS_ILOG_DBROOT : XFS_ILOG_ABROOT);
-}
-#define	XFS_ILOG_FEXT(w)	xfs_ilog_fext(w)
-static inline int xfs_ilog_fext(int w)
-{
-	return (w == XFS_DATA_FORK ? XFS_ILOG_DEXT : XFS_ILOG_AEXT);
-}
 static inline int xfs_inode_clean(xfs_inode_t *ip)
 {
 	return (!ip->i_itemp ||
 		!(ip->i_itemp->ili_format.ilf_fields & XFS_ILOG_ALL)) &&

fs/xfs/xfs_mount.h

Diff comments View file @ 847fff5

fs/xfs/xfs_trans.h

Diff comments View file @ 847fff5

 /*
  * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef	__XFS_TRANS_H__
 #define	__XFS_TRANS_H__
+struct xfs_log_item;
 /*
  * This is the structure written in the log at the head of
  * every transaction. It identifies the type and id of the
  * transaction, and contains the number of items logged by
  * the transaction so we know how many to expect during recovery.
  *
  * Do not change the below structure without redoing the code in
  * xlog_recover_add_to_trans() and xlog_recover_add_to_cont_trans().
  */
 typedef struct xfs_trans_header {
 	uint		th_magic;		/* magic number */
 	uint		th_type;		/* transaction type */
 	__int32_t	th_tid;			/* transaction id (unused) */
 	uint		th_num_items;		/* num items logged by trans */
 } xfs_trans_header_t;
 #define	XFS_TRANS_HEADER_MAGIC	0x5452414e	/* TRAN */
 /*
  * Log item types.
  */
 #define	XFS_LI_EFI		0x1236
 #define	XFS_LI_EFD		0x1237
 #define	XFS_LI_IUNLINK		0x1238
 #define	XFS_LI_INODE		0x123b	/* aligned ino chunks, var-size ibufs */
 #define	XFS_LI_BUF		0x123c	/* v2 bufs, variable sized inode bufs */
 #define	XFS_LI_DQUOT		0x123d
 #define	XFS_LI_QUOTAOFF		0x123e
 /*
  * Transaction types.  Used to distinguish types of buffers.
  */
 #define XFS_TRANS_SETATTR_NOT_SIZE	1
 #define XFS_TRANS_SETATTR_SIZE		2
 #define XFS_TRANS_INACTIVE		3
 #define XFS_TRANS_CREATE		4
 #define XFS_TRANS_CREATE_TRUNC		5
 #define XFS_TRANS_TRUNCATE_FILE		6
 #define XFS_TRANS_REMOVE		7
 #define XFS_TRANS_LINK			8
 #define XFS_TRANS_RENAME		9
 #define XFS_TRANS_MKDIR			10
 #define XFS_TRANS_RMDIR			11
 #define XFS_TRANS_SYMLINK		12
 #define XFS_TRANS_SET_DMATTRS		13
 #define XFS_TRANS_GROWFS		14
 #define XFS_TRANS_STRAT_WRITE		15
 #define XFS_TRANS_DIOSTRAT		16
 #define	XFS_TRANS_WRITE_SYNC		17
 #define	XFS_TRANS_WRITEID		18
 #define	XFS_TRANS_ADDAFORK		19
 #define	XFS_TRANS_ATTRINVAL		20
 #define	XFS_TRANS_ATRUNCATE		21
 #define	XFS_TRANS_ATTR_SET		22
 #define	XFS_TRANS_ATTR_RM		23
 #define	XFS_TRANS_ATTR_FLAG		24
 #define	XFS_TRANS_CLEAR_AGI_BUCKET	25
 #define XFS_TRANS_QM_SBCHANGE		26
 /*
  * Dummy entries since we use the transaction type to index into the
  * trans_type[] in xlog_recover_print_trans_head()
  */
 #define XFS_TRANS_DUMMY1		27
 #define XFS_TRANS_DUMMY2		28
 #define XFS_TRANS_QM_QUOTAOFF		29
 #define XFS_TRANS_QM_DQALLOC		30
 #define XFS_TRANS_QM_SETQLIM		31
 #define XFS_TRANS_QM_DQCLUSTER		32
 #define XFS_TRANS_QM_QINOCREATE		33
 #define XFS_TRANS_QM_QUOTAOFF_END	34
 #define XFS_TRANS_SB_UNIT		35
 #define XFS_TRANS_FSYNC_TS		36
 #define	XFS_TRANS_GROWFSRT_ALLOC	37
 #define	XFS_TRANS_GROWFSRT_ZERO		38
 #define	XFS_TRANS_GROWFSRT_FREE		39
 #define	XFS_TRANS_SWAPEXT		40
 #define	XFS_TRANS_SB_COUNT		41
 #define	XFS_TRANS_TYPE_MAX		41
 /* new transaction types need to be reflected in xfs_logprint(8) */
-#ifdef __KERNEL__
-struct xfs_buf;
-struct xfs_buftarg;
-struct xfs_efd_log_item;
-struct xfs_efi_log_item;
-struct xfs_inode;
-struct xfs_item_ops;
-struct xfs_log_iovec;
-struct xfs_log_item;
-struct xfs_log_item_desc;
-struct xfs_mount;
-struct xfs_trans;
-struct xfs_dquot_acct;
-typedef struct xfs_log_item {
-	struct list_head		li_ail;		/* AIL pointers */
-	xfs_lsn_t			li_lsn;		/* last on-disk lsn */
-	struct xfs_log_item_desc	*li_desc;	/* ptr to current desc*/
-	struct xfs_mount		*li_mountp;	/* ptr to fs mount */
-	uint				li_type;	/* item type */
-	uint				li_flags;	/* misc flags */
-	struct xfs_log_item		*li_bio_list;	/* buffer item list */
-	void				(*li_cb)(struct xfs_buf *,
-						 struct xfs_log_item *);
-							/* buffer item iodone */
-							/* callback func */
-	struct xfs_item_ops		*li_ops;	/* function list */
-} xfs_log_item_t;
-#define	XFS_LI_IN_AIL	0x1
-#define XFS_LI_ABORTED	0x2
-typedef struct xfs_item_ops {
-	uint (*iop_size)(xfs_log_item_t *);
-	void (*iop_format)(xfs_log_item_t *, struct xfs_log_iovec *);
-	void (*iop_pin)(xfs_log_item_t *);
-	void (*iop_unpin)(xfs_log_item_t *, int);
-	void (*iop_unpin_remove)(xfs_log_item_t *, struct xfs_trans *);
-	uint (*iop_trylock)(xfs_log_item_t *);
-	void (*iop_unlock)(xfs_log_item_t *);
-	xfs_lsn_t (*iop_committed)(xfs_log_item_t *, xfs_lsn_t);
-	void (*iop_push)(xfs_log_item_t *);
-	void (*iop_pushbuf)(xfs_log_item_t *);
-	void (*iop_committing)(xfs_log_item_t *, xfs_lsn_t);
-} xfs_item_ops_t;
-#define IOP_SIZE(ip)		(*(ip)->li_ops->iop_size)(ip)
-#define IOP_FORMAT(ip,vp)	(*(ip)->li_ops->iop_format)(ip, vp)
-#define IOP_PIN(ip)		(*(ip)->li_ops->iop_pin)(ip)
-#define IOP_UNPIN(ip, flags)	(*(ip)->li_ops->iop_unpin)(ip, flags)
-#define IOP_UNPIN_REMOVE(ip,tp) (*(ip)->li_ops->iop_unpin_remove)(ip, tp)
-#define IOP_TRYLOCK(ip)		(*(ip)->li_ops->iop_trylock)(ip)
-#define IOP_UNLOCK(ip)		(*(ip)->li_ops->iop_unlock)(ip)
-#define IOP_COMMITTED(ip, lsn)	(*(ip)->li_ops->iop_committed)(ip, lsn)
-#define IOP_PUSH(ip)		(*(ip)->li_ops->iop_push)(ip)
-#define IOP_PUSHBUF(ip)		(*(ip)->li_ops->iop_pushbuf)(ip)
-#define IOP_COMMITTING(ip, lsn) (*(ip)->li_ops->iop_committing)(ip, lsn)
 /*
- * Return values for the IOP_TRYLOCK() routines.
- */
-#define	XFS_ITEM_SUCCESS	0
-#define	XFS_ITEM_PINNED		1
-#define	XFS_ITEM_LOCKED		2
-#define	XFS_ITEM_FLUSHING	3
-#define XFS_ITEM_PUSHBUF	4
-#endif	/* __KERNEL__ */
-/*
  * This structure is used to track log items associated with
  * a transaction.  It points to the log item and keeps some
  * flags to track the state of the log item.  It also tracks
  * the amount of space needed to log the item it describes
  * once we get to commit processing (see xfs_trans_commit()).
  */
 typedef struct xfs_log_item_desc {
-	xfs_log_item_t	*lid_item;
+	struct xfs_log_item	*lid_item;
 	ushort		lid_size;
 	unsigned char	lid_flags;
 	unsigned char	lid_index;
 } xfs_log_item_desc_t;
 #define XFS_LID_DIRTY		0x1
 #define XFS_LID_PINNED		0x2
 #define XFS_LID_BUF_STALE	0x8
 /*
  * This structure is used to maintain a chunk list of log_item_desc
  * structures. The free field is a bitmask indicating which descriptors
  * in this chunk's array are free.  The unused field is the first value
  * not used since this chunk was allocated.
  */
 #define	XFS_LIC_NUM_SLOTS	15
 typedef struct xfs_log_item_chunk {
 	struct xfs_log_item_chunk	*lic_next;
 	ushort				lic_free;
 	ushort				lic_unused;
 	xfs_log_item_desc_t		lic_descs[XFS_LIC_NUM_SLOTS];
 } xfs_log_item_chunk_t;
 #define	XFS_LIC_MAX_SLOT	(XFS_LIC_NUM_SLOTS - 1)
 #define	XFS_LIC_FREEMASK	((1 << XFS_LIC_NUM_SLOTS) - 1)
 /*
  * Initialize the given chunk.  Set the chunk's free descriptor mask
  * to indicate that all descriptors are free.  The caller gets to set
  * lic_unused to the right value (0 matches all free).  The
  * lic_descs.lid_index values are set up as each desc is allocated.
  */
 static inline void xfs_lic_init(xfs_log_item_chunk_t *cp)
 {
 	cp->lic_free = XFS_LIC_FREEMASK;
 }
 static inline void xfs_lic_init_slot(xfs_log_item_chunk_t *cp, int slot)
 {
 	cp->lic_descs[slot].lid_index = (unsigned char)(slot);
 }
 static inline int xfs_lic_vacancy(xfs_log_item_chunk_t *cp)
 {
 	return cp->lic_free & XFS_LIC_FREEMASK;
 }
 static inline void xfs_lic_all_free(xfs_log_item_chunk_t *cp)
 {
 	cp->lic_free = XFS_LIC_FREEMASK;
 }
 static inline int xfs_lic_are_all_free(xfs_log_item_chunk_t *cp)
 {
 	return ((cp->lic_free & XFS_LIC_FREEMASK) == XFS_LIC_FREEMASK);
 }
 static inline int xfs_lic_isfree(xfs_log_item_chunk_t *cp, int slot)
 {
 	return (cp->lic_free & (1 << slot));
 }
 static inline void xfs_lic_claim(xfs_log_item_chunk_t *cp, int slot)
 {
 	cp->lic_free &= ~(1 << slot);
 }
 static inline void xfs_lic_relse(xfs_log_item_chunk_t *cp, int slot)
 {
 	cp->lic_free |= 1 << slot;
 }
 static inline xfs_log_item_desc_t *
 xfs_lic_slot(xfs_log_item_chunk_t *cp, int slot)
 {
 	return &(cp->lic_descs[slot]);
 }
 static inline int xfs_lic_desc_to_slot(xfs_log_item_desc_t *dp)
 {
 	return (uint)dp->lid_index;
 }
 /*
  * Calculate the address of a chunk given a descriptor pointer:
  * dp - dp->lid_index give the address of the start of the lic_descs array.
  * From this we subtract the offset of the lic_descs field in a chunk.
  * All of this yields the address of the chunk, which is
  * cast to a chunk pointer.
  */
 static inline xfs_log_item_chunk_t *
 xfs_lic_desc_to_chunk(xfs_log_item_desc_t *dp)
 {
 	return (xfs_log_item_chunk_t*) \
 		(((xfs_caddr_t)((dp) - (dp)->lid_index)) - \
 		(xfs_caddr_t)(((xfs_log_item_chunk_t*)0)->lic_descs));
 }
-#ifdef __KERNEL__
-/*
- * This structure is used to maintain a list of block ranges that have been
- * freed in the transaction.  The ranges are listed in the perag[] busy list
- * between when they're freed and the transaction is committed to disk.
- */
-typedef struct xfs_log_busy_slot {
-	xfs_agnumber_t		lbc_ag;
-	ushort			lbc_idx;	/* index in perag.busy[] */
-} xfs_log_busy_slot_t;
-#define XFS_LBC_NUM_SLOTS	31
-typedef struct xfs_log_busy_chunk {
-	struct xfs_log_busy_chunk	*lbc_next;
-	uint				lbc_free;	/* free slots bitmask */
-	ushort				lbc_unused;	/* first unused */
-	xfs_log_busy_slot_t		lbc_busy[XFS_LBC_NUM_SLOTS];
-} xfs_log_busy_chunk_t;
-#define	XFS_LBC_MAX_SLOT	(XFS_LBC_NUM_SLOTS - 1)
-#define	XFS_LBC_FREEMASK	((1U << XFS_LBC_NUM_SLOTS) - 1)
-#define	XFS_LBC_INIT(cp)	((cp)->lbc_free = XFS_LBC_FREEMASK)
-#define	XFS_LBC_CLAIM(cp, slot)	((cp)->lbc_free &= ~(1 << (slot)))
-#define	XFS_LBC_SLOT(cp, slot)	(&((cp)->lbc_busy[(slot)]))
-#define	XFS_LBC_VACANCY(cp)	(((cp)->lbc_free) & XFS_LBC_FREEMASK)
-#define	XFS_LBC_ISFREE(cp, slot) ((cp)->lbc_free & (1 << (slot)))
-/*
- * This is the type of function which can be given to xfs_trans_callback()
- * to be called upon the transaction's commit to disk.
- */
-typedef void (*xfs_trans_callback_t)(struct xfs_trans *, void *);
-/*
- * This is the structure maintained for every active transaction.
- */
-typedef struct xfs_trans {
-	unsigned int		t_magic;	/* magic number */
-	xfs_log_callback_t	t_logcb;	/* log callback struct */
-	unsigned int		t_type;		/* transaction type */
-	unsigned int		t_log_res;	/* amt of log space resvd */
-	unsigned int		t_log_count;	/* count for perm log res */
-	unsigned int		t_blk_res;	/* # of blocks resvd */
-	unsigned int		t_blk_res_used;	/* # of resvd blocks used */
-	unsigned int		t_rtx_res;	/* # of rt extents resvd */
-	unsigned int		t_rtx_res_used;	/* # of resvd rt extents used */
-	xfs_log_ticket_t	t_ticket;	/* log mgr ticket */
-	xfs_lsn_t		t_lsn;		/* log seq num of start of
-						 * transaction. */
-	xfs_lsn_t		t_commit_lsn;	/* log seq num of end of
-						 * transaction. */
-	struct xfs_mount	*t_mountp;	/* ptr to fs mount struct */
-	struct xfs_dquot_acct   *t_dqinfo;	/* acctg info for dquots */
-	xfs_trans_callback_t	t_callback;	/* transaction callback */
-	void			*t_callarg;	/* callback arg */
-	unsigned int		t_flags;	/* misc flags */
-	int64_t			t_icount_delta;	/* superblock icount change */
-	int64_t			t_ifree_delta;	/* superblock ifree change */
-	int64_t			t_fdblocks_delta; /* superblock fdblocks chg */
-	int64_t			t_res_fdblocks_delta; /* on-disk only chg */
-	int64_t			t_frextents_delta;/* superblock freextents chg*/
-	int64_t			t_res_frextents_delta; /* on-disk only chg */
-#ifdef DEBUG
-	int64_t			t_ag_freeblks_delta; /* debugging counter */
-	int64_t			t_ag_flist_delta; /* debugging counter */
-	int64_t			t_ag_btree_delta; /* debugging counter */
-#endif
-	int64_t			t_dblocks_delta;/* superblock dblocks change */
-	int64_t			t_agcount_delta;/* superblock agcount change */
-	int64_t			t_imaxpct_delta;/* superblock imaxpct change */
-	int64_t			t_rextsize_delta;/* superblock rextsize chg */
-	int64_t			t_rbmblocks_delta;/* superblock rbmblocks chg */
-	int64_t			t_rblocks_delta;/* superblock rblocks change */
-	int64_t			t_rextents_delta;/* superblocks rextents chg */
-	int64_t			t_rextslog_delta;/* superblocks rextslog chg */
-	unsigned int		t_items_free;	/* log item descs free */
-	xfs_log_item_chunk_t	t_items;	/* first log item desc chunk */
-	xfs_trans_header_t	t_header;	/* header for in-log trans */
-	unsigned int		t_busy_free;	/* busy descs free */
-	xfs_log_busy_chunk_t	t_busy;		/* busy/async free blocks */
-	unsigned long		t_pflags;	/* saved process flags state */
-} xfs_trans_t;
-#endif	/* __KERNEL__ */
 #define	XFS_TRANS_MAGIC		0x5452414E	/* 'TRAN' */
 /*
  * Values for t_flags.
  */
 #define	XFS_TRANS_DIRTY		0x01	/* something needs to be logged */
 #define	XFS_TRANS_SB_DIRTY	0x02	/* superblock is modified */
 #define	XFS_TRANS_PERM_LOG_RES	0x04	/* xact took a permanent log res */
 #define	XFS_TRANS_SYNC		0x08	/* make commit synchronous */
 #define XFS_TRANS_DQ_DIRTY	0x10	/* at least one dquot in trx dirty */
 #define XFS_TRANS_RESERVE	0x20    /* OK to use reserved data blocks */
 /*
  * Values for call flags parameter.
  */
 #define	XFS_TRANS_NOSLEEP		0x1
 #define	XFS_TRANS_WAIT			0x2
 #define	XFS_TRANS_RELEASE_LOG_RES	0x4
 #define	XFS_TRANS_ABORT			0x8
 /*
  * Field values for xfs_trans_mod_sb.
  */
 #define	XFS_TRANS_SB_ICOUNT		0x00000001
 #define	XFS_TRANS_SB_IFREE		0x00000002
 #define	XFS_TRANS_SB_FDBLOCKS		0x00000004
 #define	XFS_TRANS_SB_RES_FDBLOCKS	0x00000008
 #define	XFS_TRANS_SB_FREXTENTS		0x00000010
 #define	XFS_TRANS_SB_RES_FREXTENTS	0x00000020
 #define	XFS_TRANS_SB_DBLOCKS		0x00000040
 #define	XFS_TRANS_SB_AGCOUNT		0x00000080
 #define	XFS_TRANS_SB_IMAXPCT		0x00000100
 #define	XFS_TRANS_SB_REXTSIZE		0x00000200
 #define	XFS_TRANS_SB_RBMBLOCKS		0x00000400
 #define	XFS_TRANS_SB_RBLOCKS		0x00000800
 #define	XFS_TRANS_SB_REXTENTS		0x00001000
 #define	XFS_TRANS_SB_REXTSLOG		0x00002000
 /*
  * Various log reservation values.
  * These are based on the size of the file system block
  * because that is what most transactions manipulate.
  * Each adds in an additional 128 bytes per item logged to
  * try to account for the overhead of the transaction mechanism.
  *
  * Note:
  * Most of the reservations underestimate the number of allocation
  * groups into which they could free extents in the xfs_bmap_finish()
  * call.  This is because the number in the worst case is quite high
  * and quite unusual.  In order to fix this we need to change
  * xfs_bmap_finish() to free extents in only a single AG at a time.
  * This will require changes to the EFI code as well, however, so that
  * the EFI for the extents not freed is logged again in each transaction.
  * See bug 261917.
  */
 /*
  * Per-extent log reservation for the allocation btree changes
  * involved in freeing or allocating an extent.
  * 2 trees * (2 blocks/level * max depth - 1) * block size
  */
 #define	XFS_ALLOCFREE_LOG_RES(mp,nx) \
 	((nx) * (2 * XFS_FSB_TO_B((mp), 2 * XFS_AG_MAXLEVELS(mp) - 1)))
 #define	XFS_ALLOCFREE_LOG_COUNT(mp,nx) \
 	((nx) * (2 * (2 * XFS_AG_MAXLEVELS(mp) - 1)))
 /*
  * Per-directory log reservation for any directory change.
  * dir blocks: (1 btree block per level + data block + free block) * dblock size
  * bmap btree: (levels + 2) * max depth * block size
  * v2 directory blocks can be fragmented below the dirblksize down to the fsb
  * size, so account for that in the DAENTER macros.
  */
 #define	XFS_DIROP_LOG_RES(mp)	\
 	(XFS_FSB_TO_B(mp, XFS_DAENTER_BLOCKS(mp, XFS_DATA_FORK)) + \
 	 (XFS_FSB_TO_B(mp, XFS_DAENTER_BMAPS(mp, XFS_DATA_FORK) + 1)))
 #define	XFS_DIROP_LOG_COUNT(mp)	\
 	(XFS_DAENTER_BLOCKS(mp, XFS_DATA_FORK) + \
 	 XFS_DAENTER_BMAPS(mp, XFS_DATA_FORK) + 1)
 /*
  * In a write transaction we can allocate a maximum of 2
  * extents.  This gives:
  *    the inode getting the new extents: inode size
  *    the inode\'s bmap btree: max depth * block size
  *    the agfs of the ags from which the extents are allocated: 2 * sector
  *    the superblock free block counter: sector size
  *    the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size
  * And the bmap_finish transaction can free bmap blocks in a join:
  *    the agfs of the ags containing the blocks: 2 * sector size
  *    the agfls of the ags containing the blocks: 2 * sector size
  *    the super block free block counter: sector size
  *    the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size
  */
 #define XFS_CALC_WRITE_LOG_RES(mp) \
 	(MAX( \
 	 ((mp)->m_sb.sb_inodesize + \
 	  XFS_FSB_TO_B((mp), XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK)) + \
 	  (2 * (mp)->m_sb.sb_sectsize) + \
 	  (mp)->m_sb.sb_sectsize + \
 	  XFS_ALLOCFREE_LOG_RES(mp, 2) + \
 	  (128 * (4 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + XFS_ALLOCFREE_LOG_COUNT(mp, 2)))),\
 	 ((2 * (mp)->m_sb.sb_sectsize) + \
 	  (2 * (mp)->m_sb.sb_sectsize) + \
 	  (mp)->m_sb.sb_sectsize + \
 	  XFS_ALLOCFREE_LOG_RES(mp, 2) + \
 	  (128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2))))))
 #define	XFS_WRITE_LOG_RES(mp)	((mp)->m_reservations.tr_write)
 /*
  * In truncating a file we free up to two extents at once.  We can modify:
  *    the inode being truncated: inode size
  *    the inode\'s bmap btree: (max depth + 1) * block size
  * And the bmap_finish transaction can free the blocks and bmap blocks:
  *    the agf for each of the ags: 4 * sector size
  *    the agfl for each of the ags: 4 * sector size
  *    the super block to reflect the freed blocks: sector size
  *    worst case split in allocation btrees per extent assuming 4 extents:
  *		4 exts * 2 trees * (2 * max depth - 1) * block size
  *    the inode btree: max depth * blocksize
  *    the allocation btrees: 2 trees * (max depth - 1) * block size
  */
 #define	XFS_CALC_ITRUNCATE_LOG_RES(mp) \
 	(MAX( \
 	 ((mp)->m_sb.sb_inodesize + \
 	  XFS_FSB_TO_B((mp), XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + 1) + \
 	  (128 * (2 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK)))), \
 	 ((4 * (mp)->m_sb.sb_sectsize) + \
 	  (4 * (mp)->m_sb.sb_sectsize) + \
 	  (mp)->m_sb.sb_sectsize + \
 	  XFS_ALLOCFREE_LOG_RES(mp, 4) + \
 	  (128 * (9 + XFS_ALLOCFREE_LOG_COUNT(mp, 4))) + \
 	  (128 * 5) + \
 	  XFS_ALLOCFREE_LOG_RES(mp, 1) + \
 	   (128 * (2 + XFS_IALLOC_BLOCKS(mp) + XFS_IN_MAXLEVELS(mp) + \
 	    XFS_ALLOCFREE_LOG_COUNT(mp, 1))))))
 #define	XFS_ITRUNCATE_LOG_RES(mp)   ((mp)->m_reservations.tr_itruncate)
 /*
  * In renaming a files we can modify:
  *    the four inodes involved: 4 * inode size
  *    the two directory btrees: 2 * (max depth + v2) * dir block size
  *    the two directory bmap btrees: 2 * max depth * block size
  * And the bmap_finish transaction can free dir and bmap blocks (two sets
  *	of bmap blocks) giving:
  *    the agf for the ags in which the blocks live: 3 * sector size
  *    the agfl for the ags in which the blocks live: 3 * sector size
  *    the superblock for the free block count: sector size
  *    the allocation btrees: 3 exts * 2 trees * (2 * max depth - 1) * block size
  */
 #define	XFS_CALC_RENAME_LOG_RES(mp) \
 	(MAX( \
 	 ((4 * (mp)->m_sb.sb_inodesize) + \
 	  (2 * XFS_DIROP_LOG_RES(mp)) + \
 	  (128 * (4 + 2 * XFS_DIROP_LOG_COUNT(mp)))), \
 	 ((3 * (mp)->m_sb.sb_sectsize) + \
 	  (3 * (mp)->m_sb.sb_sectsize) + \
 	  (mp)->m_sb.sb_sectsize + \
 	  XFS_ALLOCFREE_LOG_RES(mp, 3) + \
 	  (128 * (7 + XFS_ALLOCFREE_LOG_COUNT(mp, 3))))))
 #define	XFS_RENAME_LOG_RES(mp)	((mp)->m_reservations.tr_rename)
 /*
  * For creating a link to an inode:
  *    the parent directory inode: inode size
  *    the linked inode: inode size
  *    the directory btree could split: (max depth + v2) * dir block size
  *    the directory bmap btree could join or split: (max depth + v2) * blocksize
  * And the bmap_finish transaction can free some bmap blocks giving:
  *    the agf for the ag in which the blocks live: sector size
  *    the agfl for the ag in which the blocks live: sector size
  *    the superblock for the free block count: sector size
  *    the allocation btrees: 2 trees * (2 * max depth - 1) * block size
  */
 #define	XFS_CALC_LINK_LOG_RES(mp) \
 	(MAX( \
 	 ((mp)->m_sb.sb_inodesize + \
 	  (mp)->m_sb.sb_inodesize + \
 	  XFS_DIROP_LOG_RES(mp) + \
 	  (128 * (2 + XFS_DIROP_LOG_COUNT(mp)))), \
 	 ((mp)->m_sb.sb_sectsize + \
 	  (mp)->m_sb.sb_sectsize + \
 	  (mp)->m_sb.sb_sectsize + \
 	  XFS_ALLOCFREE_LOG_RES(mp, 1) + \
 	  (128 * (3 + XFS_ALLOCFREE_LOG_COUNT(mp, 1))))))
 #define	XFS_LINK_LOG_RES(mp)	((mp)->m_reservations.tr_link)
 /*
  * For removing a directory entry we can modify:
  *    the parent directory inode: inode size
  *    the removed inode: inode size
  *    the directory btree could join: (max depth + v2) * dir block size
  *    the directory bmap btree could join or split: (max depth + v2) * blocksize
  * And the bmap_finish transaction can free the dir and bmap blocks giving:
  *    the agf for the ag in which the blocks live: 2 * sector size
  *    the agfl for the ag in which the blocks live: 2 * sector size
  *    the superblock for the free block count: sector size
  *    the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size
  */
 #define	XFS_CALC_REMOVE_LOG_RES(mp)	\
 	(MAX( \
 	 ((mp)->m_sb.sb_inodesize + \
 	  (mp)->m_sb.sb_inodesize + \
 	  XFS_DIROP_LOG_RES(mp) + \
 	  (128 * (2 + XFS_DIROP_LOG_COUNT(mp)))), \
 	 ((2 * (mp)->m_sb.sb_sectsize) + \
 	  (2 * (mp)->m_sb.sb_sectsize) + \
 	  (mp)->m_sb.sb_sectsize + \
 	  XFS_ALLOCFREE_LOG_RES(mp, 2) + \
 	  (128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2))))))
 #define	XFS_REMOVE_LOG_RES(mp)	((mp)->m_reservations.tr_remove)
 /*
  * For symlink we can modify:
  *    the parent directory inode: inode size
  *    the new inode: inode size
  *    the inode btree entry: 1 block
  *    the directory btree: (max depth + v2) * dir block size
  *    the directory inode\'s bmap btree: (max depth + v2) * block size
  *    the blocks for the symlink: 1 KB
  * Or in the first xact we allocate some inodes giving:
  *    the agi and agf of the ag getting the new inodes: 2 * sectorsize
  *    the inode blocks allocated: XFS_IALLOC_BLOCKS * blocksize
  *    the inode btree: max depth * blocksize
  *    the allocation btrees: 2 trees * (2 * max depth - 1) * block size
  */
 #define	XFS_CALC_SYMLINK_LOG_RES(mp)		\
 	(MAX( \
 	 ((mp)->m_sb.sb_inodesize + \
 	  (mp)->m_sb.sb_inodesize + \
 	  XFS_FSB_TO_B(mp, 1) + \
 	  XFS_DIROP_LOG_RES(mp) + \
 	  1024 + \
 	  (128 * (4 + XFS_DIROP_LOG_COUNT(mp)))), \
 	 (2 * (mp)->m_sb.sb_sectsize + \
 	  XFS_FSB_TO_B((mp), XFS_IALLOC_BLOCKS((mp))) + \
 	  XFS_FSB_TO_B((mp), XFS_IN_MAXLEVELS(mp)) + \
 	  XFS_ALLOCFREE_LOG_RES(mp, 1) + \
 	  (128 * (2 + XFS_IALLOC_BLOCKS(mp) + XFS_IN_MAXLEVELS(mp) + \
 	   XFS_ALLOCFREE_LOG_COUNT(mp, 1))))))
 #define	XFS_SYMLINK_LOG_RES(mp)	((mp)->m_reservations.tr_symlink)
 /*
  * For create we can modify:
  *    the parent directory inode: inode size
  *    the new inode: inode size
  *    the inode btree entry: block size
  *    the superblock for the nlink flag: sector size
  *    the directory btree: (max depth + v2) * dir block size
  *    the directory inode\'s bmap btree: (max depth + v2) * block size
  * Or in the first xact we allocate some inodes giving:
  *    the agi and agf of the ag getting the new inodes: 2 * sectorsize
  *    the superblock for the nlink flag: sector size
  *    the inode blocks allocated: XFS_IALLOC_BLOCKS * blocksize
  *    the inode btree: max depth * blocksize
  *    the allocation btrees: 2 trees * (max depth - 1) * block size
  */
 #define	XFS_CALC_CREATE_LOG_RES(mp)		\
 	(MAX( \
 	 ((mp)->m_sb.sb_inodesize + \
 	  (mp)->m_sb.sb_inodesize + \
 	  (mp)->m_sb.sb_sectsize + \
 	  XFS_FSB_TO_B(mp, 1) + \
 	  XFS_DIROP_LOG_RES(mp) + \
 	  (128 * (3 + XFS_DIROP_LOG_COUNT(mp)))), \
 	 (3 * (mp)->m_sb.sb_sectsize + \
 	  XFS_FSB_TO_B((mp), XFS_IALLOC_BLOCKS((mp))) + \
 	  XFS_FSB_TO_B((mp), XFS_IN_MAXLEVELS(mp)) + \
 	  XFS_ALLOCFREE_LOG_RES(mp, 1) + \
 	  (128 * (2 + XFS_IALLOC_BLOCKS(mp) + XFS_IN_MAXLEVELS(mp) + \
 	   XFS_ALLOCFREE_LOG_COUNT(mp, 1))))))
 #define	XFS_CREATE_LOG_RES(mp)	((mp)->m_reservations.tr_create)
 /*
  * Making a new directory is the same as creating a new file.
  */
 #define	XFS_CALC_MKDIR_LOG_RES(mp)	XFS_CALC_CREATE_LOG_RES(mp)
 #define	XFS_MKDIR_LOG_RES(mp)	((mp)->m_reservations.tr_mkdir)
 /*
  * In freeing an inode we can modify:
  *    the inode being freed: inode size
  *    the super block free inode counter: sector size
  *    the agi hash list and counters: sector size
  *    the inode btree entry: block size
  *    the on disk inode before ours in the agi hash list: inode cluster size
  *    the inode btree: max depth * blocksize
  *    the allocation btrees: 2 trees * (max depth - 1) * block size
  */
 #define	XFS_CALC_IFREE_LOG_RES(mp) \
 	((mp)->m_sb.sb_inodesize + \
 	 (mp)->m_sb.sb_sectsize + \
 	 (mp)->m_sb.sb_sectsize + \
 	 XFS_FSB_TO_B((mp), 1) + \
 	 MAX((__uint16_t)XFS_FSB_TO_B((mp), 1), XFS_INODE_CLUSTER_SIZE(mp)) + \
 	 (128 * 5) + \
 	  XFS_ALLOCFREE_LOG_RES(mp, 1) + \
 	  (128 * (2 + XFS_IALLOC_BLOCKS(mp) + XFS_IN_MAXLEVELS(mp) + \
 	   XFS_ALLOCFREE_LOG_COUNT(mp, 1))))
 #define	XFS_IFREE_LOG_RES(mp)	((mp)->m_reservations.tr_ifree)
 /*
  * When only changing the inode we log the inode and possibly the superblock
  * We also add a bit of slop for the transaction stuff.
  */
 #define	XFS_CALC_ICHANGE_LOG_RES(mp)	((mp)->m_sb.sb_inodesize + \
 					 (mp)->m_sb.sb_sectsize + 512)
 #define	XFS_ICHANGE_LOG_RES(mp)	((mp)->m_reservations.tr_ichange)
 /*
  * Growing the data section of the filesystem.
  *	superblock
  *	agi and agf
  *	allocation btrees
  */
 #define	XFS_CALC_GROWDATA_LOG_RES(mp) \
 	((mp)->m_sb.sb_sectsize * 3 + \
 	 XFS_ALLOCFREE_LOG_RES(mp, 1) + \
 	 (128 * (3 + XFS_ALLOCFREE_LOG_COUNT(mp, 1))))
 #define	XFS_GROWDATA_LOG_RES(mp)    ((mp)->m_reservations.tr_growdata)
 /*
  * Growing the rt section of the filesystem.
  * In the first set of transactions (ALLOC) we allocate space to the
  * bitmap or summary files.
  *	superblock: sector size
  *	agf of the ag from which the extent is allocated: sector size
  *	bmap btree for bitmap/summary inode: max depth * blocksize
  *	bitmap/summary inode: inode size
  *	allocation btrees for 1 block alloc: 2 * (2 * maxdepth - 1) * blocksize
  */
 #define	XFS_CALC_GROWRTALLOC_LOG_RES(mp) \
 	(2 * (mp)->m_sb.sb_sectsize + \
 	 XFS_FSB_TO_B((mp), XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK)) + \
 	 (mp)->m_sb.sb_inodesize + \
 	 XFS_ALLOCFREE_LOG_RES(mp, 1) + \
 	 (128 * \
 	  (3 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + \
 	   XFS_ALLOCFREE_LOG_COUNT(mp, 1))))
 #define	XFS_GROWRTALLOC_LOG_RES(mp)	((mp)->m_reservations.tr_growrtalloc)
 /*
  * Growing the rt section of the filesystem.
  * In the second set of transactions (ZERO) we zero the new metadata blocks.
  *	one bitmap/summary block: blocksize
  */
 #define	XFS_CALC_GROWRTZERO_LOG_RES(mp) \
 	((mp)->m_sb.sb_blocksize + 128)
 #define	XFS_GROWRTZERO_LOG_RES(mp)	((mp)->m_reservations.tr_growrtzero)
 /*
  * Growing the rt section of the filesystem.
  * In the third set of transactions (FREE) we update metadata without
  * allocating any new blocks.
  *	superblock: sector size
  *	bitmap inode: inode size
  *	summary inode: inode size
  *	one bitmap block: blocksize
  *	summary blocks: new summary size
  */
 #define	XFS_CALC_GROWRTFREE_LOG_RES(mp) \
 	((mp)->m_sb.sb_sectsize + \
 	 2 * (mp)->m_sb.sb_inodesize + \
 	 (mp)->m_sb.sb_blocksize + \
 	 (mp)->m_rsumsize + \
 	 (128 * 5))
 #define	XFS_GROWRTFREE_LOG_RES(mp)	((mp)->m_reservations.tr_growrtfree)
 /*
  * Logging the inode modification timestamp on a synchronous write.
  *	inode
  */
 #define	XFS_CALC_SWRITE_LOG_RES(mp) \
 	((mp)->m_sb.sb_inodesize + 128)
 #define	XFS_SWRITE_LOG_RES(mp)	((mp)->m_reservations.tr_swrite)
 /*
  * Logging the inode timestamps on an fsync -- same as SWRITE
  * as long as SWRITE logs the entire inode core
  */
 #define XFS_FSYNC_TS_LOG_RES(mp)        ((mp)->m_reservations.tr_swrite)
 /*
  * Logging the inode mode bits when writing a setuid/setgid file
  *	inode
  */
 #define	XFS_CALC_WRITEID_LOG_RES(mp) \
 	((mp)->m_sb.sb_inodesize + 128)
 #define	XFS_WRITEID_LOG_RES(mp)	((mp)->m_reservations.tr_swrite)
 /*
  * Converting the inode from non-attributed to attributed.
  *	the inode being converted: inode size
  *	agf block and superblock (for block allocation)
  *	the new block (directory sized)
  *	bmap blocks for the new directory block
  *	allocation btrees
  */
 #define	XFS_CALC_ADDAFORK_LOG_RES(mp)	\
 	((mp)->m_sb.sb_inodesize + \
 	 (mp)->m_sb.sb_sectsize * 2 + \
 	 (mp)->m_dirblksize + \
 	 XFS_FSB_TO_B(mp, (XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1)) + \
 	 XFS_ALLOCFREE_LOG_RES(mp, 1) + \
 	 (128 * (4 + (XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1) + \
 		 XFS_ALLOCFREE_LOG_COUNT(mp, 1))))
 #define	XFS_ADDAFORK_LOG_RES(mp)	((mp)->m_reservations.tr_addafork)
 /*
  * Removing the attribute fork of a file
  *    the inode being truncated: inode size
  *    the inode\'s bmap btree: max depth * block size
  * And the bmap_finish transaction can free the blocks and bmap blocks:
  *    the agf for each of the ags: 4 * sector size
  *    the agfl for each of the ags: 4 * sector size
  *    the super block to reflect the freed blocks: sector size
  *    worst case split in allocation btrees per extent assuming 4 extents:
  *		4 exts * 2 trees * (2 * max depth - 1) * block size
  */
 #define	XFS_CALC_ATTRINVAL_LOG_RES(mp)	\
 	(MAX( \
 	 ((mp)->m_sb.sb_inodesize + \
 	  XFS_FSB_TO_B((mp), XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) + \
 	  (128 * (1 + XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)))), \
 	 ((4 * (mp)->m_sb.sb_sectsize) + \
 	  (4 * (mp)->m_sb.sb_sectsize) + \
 	  (mp)->m_sb.sb_sectsize + \
 	  XFS_ALLOCFREE_LOG_RES(mp, 4) + \
 	  (128 * (9 + XFS_ALLOCFREE_LOG_COUNT(mp, 4))))))
 #define	XFS_ATTRINVAL_LOG_RES(mp)	((mp)->m_reservations.tr_attrinval)
 /*
  * Setting an attribute.
  *	the inode getting the attribute
  *	the superblock for allocations
  *	the agfs extents are allocated from
  *	the attribute btree * max depth
  *	the inode allocation btree
  * Since attribute transaction space is dependent on the size of the attribute,
  * the calculation is done partially at mount time and partially at runtime.
  */
 #define	XFS_CALC_ATTRSET_LOG_RES(mp)	\
 	((mp)->m_sb.sb_inodesize + \
 	 (mp)->m_sb.sb_sectsize + \
 	  XFS_FSB_TO_B((mp), XFS_DA_NODE_MAXDEPTH) + \
 	  (128 * (2 + XFS_DA_NODE_MAXDEPTH)))
 #define	XFS_ATTRSET_LOG_RES(mp, ext)	\
 	((mp)->m_reservations.tr_attrset + \
 	 (ext * (mp)->m_sb.sb_sectsize) + \
 	 (ext * XFS_FSB_TO_B((mp), XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK))) + \
 	 (128 * (ext + (ext * XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)))))
 /*
  * Removing an attribute.
  *    the inode: inode size
  *    the attribute btree could join: max depth * block size
  *    the inode bmap btree could join or split: max depth * block size
  * And the bmap_finish transaction can free the attr blocks freed giving:
  *    the agf for the ag in which the blocks live: 2 * sector size
  *    the agfl for the ag in which the blocks live: 2 * sector size
  *    the superblock for the free block count: sector size
  *    the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size
  */
 #define	XFS_CALC_ATTRRM_LOG_RES(mp)	\
 	(MAX( \
 	  ((mp)->m_sb.sb_inodesize + \
 	  XFS_FSB_TO_B((mp), XFS_DA_NODE_MAXDEPTH) + \
 	  XFS_FSB_TO_B((mp), XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) + \
 	  (128 * (1 + XFS_DA_NODE_MAXDEPTH + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK)))), \
 	 ((2 * (mp)->m_sb.sb_sectsize) + \
 	  (2 * (mp)->m_sb.sb_sectsize) + \
 	  (mp)->m_sb.sb_sectsize + \
 	  XFS_ALLOCFREE_LOG_RES(mp, 2) + \
 	  (128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2))))))
 #define	XFS_ATTRRM_LOG_RES(mp)	((mp)->m_reservations.tr_attrrm)
 /*
  * Clearing a bad agino number in an agi hash bucket.
  */
 #define	XFS_CALC_CLEAR_AGI_BUCKET_LOG_RES(mp) \
 	((mp)->m_sb.sb_sectsize + 128)
 #define	XFS_CLEAR_AGI_BUCKET_LOG_RES(mp)  ((mp)->m_reservations.tr_clearagi)
 /*
  * Various log count values.
  */
 #define	XFS_DEFAULT_LOG_COUNT		1
 #define	XFS_DEFAULT_PERM_LOG_COUNT	2
 #define	XFS_ITRUNCATE_LOG_COUNT		2
 #define XFS_INACTIVE_LOG_COUNT		2
 #define	XFS_CREATE_LOG_COUNT		2
 #define	XFS_MKDIR_LOG_COUNT		3
 #define	XFS_SYMLINK_LOG_COUNT		3
 #define	XFS_REMOVE_LOG_COUNT		2
 #define	XFS_LINK_LOG_COUNT		2
 #define	XFS_RENAME_LOG_COUNT		2
 #define	XFS_WRITE_LOG_COUNT		2
 #define	XFS_ADDAFORK_LOG_COUNT		2
 #define	XFS_ATTRINVAL_LOG_COUNT		1
 #define	XFS_ATTRSET_LOG_COUNT		3
 #define	XFS_ATTRRM_LOG_COUNT		3
 /*
  * Here we centralize the specification of XFS meta-data buffer
  * reference count values.  This determine how hard the buffer
  * cache tries to hold onto the buffer.
  */
 #define	XFS_AGF_REF		4
 #define	XFS_AGI_REF		4
 #define	XFS_AGFL_REF		3
 #define	XFS_INO_BTREE_REF	3
 #define	XFS_ALLOC_BTREE_REF	2
 #define	XFS_BMAP_BTREE_REF	2
 #define	XFS_DIR_BTREE_REF	2
 #define	XFS_ATTR_BTREE_REF	1
 #define	XFS_INO_REF		1
 #define	XFS_DQUOT_REF		1
 #ifdef __KERNEL__
+struct xfs_buf;
+struct xfs_buftarg;
+struct xfs_efd_log_item;
+struct xfs_efi_log_item;
+struct xfs_inode;
+struct xfs_item_ops;
+struct xfs_log_iovec;
+struct xfs_log_item_desc;
+struct xfs_mount;
+struct xfs_trans;
+struct xfs_dquot_acct;
+typedef struct xfs_log_item {
+	struct list_head		li_ail;		/* AIL pointers */
+	xfs_lsn_t			li_lsn;		/* last on-disk lsn */
+	struct xfs_log_item_desc	*li_desc;	/* ptr to current desc*/
+	struct xfs_mount		*li_mountp;	/* ptr to fs mount */
+	uint				li_type;	/* item type */
+	uint				li_flags;	/* misc flags */
+	struct xfs_log_item		*li_bio_list;	/* buffer item list */
+	void				(*li_cb)(struct xfs_buf *,
+						 struct xfs_log_item *);
+							/* buffer item iodone */
+							/* callback func */
+	struct xfs_item_ops		*li_ops;	/* function list */
+} xfs_log_item_t;
+#define	XFS_LI_IN_AIL	0x1
+#define XFS_LI_ABORTED	0x2
+typedef struct xfs_item_ops {
+	uint (*iop_size)(xfs_log_item_t *);
+	void (*iop_format)(xfs_log_item_t *, struct xfs_log_iovec *);
+	void (*iop_pin)(xfs_log_item_t *);
+	void (*iop_unpin)(xfs_log_item_t *, int);
+	void (*iop_unpin_remove)(xfs_log_item_t *, struct xfs_trans *);
+	uint (*iop_trylock)(xfs_log_item_t *);
+	void (*iop_unlock)(xfs_log_item_t *);
+	xfs_lsn_t (*iop_committed)(xfs_log_item_t *, xfs_lsn_t);
+	void (*iop_push)(xfs_log_item_t *);
+	void (*iop_pushbuf)(xfs_log_item_t *);
+	void (*iop_committing)(xfs_log_item_t *, xfs_lsn_t);
+} xfs_item_ops_t;
+#define IOP_SIZE(ip)		(*(ip)->li_ops->iop_size)(ip)
+#define IOP_FORMAT(ip,vp)	(*(ip)->li_ops->iop_format)(ip, vp)
+#define IOP_PIN(ip)		(*(ip)->li_ops->iop_pin)(ip)
+#define IOP_UNPIN(ip, flags)	(*(ip)->li_ops->iop_unpin)(ip, flags)
+#define IOP_UNPIN_REMOVE(ip,tp) (*(ip)->li_ops->iop_unpin_remove)(ip, tp)
+#define IOP_TRYLOCK(ip)		(*(ip)->li_ops->iop_trylock)(ip)
+#define IOP_UNLOCK(ip)		(*(ip)->li_ops->iop_unlock)(ip)
+#define IOP_COMMITTED(ip, lsn)	(*(ip)->li_ops->iop_committed)(ip, lsn)
+#define IOP_PUSH(ip)		(*(ip)->li_ops->iop_push)(ip)
+#define IOP_PUSHBUF(ip)		(*(ip)->li_ops->iop_pushbuf)(ip)
+#define IOP_COMMITTING(ip, lsn) (*(ip)->li_ops->iop_committing)(ip, lsn)
 /*
+ * Return values for the IOP_TRYLOCK() routines.
+ */
+#define	XFS_ITEM_SUCCESS	0
+#define	XFS_ITEM_PINNED		1
+#define	XFS_ITEM_LOCKED		2
+#define	XFS_ITEM_FLUSHING	3
+#define XFS_ITEM_PUSHBUF	4
+/*
+ * This structure is used to maintain a list of block ranges that have been
+ * freed in the transaction.  The ranges are listed in the perag[] busy list
+ * between when they're freed and the transaction is committed to disk.
+ */
+typedef struct xfs_log_busy_slot {
+	xfs_agnumber_t		lbc_ag;
+	ushort			lbc_idx;	/* index in perag.busy[] */
+} xfs_log_busy_slot_t;
+#define XFS_LBC_NUM_SLOTS	31
+typedef struct xfs_log_busy_chunk {
+	struct xfs_log_busy_chunk	*lbc_next;
+	uint				lbc_free;	/* free slots bitmask */
+	ushort				lbc_unused;	/* first unused */
+	xfs_log_busy_slot_t		lbc_busy[XFS_LBC_NUM_SLOTS];
+} xfs_log_busy_chunk_t;

1	/*	1	/*
2	* Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.	2	* Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
3	* All Rights Reserved.	3	* All Rights Reserved.
4	*	4	*
5	* This program is free software; you can redistribute it and/or	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	6	* modify it under the terms of the GNU General Public License as
7	* published by the Free Software Foundation.	7	* published by the Free Software Foundation.
8	*	8	*
9	* This program is distributed in the hope that it would be useful,	9	* This program is distributed in the hope that it would be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	* GNU General Public License for more details.	12	* GNU General Public License for more details.
13	*	13	*
14	* You should have received a copy of the GNU General Public License	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,	15	* along with this program; if not, write the Free Software Foundation,
16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17	*/	17	*/
18	#ifndef __XFS_AG_H__	18	#ifndef __XFS_AG_H__
19	#define __XFS_AG_H__	19	#define __XFS_AG_H__
20		20
21	/*	21	/*
22	* Allocation group header	22	* Allocation group header
23	* This is divided into three structures, placed in sequential 512-byte	23	* This is divided into three structures, placed in sequential 512-byte
24	* buffers after a copy of the superblock (also in a 512-byte buffer).	24	* buffers after a copy of the superblock (also in a 512-byte buffer).
25	*/	25	*/
26		26
27	struct xfs_buf;	27	struct xfs_buf;
28	struct xfs_mount;	28	struct xfs_mount;
29	struct xfs_trans;	29	struct xfs_trans;
30		30
31	#define XFS_AGF_MAGIC 0x58414746 /* 'XAGF' */	31	#define XFS_AGF_MAGIC 0x58414746 /* 'XAGF' */
32	#define XFS_AGI_MAGIC 0x58414749 /* 'XAGI' */	32	#define XFS_AGI_MAGIC 0x58414749 /* 'XAGI' */
33	#define XFS_AGF_VERSION 1	33	#define XFS_AGF_VERSION 1
34	#define XFS_AGI_VERSION 1	34	#define XFS_AGI_VERSION 1
35		35
36	#define XFS_AGF_GOOD_VERSION(v) ((v) == XFS_AGF_VERSION)	36	#define XFS_AGF_GOOD_VERSION(v) ((v) == XFS_AGF_VERSION)
37	#define XFS_AGI_GOOD_VERSION(v) ((v) == XFS_AGI_VERSION)	37	#define XFS_AGI_GOOD_VERSION(v) ((v) == XFS_AGI_VERSION)
38		38
39	/*	39	/*
40	* Btree number 0 is bno, 1 is cnt. This value gives the size of the	40	* Btree number 0 is bno, 1 is cnt. This value gives the size of the
41	* arrays below.	41	* arrays below.
42	*/	42	*/
43	#define XFS_BTNUM_AGF ((int)XFS_BTNUM_CNTi + 1)	43	#define XFS_BTNUM_AGF ((int)XFS_BTNUM_CNTi + 1)
44		44
45	/*	45	/*
46	* The second word of agf_levels in the first a.g. overlaps the EFS	46	* The second word of agf_levels in the first a.g. overlaps the EFS
47	* superblock's magic number. Since the magic numbers valid for EFS	47	* superblock's magic number. Since the magic numbers valid for EFS
48	* are > 64k, our value cannot be confused for an EFS superblock's.	48	* are > 64k, our value cannot be confused for an EFS superblock's.
49	*/	49	*/
50		50
51	typedef struct xfs_agf {	51	typedef struct xfs_agf {
52	/*	52	/*
53	* Common allocation group header information	53	* Common allocation group header information
54	*/	54	*/
55	__be32 agf_magicnum; /* magic number == XFS_AGF_MAGIC */	55	__be32 agf_magicnum; /* magic number == XFS_AGF_MAGIC */
56	__be32 agf_versionnum; /* header version == XFS_AGF_VERSION */	56	__be32 agf_versionnum; /* header version == XFS_AGF_VERSION */
57	__be32 agf_seqno; /* sequence # starting from 0 */	57	__be32 agf_seqno; /* sequence # starting from 0 */
58	__be32 agf_length; /* size in blocks of a.g. */	58	__be32 agf_length; /* size in blocks of a.g. */
59	/*	59	/*
60	* Freespace information	60	* Freespace information
61	*/	61	*/
62	__be32 agf_roots[XFS_BTNUM_AGF]; /* root blocks */	62	__be32 agf_roots[XFS_BTNUM_AGF]; /* root blocks */
63	__be32 agf_spare0; /* spare field */	63	__be32 agf_spare0; /* spare field */
64	__be32 agf_levels[XFS_BTNUM_AGF]; /* btree levels */	64	__be32 agf_levels[XFS_BTNUM_AGF]; /* btree levels */
65	__be32 agf_spare1; /* spare field */	65	__be32 agf_spare1; /* spare field */
66	__be32 agf_flfirst; /* first freelist block's index */	66	__be32 agf_flfirst; /* first freelist block's index */
67	__be32 agf_fllast; /* last freelist block's index */	67	__be32 agf_fllast; /* last freelist block's index */
68	__be32 agf_flcount; /* count of blocks in freelist */	68	__be32 agf_flcount; /* count of blocks in freelist */
69	__be32 agf_freeblks; /* total free blocks */	69	__be32 agf_freeblks; /* total free blocks */
70	__be32 agf_longest; /* longest free space */	70	__be32 agf_longest; /* longest free space */
71	__be32 agf_btreeblks; /* # of blocks held in AGF btrees */	71	__be32 agf_btreeblks; /* # of blocks held in AGF btrees */
72	} xfs_agf_t;	72	} xfs_agf_t;
73		73
74	#define XFS_AGF_MAGICNUM 0x00000001	74	#define XFS_AGF_MAGICNUM 0x00000001
75	#define XFS_AGF_VERSIONNUM 0x00000002	75	#define XFS_AGF_VERSIONNUM 0x00000002
76	#define XFS_AGF_SEQNO 0x00000004	76	#define XFS_AGF_SEQNO 0x00000004
77	#define XFS_AGF_LENGTH 0x00000008	77	#define XFS_AGF_LENGTH 0x00000008
78	#define XFS_AGF_ROOTS 0x00000010	78	#define XFS_AGF_ROOTS 0x00000010
79	#define XFS_AGF_LEVELS 0x00000020	79	#define XFS_AGF_LEVELS 0x00000020
80	#define XFS_AGF_FLFIRST 0x00000040	80	#define XFS_AGF_FLFIRST 0x00000040
81	#define XFS_AGF_FLLAST 0x00000080	81	#define XFS_AGF_FLLAST 0x00000080
82	#define XFS_AGF_FLCOUNT 0x00000100	82	#define XFS_AGF_FLCOUNT 0x00000100
83	#define XFS_AGF_FREEBLKS 0x00000200	83	#define XFS_AGF_FREEBLKS 0x00000200
84	#define XFS_AGF_LONGEST 0x00000400	84	#define XFS_AGF_LONGEST 0x00000400
85	#define XFS_AGF_BTREEBLKS 0x00000800	85	#define XFS_AGF_BTREEBLKS 0x00000800
86	#define XFS_AGF_NUM_BITS 12	86	#define XFS_AGF_NUM_BITS 12
87	#define XFS_AGF_ALL_BITS ((1 << XFS_AGF_NUM_BITS) - 1)	87	#define XFS_AGF_ALL_BITS ((1 << XFS_AGF_NUM_BITS) - 1)
88		88
89	/* disk block (xfs_daddr_t) in the AG */	89	/* disk block (xfs_daddr_t) in the AG */
90	#define XFS_AGF_DADDR(mp) ((xfs_daddr_t)(1 << (mp)->m_sectbb_log))	90	#define XFS_AGF_DADDR(mp) ((xfs_daddr_t)(1 << (mp)->m_sectbb_log))
91	#define XFS_AGF_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_AGF_DADDR(mp))	91	#define XFS_AGF_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_AGF_DADDR(mp))
92	#define XFS_BUF_TO_AGF(bp) ((xfs_agf_t *)XFS_BUF_PTR(bp))	92	#define XFS_BUF_TO_AGF(bp) ((xfs_agf_t *)XFS_BUF_PTR(bp))
93		93
94		94
95	/*	95	/*
96	* Size of the unlinked inode hash table in the agi.	96	* Size of the unlinked inode hash table in the agi.
97	*/	97	*/
98	#define XFS_AGI_UNLINKED_BUCKETS 64	98	#define XFS_AGI_UNLINKED_BUCKETS 64
99		99
100	typedef struct xfs_agi {	100	typedef struct xfs_agi {
101	/*	101	/*
102	* Common allocation group header information	102	* Common allocation group header information
103	*/	103	*/
104	__be32 agi_magicnum; /* magic number == XFS_AGI_MAGIC */	104	__be32 agi_magicnum; /* magic number == XFS_AGI_MAGIC */
105	__be32 agi_versionnum; /* header version == XFS_AGI_VERSION */	105	__be32 agi_versionnum; /* header version == XFS_AGI_VERSION */
106	__be32 agi_seqno; /* sequence # starting from 0 */	106	__be32 agi_seqno; /* sequence # starting from 0 */
107	__be32 agi_length; /* size in blocks of a.g. */	107	__be32 agi_length; /* size in blocks of a.g. */
108	/*	108	/*
109	* Inode information	109	* Inode information
110	* Inodes are mapped by interpreting the inode number, so no	110	* Inodes are mapped by interpreting the inode number, so no
111	* mapping data is needed here.	111	* mapping data is needed here.
112	*/	112	*/
113	__be32 agi_count; /* count of allocated inodes */	113	__be32 agi_count; /* count of allocated inodes */
114	__be32 agi_root; /* root of inode btree */	114	__be32 agi_root; /* root of inode btree */
115	__be32 agi_level; /* levels in inode btree */	115	__be32 agi_level; /* levels in inode btree */
116	__be32 agi_freecount; /* number of free inodes */	116	__be32 agi_freecount; /* number of free inodes */
117	__be32 agi_newino; /* new inode just allocated */	117	__be32 agi_newino; /* new inode just allocated */
118	__be32 agi_dirino; /* last directory inode chunk */	118	__be32 agi_dirino; /* last directory inode chunk */
119	/*	119	/*
120	* Hash table of inodes which have been unlinked but are	120	* Hash table of inodes which have been unlinked but are
121	* still being referenced.	121	* still being referenced.
122	*/	122	*/
123	__be32 agi_unlinked[XFS_AGI_UNLINKED_BUCKETS];	123	__be32 agi_unlinked[XFS_AGI_UNLINKED_BUCKETS];
124	} xfs_agi_t;	124	} xfs_agi_t;
125		125
126	#define XFS_AGI_MAGICNUM 0x00000001	126	#define XFS_AGI_MAGICNUM 0x00000001
127	#define XFS_AGI_VERSIONNUM 0x00000002	127	#define XFS_AGI_VERSIONNUM 0x00000002
128	#define XFS_AGI_SEQNO 0x00000004	128	#define XFS_AGI_SEQNO 0x00000004
129	#define XFS_AGI_LENGTH 0x00000008	129	#define XFS_AGI_LENGTH 0x00000008
130	#define XFS_AGI_COUNT 0x00000010	130	#define XFS_AGI_COUNT 0x00000010
131	#define XFS_AGI_ROOT 0x00000020	131	#define XFS_AGI_ROOT 0x00000020
132	#define XFS_AGI_LEVEL 0x00000040	132	#define XFS_AGI_LEVEL 0x00000040
133	#define XFS_AGI_FREECOUNT 0x00000080	133	#define XFS_AGI_FREECOUNT 0x00000080
134	#define XFS_AGI_NEWINO 0x00000100	134	#define XFS_AGI_NEWINO 0x00000100
135	#define XFS_AGI_DIRINO 0x00000200	135	#define XFS_AGI_DIRINO 0x00000200
136	#define XFS_AGI_UNLINKED 0x00000400	136	#define XFS_AGI_UNLINKED 0x00000400
137	#define XFS_AGI_NUM_BITS 11	137	#define XFS_AGI_NUM_BITS 11
138	#define XFS_AGI_ALL_BITS ((1 << XFS_AGI_NUM_BITS) - 1)	138	#define XFS_AGI_ALL_BITS ((1 << XFS_AGI_NUM_BITS) - 1)
139		139
140	/* disk block (xfs_daddr_t) in the AG */	140	/* disk block (xfs_daddr_t) in the AG */
141	#define XFS_AGI_DADDR(mp) ((xfs_daddr_t)(2 << (mp)->m_sectbb_log))	141	#define XFS_AGI_DADDR(mp) ((xfs_daddr_t)(2 << (mp)->m_sectbb_log))
142	#define XFS_AGI_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_AGI_DADDR(mp))	142	#define XFS_AGI_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_AGI_DADDR(mp))
143	#define XFS_BUF_TO_AGI(bp) ((xfs_agi_t *)XFS_BUF_PTR(bp))	143	#define XFS_BUF_TO_AGI(bp) ((xfs_agi_t *)XFS_BUF_PTR(bp))
144		144
145	/*	145	/*
146	* The third a.g. block contains the a.g. freelist, an array	146	* The third a.g. block contains the a.g. freelist, an array
147	* of block pointers to blocks owned by the allocation btree code.	147	* of block pointers to blocks owned by the allocation btree code.
148	*/	148	*/
149	#define XFS_AGFL_DADDR(mp) ((xfs_daddr_t)(3 << (mp)->m_sectbb_log))	149	#define XFS_AGFL_DADDR(mp) ((xfs_daddr_t)(3 << (mp)->m_sectbb_log))
150	#define XFS_AGFL_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_AGFL_DADDR(mp))	150	#define XFS_AGFL_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_AGFL_DADDR(mp))
151	#define XFS_AGFL_SIZE(mp) ((mp)->m_sb.sb_sectsize / sizeof(xfs_agblock_t))	151	#define XFS_AGFL_SIZE(mp) ((mp)->m_sb.sb_sectsize / sizeof(xfs_agblock_t))
152	#define XFS_BUF_TO_AGFL(bp) ((xfs_agfl_t *)XFS_BUF_PTR(bp))	152	#define XFS_BUF_TO_AGFL(bp) ((xfs_agfl_t *)XFS_BUF_PTR(bp))
153		153
154	typedef struct xfs_agfl {	154	typedef struct xfs_agfl {
155	__be32 agfl_bno[1]; /* actually XFS_AGFL_SIZE(mp) */	155	__be32 agfl_bno[1]; /* actually XFS_AGFL_SIZE(mp) */
156	} xfs_agfl_t;	156	} xfs_agfl_t;
157		157
158	/*	158	/*
159	* Busy block/extent entry. Used in perag to mark blocks that have been freed	159	* Busy block/extent entry. Used in perag to mark blocks that have been freed
160	* but whose transactions aren't committed to disk yet.	160	* but whose transactions aren't committed to disk yet.
161	*/	161	*/
162	typedef struct xfs_perag_busy {	162	typedef struct xfs_perag_busy {
163	xfs_agblock_t busy_start;	163	xfs_agblock_t busy_start;
164	xfs_extlen_t busy_length;	164	xfs_extlen_t busy_length;
165	struct xfs_trans busy_tp; / transaction that did the free */	165	struct xfs_trans busy_tp; / transaction that did the free */
166	} xfs_perag_busy_t;	166	} xfs_perag_busy_t;
167		167
168	/*	168	/*
169	* Per-ag incore structure, copies of information in agf and agi,	169	* Per-ag incore structure, copies of information in agf and agi,
170	* to improve the performance of allocation group selection.	170	* to improve the performance of allocation group selection.
171	*	171	*
172	* pick sizes which fit in allocation buckets well	172	* pick sizes which fit in allocation buckets well
173	*/	173	*/
174	#if (BITS_PER_LONG == 32)	174	#if (BITS_PER_LONG == 32)
175	#define XFS_PAGB_NUM_SLOTS 84	175	#define XFS_PAGB_NUM_SLOTS 84
176	#elif (BITS_PER_LONG == 64)	176	#elif (BITS_PER_LONG == 64)
177	#define XFS_PAGB_NUM_SLOTS 128	177	#define XFS_PAGB_NUM_SLOTS 128
178	#endif	178	#endif
179		179
180	typedef struct xfs_perag	180	typedef struct xfs_perag
181	{	181	{
182	char pagf_init; /* this agf's entry is initialized */	182	char pagf_init; /* this agf's entry is initialized */
183	char pagi_init; /* this agi's entry is initialized */	183	char pagi_init; /* this agi's entry is initialized */
184	char pagf_metadata; /* the agf is preferred to be metadata */	184	char pagf_metadata; /* the agf is preferred to be metadata */
185	char pagi_inodeok; /* The agi is ok for inodes */	185	char pagi_inodeok; /* The agi is ok for inodes */
186	__uint8_t pagf_levels[XFS_BTNUM_AGF];	186	__uint8_t pagf_levels[XFS_BTNUM_AGF];
187	/* # of levels in bno & cnt btree */	187	/* # of levels in bno & cnt btree */
188	__uint32_t pagf_flcount; /* count of blocks in freelist */	188	__uint32_t pagf_flcount; /* count of blocks in freelist */
189	xfs_extlen_t pagf_freeblks; /* total free blocks */	189	xfs_extlen_t pagf_freeblks; /* total free blocks */
190	xfs_extlen_t pagf_longest; /* longest free space */	190	xfs_extlen_t pagf_longest; /* longest free space */
191	__uint32_t pagf_btreeblks; /* # of blocks held in AGF btrees */	191	__uint32_t pagf_btreeblks; /* # of blocks held in AGF btrees */
192	xfs_agino_t pagi_freecount; /* number of free inodes */	192	xfs_agino_t pagi_freecount; /* number of free inodes */
193	xfs_agino_t pagi_count; /* number of allocated inodes */	193	xfs_agino_t pagi_count; /* number of allocated inodes */
194	int pagb_count; /* pagb slots in use */	194	int pagb_count; /* pagb slots in use */
		195	xfs_perag_busy_t pagb_list; / unstable blocks */
195	#ifdef __KERNEL__	196	#ifdef __KERNEL__
196	spinlock_t pagb_lock; /* lock for pagb_list */	197	spinlock_t pagb_lock; /* lock for pagb_list */
197	#endif	198
198	xfs_perag_busy_t pagb_list; / unstable blocks */
199	atomic_t pagf_fstrms; /* # of filestreams active in this AG */	199	atomic_t pagf_fstrms; /* # of filestreams active in this AG */
200		200
201	int pag_ici_init; /* incore inode cache initialised */	201	int pag_ici_init; /* incore inode cache initialised */
202	rwlock_t pag_ici_lock; /* incore inode lock */	202	rwlock_t pag_ici_lock; /* incore inode lock */
203	struct radix_tree_root pag_ici_root; /* incore inode cache root */	203	struct radix_tree_root pag_ici_root; /* incore inode cache root */
		204	#endif
204	} xfs_perag_t;	205	} xfs_perag_t;
205		206
206	#define XFS_AG_MAXLEVELS(mp) ((mp)->m_ag_maxlevels)	207	#define XFS_AG_MAXLEVELS(mp) ((mp)->m_ag_maxlevels)
207	#define XFS_MIN_FREELIST_RAW(bl,cl,mp) \	208	#define XFS_MIN_FREELIST_RAW(bl,cl,mp) \
208	(MIN(bl + 1, XFS_AG_MAXLEVELS(mp)) + MIN(cl + 1, XFS_AG_MAXLEVELS(mp)))	209	(MIN(bl + 1, XFS_AG_MAXLEVELS(mp)) + MIN(cl + 1, XFS_AG_MAXLEVELS(mp)))
209	#define XFS_MIN_FREELIST(a,mp) \	210	#define XFS_MIN_FREELIST(a,mp) \
210	(XFS_MIN_FREELIST_RAW( \	211	(XFS_MIN_FREELIST_RAW( \
211	be32_to_cpu((a)->agf_levels[XFS_BTNUM_BNOi]), \	212	be32_to_cpu((a)->agf_levels[XFS_BTNUM_BNOi]), \
212	be32_to_cpu((a)->agf_levels[XFS_BTNUM_CNTi]), mp))	213	be32_to_cpu((a)->agf_levels[XFS_BTNUM_CNTi]), mp))
213	#define XFS_MIN_FREELIST_PAG(pag,mp) \	214	#define XFS_MIN_FREELIST_PAG(pag,mp) \
214	(XFS_MIN_FREELIST_RAW( \	215	(XFS_MIN_FREELIST_RAW( \
215	(uint_t)(pag)->pagf_levels[XFS_BTNUM_BNOi], \	216	(uint_t)(pag)->pagf_levels[XFS_BTNUM_BNOi], \
216	(uint_t)(pag)->pagf_levels[XFS_BTNUM_CNTi], mp))	217	(uint_t)(pag)->pagf_levels[XFS_BTNUM_CNTi], mp))
217		218
218	#define XFS_AGB_TO_FSB(mp,agno,agbno) \	219	#define XFS_AGB_TO_FSB(mp,agno,agbno) \
219	(((xfs_fsblock_t)(agno) << (mp)->m_sb.sb_agblklog) \| (agbno))	220	(((xfs_fsblock_t)(agno) << (mp)->m_sb.sb_agblklog) \| (agbno))
220	#define XFS_FSB_TO_AGNO(mp,fsbno) \	221	#define XFS_FSB_TO_AGNO(mp,fsbno) \
221	((xfs_agnumber_t)((fsbno) >> (mp)->m_sb.sb_agblklog))	222	((xfs_agnumber_t)((fsbno) >> (mp)->m_sb.sb_agblklog))
222	#define XFS_FSB_TO_AGBNO(mp,fsbno) \	223	#define XFS_FSB_TO_AGBNO(mp,fsbno) \
223	((xfs_agblock_t)((fsbno) & XFS_MASK32LO((mp)->m_sb.sb_agblklog)))	224	((xfs_agblock_t)((fsbno) & XFS_MASK32LO((mp)->m_sb.sb_agblklog)))
224	#define XFS_AGB_TO_DADDR(mp,agno,agbno) \	225	#define XFS_AGB_TO_DADDR(mp,agno,agbno) \
225	((xfs_daddr_t)XFS_FSB_TO_BB(mp, \	226	((xfs_daddr_t)XFS_FSB_TO_BB(mp, \
226	(xfs_fsblock_t)(agno) * (mp)->m_sb.sb_agblocks + (agbno)))	227	(xfs_fsblock_t)(agno) * (mp)->m_sb.sb_agblocks + (agbno)))
227	#define XFS_AG_DADDR(mp,agno,d) (XFS_AGB_TO_DADDR(mp, agno, 0) + (d))	228	#define XFS_AG_DADDR(mp,agno,d) (XFS_AGB_TO_DADDR(mp, agno, 0) + (d))
228		229
229	/*	230	/*
230	* For checking for bad ranges of xfs_daddr_t's, covering multiple	231	* For checking for bad ranges of xfs_daddr_t's, covering multiple
231	* allocation groups or a single xfs_daddr_t that's a superblock copy.	232	* allocation groups or a single xfs_daddr_t that's a superblock copy.
232	*/	233	*/
233	#define XFS_AG_CHECK_DADDR(mp,d,len) \	234	#define XFS_AG_CHECK_DADDR(mp,d,len) \
234	((len) == 1 ? \	235	((len) == 1 ? \
235	ASSERT((d) == XFS_SB_DADDR \|\| \	236	ASSERT((d) == XFS_SB_DADDR \|\| \
236	XFS_DADDR_TO_AGBNO(mp, d) != XFS_SB_DADDR) : \	237	XFS_DADDR_TO_AGBNO(mp, d) != XFS_SB_DADDR) : \
237	ASSERT(XFS_DADDR_TO_AGNO(mp, d) == \	238	ASSERT(XFS_DADDR_TO_AGNO(mp, d) == \
238	XFS_DADDR_TO_AGNO(mp, (d) + (len) - 1)))	239	XFS_DADDR_TO_AGNO(mp, (d) + (len) - 1)))
239		240
240	#endif /* __XFS_AG_H__ */	241	#endif /* __XFS_AG_H__ */