[thirdparty/xfsprogs-dev.git] / libxfs / xfs_dir2.h

/*
 * 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_DIR2_H__
#define __XFS_DIR2_H__

#include "xfs_da_format.h"
#include "xfs_da_btree.h"

struct xfs_defer_ops;
struct xfs_da_args;
struct xfs_inode;
struct xfs_mount;
struct xfs_trans;
struct xfs_dir2_sf_hdr;
struct xfs_dir2_sf_entry;
struct xfs_dir2_data_hdr;
struct xfs_dir2_data_entry;
struct xfs_dir2_data_unused;

extern struct xfs_name	xfs_name_dotdot;

/*
 * Convert inode mode to directory entry filetype
 */
extern unsigned char xfs_mode_to_ftype(int mode);

/*
 * directory operations vector for encode/decode routines
 */
struct xfs_dir_ops {
	int	(*sf_entsize)(struct xfs_dir2_sf_hdr *hdr, int len);
	struct xfs_dir2_sf_entry *
		(*sf_nextentry)(struct xfs_dir2_sf_hdr *hdr,
				struct xfs_dir2_sf_entry *sfep);
	uint8_t (*sf_get_ftype)(struct xfs_dir2_sf_entry *sfep);
	void	(*sf_put_ftype)(struct xfs_dir2_sf_entry *sfep,
				uint8_t ftype);
	xfs_ino_t (*sf_get_ino)(struct xfs_dir2_sf_hdr *hdr,
				struct xfs_dir2_sf_entry *sfep);
	void	(*sf_put_ino)(struct xfs_dir2_sf_hdr *hdr,
			      struct xfs_dir2_sf_entry *sfep,
			      xfs_ino_t ino);
	xfs_ino_t (*sf_get_parent_ino)(struct xfs_dir2_sf_hdr *hdr);
	void	(*sf_put_parent_ino)(struct xfs_dir2_sf_hdr *hdr,
				     xfs_ino_t ino);

	int	(*data_entsize)(int len);
	uint8_t (*data_get_ftype)(struct xfs_dir2_data_entry *dep);
	void	(*data_put_ftype)(struct xfs_dir2_data_entry *dep,
				uint8_t ftype);
	__be16 * (*data_entry_tag_p)(struct xfs_dir2_data_entry *dep);
	struct xfs_dir2_data_free *
		(*data_bestfree_p)(struct xfs_dir2_data_hdr *hdr);

	xfs_dir2_data_aoff_t data_dot_offset;
	xfs_dir2_data_aoff_t data_dotdot_offset;
	xfs_dir2_data_aoff_t data_first_offset;
	size_t	data_entry_offset;

	struct xfs_dir2_data_entry *
		(*data_dot_entry_p)(struct xfs_dir2_data_hdr *hdr);
	struct xfs_dir2_data_entry *
		(*data_dotdot_entry_p)(struct xfs_dir2_data_hdr *hdr);
	struct xfs_dir2_data_entry *
		(*data_first_entry_p)(struct xfs_dir2_data_hdr *hdr);
	struct xfs_dir2_data_entry *
		(*data_entry_p)(struct xfs_dir2_data_hdr *hdr);
	struct xfs_dir2_data_unused *
		(*data_unused_p)(struct xfs_dir2_data_hdr *hdr);

	int	leaf_hdr_size;
	void	(*leaf_hdr_to_disk)(struct xfs_dir2_leaf *to,
				    struct xfs_dir3_icleaf_hdr *from);
	void	(*leaf_hdr_from_disk)(struct xfs_dir3_icleaf_hdr *to,
				      struct xfs_dir2_leaf *from);
	int	(*leaf_max_ents)(struct xfs_da_geometry *geo);
	struct xfs_dir2_leaf_entry *
		(*leaf_ents_p)(struct xfs_dir2_leaf *lp);

	int	node_hdr_size;
	void	(*node_hdr_to_disk)(struct xfs_da_intnode *to,
				    struct xfs_da3_icnode_hdr *from);
	void	(*node_hdr_from_disk)(struct xfs_da3_icnode_hdr *to,
				      struct xfs_da_intnode *from);
	struct xfs_da_node_entry *
		(*node_tree_p)(struct xfs_da_intnode *dap);

	int	free_hdr_size;
	void	(*free_hdr_to_disk)(struct xfs_dir2_free *to,
				    struct xfs_dir3_icfree_hdr *from);
	void	(*free_hdr_from_disk)(struct xfs_dir3_icfree_hdr *to,
				      struct xfs_dir2_free *from);
	int	(*free_max_bests)(struct xfs_da_geometry *geo);
	__be16 * (*free_bests_p)(struct xfs_dir2_free *free);
	xfs_dir2_db_t (*db_to_fdb)(struct xfs_da_geometry *geo,
				   xfs_dir2_db_t db);
	int	(*db_to_fdindex)(struct xfs_da_geometry *geo,
				 xfs_dir2_db_t db);
};

extern const struct xfs_dir_ops *
	xfs_dir_get_ops(struct xfs_mount *mp, struct xfs_inode *dp);
extern const struct xfs_dir_ops *
	xfs_nondir_get_ops(struct xfs_mount *mp, struct xfs_inode *dp);

/*
 * Generic directory interface routines
 */
extern void xfs_dir_startup(void);
extern int xfs_da_mount(struct xfs_mount *mp);
extern void xfs_da_unmount(struct xfs_mount *mp);

extern int xfs_dir_isempty(struct xfs_inode *dp);
extern int xfs_dir_init(struct xfs_trans *tp, struct xfs_inode *dp,
				struct xfs_inode *pdp);
extern int xfs_dir_createname(struct xfs_trans *tp, struct xfs_inode *dp,
				struct xfs_name *name, xfs_ino_t inum,
				xfs_fsblock_t *first,
				struct xfs_defer_ops *dfops, xfs_extlen_t tot);
extern int xfs_dir_lookup(struct xfs_trans *tp, struct xfs_inode *dp,
				struct xfs_name *name, xfs_ino_t *inum,
				struct xfs_name *ci_name);
extern int xfs_dir_removename(struct xfs_trans *tp, struct xfs_inode *dp,
				struct xfs_name *name, xfs_ino_t ino,
				xfs_fsblock_t *first,
				struct xfs_defer_ops *dfops, xfs_extlen_t tot);
extern int xfs_dir_replace(struct xfs_trans *tp, struct xfs_inode *dp,
				struct xfs_name *name, xfs_ino_t inum,
				xfs_fsblock_t *first,
				struct xfs_defer_ops *dfops, xfs_extlen_t tot);
extern int xfs_dir_canenter(struct xfs_trans *tp, struct xfs_inode *dp,
				struct xfs_name *name);

/*
 * Direct call from the bmap code, bypassing the generic directory layer.
 */
extern int xfs_dir2_sf_to_block(struct xfs_da_args *args);

/*
 * Interface routines used by userspace utilities
 */
extern int xfs_dir2_isblock(struct xfs_da_args *args, int *r);
extern int xfs_dir2_isleaf(struct xfs_da_args *args, int *r);
extern int xfs_dir2_shrink_inode(struct xfs_da_args *args, xfs_dir2_db_t db,
				struct xfs_buf *bp);

extern void xfs_dir2_data_freescan_int(struct xfs_da_geometry *geo,
		const struct xfs_dir_ops *ops,
		struct xfs_dir2_data_hdr *hdr, int *loghead);
extern void xfs_dir2_data_freescan(struct xfs_inode *dp,
		struct xfs_dir2_data_hdr *hdr, int *loghead);
extern void xfs_dir2_data_log_entry(struct xfs_da_args *args,
		struct xfs_buf *bp, struct xfs_dir2_data_entry *dep);
extern void xfs_dir2_data_log_header(struct xfs_da_args *args,
		struct xfs_buf *bp);
extern void xfs_dir2_data_log_unused(struct xfs_da_args *args,
		struct xfs_buf *bp, struct xfs_dir2_data_unused *dup);
extern void xfs_dir2_data_make_free(struct xfs_da_args *args,
		struct xfs_buf *bp, xfs_dir2_data_aoff_t offset,
		xfs_dir2_data_aoff_t len, int *needlogp, int *needscanp);
extern int xfs_dir2_data_use_free(struct xfs_da_args *args,
		struct xfs_buf *bp, struct xfs_dir2_data_unused *dup,
		xfs_dir2_data_aoff_t offset, xfs_dir2_data_aoff_t len,
		int *needlogp, int *needscanp);

extern struct xfs_dir2_data_free *xfs_dir2_data_freefind(
		struct xfs_dir2_data_hdr *hdr, struct xfs_dir2_data_free *bf,
		struct xfs_dir2_data_unused *dup);

extern int xfs_dir_ino_validate(struct xfs_mount *mp, xfs_ino_t ino);

extern const struct xfs_buf_ops xfs_dir3_block_buf_ops;
extern const struct xfs_buf_ops xfs_dir3_leafn_buf_ops;
extern const struct xfs_buf_ops xfs_dir3_leaf1_buf_ops;
extern const struct xfs_buf_ops xfs_dir3_free_buf_ops;
extern const struct xfs_buf_ops xfs_dir3_data_buf_ops;

/*
 * Directory offset/block conversion functions.
 *
 * DB blocks here are logical directory block numbers, not filesystem blocks.
 */

/*
 * Convert dataptr to byte in file space
 */
static inline xfs_dir2_off_t
xfs_dir2_dataptr_to_byte(xfs_dir2_dataptr_t dp)
{
	return (xfs_dir2_off_t)dp << XFS_DIR2_DATA_ALIGN_LOG;
}

/*
 * Convert byte in file space to dataptr.  It had better be aligned.
 */
static inline xfs_dir2_dataptr_t
xfs_dir2_byte_to_dataptr(xfs_dir2_off_t by)
{
	return (xfs_dir2_dataptr_t)(by >> XFS_DIR2_DATA_ALIGN_LOG);
}

/*
 * Convert byte in space to (DB) block
 */
static inline xfs_dir2_db_t
xfs_dir2_byte_to_db(struct xfs_da_geometry *geo, xfs_dir2_off_t by)
{
	return (xfs_dir2_db_t)(by >> geo->blklog);
}

/*
 * Convert dataptr to a block number
 */
static inline xfs_dir2_db_t
xfs_dir2_dataptr_to_db(struct xfs_da_geometry *geo, xfs_dir2_dataptr_t dp)
{
	return xfs_dir2_byte_to_db(geo, xfs_dir2_dataptr_to_byte(dp));
}

/*
 * Convert byte in space to offset in a block
 */
static inline xfs_dir2_data_aoff_t
xfs_dir2_byte_to_off(struct xfs_da_geometry *geo, xfs_dir2_off_t by)
{
	return (xfs_dir2_data_aoff_t)(by & (geo->blksize - 1));
}

/*
 * Convert dataptr to a byte offset in a block
 */
static inline xfs_dir2_data_aoff_t
xfs_dir2_dataptr_to_off(struct xfs_da_geometry *geo, xfs_dir2_dataptr_t dp)
{
	return xfs_dir2_byte_to_off(geo, xfs_dir2_dataptr_to_byte(dp));
}

/*
 * Convert block and offset to byte in space
 */
static inline xfs_dir2_off_t
xfs_dir2_db_off_to_byte(struct xfs_da_geometry *geo, xfs_dir2_db_t db,
			xfs_dir2_data_aoff_t o)
{
	return ((xfs_dir2_off_t)db << geo->blklog) + o;
}

/*
 * Convert block (DB) to block (dablk)
 */
static inline xfs_dablk_t
xfs_dir2_db_to_da(struct xfs_da_geometry *geo, xfs_dir2_db_t db)
{
	return (xfs_dablk_t)(db << (geo->blklog - geo->fsblog));
}

/*
 * Convert byte in space to (DA) block
 */
static inline xfs_dablk_t
xfs_dir2_byte_to_da(struct xfs_da_geometry *geo, xfs_dir2_off_t by)
{
	return xfs_dir2_db_to_da(geo, xfs_dir2_byte_to_db(geo, by));
}

/*
 * Convert block and offset to dataptr
 */
static inline xfs_dir2_dataptr_t
xfs_dir2_db_off_to_dataptr(struct xfs_da_geometry *geo, xfs_dir2_db_t db,
			   xfs_dir2_data_aoff_t o)
{
	return xfs_dir2_byte_to_dataptr(xfs_dir2_db_off_to_byte(geo, db, o));
}

/*
 * Convert block (dablk) to block (DB)
 */
static inline xfs_dir2_db_t
xfs_dir2_da_to_db(struct xfs_da_geometry *geo, xfs_dablk_t da)
{
	return (xfs_dir2_db_t)(da >> (geo->blklog - geo->fsblog));
}

/*
 * Convert block (dablk) to byte offset in space
 */
static inline xfs_dir2_off_t
xfs_dir2_da_to_byte(struct xfs_da_geometry *geo, xfs_dablk_t da)
{
	return xfs_dir2_db_off_to_byte(geo, xfs_dir2_da_to_db(geo, da), 0);
}

/*
 * Directory tail pointer accessor functions. Based on block geometry.
 */
static inline struct xfs_dir2_block_tail *
xfs_dir2_block_tail_p(struct xfs_da_geometry *geo, struct xfs_dir2_data_hdr *hdr)
{
	return ((struct xfs_dir2_block_tail *)
		((char *)hdr + geo->blksize)) - 1;
}

static inline struct xfs_dir2_leaf_tail *
xfs_dir2_leaf_tail_p(struct xfs_da_geometry *geo, struct xfs_dir2_leaf *lp)
{
	return (struct xfs_dir2_leaf_tail *)
		((char *)lp + geo->blksize -
		  sizeof(struct xfs_dir2_leaf_tail));
}

/*
 * The Linux API doesn't pass down the total size of the buffer
 * we read into down to the filesystem.  With the filldir concept
 * it's not needed for correct information, but the XFS dir2 leaf
 * code wants an estimate of the buffer size to calculate it's
 * readahead window and size the buffers used for mapping to
 * physical blocks.
 *
 * Try to give it an estimate that's good enough, maybe at some
 * point we can change the ->readdir prototype to include the
 * buffer size.  For now we use the current glibc buffer size.
 * musl libc hardcodes 2k and dietlibc uses PAGE_SIZE.
 */
#define XFS_READDIR_BUFSIZE	(32768)

unsigned char xfs_dir3_get_dtype(struct xfs_mount *mp, uint8_t filetype);
void *xfs_dir3_data_endp(struct xfs_da_geometry *geo,
		struct xfs_dir2_data_hdr *hdr);

#endif	/* __XFS_DIR2_H__ */
Commit	Line	Data
2bd0ea18	1	/*
f302e9e4 NS	2	* Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
f302e9e4 NS	3	* All Rights Reserved.
5000d01d	4	*
f302e9e4 NS	5	* This program is free software; you can redistribute it and/or
f302e9e4 NS	6	* modify it under the terms of the GNU General Public License as
2bd0ea18	7	* published by the Free Software Foundation.
5000d01d	8	*
f302e9e4 NS	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
5000d01d	13	*
f302e9e4 NS	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write the Free Software Foundation,
	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
2bd0ea18 NS	17	*/
2bd0ea18 NS	18	#ifndef __XFS_DIR2_H__
a2ceac1f	19	#define __XFS_DIR2_H__
2bd0ea18	20
3e86cfde AG	21	#include "xfs_da_format.h"
	22	#include "xfs_da_btree.h"
	23
6f530e9a	24	struct xfs_defer_ops;
a2ceac1f	25	struct xfs_da_args;
2bd0ea18	26	struct xfs_inode;
5e656dbb	27	struct xfs_mount;
2bd0ea18	28	struct xfs_trans;
a2ceac1f DC	29	struct xfs_dir2_sf_hdr;
	30	struct xfs_dir2_sf_entry;
	31	struct xfs_dir2_data_hdr;
	32	struct xfs_dir2_data_entry;
	33	struct xfs_dir2_data_unused;
2bd0ea18	34
5e656dbb	35	extern struct xfs_name xfs_name_dotdot;
2bd0ea18	36
ff105f75	37	/*
3297e0ca	38	* Convert inode mode to directory entry filetype
ff105f75	39	*/
5b1caea4	40	extern unsigned char xfs_mode_to_ftype(int mode);
ff105f75 DC	41
	42	/*
	43	* directory operations vector for encode/decode routines
	44	*/
	45	struct xfs_dir_ops {
	46	int (sf_entsize)(struct xfs_dir2_sf_hdr hdr, int len);
	47	struct xfs_dir2_sf_entry *
	48	(sf_nextentry)(struct xfs_dir2_sf_hdr hdr,
	49	struct xfs_dir2_sf_entry *sfep);
4a492e72	50	uint8_t (sf_get_ftype)(struct xfs_dir2_sf_entry sfep);
ff105f75	51	void (sf_put_ftype)(struct xfs_dir2_sf_entry sfep,
4a492e72	52	uint8_t ftype);
ff105f75 DC	53	xfs_ino_t (sf_get_ino)(struct xfs_dir2_sf_hdr hdr,
	54	struct xfs_dir2_sf_entry *sfep);
	55	void (sf_put_ino)(struct xfs_dir2_sf_hdr hdr,
	56	struct xfs_dir2_sf_entry *sfep,
	57	xfs_ino_t ino);
	58	xfs_ino_t (sf_get_parent_ino)(struct xfs_dir2_sf_hdr hdr);
	59	void (sf_put_parent_ino)(struct xfs_dir2_sf_hdr hdr,
	60	xfs_ino_t ino);
	61
	62	int (*data_entsize)(int len);
4a492e72	63	uint8_t (data_get_ftype)(struct xfs_dir2_data_entry dep);
ff105f75	64	void (data_put_ftype)(struct xfs_dir2_data_entry dep,
4a492e72	65	uint8_t ftype);
ff105f75 DC	66	__be16 * (data_entry_tag_p)(struct xfs_dir2_data_entry dep);
	67	struct xfs_dir2_data_free *
	68	(data_bestfree_p)(struct xfs_dir2_data_hdr hdr);
	69
	70	xfs_dir2_data_aoff_t data_dot_offset;
	71	xfs_dir2_data_aoff_t data_dotdot_offset;
	72	xfs_dir2_data_aoff_t data_first_offset;
	73	size_t data_entry_offset;
	74
	75	struct xfs_dir2_data_entry *
	76	(data_dot_entry_p)(struct xfs_dir2_data_hdr hdr);
	77	struct xfs_dir2_data_entry *
	78	(data_dotdot_entry_p)(struct xfs_dir2_data_hdr hdr);
	79	struct xfs_dir2_data_entry *
	80	(data_first_entry_p)(struct xfs_dir2_data_hdr hdr);
	81	struct xfs_dir2_data_entry *
	82	(data_entry_p)(struct xfs_dir2_data_hdr hdr);
	83	struct xfs_dir2_data_unused *
	84	(data_unused_p)(struct xfs_dir2_data_hdr hdr);
	85
	86	int leaf_hdr_size;
	87	void (leaf_hdr_to_disk)(struct xfs_dir2_leaf to,
	88	struct xfs_dir3_icleaf_hdr *from);
	89	void (leaf_hdr_from_disk)(struct xfs_dir3_icleaf_hdr to,
	90	struct xfs_dir2_leaf *from);
	91	int (leaf_max_ents)(struct xfs_da_geometry geo);
	92	struct xfs_dir2_leaf_entry *
	93	(leaf_ents_p)(struct xfs_dir2_leaf lp);
	94
	95	int node_hdr_size;
	96	void (node_hdr_to_disk)(struct xfs_da_intnode to,
	97	struct xfs_da3_icnode_hdr *from);
	98	void (node_hdr_from_disk)(struct xfs_da3_icnode_hdr to,
	99	struct xfs_da_intnode *from);
	100	struct xfs_da_node_entry *
	101	(node_tree_p)(struct xfs_da_intnode dap);
	102
	103	int free_hdr_size;
	104	void (free_hdr_to_disk)(struct xfs_dir2_free to,
	105	struct xfs_dir3_icfree_hdr *from);
	106	void (free_hdr_from_disk)(struct xfs_dir3_icfree_hdr to,
	107	struct xfs_dir2_free *from);
	108	int (free_max_bests)(struct xfs_da_geometry geo);
	109	__be16 * (free_bests_p)(struct xfs_dir2_free free);
	110	xfs_dir2_db_t (db_to_fdb)(struct xfs_da_geometry geo,
	111	xfs_dir2_db_t db);
	112	int (db_to_fdindex)(struct xfs_da_geometry geo,
	113	xfs_dir2_db_t db);
	114	};
	115
	116	extern const struct xfs_dir_ops *
	117	xfs_dir_get_ops(struct xfs_mount mp, struct xfs_inode dp);
	118	extern const struct xfs_dir_ops *
	119	xfs_nondir_get_ops(struct xfs_mount mp, struct xfs_inode dp);
	120
2bd0ea18	121	/*
5e656dbb	122	* Generic directory interface routines
2bd0ea18	123	*/
5e656dbb	124	extern void xfs_dir_startup(void);
ff105f75 DC	125	extern int xfs_da_mount(struct xfs_mount *mp);
	126	extern void xfs_da_unmount(struct xfs_mount *mp);
	127
5e656dbb BN	128	extern int xfs_dir_isempty(struct xfs_inode *dp);
	129	extern int xfs_dir_init(struct xfs_trans tp, struct xfs_inode dp,
	130	struct xfs_inode *pdp);
	131	extern int xfs_dir_createname(struct xfs_trans tp, struct xfs_inode dp,
	132	struct xfs_name *name, xfs_ino_t inum,
	133	xfs_fsblock_t *first,
f33cea1a	134	struct xfs_defer_ops *dfops, xfs_extlen_t tot);
5e656dbb BN	135	extern int xfs_dir_lookup(struct xfs_trans tp, struct xfs_inode dp,
	136	struct xfs_name name, xfs_ino_t inum,
	137	struct xfs_name *ci_name);
	138	extern int xfs_dir_removename(struct xfs_trans tp, struct xfs_inode dp,
	139	struct xfs_name *name, xfs_ino_t ino,
	140	xfs_fsblock_t *first,
f33cea1a	141	struct xfs_defer_ops *dfops, xfs_extlen_t tot);
5e656dbb BN	142	extern int xfs_dir_replace(struct xfs_trans tp, struct xfs_inode dp,
	143	struct xfs_name *name, xfs_ino_t inum,
	144	xfs_fsblock_t *first,
f33cea1a	145	struct xfs_defer_ops *dfops, xfs_extlen_t tot);
5e656dbb	146	extern int xfs_dir_canenter(struct xfs_trans tp, struct xfs_inode dp,
5a35bf2c	147	struct xfs_name *name);
2bd0ea18	148
2bd0ea18	149	/*
a2ceac1f DC	150	* Direct call from the bmap code, bypassing the generic directory layer.
	151	*/
	152	extern int xfs_dir2_sf_to_block(struct xfs_da_args *args);
	153
	154	/*
79737cd9	155	* Interface routines used by userspace utilities
2bd0ea18	156	*/
ff105f75 DC	157	extern int xfs_dir2_isblock(struct xfs_da_args args, int r);
ff105f75 DC	158	extern int xfs_dir2_isleaf(struct xfs_da_args args, int r);
5e656dbb	159	extern int xfs_dir2_shrink_inode(struct xfs_da_args *args, xfs_dir2_db_t db,
a2ceac1f DC	160	struct xfs_buf *bp);
a2ceac1f DC	161
7b111d36	162	extern void xfs_dir2_data_freescan_int(struct xfs_da_geometry *geo,
ff105f75	163	const struct xfs_dir_ops *ops,
a2ceac1f	164	struct xfs_dir2_data_hdr hdr, int loghead);
7b111d36 DW	165	extern void xfs_dir2_data_freescan(struct xfs_inode *dp,
7b111d36 DW	166	struct xfs_dir2_data_hdr hdr, int loghead);
ff105f75 DC	167	extern void xfs_dir2_data_log_entry(struct xfs_da_args *args,
	168	struct xfs_buf bp, struct xfs_dir2_data_entry dep);
	169	extern void xfs_dir2_data_log_header(struct xfs_da_args *args,
a2ceac1f	170	struct xfs_buf *bp);
ff105f75 DC	171	extern void xfs_dir2_data_log_unused(struct xfs_da_args *args,
	172	struct xfs_buf bp, struct xfs_dir2_data_unused dup);
	173	extern void xfs_dir2_data_make_free(struct xfs_da_args *args,
	174	struct xfs_buf *bp, xfs_dir2_data_aoff_t offset,
	175	xfs_dir2_data_aoff_t len, int needlogp, int needscanp);
15348e04	176	extern int xfs_dir2_data_use_free(struct xfs_da_args *args,
ff105f75	177	struct xfs_buf bp, struct xfs_dir2_data_unused dup,
a2ceac1f DC	178	xfs_dir2_data_aoff_t offset, xfs_dir2_data_aoff_t len,
a2ceac1f DC	179	int needlogp, int needscanp);
2bd0ea18	180
a2ceac1f	181	extern struct xfs_dir2_data_free *xfs_dir2_data_freefind(
ff105f75 DC	182	struct xfs_dir2_data_hdr hdr, struct xfs_dir2_data_free bf,
ff105f75 DC	183	struct xfs_dir2_data_unused *dup);
2bd0ea18	184
01914f06 DW	185	extern int xfs_dir_ino_validate(struct xfs_mount *mp, xfs_ino_t ino);
01914f06 DW	186
75c8b434 DC	187	extern const struct xfs_buf_ops xfs_dir3_block_buf_ops;
	188	extern const struct xfs_buf_ops xfs_dir3_leafn_buf_ops;
	189	extern const struct xfs_buf_ops xfs_dir3_leaf1_buf_ops;
	190	extern const struct xfs_buf_ops xfs_dir3_free_buf_ops;
	191	extern const struct xfs_buf_ops xfs_dir3_data_buf_ops;
	192
ff105f75 DC	193	/*
	194	* Directory offset/block conversion functions.
	195	*
	196	* DB blocks here are logical directory block numbers, not filesystem blocks.
	197	*/
	198
	199	/*
	200	* Convert dataptr to byte in file space
	201	*/
	202	static inline xfs_dir2_off_t
	203	xfs_dir2_dataptr_to_byte(xfs_dir2_dataptr_t dp)
	204	{
	205	return (xfs_dir2_off_t)dp << XFS_DIR2_DATA_ALIGN_LOG;
	206	}
	207
	208	/*
	209	* Convert byte in file space to dataptr. It had better be aligned.
	210	*/
	211	static inline xfs_dir2_dataptr_t
	212	xfs_dir2_byte_to_dataptr(xfs_dir2_off_t by)
	213	{
	214	return (xfs_dir2_dataptr_t)(by >> XFS_DIR2_DATA_ALIGN_LOG);
	215	}
	216
	217	/*
	218	* Convert byte in space to (DB) block
	219	*/
	220	static inline xfs_dir2_db_t
	221	xfs_dir2_byte_to_db(struct xfs_da_geometry *geo, xfs_dir2_off_t by)
	222	{
	223	return (xfs_dir2_db_t)(by >> geo->blklog);
	224	}
	225
	226	/*
	227	* Convert dataptr to a block number
	228	*/
	229	static inline xfs_dir2_db_t
	230	xfs_dir2_dataptr_to_db(struct xfs_da_geometry *geo, xfs_dir2_dataptr_t dp)
	231	{
	232	return xfs_dir2_byte_to_db(geo, xfs_dir2_dataptr_to_byte(dp));
	233	}
	234
	235	/*
	236	* Convert byte in space to offset in a block
	237	*/
	238	static inline xfs_dir2_data_aoff_t
	239	xfs_dir2_byte_to_off(struct xfs_da_geometry *geo, xfs_dir2_off_t by)
	240	{
	241	return (xfs_dir2_data_aoff_t)(by & (geo->blksize - 1));
	242	}
	243
	244	/*
	245	* Convert dataptr to a byte offset in a block
	246	*/
	247	static inline xfs_dir2_data_aoff_t
	248	xfs_dir2_dataptr_to_off(struct xfs_da_geometry *geo, xfs_dir2_dataptr_t dp)
	249	{
	250	return xfs_dir2_byte_to_off(geo, xfs_dir2_dataptr_to_byte(dp));
	251	}
	252
	253	/*
	254	* Convert block and offset to byte in space
	255	*/
	256	static inline xfs_dir2_off_t
257	xfs_dir2_db_off_to_byte(struct xfs_da_geometry *geo, xfs_dir2_db_t db,
258	xfs_dir2_data_aoff_t o)
259	{
260	return ((xfs_dir2_off_t)db << geo->blklog) + o;
261	}
262
263	/*
264	* Convert block (DB) to block (dablk)
265	*/
266	static inline xfs_dablk_t
267	xfs_dir2_db_to_da(struct xfs_da_geometry *geo, xfs_dir2_db_t db)
268	{
269	return (xfs_dablk_t)(db << (geo->blklog - geo->fsblog));
270	}
271
272	/*
273	* Convert byte in space to (DA) block
274	*/
275	static inline xfs_dablk_t
276	xfs_dir2_byte_to_da(struct xfs_da_geometry *geo, xfs_dir2_off_t by)
277	{
278	return xfs_dir2_db_to_da(geo, xfs_dir2_byte_to_db(geo, by));
279	}
280
281	/*
282	* Convert block and offset to dataptr
283	*/
284	static inline xfs_dir2_dataptr_t
285	xfs_dir2_db_off_to_dataptr(struct xfs_da_geometry *geo, xfs_dir2_db_t db,
286	xfs_dir2_data_aoff_t o)
287	{
288	return xfs_dir2_byte_to_dataptr(xfs_dir2_db_off_to_byte(geo, db, o));
289	}
290
291	/*
292	* Convert block (dablk) to block (DB)
293	*/
294	static inline xfs_dir2_db_t
295	xfs_dir2_da_to_db(struct xfs_da_geometry *geo, xfs_dablk_t da)
296	{
297	return (xfs_dir2_db_t)(da >> (geo->blklog - geo->fsblog));
298	}
299
300	/*
301	* Convert block (dablk) to byte offset in space
302	*/
303	static inline xfs_dir2_off_t
304	xfs_dir2_da_to_byte(struct xfs_da_geometry *geo, xfs_dablk_t da)
305	{
306	return xfs_dir2_db_off_to_byte(geo, xfs_dir2_da_to_db(geo, da), 0);
307	}
308
309	/*
310	* Directory tail pointer accessor functions. Based on block geometry.
311	*/
312	static inline struct xfs_dir2_block_tail *
313	xfs_dir2_block_tail_p(struct xfs_da_geometry geo, struct xfs_dir2_data_hdr hdr)
314	{
315	return ((struct xfs_dir2_block_tail *)
316	((char *)hdr + geo->blksize)) - 1;
317	}
318
319	static inline struct xfs_dir2_leaf_tail *
320	xfs_dir2_leaf_tail_p(struct xfs_da_geometry geo, struct xfs_dir2_leaf lp)
321	{
322	return (struct xfs_dir2_leaf_tail *)
323	((char *)lp + geo->blksize -
324	sizeof(struct xfs_dir2_leaf_tail));
325	}
326
16c101bb DW	327	/*
	328	* The Linux API doesn't pass down the total size of the buffer
	329	* we read into down to the filesystem. With the filldir concept
	330	* it's not needed for correct information, but the XFS dir2 leaf
	331	* code wants an estimate of the buffer size to calculate it's
	332	* readahead window and size the buffers used for mapping to
	333	* physical blocks.
	334	*
	335	* Try to give it an estimate that's good enough, maybe at some
	336	* point we can change the ->readdir prototype to include the
	337	* buffer size. For now we use the current glibc buffer size.
	338	* musl libc hardcodes 2k and dietlibc uses PAGE_SIZE.
	339	*/
	340	#define XFS_READDIR_BUFSIZE (32768)
	341
	342	unsigned char xfs_dir3_get_dtype(struct xfs_mount *mp, uint8_t filetype);
b67317ef DW	343	void xfs_dir3_data_endp(struct xfs_da_geometry geo,
b67317ef DW	344	struct xfs_dir2_data_hdr *hdr);
16c101bb	345
2bd0ea18	346	#endif /* __XFS_DIR2_H__ */