[thirdparty/xfsprogs-dev.git] / libxfs / rdwr.c

/*
 * Copyright (c) 2000-2006 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
 */

#include <xfs/libxfs.h>
#include <xfs/xfs_log.h>
#include <xfs/xfs_log_priv.h>
#include "init.h"

#define BDSTRAT_SIZE	(256 * 1024)
#define min(x, y)	((x) < (y) ? (x) : (y))

static inline void *
libxfs_memalign(size_t size)
{
	static size_t	memalignment;

	if (!memalignment)
		memalignment = platform_memalignment();
	return memalign(memalignment, size);
}

void
libxfs_device_zero(dev_t dev, xfs_daddr_t start, uint len)
{
	xfs_off_t	start_offset, end_offset, offset;
	ssize_t		zsize, bytes;
	char		*z;
	int		fd;

	zsize = min(BDSTRAT_SIZE, BBTOB(len));
	if ((z = libxfs_memalign(zsize)) == NULL) {
		fprintf(stderr,
			_("%s: %s can't memalign %d bytes: %s\n"),
			progname, __FUNCTION__, (int)zsize, strerror(errno));
		exit(1);
	}
	memset(z, 0, zsize);

	fd = libxfs_device_to_fd(dev);
	start_offset = LIBXFS_BBTOOFF64(start);

	if ((lseek64(fd, start_offset, SEEK_SET)) < 0) {
		fprintf(stderr, _("%s: %s seek to offset %llu failed: %s\n"),
			progname, __FUNCTION__,
			(unsigned long long)start_offset, strerror(errno));
		exit(1);
	}

	end_offset = LIBXFS_BBTOOFF64(start + len) - start_offset;
	for (offset = 0; offset < end_offset; ) {
		bytes = min((ssize_t)(end_offset - offset), zsize);
		if ((bytes = write(fd, z, bytes)) < 0) {
			fprintf(stderr, _("%s: %s write failed: %s\n"),
				progname, __FUNCTION__, strerror(errno));
			exit(1);
		} else if (bytes == 0) {
			fprintf(stderr, _("%s: %s not progressing?\n"),
				progname, __FUNCTION__);
			exit(1);
		}
		offset += bytes;
	}
	free(z);
}

static void unmount_record(void *p)
{
	xlog_op_header_t	*op = (xlog_op_header_t *)p;
	/* the data section must be 32 bit size aligned */
	struct {
	    __uint16_t magic;
	    __uint16_t pad1;
	    __uint32_t pad2; /* may as well make it 64 bits */
	} magic = { XLOG_UNMOUNT_TYPE, 0, 0 };

	memset(p, 0, BBSIZE);
	INT_SET(op->oh_tid,		ARCH_CONVERT, 1);
	INT_SET(op->oh_len,		ARCH_CONVERT, sizeof(magic));
	INT_SET(op->oh_clientid,	ARCH_CONVERT, XFS_LOG);
	INT_SET(op->oh_flags,		ARCH_CONVERT, XLOG_UNMOUNT_TRANS);
	INT_SET(op->oh_res2,		ARCH_CONVERT, 0);

	/* and the data for this op */
	memcpy((char *)p + sizeof(xlog_op_header_t), &magic, sizeof(magic));
}

static xfs_caddr_t next(xfs_caddr_t ptr, int offset, void *private)
{
	xfs_buf_t	*buf = (xfs_buf_t *)private;

	if (XFS_BUF_COUNT(buf) < (int)(ptr - XFS_BUF_PTR(buf)) + offset)
		abort();
	return ptr + offset;
}

int
libxfs_log_clear(
	dev_t			device,
	xfs_daddr_t		start,
	uint			length,
	uuid_t			*fs_uuid,
	int			version,
	int			sunit,
	int			fmt)
{
	xfs_buf_t		*buf;
	int			len;

	if (!device || !fs_uuid)
		return -EINVAL;

	/* first zero the log */
	libxfs_device_zero(device, start, length);

	/* then write a log record header */
	len = ((version == 2) && sunit) ? BTOBB(sunit) : 2;
	len = MAX(len, 2);
	buf = libxfs_getbuf(device, start, len);
	libxfs_log_header(XFS_BUF_PTR(buf),
			  fs_uuid, version, sunit, fmt, next, buf);
	libxfs_writebufr(buf);
	libxfs_putbuf(buf);
	return 0;
}

int
libxfs_log_header(
	xfs_caddr_t		caddr,
	uuid_t			*fs_uuid,
	int			version,
	int			sunit,
	int			fmt,
	libxfs_get_block_t	*nextfunc,
	void			*private)
{
	xlog_rec_header_t	*head = (xlog_rec_header_t *)caddr;
	xfs_caddr_t		p = caddr;
	uint			cycle_lsn;
	int			i, len;

	len = ((version == 2) && sunit) ? BTOBB(sunit) : 1;

	/* note that oh_tid actually contains the cycle number
	 * and the tid is stored in h_cycle_data[0] - that's the
	 * way things end up on disk.
	 */
	memset(p, 0, BBSIZE);
	INT_SET(head->h_magicno,	ARCH_CONVERT, XLOG_HEADER_MAGIC_NUM);
	INT_SET(head->h_cycle,		ARCH_CONVERT, 1);
	INT_SET(head->h_version,	ARCH_CONVERT, version);
	if (len != 1)
		INT_SET(head->h_len,		ARCH_CONVERT, sunit - BBSIZE);
	else
		INT_SET(head->h_len,		ARCH_CONVERT, 20);
	INT_SET(head->h_chksum,		ARCH_CONVERT, 0);
	INT_SET(head->h_prev_block,	ARCH_CONVERT, -1);
	INT_SET(head->h_num_logops,	ARCH_CONVERT, 1);
	INT_SET(head->h_cycle_data[0],	ARCH_CONVERT, 0xb0c0d0d0);
	INT_SET(head->h_fmt,		ARCH_CONVERT, fmt);
	INT_SET(head->h_size,		ARCH_CONVERT, XLOG_HEADER_CYCLE_SIZE);

	ASSIGN_ANY_LSN_DISK(head->h_lsn, 1, 0);
	ASSIGN_ANY_LSN_DISK(head->h_tail_lsn, 1, 0);

	memcpy(&head->h_fs_uuid, fs_uuid, sizeof(uuid_t));

	len = MAX(len, 2);
	p = nextfunc(p, BBSIZE, private);
	unmount_record(p);

	cycle_lsn = CYCLE_LSN_DISK(head->h_lsn);
	for (i = 2; i < len; i++) {
		p = nextfunc(p, BBSIZE, private);
		memset(p, 0, BBSIZE);
		*(uint *)p = cycle_lsn;
	}

	return BBTOB(len);
}

xfs_buf_t *
libxfs_getsb(xfs_mount_t *mp, int flags)
{
	return libxfs_readbuf(mp->m_dev, XFS_SB_DADDR,
				XFS_FSS_TO_BB(mp, 1), flags);
}


/*
 * Simple I/O (buffer cache) interface
 */

xfs_zone_t	*xfs_buf_zone;

typedef struct {
	dev_t		device;
	xfs_daddr_t	blkno;
	unsigned int	count;
} xfs_bufkey_t;

static unsigned int
libxfs_bhash(cache_key_t key, unsigned int hashsize)
{
	return ((unsigned int)((xfs_bufkey_t *)key)->blkno) % hashsize;
}

static int
libxfs_bcompare(struct cache_node *node, cache_key_t key)
{
	xfs_buf_t	*bp = (xfs_buf_t *)node;
	xfs_bufkey_t	*bkey = (xfs_bufkey_t *)key;

#ifdef IO_BCOMPARE_CHECK
	if (bp->b_dev == bkey->device &&
	    bp->b_blkno == bkey->blkno &&
	    bp->b_bcount != bkey->count)
		fprintf(stderr, "Badness in key lookup (length)\n"
			"bp=(bno %llu, len %u bb) key=(bno %llu, len %u bbs)\n",
			(unsigned long long)bp->b_blkno, (int)bp->b_bcount,
			(unsigned long long)bkey->blkno, (int)bkey->count);
#endif

	return (bp->b_dev == bkey->device &&
		bp->b_blkno == bkey->blkno &&
		bp->b_bcount == bkey->count);
}

void
libxfs_bprint(xfs_buf_t *bp)
{
	fprintf(stderr, "Buffer 0x%p blkno=%llu bytes=%u flags=0x%x count=%u\n",
		bp, (unsigned long long)bp->b_blkno, (unsigned)bp->b_bcount,
		bp->b_flags, bp->b_node.cn_count);
}

xfs_buf_t *
libxfs_getbuf(dev_t device, xfs_daddr_t blkno, int len)
{
	xfs_buf_t	*bp;
	xfs_bufkey_t	key;
	unsigned int	bytes = BBTOB(len);

	key.device = device;
	key.blkno = blkno;
	key.count = bytes;

	if (cache_node_get(libxfs_bcache, &key, (struct cache_node **)&bp)) {
#ifdef IO_DEBUG
		fprintf(stderr, "%s: allocated buffer, key=%llu(%llu), %p\n",
			__FUNCTION__, BBTOB(len), LIBXFS_BBTOOFF64(blkno), blkno, buf);
#endif
		bp->b_flags = 0;
		bp->b_blkno = blkno;
		bp->b_bcount = bytes;
		bp->b_dev = device;
		if (!(bp->b_addr = libxfs_memalign(bytes))) {
			fprintf(stderr,
				_("%s: %s can't memalign %d bytes: %s\n"),
				progname, __FUNCTION__, (int)bytes,
				strerror(errno));
			exit(1);
		}
	}
	return bp;
}

void
libxfs_putbuf(xfs_buf_t *bp)
{
	cache_node_put((struct cache_node *)bp);
}

void
libxfs_purgebuf(xfs_buf_t *bp)
{
	xfs_bufkey_t	key;

	key.device = bp->b_dev;
	key.blkno = bp->b_blkno;
	key.count = bp->b_bcount;

	cache_node_purge(libxfs_bcache, &key, (struct cache_node *)bp);
}

static struct cache_node *
libxfs_balloc(void)
{
	return libxfs_zone_zalloc(xfs_buf_zone);
}

int
libxfs_readbufr(dev_t dev, xfs_daddr_t blkno, xfs_buf_t *bp, int len, int flags)
{
	int	fd = libxfs_device_to_fd(dev);
	int	bytes = BBTOB(len);

	ASSERT(BBTOB(len) <= bp->b_bcount);

	if (pread64(fd, bp->b_addr, bytes, LIBXFS_BBTOOFF64(blkno)) < 0) {
		fprintf(stderr, _("%s: read failed: %s\n"),
			progname, strerror(errno));
		if (flags & LIBXFS_EXIT_ON_FAILURE)
			exit(1);
		return errno;
	}
#ifdef IO_DEBUG
	fprintf(stderr, "readbufr read %ubytes, blkno=%llu(%llu), %p\n",
		bytes, LIBXFS_BBTOOFF64(blkno), blkno, bp);
#endif
	if (bp->b_dev == dev &&
	    bp->b_blkno == blkno &&
	    bp->b_bcount == bytes)
		bp->b_flags |= LIBXFS_B_UPTODATE;
	return 0;
}

xfs_buf_t *
libxfs_readbuf(dev_t dev, xfs_daddr_t blkno, int len, int flags)
{
	xfs_buf_t	*bp;
	int		error;

	bp = libxfs_getbuf(dev, blkno, len);
	if (!(bp->b_flags & (LIBXFS_B_UPTODATE|LIBXFS_B_DIRTY))) {
		error = libxfs_readbufr(dev, blkno, bp, len, flags);
		if (error) {
			libxfs_putbuf(bp);
			return NULL;
		}
	}
	return bp;
}

int
libxfs_writebufr(xfs_buf_t *bp)
{
	int	sts;
	int	fd = libxfs_device_to_fd(bp->b_dev);

	sts = pwrite64(fd, bp->b_addr, bp->b_bcount, LIBXFS_BBTOOFF64(bp->b_blkno));
	if (sts < 0) {
		fprintf(stderr, _("%s: pwrite64 failed: %s\n"),
			progname, strerror(errno));
		if (bp->b_flags & LIBXFS_B_EXIT)
			exit(1);
		return errno;
	}
	else if (sts != bp->b_bcount) {
		fprintf(stderr, _("%s: error - wrote only %d of %d bytes\n"),
			progname, sts, bp->b_bcount);
		if (bp->b_flags & LIBXFS_B_EXIT)
			exit(1);
		return EIO;
	}
#ifdef IO_DEBUG
	fprintf(stderr, "writebufr wrote %ubytes, blkno=%llu(%llu), %p\n",
		bp->b_bcount, LIBXFS_BBTOOFF64(bp->b_blkno), bp->b_blkno, bp);
#endif
	bp->b_flags |= LIBXFS_B_UPTODATE;
	bp->b_flags &= ~(LIBXFS_B_DIRTY | LIBXFS_B_EXIT);
	return 0;
}

int
libxfs_writebuf_int(xfs_buf_t *bp, int flags)
{
	bp->b_flags |= (LIBXFS_B_DIRTY | flags);
	return 0;
}

int
libxfs_writebuf(xfs_buf_t *bp, int flags)
{
	bp->b_flags |= (LIBXFS_B_DIRTY | flags);
	libxfs_putbuf(bp);
	return 0;
}

void
libxfs_iomove(xfs_buf_t *bp, uint boff, int len, void *data, int flags)
{
#ifdef IO_DEBUG
	if (boff + len > bp->b_bcount) {
		fprintf(stderr, "Badness, iomove out of range!\n"
			"bp=(bno %llu, bytes %u) range=(boff %u, bytes %u)\n",
			bp->b_blkno, bp->b_bcount, boff, len);
		abort();
	}
#endif
	switch (flags) {
	case LIBXFS_BZERO:
		memset(bp->b_addr + boff, 0, len);
		break;
	case LIBXFS_BREAD:
		memcpy(data, bp->b_addr + boff, len);
		break;
	case LIBXFS_BWRITE:
		memcpy(bp->b_addr + boff, data, len);
		break;
	}
}

static void
libxfs_brelse(struct cache_node *node)
{
	xfs_buf_t		*bp = (xfs_buf_t *)node;
	xfs_buf_log_item_t	*bip;
	extern xfs_zone_t	*xfs_buf_item_zone;

	if (bp != NULL) {
		if (bp->b_flags & LIBXFS_B_DIRTY)
			libxfs_writebufr(bp);
		bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
		if (bip)
		    libxfs_zone_free(xfs_buf_item_zone, bip);
		free(bp->b_addr);
		bp->b_addr = NULL;
		bp->b_flags = 0;
		free(bp);
		bp = NULL;
	}
}

void
libxfs_bcache_purge(void)
{
	cache_purge(libxfs_bcache);
}

struct cache_operations libxfs_bcache_operations = {
	/* .hash */	libxfs_bhash,
	/* .alloc */	libxfs_balloc,
	/* .relse */	libxfs_brelse,
	/* .compare */	libxfs_bcompare,
	/* .bulkrelse */ NULL	/* TODO: lio_listio64 interface? */
};


/*
 * Simple memory interface
 */

xfs_zone_t *
libxfs_zone_init(int size, char *name)
{
	xfs_zone_t	*ptr;

	if ((ptr = malloc(sizeof(xfs_zone_t))) == NULL) {
		fprintf(stderr, _("%s: zone init failed (%s, %d bytes): %s\n"),
			progname, name, (int)sizeof(xfs_zone_t), strerror(errno));
		exit(1);
	}
	ptr->zone_unitsize = size;
	ptr->zone_name = name;
#ifdef MEM_DEBUG
	ptr->allocated = 0;
	fprintf(stderr, "new zone %p for \"%s\", size=%d\n", ptr, name, size);
#endif
	return ptr;
}

void *
libxfs_zone_zalloc(xfs_zone_t *z)
{
	void	*ptr;

	if ((ptr = calloc(z->zone_unitsize, 1)) == NULL) {
		fprintf(stderr, _("%s: zone calloc failed (%s, %d bytes): %s\n"),
			progname, z->zone_name, z->zone_unitsize,
			strerror(errno));
		exit(1);
	}
#ifdef MEM_DEBUG
	z->allocated++;
	fprintf(stderr, "## zone alloc'd item %p from %s (%d bytes) (%d active)\n",
		ptr, z->zone_name,  z->zone_unitsize,
		z->allocated);
#endif
	return ptr;
}

void
libxfs_zone_free(xfs_zone_t *z, void *ptr)
{
#ifdef MEM_DEBUG
	z->allocated--;
	fprintf(stderr, "## zone freed item %p from %s (%d bytes) (%d active)\n",
		ptr, z->zone_name, z->zone_unitsize,
		z->allocated);
#endif
	if (ptr != NULL) {
		free(ptr);
		ptr = NULL;
	}
}

void *
libxfs_malloc(size_t size)
{
	void	*ptr;

	if ((ptr = calloc(1, size)) == NULL) {
		fprintf(stderr, _("%s: calloc failed (%d bytes): %s\n"),
			progname, (int)size, strerror(errno));
		exit(1);
	}
#ifdef MEM_DEBUG
	fprintf(stderr, "## calloc'd item %p size %d bytes\n", ptr, size);
#endif
	return ptr;
}

void
libxfs_free(void *ptr)
{
#ifdef MEM_DEBUG
	fprintf(stderr, "## freed item %p\n", ptr);
#endif
	if (ptr != NULL) {
		free(ptr);
		ptr = NULL;
	}
}

void *
libxfs_realloc(void *ptr, size_t size)
{
#ifdef MEM_DEBUG
	void *optr=ptr;
#endif
	if ((ptr = realloc(ptr, size)) == NULL) {
		fprintf(stderr, _("%s: realloc failed (%d bytes): %s\n"),
			progname, (int)size, strerror(errno));
		exit(1);
	}
#ifdef MEM_DEBUG
	fprintf(stderr, "## realloc'd item %p now %p size %d bytes\n",
		optr, ptr, size);
#endif
	return ptr;
}


/*
 * Inode cache interfaces
 */

extern xfs_zone_t	*xfs_ili_zone;
extern xfs_zone_t	*xfs_inode_zone;

static unsigned int
libxfs_ihash(cache_key_t key, unsigned int hashsize)
{
	return ((unsigned int)*(xfs_ino_t *)key) % hashsize;
}

static int
libxfs_icompare(struct cache_node *node, cache_key_t key)
{
	xfs_inode_t	*ip = (xfs_inode_t *)node;

	return (ip->i_ino == *(xfs_ino_t *)key);
}

int
libxfs_iget(xfs_mount_t *mp, xfs_trans_t *tp, xfs_ino_t ino, uint lock_flags,
		xfs_inode_t **ipp, xfs_daddr_t bno)
{
	xfs_inode_t	*ip;
	int		error = 0;

	if (cache_node_get(libxfs_icache, &ino, (struct cache_node **)&ip)) {
#ifdef INO_DEBUG
		fprintf(stderr, "%s: allocated inode, ino=%llu(%llu), %p\n",
			__FUNCTION__, (unsigned long long)ino, bno, ip);
#endif
		if ((error = libxfs_iread(mp, tp, ino, ip, bno))) {
			cache_node_purge(libxfs_icache, &ino,
					(struct cache_node *)ip);
			ip = NULL;
		}
	}
	*ipp = ip;
	return error;
}

void
libxfs_iput(xfs_inode_t *ip, uint lock_flags)
{
	cache_node_put((struct cache_node *)ip);
}

static struct cache_node *
libxfs_ialloc(void)
{
	return libxfs_zone_zalloc(xfs_inode_zone);
}

static void
libxfs_idestroy(xfs_inode_t *ip)
{
	switch (ip->i_d.di_mode & S_IFMT) {
		case S_IFREG:
		case S_IFDIR:
		case S_IFLNK:
			libxfs_idestroy_fork(ip, XFS_DATA_FORK);
			break;
	}
	if (ip->i_afp)
		libxfs_idestroy_fork(ip, XFS_ATTR_FORK);
}

static void
libxfs_irelse(struct cache_node *node)
{
	xfs_inode_t	*ip = (xfs_inode_t *)node;

	if (ip != NULL) {
		if (ip->i_itemp)
			libxfs_zone_free(xfs_ili_zone, ip->i_itemp);
		ip->i_itemp = NULL;
		libxfs_idestroy(ip);
		libxfs_zone_free(xfs_inode_zone, ip);
		ip = NULL;
	}
}

void
libxfs_icache_purge(void)
{
	cache_purge(libxfs_icache);
}

struct cache_operations libxfs_icache_operations = {
	/* .hash */	libxfs_ihash,
	/* .alloc */	libxfs_ialloc,
	/* .relse */	libxfs_irelse,
	/* .compare */	libxfs_icompare,
	/* .bulkrelse */ NULL
};
Commit	Line	Data
2bd0ea18	1	/*
f1b058f9	2	* Copyright (c) 2000-2006 Silicon Graphics, Inc.
da23017d	3	* All Rights Reserved.
2bd0ea18	4	*
da23017d NS	5	* This program is free software; you can redistribute it and/or
da23017d NS	6	* modify it under the terms of the GNU General Public License as
2bd0ea18 NS	7	* published by the Free Software Foundation.
2bd0ea18 NS	8	*
da23017d 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.
2bd0ea18	13	*
da23017d 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
1d7e80ee NS	19	#include <xfs/libxfs.h>
	20	#include <xfs/xfs_log.h>
	21	#include <xfs/xfs_log_priv.h>
1aef52f8	22	#include "init.h"
2bd0ea18	23
5000d01d	24	#define BDSTRAT_SIZE (256 * 1024)
3cc4d0db	25	#define min(x, y) ((x) < (y) ? (x) : (y))
2bd0ea18	26
f1b058f9 NS	27	static inline void *
	28	libxfs_memalign(size_t size)
	29	{
1aef52f8	30	static size_t memalignment;
f1b058f9	31
1aef52f8 MV	32	if (!memalignment)
	33	memalignment = platform_memalignment();
	34	return memalign(memalignment, size);
f1b058f9 NS	35	}
f1b058f9 NS	36
2bd0ea18 NS	37	void
	38	libxfs_device_zero(dev_t dev, xfs_daddr_t start, uint len)
	39	{
3cc4d0db NS	40	xfs_off_t start_offset, end_offset, offset;
3cc4d0db NS	41	ssize_t zsize, bytes;
2bd0ea18	42	char *z;
3cc4d0db	43	int fd;
2bd0ea18	44
3cc4d0db	45	zsize = min(BDSTRAT_SIZE, BBTOB(len));
f1b058f9	46	if ((z = libxfs_memalign(zsize)) == NULL) {
9440d84d NS	47	fprintf(stderr,
9440d84d NS	48	_("%s: %s can't memalign %d bytes: %s\n"),
7dfd8291	49	progname, __FUNCTION__, (int)zsize, strerror(errno));
2bd0ea18 NS	50	exit(1);
2bd0ea18 NS	51	}
3cc4d0db NS	52	memset(z, 0, zsize);
3cc4d0db NS	53
2bd0ea18	54	fd = libxfs_device_to_fd(dev);
cb5b3ef4	55	start_offset = LIBXFS_BBTOOFF64(start);
3cc4d0db NS	56
	57	if ((lseek64(fd, start_offset, SEEK_SET)) < 0) {
	58	fprintf(stderr, _("%s: %s seek to offset %llu failed: %s\n"),
7dfd8291 NS	59	progname, __FUNCTION__,
7dfd8291 NS	60	(unsigned long long)start_offset, strerror(errno));
3cc4d0db NS	61	exit(1);
	62	}
	63
cb5b3ef4	64	end_offset = LIBXFS_BBTOOFF64(start + len) - start_offset;
3cc4d0db NS	65	for (offset = 0; offset < end_offset; ) {
	66	bytes = min((ssize_t)(end_offset - offset), zsize);
	67	if ((bytes = write(fd, z, bytes)) < 0) {
	68	fprintf(stderr, _("%s: %s write failed: %s\n"),
9440d84d	69	progname, __FUNCTION__, strerror(errno));
2bd0ea18	70	exit(1);
3cc4d0db NS	71	} else if (bytes == 0) {
	72	fprintf(stderr, _("%s: %s not progressing?\n"),
	73	progname, __FUNCTION__);
	74	exit(1);
2bd0ea18	75	}
3cc4d0db	76	offset += bytes;
2bd0ea18 NS	77	}
	78	free(z);
	79	}
	80
989b74bc	81	static void unmount_record(void *p)
2bd0ea18	82	{
989b74bc	83	xlog_op_header_t op = (xlog_op_header_t )p;
5000d01d SL	84	/* the data section must be 32 bit size aligned */
	85	struct {
	86	__uint16_t magic;
	87	__uint16_t pad1;
	88	__uint32_t pad2; /* may as well make it 64 bits */
	89	} magic = { XLOG_UNMOUNT_TYPE, 0, 0 };
	90
989b74bc NS	91	memset(p, 0, BBSIZE);
	92	INT_SET(op->oh_tid, ARCH_CONVERT, 1);
	93	INT_SET(op->oh_len, ARCH_CONVERT, sizeof(magic));
	94	INT_SET(op->oh_clientid, ARCH_CONVERT, XFS_LOG);
	95	INT_SET(op->oh_flags, ARCH_CONVERT, XLOG_UNMOUNT_TRANS);
	96	INT_SET(op->oh_res2, ARCH_CONVERT, 0);
	97
	98	/* and the data for this op */
1552a820	99	memcpy((char *)p + sizeof(xlog_op_header_t), &magic, sizeof(magic));
989b74bc NS	100	}
	101
	102	static xfs_caddr_t next(xfs_caddr_t ptr, int offset, void *private)
	103	{
	104	xfs_buf_t buf = (xfs_buf_t )private;
	105
	106	if (XFS_BUF_COUNT(buf) < (int)(ptr - XFS_BUF_PTR(buf)) + offset)
	107	abort();
	108	return ptr + offset;
	109	}
	110
	111	int
	112	libxfs_log_clear(
	113	dev_t device,
	114	xfs_daddr_t start,
	115	uint length,
	116	uuid_t *fs_uuid,
	117	int version,
	118	int sunit,
	119	int fmt)
	120	{
	121	xfs_buf_t *buf;
	122	int len;
	123
2bd0ea18 NS	124	if (!device \|\| !fs_uuid)
2bd0ea18 NS	125	return -EINVAL;
5000d01d SL	126
	127	/* first zero the log */
	128	libxfs_device_zero(device, start, length);
	129
	130	/* then write a log record header */
989b74bc NS	131	len = ((version == 2) && sunit) ? BTOBB(sunit) : 2;
989b74bc NS	132	len = MAX(len, 2);
5000d01d	133	buf = libxfs_getbuf(device, start, len);
989b74bc NS	134	libxfs_log_header(XFS_BUF_PTR(buf),
989b74bc NS	135	fs_uuid, version, sunit, fmt, next, buf);
f1b058f9 NS	136	libxfs_writebufr(buf);
f1b058f9 NS	137	libxfs_putbuf(buf);
989b74bc NS	138	return 0;
989b74bc NS	139	}
5000d01d	140
989b74bc NS	141	int
	142	libxfs_log_header(
	143	xfs_caddr_t caddr,
	144	uuid_t *fs_uuid,
	145	int version,
	146	int sunit,
	147	int fmt,
	148	libxfs_get_block_t *nextfunc,
	149	void *private)
	150	{
	151	xlog_rec_header_t head = (xlog_rec_header_t )caddr;
	152	xfs_caddr_t p = caddr;
	153	uint cycle_lsn;
	154	int i, len;
	155
	156	len = ((version == 2) && sunit) ? BTOBB(sunit) : 1;
5000d01d SL	157
	158	/* note that oh_tid actually contains the cycle number
	159	* and the tid is stored in h_cycle_data[0] - that's the
	160	* way things end up on disk.
	161	*/
989b74bc	162	memset(p, 0, BBSIZE);
5000d01d SL	163	INT_SET(head->h_magicno, ARCH_CONVERT, XLOG_HEADER_MAGIC_NUM);
	164	INT_SET(head->h_cycle, ARCH_CONVERT, 1);
	165	INT_SET(head->h_version, ARCH_CONVERT, version);
73bf5988	166	if (len != 1)
5000d01d	167	INT_SET(head->h_len, ARCH_CONVERT, sunit - BBSIZE);
73bf5988	168	else
5000d01d SL	169	INT_SET(head->h_len, ARCH_CONVERT, 20);
	170	INT_SET(head->h_chksum, ARCH_CONVERT, 0);
	171	INT_SET(head->h_prev_block, ARCH_CONVERT, -1);
	172	INT_SET(head->h_num_logops, ARCH_CONVERT, 1);
	173	INT_SET(head->h_cycle_data[0], ARCH_CONVERT, 0xb0c0d0d0);
	174	INT_SET(head->h_fmt, ARCH_CONVERT, fmt);
73bf5988	175	INT_SET(head->h_size, ARCH_CONVERT, XLOG_HEADER_CYCLE_SIZE);
5000d01d	176
46eca962 NS	177	ASSIGN_ANY_LSN_DISK(head->h_lsn, 1, 0);
46eca962 NS	178	ASSIGN_ANY_LSN_DISK(head->h_tail_lsn, 1, 0);
5000d01d	179
6699422d	180	memcpy(&head->h_fs_uuid, fs_uuid, sizeof(uuid_t));
73bf5988	181
989b74bc NS	182	len = MAX(len, 2);
	183	p = nextfunc(p, BBSIZE, private);
	184	unmount_record(p);
73bf5988	185
46eca962	186	cycle_lsn = CYCLE_LSN_DISK(head->h_lsn);
989b74bc NS	187	for (i = 2; i < len; i++) {
	188	p = nextfunc(p, BBSIZE, private);
	189	memset(p, 0, BBSIZE);
	190	(uint )p = cycle_lsn;
73bf5988	191	}
5000d01d	192
989b74bc	193	return BBTOB(len);
2bd0ea18 NS	194	}
2bd0ea18 NS	195
f1b058f9 NS	196	xfs_buf_t *
	197	libxfs_getsb(xfs_mount_t *mp, int flags)
	198	{
	199	return libxfs_readbuf(mp->m_dev, XFS_SB_DADDR,
	200	XFS_FSS_TO_BB(mp, 1), flags);
	201	}
	202
989b74bc	203
2bd0ea18	204	/*
f1b058f9	205	* Simple I/O (buffer cache) interface
2bd0ea18 NS	206	*/
2bd0ea18 NS	207
f1b058f9 NS	208	xfs_zone_t *xfs_buf_zone;
	209
	210	typedef struct {
	211	dev_t device;
	212	xfs_daddr_t blkno;
	213	unsigned int count;
	214	} xfs_bufkey_t;
	215
	216	static unsigned int
	217	libxfs_bhash(cache_key_t key, unsigned int hashsize)
	218	{
	219	return ((unsigned int)((xfs_bufkey_t *)key)->blkno) % hashsize;
	220	}
	221
	222	static int
	223	libxfs_bcompare(struct cache_node *node, cache_key_t key)
	224	{
	225	xfs_buf_t bp = (xfs_buf_t )node;
	226	xfs_bufkey_t bkey = (xfs_bufkey_t )key;
	227
	228	#ifdef IO_BCOMPARE_CHECK
	229	if (bp->b_dev == bkey->device &&
	230	bp->b_blkno == bkey->blkno &&
	231	bp->b_bcount != bkey->count)
	232	fprintf(stderr, "Badness in key lookup (length)\n"
	233	"bp=(bno %llu, len %u bb) key=(bno %llu, len %u bbs)\n",
	234	(unsigned long long)bp->b_blkno, (int)bp->b_bcount,
	235	(unsigned long long)bkey->blkno, (int)bkey->count);
	236	#endif
	237
	238	return (bp->b_dev == bkey->device &&
	239	bp->b_blkno == bkey->blkno &&
	240	bp->b_bcount == bkey->count);
	241	}
	242
	243	void
	244	libxfs_bprint(xfs_buf_t *bp)
	245	{
	246	fprintf(stderr, "Buffer 0x%p blkno=%llu bytes=%u flags=0x%x count=%u\n",
	247	bp, (unsigned long long)bp->b_blkno, (unsigned)bp->b_bcount,
	248	bp->b_flags, bp->b_node.cn_count);
	249	}
	250
2bd0ea18 NS	251	xfs_buf_t *
	252	libxfs_getbuf(dev_t device, xfs_daddr_t blkno, int len)
	253	{
f1b058f9 NS	254	xfs_buf_t *bp;
	255	xfs_bufkey_t key;
	256	unsigned int bytes = BBTOB(len);
2bd0ea18	257
f1b058f9 NS	258	key.device = device;
	259	key.blkno = blkno;
	260	key.count = bytes;
	261
	262	if (cache_node_get(libxfs_bcache, &key, (struct cache_node **)&bp)) {
2bd0ea18	263	#ifdef IO_DEBUG
f1b058f9	264	fprintf(stderr, "%s: allocated buffer, key=%llu(%llu), %p\n",
cb5b3ef4	265	__FUNCTION__, BBTOB(len), LIBXFS_BBTOOFF64(blkno), blkno, buf);
2bd0ea18	266	#endif
f1b058f9 NS	267	bp->b_flags = 0;
	268	bp->b_blkno = blkno;
	269	bp->b_bcount = bytes;
	270	bp->b_dev = device;
	271	if (!(bp->b_addr = libxfs_memalign(bytes))) {
	272	fprintf(stderr,
	273	_("%s: %s can't memalign %d bytes: %s\n"),
	274	progname, __FUNCTION__, (int)bytes,
	275	strerror(errno));
	276	exit(1);
	277	}
	278	}
	279	return bp;
	280	}
	281
	282	void
	283	libxfs_putbuf(xfs_buf_t *bp)
	284	{
	285	cache_node_put((struct cache_node *)bp);
	286	}
	287
	288	void
	289	libxfs_purgebuf(xfs_buf_t *bp)
	290	{
	291	xfs_bufkey_t key;
	292
	293	key.device = bp->b_dev;
	294	key.blkno = bp->b_blkno;
	295	key.count = bp->b_bcount;
	296
	297	cache_node_purge(libxfs_bcache, &key, (struct cache_node *)bp);
	298	}
2bd0ea18	299
f1b058f9 NS	300	static struct cache_node *
	301	libxfs_balloc(void)
	302	{
	303	return libxfs_zone_zalloc(xfs_buf_zone);
2bd0ea18 NS	304	}
	305
	306	int
f1b058f9	307	libxfs_readbufr(dev_t dev, xfs_daddr_t blkno, xfs_buf_t *bp, int len, int flags)
2bd0ea18 NS	308	{
2bd0ea18 NS	309	int fd = libxfs_device_to_fd(dev);
f1b058f9	310	int bytes = BBTOB(len);
2bd0ea18	311
f1b058f9	312	ASSERT(BBTOB(len) <= bp->b_bcount);
2bd0ea18	313
cb5b3ef4	314	if (pread64(fd, bp->b_addr, bytes, LIBXFS_BBTOOFF64(blkno)) < 0) {
9440d84d	315	fprintf(stderr, _("%s: read failed: %s\n"),
2bd0ea18	316	progname, strerror(errno));
9440d84d	317	if (flags & LIBXFS_EXIT_ON_FAILURE)
2bd0ea18 NS	318	exit(1);
	319	return errno;
	320	}
	321	#ifdef IO_DEBUG
	322	fprintf(stderr, "readbufr read %ubytes, blkno=%llu(%llu), %p\n",
cb5b3ef4	323	bytes, LIBXFS_BBTOOFF64(blkno), blkno, bp);
2bd0ea18	324	#endif
f1b058f9 NS	325	if (bp->b_dev == dev &&
	326	bp->b_blkno == blkno &&
	327	bp->b_bcount == bytes)
	328	bp->b_flags \|= LIBXFS_B_UPTODATE;
2bd0ea18 NS	329	return 0;
	330	}
	331
	332	xfs_buf_t *
9440d84d	333	libxfs_readbuf(dev_t dev, xfs_daddr_t blkno, int len, int flags)
2bd0ea18	334	{
f1b058f9	335	xfs_buf_t *bp;
2bd0ea18 NS	336	int error;
2bd0ea18 NS	337
f1b058f9 NS	338	bp = libxfs_getbuf(dev, blkno, len);
	339	if (!(bp->b_flags & (LIBXFS_B_UPTODATE\|LIBXFS_B_DIRTY))) {
	340	error = libxfs_readbufr(dev, blkno, bp, len, flags);
	341	if (error) {
	342	libxfs_putbuf(bp);
	343	return NULL;
	344	}
2bd0ea18	345	}
f1b058f9	346	return bp;
2bd0ea18 NS	347	}
	348
	349	int
f1b058f9	350	libxfs_writebufr(xfs_buf_t *bp)
2bd0ea18 NS	351	{
2bd0ea18 NS	352	int sts;
f1b058f9	353	int fd = libxfs_device_to_fd(bp->b_dev);
2bd0ea18	354
cb5b3ef4	355	sts = pwrite64(fd, bp->b_addr, bp->b_bcount, LIBXFS_BBTOOFF64(bp->b_blkno));
2bd0ea18	356	if (sts < 0) {
9440d84d	357	fprintf(stderr, _("%s: pwrite64 failed: %s\n"),
2bd0ea18	358	progname, strerror(errno));
f1b058f9	359	if (bp->b_flags & LIBXFS_B_EXIT)
2bd0ea18 NS	360	exit(1);
	361	return errno;
	362	}
f1b058f9	363	else if (sts != bp->b_bcount) {
9440d84d	364	fprintf(stderr, _("%s: error - wrote only %d of %d bytes\n"),
f1b058f9 NS	365	progname, sts, bp->b_bcount);
f1b058f9 NS	366	if (bp->b_flags & LIBXFS_B_EXIT)
2bd0ea18 NS	367	exit(1);
	368	return EIO;
	369	}
f1b058f9 NS	370	#ifdef IO_DEBUG
f1b058f9 NS	371	fprintf(stderr, "writebufr wrote %ubytes, blkno=%llu(%llu), %p\n",
cb5b3ef4	372	bp->b_bcount, LIBXFS_BBTOOFF64(bp->b_blkno), bp->b_blkno, bp);
f1b058f9 NS	373	#endif
	374	bp->b_flags \|= LIBXFS_B_UPTODATE;
	375	bp->b_flags &= ~(LIBXFS_B_DIRTY \| LIBXFS_B_EXIT);
2bd0ea18 NS	376	return 0;
	377	}
	378
	379	int
f1b058f9	380	libxfs_writebuf_int(xfs_buf_t *bp, int flags)
2bd0ea18	381	{
f1b058f9 NS	382	bp->b_flags \|= (LIBXFS_B_DIRTY \| flags);
	383	return 0;
	384	}
	385
	386	int
	387	libxfs_writebuf(xfs_buf_t *bp, int flags)
	388	{
	389	bp->b_flags \|= (LIBXFS_B_DIRTY \| flags);
	390	libxfs_putbuf(bp);
	391	return 0;
2bd0ea18 NS	392	}
2bd0ea18 NS	393
57c9fccb	394	void
f1b058f9	395	libxfs_iomove(xfs_buf_t bp, uint boff, int len, void data, int flags)
57c9fccb	396	{
f1b058f9 NS	397	#ifdef IO_DEBUG
	398	if (boff + len > bp->b_bcount) {
	399	fprintf(stderr, "Badness, iomove out of range!\n"
	400	"bp=(bno %llu, bytes %u) range=(boff %u, bytes %u)\n",
	401	bp->b_blkno, bp->b_bcount, boff, len);
57c9fccb	402	abort();
f1b058f9 NS	403	}
f1b058f9 NS	404	#endif
57c9fccb NS	405	switch (flags) {
57c9fccb NS	406	case LIBXFS_BZERO:
f1b058f9	407	memset(bp->b_addr + boff, 0, len);
57c9fccb NS	408	break;
57c9fccb NS	409	case LIBXFS_BREAD:
f1b058f9	410	memcpy(data, bp->b_addr + boff, len);
57c9fccb NS	411	break;
57c9fccb NS	412	case LIBXFS_BWRITE:
f1b058f9	413	memcpy(bp->b_addr + boff, data, len);
57c9fccb NS	414	break;
	415	}
	416	}
	417
f1b058f9 NS	418	static void
f1b058f9 NS	419	libxfs_brelse(struct cache_node *node)
2bd0ea18	420	{
f1b058f9 NS	421	xfs_buf_t bp = (xfs_buf_t )node;
	422	xfs_buf_log_item_t *bip;
	423	extern xfs_zone_t *xfs_buf_item_zone;
	424
	425	if (bp != NULL) {
	426	if (bp->b_flags & LIBXFS_B_DIRTY)
	427	libxfs_writebufr(bp);
	428	bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
5000d01d SL	429	if (bip)
5000d01d SL	430	libxfs_zone_free(xfs_buf_item_zone, bip);
f1b058f9 NS	431	free(bp->b_addr);
	432	bp->b_addr = NULL;
	433	bp->b_flags = 0;
	434	free(bp);
	435	bp = NULL;
2bd0ea18 NS	436	}
	437	}
	438
f1b058f9 NS	439	void
	440	libxfs_bcache_purge(void)
	441	{
	442	cache_purge(libxfs_bcache);
	443	}
	444
	445	struct cache_operations libxfs_bcache_operations = {
	446	/* .hash */ libxfs_bhash,
	447	/* .alloc */ libxfs_balloc,
	448	/* .relse */ libxfs_brelse,
	449	/* .compare */ libxfs_bcompare,
1c4110bd	450	/* .bulkrelse / NULL / TODO: lio_listio64 interface? */
f1b058f9 NS	451	};
f1b058f9 NS	452
2bd0ea18 NS	453
	454	/*
	455	* Simple memory interface
	456	*/
	457
	458	xfs_zone_t *
	459	libxfs_zone_init(int size, char *name)
	460	{
	461	xfs_zone_t *ptr;
	462
	463	if ((ptr = malloc(sizeof(xfs_zone_t))) == NULL) {
9440d84d	464	fprintf(stderr, _("%s: zone init failed (%s, %d bytes): %s\n"),
5b64e00a	465	progname, name, (int)sizeof(xfs_zone_t), strerror(errno));
2bd0ea18 NS	466	exit(1);
	467	}
	468	ptr->zone_unitsize = size;
	469	ptr->zone_name = name;
	470	#ifdef MEM_DEBUG
5000d01d	471	ptr->allocated = 0;
2bd0ea18 NS	472	fprintf(stderr, "new zone %p for \"%s\", size=%d\n", ptr, name, size);
	473	#endif
	474	return ptr;
	475	}
	476
	477	void *
	478	libxfs_zone_zalloc(xfs_zone_t *z)
	479	{
	480	void *ptr;
	481
2bd0ea18	482	if ((ptr = calloc(z->zone_unitsize, 1)) == NULL) {
9440d84d	483	fprintf(stderr, _("%s: zone calloc failed (%s, %d bytes): %s\n"),
2bd0ea18 NS	484	progname, z->zone_name, z->zone_unitsize,
	485	strerror(errno));
	486	exit(1);
	487	}
	488	#ifdef MEM_DEBUG
5000d01d SL	489	z->allocated++;
	490	fprintf(stderr, "## zone alloc'd item %p from %s (%d bytes) (%d active)\n",
	491	ptr, z->zone_name, z->zone_unitsize,
	492	z->allocated);
2bd0ea18 NS	493	#endif
	494	return ptr;
	495	}
	496
	497	void
	498	libxfs_zone_free(xfs_zone_t z, void ptr)
	499	{
	500	#ifdef MEM_DEBUG
5000d01d SL	501	z->allocated--;
	502	fprintf(stderr, "## zone freed item %p from %s (%d bytes) (%d active)\n",
	503	ptr, z->zone_name, z->zone_unitsize,
	504	z->allocated);
2bd0ea18 NS	505	#endif
	506	if (ptr != NULL) {
	507	free(ptr);
	508	ptr = NULL;
	509	}
	510	}
	511
	512	void *
	513	libxfs_malloc(size_t size)
	514	{
	515	void *ptr;
	516
044fe078	517	if ((ptr = calloc(1, size)) == NULL) {
9440d84d	518	fprintf(stderr, _("%s: calloc failed (%d bytes): %s\n"),
5b64e00a	519	progname, (int)size, strerror(errno));
2bd0ea18 NS	520	exit(1);
	521	}
	522	#ifdef MEM_DEBUG
f1b058f9	523	fprintf(stderr, "## calloc'd item %p size %d bytes\n", ptr, size);
2bd0ea18 NS	524	#endif
	525	return ptr;
	526	}
	527
	528	void
	529	libxfs_free(void *ptr)
	530	{
	531	#ifdef MEM_DEBUG
f1b058f9	532	fprintf(stderr, "## freed item %p\n", ptr);
2bd0ea18 NS	533	#endif
	534	if (ptr != NULL) {
	535	free(ptr);
	536	ptr = NULL;
	537	}
	538	}
	539
	540	void *
	541	libxfs_realloc(void *ptr, size_t size)
	542	{
	543	#ifdef MEM_DEBUG
5000d01d	544	void *optr=ptr;
2bd0ea18 NS	545	#endif
2bd0ea18 NS	546	if ((ptr = realloc(ptr, size)) == NULL) {
9440d84d	547	fprintf(stderr, _("%s: realloc failed (%d bytes): %s\n"),
5b64e00a	548	progname, (int)size, strerror(errno));
2bd0ea18 NS	549	exit(1);
	550	}
	551	#ifdef MEM_DEBUG
5000d01d SL	552	fprintf(stderr, "## realloc'd item %p now %p size %d bytes\n",
5000d01d SL	553	optr, ptr, size);
2bd0ea18 NS	554	#endif
	555	return ptr;
	556	}
	557
	558
f1b058f9 NS	559	/*
	560	* Inode cache interfaces
	561	*/
	562
	563	extern xfs_zone_t *xfs_ili_zone;
	564	extern xfs_zone_t *xfs_inode_zone;
	565
	566	static unsigned int
	567	libxfs_ihash(cache_key_t key, unsigned int hashsize)
	568	{
	569	return ((unsigned int)(xfs_ino_t )key) % hashsize;
	570	}
	571
	572	static int
	573	libxfs_icompare(struct cache_node *node, cache_key_t key)
	574	{
	575	xfs_inode_t ip = (xfs_inode_t )node;
	576
	577	return (ip->i_ino == (xfs_ino_t )key);
	578	}
	579
2bd0ea18 NS	580	int
	581	libxfs_iget(xfs_mount_t mp, xfs_trans_t tp, xfs_ino_t ino, uint lock_flags,
	582	xfs_inode_t **ipp, xfs_daddr_t bno)
	583	{
	584	xfs_inode_t *ip;
f1b058f9	585	int error = 0;
2bd0ea18	586
f1b058f9 NS	587	if (cache_node_get(libxfs_icache, &ino, (struct cache_node **)&ip)) {
	588	#ifdef INO_DEBUG
	589	fprintf(stderr, "%s: allocated inode, ino=%llu(%llu), %p\n",
	590	__FUNCTION__, (unsigned long long)ino, bno, ip);
	591	#endif
	592	if ((error = libxfs_iread(mp, tp, ino, ip, bno))) {
	593	cache_node_purge(libxfs_icache, &ino,
	594	(struct cache_node *)ip);
	595	ip = NULL;
	596	}
	597	}
2bd0ea18	598	*ipp = ip;
f1b058f9	599	return error;
2bd0ea18 NS	600	}
2bd0ea18 NS	601
014e5f6d	602	void
f1b058f9 NS	603	libxfs_iput(xfs_inode_t *ip, uint lock_flags)
	604	{
	605	cache_node_put((struct cache_node *)ip);
	606	}
	607
	608	static struct cache_node *
	609	libxfs_ialloc(void)
	610	{
	611	return libxfs_zone_zalloc(xfs_inode_zone);
	612	}
	613
	614	static void
014e5f6d ES	615	libxfs_idestroy(xfs_inode_t *ip)
	616	{
	617	switch (ip->i_d.di_mode & S_IFMT) {
	618	case S_IFREG:
	619	case S_IFDIR:
	620	case S_IFLNK:
	621	libxfs_idestroy_fork(ip, XFS_DATA_FORK);
	622	break;
	623	}
	624	if (ip->i_afp)
	625	libxfs_idestroy_fork(ip, XFS_ATTR_FORK);
	626	}
	627
f1b058f9 NS	628	static void
f1b058f9 NS	629	libxfs_irelse(struct cache_node *node)
2bd0ea18	630	{
f1b058f9	631	xfs_inode_t ip = (xfs_inode_t )node;
2bd0ea18 NS	632
2bd0ea18 NS	633	if (ip != NULL) {
5000d01d SL	634	if (ip->i_itemp)
	635	libxfs_zone_free(xfs_ili_zone, ip->i_itemp);
	636	ip->i_itemp = NULL;
014e5f6d	637	libxfs_idestroy(ip);
2bd0ea18 NS	638	libxfs_zone_free(xfs_inode_zone, ip);
	639	ip = NULL;
	640	}
	641	}
	642
2bd0ea18	643	void
f1b058f9	644	libxfs_icache_purge(void)
2bd0ea18	645	{
f1b058f9	646	cache_purge(libxfs_icache);
2bd0ea18	647	}
f1b058f9 NS	648
	649	struct cache_operations libxfs_icache_operations = {
	650	/* .hash */ libxfs_ihash,
	651	/* .alloc */ libxfs_ialloc,
	652	/* .relse */ libxfs_irelse,
	653	/* .compare */ libxfs_icompare,
1c4110bd	654	/* .bulkrelse */ NULL
f1b058f9	655	};