/*****************************************************************************

******************************************************************************

**

**  gfs2_convert - convert a gfs1 filesystem into a gfs2 filesystem.

**

******************************************************************************

*****************************************************************************/

#include "clusterautoconfig.h"

#include <unistd.h>

#include <stdio.h>

#include <stdint.h>

#include <stdlib.h>

#include <libgen.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdarg.h>

#include <dirent.h>

#include <string.h>

#include <time.h>

#include <sys/time.h>

#include <errno.h>

#include <ctype.h>

#include <termios.h>

#include <libintl.h>

#include <locale.h>

#define _(String) gettext(String)

#include <linux/types.h>

#include <linux/gfs2_ondisk.h>

#include <logging.h>

#include "osi_list.h"

#include "copyright.cf"

#include "libgfs2.h"

/* The following declares are needed because gfs2 can't have  */

/* dependencies on gfs1:                                      */

#define RGRP_STUFFED_BLKS(sb) (((sb)->sb_bsize - sizeof(struct gfs2_rgrp)) * GFS2_NBBY)

#define RGRP_BITMAP_BLKS(sb) (((sb)->sb_bsize - sizeof(struct gfs2_meta_header)) * GFS2_NBBY)

/* Define some gfs1 constants from gfs1's gfs_ondisk.h */

#define GFS_METATYPE_NONE       (0)

#define GFS_METATYPE_SB         (1)    /* Super-Block */

#define GFS_METATYPE_RG         (2)    /* Resource Group Header */

#define GFS_METATYPE_RB         (3)    /* Resource Group Block Alloc BitBlock */

#define GFS_METATYPE_DI         (4)    /* "Disk" inode (dinode) */

#define GFS_METATYPE_IN         (5)    /* Indirect dinode block list */

#define GFS_METATYPE_LF         (6)    /* Leaf dinode block list */

#define GFS_METATYPE_JD         (7)    /* Journal Data */

#define GFS_METATYPE_LH         (8)    /* Log Header (gfs_log_header) */

#define GFS_METATYPE_LD         (9)    /* Log Descriptor (gfs_log_descriptor) */

#define GFS_METATYPE_EA         (10)   /* Extended Attribute */

#define GFS_METATYPE_ED         (11)   /* Extended Attribute data */

/* GFS1 Dinode types  */

#define GFS_FILE_NON            (0)

#define GFS_FILE_REG            (1)    /* regular file */

#define GFS_FILE_DIR            (2)    /* directory */

#define GFS_FILE_LNK            (5)    /* link */

#define GFS_FILE_BLK            (7)    /* block device node */

#define GFS_FILE_CHR            (8)    /* character device node */

#define GFS_FILE_FIFO           (101)  /* fifo/pipe */

#define GFS_FILE_SOCK           (102)  /* socket */

#define GFS_FORMAT_SB           (100)  /* Super-Block */

#define GFS_FORMAT_FS           (1309) /* Filesystem (all-encompassing) */

#define GFS_FORMAT_MULTI        (1401) /* Multi-Host */

#define DIV_RU(x, y) (((x) + (y) - 1) / (y))

struct inode_dir_block {

	osi_list_t list;

	uint64_t di_addr;

	uint64_t di_paddr; /* Parent dir inode addr */

};

struct inode_block {

	osi_list_t list;

	uint64_t di_addr;

};

struct blocklist {

	osi_list_t list;

	uint64_t block;

	struct metapath mp;

	int height;

	char *ptrbuf;

};

struct gfs2_options {

	char *device;

	unsigned int yes:1;

	unsigned int no:1;

	unsigned int query:1;

};

struct gfs_sb  raw_gfs1_ondisk_sb;

struct gfs2_sbd sb2;

struct inode_block dirs_to_fix;  /* linked list of directories to fix */

struct inode_dir_block cdpns_to_fix; /* linked list of cdpn symlinks */

int seconds;

struct timeval tv;

uint64_t dirs_fixed;

uint64_t cdpns_fixed;

uint64_t dirents_fixed;

struct gfs_jindex *sd_jindex = NULL;    /* gfs1 journal index in memory */

int gfs2_inptrs;

uint64_t gfs2_heightsize[GFS2_MAX_META_HEIGHT];

uint64_t gfs2_jheightsize[GFS2_MAX_META_HEIGHT];

uint32_t gfs2_max_height;

uint32_t gfs2_max_jheight;

uint64_t jindex_addr = 0, rindex_addr = 0;

int print_level = MSG_NOTICE;

unsigned orig_journals = 0;

/* ------------------------------------------------------------------------- */

/* This function is for libgfs's sake.                                       */

/* ------------------------------------------------------------------------- */

void print_it(const char *label, const char *fmt, const char *fmt2, ...)

{

	va_list args;

	va_start(args, fmt2);

	printf("%s: ", label);

	vprintf(fmt, args);

	va_end(args);

}

/* ------------------------------------------------------------------------- */

/* convert_bitmaps - Convert gfs1 bitmaps to gfs2 bitmaps.                   */

/*                   Fixes all unallocated metadata bitmap states (which are */

/*                   valid in gfs1 but invalid in gfs2).                     */

/* ------------------------------------------------------------------------- */

static void convert_bitmaps(struct gfs2_sbd *sdp, struct rgrp_tree *rg)

{

	uint32_t blk;

	int x, y;

	struct gfs2_rindex *ri;

	unsigned char state;

	ri = &rg->ri;

	for (blk = 0; blk < ri->ri_length; blk++) {

		struct gfs2_bitmap *bi;

		x = (blk) ? sizeof(struct gfs2_meta_header) :

			sizeof(struct gfs2_rgrp);

		bi = &rg->bits[blk];

		for (; x < sdp->bsize; x++)

			for (y = 0; y < GFS2_NBBY; y++) {

				state = (bi->bi_bh->b_data[x] >>

					 (GFS2_BIT_SIZE * y)) & 0x03;

				if (state == 0x02) {/* unallocated metadata state invalid */

					bi->bi_bh->b_data[x] &= ~(0x02 << (GFS2_BIT_SIZE * y));

					bmodified(bi->bi_bh);

				}

			}

	}

}/* convert_bitmaps */

/* ------------------------------------------------------------------------- */

/* convert_rgs - Convert gfs1 resource groups to gfs2.                       */

/* Returns: 0 on success, -1 on failure                                      */

/* ------------------------------------------------------------------------- */

static int convert_rgs(struct gfs2_sbd *sbp)

{

	struct rgrp_tree *rgd;

	struct osi_node *n, *next = NULL;

	struct gfs_rgrp *rgd1;

	int rgs = 0;

	/* --------------------------------- */

	/* Now convert its rgs into gfs2 rgs */

	/* --------------------------------- */

	for (n = osi_first(&sbp->rgtree); n; n = next) {

		next = osi_next(n);

		rgd = (struct rgrp_tree *)n;

		rgd1 = (struct gfs_rgrp *)&rgd->rg; /* recast as gfs1 structure */

		/* rg_freemeta is a gfs1 structure, so libgfs2 doesn't know to */

		/* convert from be to cpu. We must do it now. */

		rgd->rg.rg_free = rgd1->rg_free + be32_to_cpu(rgd1->rg_freemeta);

		/* Zero it out so we don't add it again in case something breaks */

		/* later on in the process and we have to re-run convert */

		rgd1->rg_freemeta = 0;

		sbp->blks_total += rgd->ri.ri_data;

		sbp->blks_alloced += (rgd->ri.ri_data - rgd->rg.rg_free);

		sbp->dinodes_alloced += rgd1->rg_useddi;

		convert_bitmaps(sbp, rgd);

		/* Write the updated rgrp to the gfs2 buffer */

		gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_bh->b_data);

		bmodified(rgd->bits[0].bi_bh);

		rgs++;

		if (rgs % 100 == 0) {

			printf(".");

			fflush(stdout);

		}

	}

	return 0;

}/* superblock_cvt */

/* ------------------------------------------------------------------------- */

/* calc_gfs2_tree_height - calculate new dinode height as if this is gfs2    */

/*                                                                           */

/* This is similar to calc_tree_height in libgfs2 but at the point this      */

/* function is called, I have the wrong (gfs1 not gfs2) constants in place.  */

/* ------------------------------------------------------------------------- */

static unsigned int calc_gfs2_tree_height(struct gfs2_inode *ip, uint64_t size)

{

	uint64_t *arr;

	unsigned int max, height;

	if (ip->i_di.di_size > size)

		size = ip->i_di.di_size;

	if (S_ISDIR(ip->i_di.di_mode)) {

		arr = gfs2_jheightsize;

		max = gfs2_max_jheight;

	} else {

		arr = gfs2_heightsize;

		max = gfs2_max_height;

	}

	for (height = 0; height < max; height++)

		if (arr[height] >= size)

			break;

	/* If calc_gfs2_tree_height was called, the dinode is not stuffed or

	   we would have returned before this point. After the call, a call is

	   made to fix_metatree, which unstuffs the dinode. Therefore, the

	   smallest height that can result after this call is 1. */

	if (!height)

		height = 1;

	return height;

}

/* ------------------------------------------------------------------------- */

/* mp_gfs1_to_gfs2 - convert a gfs1 metapath to a gfs2 metapath.             */

/* ------------------------------------------------------------------------- */

static void mp_gfs1_to_gfs2(struct gfs2_sbd *sbp, int gfs1_h, int gfs2_h,

		     struct metapath *gfs1mp, struct metapath *gfs2mp)

{

	uint64_t lblock;

	int h;

	uint64_t gfs1factor[GFS2_MAX_META_HEIGHT];

	uint64_t gfs2factor[GFS2_MAX_META_HEIGHT];

	/* figure out multiplication factors for each height - gfs1 */

	memset(&gfs1factor, 0, sizeof(gfs1factor));

	gfs1factor[gfs1_h - 1] = 1ull;

	for (h = gfs1_h - 1; h > 0; h--)

		gfs1factor[h - 1] = gfs1factor[h] * sbp->sd_inptrs;

	/* figure out multiplication factors for each height - gfs2 */

	memset(&gfs2factor, 0, sizeof(gfs2factor));

	gfs2factor[gfs2_h - 1] = 1ull;

	for (h = gfs2_h - 1; h > 0; h--)

		gfs2factor[h - 1] = gfs2factor[h] * gfs2_inptrs;

	/* Convert from gfs1 to a logical block */

	lblock = 0;

	for (h = 0; h < gfs1_h; h++)

		lblock += (gfs1mp->mp_list[h] * gfs1factor[h]);

	/* Convert from a logical block back to gfs2 */

	memset(gfs2mp, 0, sizeof(*gfs2mp));

	for (h = 0; h < gfs2_h; h++) {

		/* Can't use do_div here because the factors are too large. */

		gfs2mp->mp_list[h] = lblock / gfs2factor[h];

		lblock %= gfs2factor[h];

	}

}

/* ------------------------------------------------------------------------- */

/* fix_metatree - Fix up the metatree to match the gfs2 metapath info        */

/*                Similar to gfs2_writei in libgfs2 but we're only           */

/*                interested in rearranging the metadata while leaving the   */

/*                actual data blocks intact.                                 */

/* ------------------------------------------------------------------------- */

static void fix_metatree(struct gfs2_sbd *sbp, struct gfs2_inode *ip,

		  struct blocklist *blk, uint64_t *first_nonzero_ptr,

		  unsigned int size)

{

	uint64_t block;

	struct gfs2_buffer_head *bh;

	unsigned int amount, ptramt;

	int hdrsize, h, copied = 0, new;

	struct gfs2_meta_header mh;

	char *srcptr = (char *)first_nonzero_ptr;

	mh.mh_magic = GFS2_MAGIC;

	mh.mh_type = GFS2_METATYPE_IN;

	mh.mh_format = GFS2_FORMAT_IN;

	if (!ip->i_di.di_height)

		unstuff_dinode(ip);

	ptramt = blk->mp.mp_list[blk->height] * sizeof(uint64_t);

	amount = size;

	while (copied < size) {

		bh = ip->i_bh;

		/* First, build up the metatree */

		for (h = 0; h < blk->height; h++) {

			new = 0;

			lookup_block(ip, bh, h, &blk->mp, 1, &new, &block);

			if (bh != ip->i_bh)

				brelse(bh);

			if (!block)

				break;

			bh = bread(sbp, block);

			if (new)

				memset(bh->b_data, 0, sbp->bsize);

			gfs2_meta_header_out(&mh, bh->b_data);

			bmodified(bh);

		}

		hdrsize = blk->height ? sizeof(struct gfs2_meta_header) :

			sizeof(struct gfs2_dinode);

		if (amount > sbp->bsize - hdrsize - ptramt)

			amount = sbp->bsize - hdrsize - ptramt;

		memcpy(bh->b_data + hdrsize + ptramt, (char *)srcptr, amount);

		srcptr += amount;

		bmodified(bh);

		if (bh != ip->i_bh)

			brelse(bh);

		copied += amount;

		if (hdrsize + ptramt + amount >= sbp->bsize) {

			/* advance to the next metablock */

			blk->mp.mp_list[blk->height] +=

				(amount / sizeof(uint64_t));

			for (h = blk->height; h > 0; h--) {

				if (blk->mp.mp_list[h] >= gfs2_inptrs) {

					blk->mp.mp_list[h] = 0;

					blk->mp.mp_list[h - 1]++;

					continue;

				}

				break;

			}

		}

		amount = size - copied;

		ptramt = 0;

	}

}

/* ------------------------------------------------------------------------- */

/* adjust_indirect_blocks - convert all gfs_indirect blocks to gfs2.         */

/*                                                                           */

/* This function converts all gfs_indirect blocks to GFS2.  The difference   */

/* is that gfs1 indirect block has a 64-byte chunk of reserved space that    */

/* gfs2 does not.  Since GFS block locations (relative to the start of the   */

/* file have their locations defined by the offset from the end of the       */

/* structure, all block pointers must be shifted.                            */

/*                                                                           */

/* Stuffed inodes don't need to be shifted at since there are no indirect    */

/* blocks.  Inodes with height 1 don't need to be shifted either, because    */

/* the dinode size is the same between gfs and gfs2 (232 bytes), and         */

/* therefore you can fit the same number of block pointers after the dinode  */

/* structure.  For the normal 4K block size, that's 483 pointers.  For 1K    */

/* blocks, it's 99 pointers.                                                 */

/*                                                                           */

/* At height 2 things get complex.  GFS1 reserves an area of 64 (0x40) bytes */

/* at the start of the indirect block, so for 4K blocks, you can fit 501     */

/* pointers.  GFS2 doesn't reserve that space, so you can fit 509 pointers.  */

/* For 1K blocks, it's 117 pointers in GFS1 and 125 in GFS2.                 */

/*                                                                           */

/* That means, for example, that if you have 4K blocks, a 946MB file will    */

/* require a height of 3 for GFS, but only a height of 2 for GFS2.           */

/* There isn't a good way to shift the pointers around from one height to    */

/* another, so the only way to do it is to rebuild all those indirect blocks */

/* from empty ones.                                                          */

/*                                                                           */

/* For example, with a 1K block size, if you do:                             */

/*                                                                           */

/* dd if=/mnt/gfs/big of=/tmp/tocompare skip=496572346368 bs=1024 count=1    */

/*                                                                           */

/* the resulting metadata paths will look vastly different for the data:     */

/*                                                                           */

/* height    0     1     2     3     4     5                                 */

/* GFS1:  0x16  0x4b  0x70  0x11  0x5e  0x48                                 */

/* GFS2:  0x10  0x21  0x78  0x05  0x14  0x76                                 */

/*                                                                           */

/* To complicate matters, we can't really require free space.  A user might  */

/* be trying to migrate a "full" gfs1 file system to GFS2.  After we         */

/* convert the journals to GFS2, we might have more free space, so we can    */

/* allocate blocks at that time.                                             */

/*                                                                           */

/* Assumes: GFS1 values are in place for diptrs and inptrs.                  */

/*                                                                           */

/* Returns: 0 on success, -1 on failure                                      */

/*                                                                           */

/* Adapted from fsck.gfs2 metawalk.c's build_and_check_metalist              */

/* ------------------------------------------------------------------------- */

static void jdata_mp_gfs1_to_gfs2(struct gfs2_sbd *sbp, int gfs1_h, int gfs2_h,

			   struct metapath *gfs1mp, struct metapath *gfs2mp,

			   unsigned int *len, uint64_t dinode_size)

{

	uint64_t offset;

	int h;

	uint64_t gfs1factor[GFS2_MAX_META_HEIGHT];

	uint64_t gfs2factor[GFS2_MAX_META_HEIGHT];

	/* figure out multiplication factors for each height - gfs1 */

	memset(&gfs1factor, 0, sizeof(gfs1factor));

	gfs1factor[gfs1_h - 1] = sbp->bsize - sizeof(struct gfs2_meta_header);

	for (h = gfs1_h - 1; h > 0; h--)

		gfs1factor[h - 1] = gfs1factor[h] * sbp->sd_inptrs;

	/* figure out multiplication factors for each height - gfs2 */

	memset(&gfs2factor, 0, sizeof(gfs2factor));

	gfs2factor[gfs2_h] = 1ull;

	gfs2factor[gfs2_h - 1] = sbp->bsize;

	for (h = gfs2_h - 1; h > 0; h--)

		gfs2factor[h - 1] = gfs2factor[h] * gfs2_inptrs;

	/* Convert from gfs1 to an offset */

	offset = 0;

	for (h = 0; h < gfs1_h; h++)

		offset += (gfs1mp->mp_list[h] * gfs1factor[h]);

	if (dinode_size - offset < *len)

		*len = dinode_size - offset;

	/* Convert from an offset back to gfs2 */

	memset(gfs2mp, 0, sizeof(*gfs2mp));

	for (h = 0; h <= gfs2_h; h++) {

		/* Can't use do_div here because the factors are too large. */

		gfs2mp->mp_list[h] = offset / gfs2factor[h];

		offset %= gfs2factor[h];

	}

}

static uint64_t fix_jdatatree(struct gfs2_sbd *sbp, struct gfs2_inode *ip,

			      struct blocklist *blk, char *srcptr,

			      unsigned int size)

{

	uint64_t block;

	struct gfs2_buffer_head *bh;

	unsigned int amount, ptramt;

	int h, copied = 0, new = 0;

	struct gfs2_meta_header mh;

	mh.mh_magic = GFS2_MAGIC;

	mh.mh_type = GFS2_METATYPE_IN;

	mh.mh_format = GFS2_FORMAT_IN;

	if (!ip->i_di.di_height)

		unstuff_dinode(ip);

	ptramt = blk->mp.mp_list[blk->height];

	amount = size;

	while (copied < size) {

		bh = ip->i_bh;

		/* First, build up the metatree */

		for (h = 0; h < blk->height; h++) {

			new = 0;

			lookup_block(ip, bh, h, &blk->mp, 1, &new, &block);

			if (bh != ip->i_bh)

				brelse(bh);

			if (!block)

				break;

			bh = bread(sbp, block);

			if (new)

				memset(bh->b_data, 0, sbp->bsize);

			if (h < (blk->height - 1)) {

				gfs2_meta_header_out(&mh, bh->b_data);

				bmodified(bh);

			}

		}

		if (amount > sbp->bsize - ptramt)

			amount = sbp->bsize - ptramt;

		memcpy(bh->b_data + ptramt, (char *)srcptr, amount);

		srcptr += amount;

		bmodified(bh);

		if (bh != ip->i_bh)

			brelse(bh);

		copied += amount;

		if (ptramt + amount >= sbp->bsize) {

			/* advance to the next metablock */

			blk->mp.mp_list[blk->height] += amount;

			for (h = blk->height; h > 0; h--) {

				if (blk->mp.mp_list[h] >= gfs2_inptrs) {

					blk->mp.mp_list[h] = 0;

					blk->mp.mp_list[h - 1]++;

					continue;

				}

				break;

			}

		}

		amount = size - copied;

		ptramt = 0;

	}

	return block;

}

static int get_inode_metablocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip, struct blocklist *blocks)

{

	struct blocklist *blk, *newblk;

	struct gfs2_buffer_head *bh, *dibh = ip->i_bh;

	osi_list_t *tmp;

	uint64_t *ptr1, block;

	int h, ptrnum;

	int bufsize = sbp->bsize - sizeof(struct gfs_indirect);

	/* Add dinode block to the list */

	blk = malloc(sizeof(struct blocklist));

	if (!blk) {

		log_crit(_("Error: Can't allocate memory for indirect block fix\n"));

		return -1;

	}

	memset(blk, 0, sizeof(*blk));

	blk->block = dibh->b_blocknr;

	blk->ptrbuf = malloc(bufsize);

	if (!blk->ptrbuf) {

		log_crit(_("Error: Can't allocate memory"

			 " for file conversion.\n"));

		free(blk);

		return -1;

	}

	memset(blk->ptrbuf, 0, bufsize);

	/* Fill in the pointers from the dinode buffer */

	memcpy(blk->ptrbuf, dibh->b_data + sizeof(struct gfs_dinode),

	       sbp->bsize - sizeof(struct gfs_dinode));

	/* Zero out the pointers so we can fill them in later. */

	memset(dibh->b_data + sizeof(struct gfs_dinode), 0,

	       sbp->bsize - sizeof(struct gfs_dinode));

	osi_list_add_prev(&blk->list, &blocks->list);

	/* Now run the metadata chain and build lists of all metadata blocks */

	osi_list_foreach(tmp, &blocks->list) {

		blk = osi_list_entry(tmp, struct blocklist, list);

		if (blk->height >= ip->i_di.di_height - 1)

			continue;

		for (ptr1 = (uint64_t *)blk->ptrbuf, ptrnum = 0;

		     ptrnum < sbp->sd_inptrs; ptr1++, ptrnum++) {

			if (!*ptr1)

				continue;

			block = be64_to_cpu(*ptr1);

			newblk = malloc(sizeof(struct blocklist));

			if (!newblk) {

				log_crit(_("Error: Can't allocate memory for indirect block fix.\n"));

				return -1;

			}

			memset(newblk, 0, sizeof(*newblk));

			newblk->ptrbuf = malloc(bufsize);

			if (!newblk->ptrbuf) {

				/* FIXME: This message should be different, to not conflit with the above file conversion */

				log_crit(_("Error: Can't allocate memory for file conversion.\n"));

				free(newblk);

				return -1;

			}

			memset(newblk->ptrbuf, 0, bufsize);

			newblk->block = block;

			newblk->height = blk->height + 1;

			/* Build the metapointer list from our predecessors */

			for (h = 0; h < blk->height; h++)

				newblk->mp.mp_list[h] = blk->mp.mp_list[h];

			newblk->mp.mp_list[h] = ptrnum;

			/* Queue it to be processed later on in the loop. */

			osi_list_add_prev(&newblk->list, &blocks->list);

			/* read the new metadata block's pointers */

			bh = bread(sbp, block);

			memcpy(newblk->ptrbuf, bh->b_data + sizeof(struct gfs_indirect), bufsize);

			/* Zero the buffer so we can fill it in later */

			memset(bh->b_data + sizeof(struct gfs_indirect), 0, bufsize);

			bmodified(bh);

			brelse(bh);

			/* Free the block so we can reuse it. This allows us to

			   convert a "full" file system. */

			ip->i_di.di_blocks--;

			gfs2_free_block(sbp, block);

		}

	}

	return 0;

}

static int fix_ind_reg_or_dir(struct gfs2_sbd *sbp, struct gfs2_inode *ip, uint32_t di_height,

		       uint32_t gfs2_hgt, struct blocklist *blk, struct blocklist *blocks)

{

	unsigned int len, bufsize;

	uint64_t *ptr1, *ptr2;

	int ptrnum;

	struct metapath gfs2mp;

	bufsize = sbp->bsize - sizeof(struct gfs_indirect);

	len = bufsize;

	/* Skip zero pointers at the start of the buffer.  This may 

	   seem pointless, but the gfs1 blocks won't align with the 

	   gfs2 blocks.  That means that a single block write of 

	   gfs1's pointers is likely to span two blocks on gfs2. 

	   That's a problem if the file system is full. 

	   So I'm trying to truncate the data at the start and end 

	   of the buffers (i.e. write only what we need to). */

	for (ptr1 = (uint64_t *)blk->ptrbuf, ptrnum = 0;

	     ptrnum < sbp->sd_inptrs; ptr1++, ptrnum++) {

		if (*ptr1 != 0x00)

			break;

		len -= sizeof(uint64_t);

	}

	/* Skip zero bytes at the end of the buffer */

	ptr2 = (uint64_t *)(blk->ptrbuf + bufsize) - 1;

	while (len > 0 && *ptr2 == 0) {

		ptr2--;

		len -= sizeof(uint64_t);

	}

	blk->mp.mp_list[di_height - 1] = ptrnum;

	mp_gfs1_to_gfs2(sbp, di_height, gfs2_hgt, &blk->mp, &gfs2mp);

	memcpy(&blk->mp, &gfs2mp, sizeof(struct metapath));

	blk->height -= di_height - gfs2_hgt;

	if (len) {

		fix_metatree(sbp, ip, blk, ptr1, len);

		ip->i_di.di_goal_meta = be64_to_cpu(*ptr2);

	}

	return 0;

}

static int fix_ind_jdata(struct gfs2_sbd *sbp, struct gfs2_inode *ip, uint32_t di_height, 

		  uint32_t gfs2_hgt, uint64_t dinode_size, struct blocklist *blk, 

		  struct blocklist *blocks)

{

	/*FIXME: Messages here should be different, to not conflit with messages in get_inode_metablocks */

	struct blocklist *newblk;

	unsigned int len, bufsize;

	uint64_t *ptr1, block;

	int ptrnum, h;

	struct metapath gfs2mp;

	struct gfs2_buffer_head *bh;

	bufsize = sbp->bsize - sizeof(struct gfs2_meta_header);

	/*

	 * For each metadata block that holds jdata block pointers,

	 * get the blk pointers and copy them block by block

	 */

	for (ptr1 = (uint64_t *) blk->ptrbuf, ptrnum = 0;

	     ptrnum < sbp->sd_inptrs; ptr1++, ptrnum++) {

		if (!*ptr1)

			continue;

		block = be64_to_cpu(*ptr1);

		newblk = malloc(sizeof(struct blocklist));

		if (!newblk) {

			log_crit(_("Error: Can't allocate memory for indirect block fix.\n"));

			return -1;

		}

		memset(newblk, 0, sizeof(*newblk));

		newblk->ptrbuf = malloc(bufsize); 

		if (!newblk->ptrbuf) {

			log_crit(_("Error: Can't allocate memory for file conversion.\n"));

			free(newblk);

			return -1;

		}

		memset(newblk->ptrbuf, 0, bufsize);

		newblk->block = block;

		newblk->height = blk->height + 1;

		/* Build the metapointer list from our predecessors */

		for (h=0; h < blk->height; h++)

			newblk->mp.mp_list[h] = blk->mp.mp_list[h];

		newblk->mp.mp_list[h] = ptrnum;

		bh = bread(sbp, block);

		/* This is a data block. i.e newblk->height == ip->i_di.di_height */

		/* read in the jdata block */

		memcpy(newblk->ptrbuf, bh->b_data +

		       sizeof(struct gfs2_meta_header), bufsize);

		memset(bh->b_data + sizeof(struct gfs2_meta_header), 0, bufsize);

		bmodified(bh);

		brelse(bh);

		/* Free the block so we can reuse it. This allows us to

		   convert a "full" file system */

		ip->i_di.di_blocks--;

		gfs2_free_block(sbp, block);

		len = bufsize;

		jdata_mp_gfs1_to_gfs2(sbp, di_height, gfs2_hgt, &newblk->mp, &gfs2mp,

				      &len, dinode_size);

		memcpy(&newblk->mp, &gfs2mp, sizeof(struct metapath));

		newblk->height -= di_height - gfs2_hgt;

		if (len)

			ip->i_di.di_goal_meta = fix_jdatatree(sbp, ip, newblk,

							      newblk->ptrbuf, len);

		free(newblk->ptrbuf);

		free(newblk);

	}

	return 0;

}

static int adjust_indirect_blocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip)

{

	uint64_t dinode_size;

	uint32_t gfs2_hgt, di_height;

	osi_list_t *tmp=NULL, *x;

	struct blocklist blocks, *blk;

	int error = 0;

	int isdir = S_ISDIR(ip->i_di.di_mode); /* is always jdata */

	int isjdata = ((GFS2_DIF_JDATA & ip->i_di.di_flags) && !isdir);

	int isreg = (!isjdata && !isdir);

	int issys = (GFS2_DIF_SYSTEM & ip->i_di.di_flags);

	/* regular files and dirs are same upto height=2

	   jdata files (not dirs) are same only when height=0 */

	if (((isreg||isdir) && ip->i_di.di_height <= 1) ||

	    (isjdata && ip->i_di.di_height == 0)) {

		if (!issys)

			ip->i_di.di_goal_meta = ip->i_di.di_num.no_addr;

		return 0; /* nothing to do */

	}

	osi_list_init(&blocks.list);

	error = get_inode_metablocks(sbp, ip, &blocks;;

	if (error)

		goto out;

	/* The gfs2 height may be different.  We need to rebuild the

	   metadata tree to the gfs2 height. */

	gfs2_hgt = calc_gfs2_tree_height(ip, ip->i_di.di_size);

	/* Save off the size because we're going to empty the contents

	   and add the data blocks back in later. */

	dinode_size = ip->i_di.di_size;

	ip->i_di.di_size = 0ULL;

	di_height = ip->i_di.di_height;

	ip->i_di.di_height = 0;

	/* Now run through the block list a second time.  If the block

	   is a data block, rewrite the data to the gfs2 offset. */

	osi_list_foreach_safe(tmp, &blocks.list, x) {

		blk = osi_list_entry(tmp, struct blocklist, list);

		/* If it's not metadata that holds data block pointers

		   (i.e. metadata pointing to other metadata) */

		if (blk->height != di_height - 1) {

			osi_list_del(tmp);

			free(blk->ptrbuf);

			free(blk);

			continue;

		}

		if (isreg || isdir) /* more or less same way to deal with either */

			error = fix_ind_reg_or_dir(sbp, ip, di_height, 

						   gfs2_hgt, blk, &blocks;;

		else if (isjdata)

			error = fix_ind_jdata(sbp, ip, di_height, gfs2_hgt, 

					      dinode_size, blk, &blocks;;

		if (error)

			goto out;

		osi_list_del(tmp);

		free(blk->ptrbuf);

		free(blk);

	}

	ip->i_di.di_size = dinode_size;

	/* Set the new dinode height, which may or may not have changed.  */

	/* The caller will take it from the ip and write it to the buffer */

	ip->i_di.di_height = gfs2_hgt;

	return error;

out:

	while (!osi_list_empty(&blocks.list)) {

		blk = osi_list_entry(tmp, struct blocklist, list);

		osi_list_del(&blocks.list);

		free(blk->ptrbuf);

		free(blk);

	}

	return error;

}

const char *cdpn[14] = {"{hostname}", "{mach}", "{os}", "{uid}", "{gid}", "{sys}", "{jid}",

			"@hostname", "@mach", "@os", "@uid", "@gid", "@sys", "@jid"};

static int has_cdpn(const char *str)

{

	int i;

	for (i=0; i<14; i++)

		if (strstr(str, cdpn[i]) != NULL)

			return 1;

	return 0;

}

static int fix_cdpn_symlink(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh, struct gfs2_inode *ip)

{

	char *linkptr = NULL;

	if (ip->i_di.di_height != 0)

		return 0;

	linkptr = bh->b_data + sizeof(struct gfs_dinode);

	if (has_cdpn(linkptr)) {

		struct inode_dir_block *fix;

		/* Save the symlink di_addr. We'll find the parent di_addr later */

		fix = malloc(sizeof(struct inode_dir_block));

		if (!fix) {

			log_crit(_("Error: out of memory.\n"));

			return -1;

		}

		memset(fix, 0, sizeof(struct inode_dir_block));

		fix->di_addr = ip->i_di.di_num.no_addr;

		osi_list_add_prev((osi_list_t *)&fix->list,

				  (osi_list_t *)&cdpns_to_fix);

	}

	return 0;

}

/*

 * fix_xattr -

 * Extended attributes can be either direct (in the ip->i_di.di_eattr block) or

 * then can be at a maximum of 1 indirect level. Multiple levels of indirection

 * are not supported. If the di_eattr block contains extended attribute data,

 * i.e block type = GFS_METATYPE_EA, we ignore it.

 * If the di_eattr block contains block pointers to extended attributes we need

 * to fix the header. gfs1 uses gfs_indirect as the header which is 64 bytes

 * bigger than gfs2_meta_header that gfs2 uses.

 */

static int fix_xattr(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh, struct gfs2_inode *ip)

{

	int len, old_hdr_sz, new_hdr_sz;

	struct gfs2_buffer_head *eabh;

	char *buf;

	/* Read in the i_di.di_eattr block */

	eabh = bread(sbp, ip->i_di.di_eattr);

        if (!gfs2_check_meta(eabh, GFS_METATYPE_IN)) {/* if it is an indirect block */

		len = sbp->bsize - sizeof(struct gfs_indirect);

		buf = malloc(len);

		if (!buf) {

			/*FIXME: Same message as fix_cdpn_symlink */

			log_crit(_("Error: out of memory.\n"));

			return -1;

		}

		old_hdr_sz = sizeof(struct gfs_indirect);

		new_hdr_sz = sizeof(struct gfs2_meta_header);

		memcpy(buf, eabh->b_data + old_hdr_sz, sbp->bsize - old_hdr_sz);

		memset(eabh->b_data + new_hdr_sz, 0, sbp->bsize - new_hdr_sz);

		memcpy(eabh->b_data + new_hdr_sz, buf, len);

		free(buf);

		bmodified(eabh);

	}

        brelse(eabh);

	return 0;

}

/* ------------------------------------------------------------------------- */

/* adjust_inode - change an inode from gfs1 to gfs2                          */

/*                                                                           */

/* Returns: 0 on success, -1 on failure                                      */

/* ------------------------------------------------------------------------- */

static int adjust_inode(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh)

{

	struct gfs2_inode *inode;

	struct inode_block *fixdir;

	int inode_was_gfs1;

	inode = lgfs2_gfs_inode_get(sbp, bh);

	if (inode == NULL) {

		log_crit(_("Error reading inode: %s\n"), strerror(errno));

		return -1;

	}

	inode_was_gfs1 = (inode->i_di.di_num.no_formal_ino ==

					  inode->i_di.di_num.no_addr);

	/* Fix the inode number: */

	inode->i_di.di_num.no_formal_ino = sbp->md.next_inum;