#include "clusterautoconfig.h"

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <string.h>

#include <inttypes.h>

#include <sys/types.h>

#include <linux/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <errno.h>

#include <curses.h>

#include <term.h>

#include <time.h>

#include <signal.h>

#include <sys/ioctl.h>

#include <sys/mount.h>

#include <dirent.h>

#include <linux/gfs2_ondisk.h>

#include "copyright.cf"

#include "hexedit.h"

#include "libgfs2.h"

#include "gfs2hex.h"

#include "extended.h"

#include "journal.h"

const char *mtypes[] = {"none", "sb", "rg", "rb", "di", "in", "lf", "jd",

			"lh", "ld", "ea", "ed", "lb", "13", "qc"};

const char *allocdesc[2][5] = {

	{"Free ", "Data ", "Unlnk", "Meta ", "Resrv"},

	{"Free ", "Data ", "FreeM", "Meta ", "Resrv"},};

struct gfs2_buffer_head *bh;

struct gfs2_rgrp *lrgrp;

struct gfs2_meta_header *lmh;

struct gfs2_dinode *ldi;

struct gfs2_leaf *lleaf;

struct gfs2_log_header *llh;

struct gfs2_log_descriptor *lld;

int pgnum;

int details = 0;

long int gziplevel = 9;

static int termcols;

char *device = NULL;

extern uint64_t block;

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

/* erase - clear the screen */

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

static void Erase(void)

{

	bkgd(A_NORMAL|COLOR_PAIR(COLOR_NORMAL));

	/* clear();*/ /* doesn't set background correctly */

	erase();

	/*bkgd(bg);*/

}

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

/* display_title_lines */

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

static void display_title_lines(void)

{

	Erase();

	COLORS_TITLE;

	move(0, 0);

	printw("%-80s",TITLE1);

	move(termlines, 0);

	printw("%-79s",TITLE2);

	COLORS_NORMAL;

}

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

/* bobgets - get a string                                                    */

/* returns: 1 if user exited by hitting enter                                */

/*          0 if user exited by hitting escape                               */

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

static int bobgets(char string[],int x,int y,int sz,int *ch)

{

	int done,runningy,rc;

	move(x,y);

	done=FALSE;

	COLORS_INVERSE;

	move(x,y);

	addstr(string);

	move(x,y);

	curs_set(2);

	refresh();

	runningy=y;

	rc=0;

	while (!done) {

		*ch = getch();

		if(*ch < 0x0100 && isprint(*ch)) {

			char *p=string+strlen(string); // end of the string

			*(p+1)='\0';

			while (insert && p > &string[runningy-y]) {

				*p=*(p-1);

				p--;

			}

			string[runningy-y]=*ch;

			runningy++;

			move(x,y);

			addstr(string);

			if (runningy-y >= sz) {

				rc=1;

				*ch = KEY_RIGHT;

				done = TRUE;

			}

		}

		else {

			// special character, is it one we recognize?

			switch(*ch)

			{

			case(KEY_ENTER):

			case('\n'):

			case('\r'):

				rc=1;

				done=TRUE;

				string[runningy-y] = '\0';

				break;

			case(KEY_CANCEL):

			case(0x01B):

				rc=0;

				done=TRUE;

				break;

			case(KEY_LEFT):

				if (dmode == HEX_MODE) {

					done = TRUE;

					rc = 1;

				}

				else

					runningy--;

				break;

			case(KEY_RIGHT):

				if (dmode == HEX_MODE) {

					done = TRUE;

					rc = 1;

				}

				else

					runningy++;

				break;

			case(KEY_DC):

			case(0x07F):

				if (runningy>=y) {

					char *p;

					p = &string[runningy - y];

					while (*p) {

						*p = *(p + 1);

						p++;

					}

					*p = '\0';

					runningy--;

					// remove the character from the string 

					move(x,y);

					addstr(string);

					COLORS_NORMAL;

					addstr(" ");

					COLORS_INVERSE;

					runningy++;

				}

				break;

			case(KEY_BACKSPACE):

				if (runningy>y) {

					char *p;

					p = &string[runningy - y - 1];

					while (*p) {

						*p = *(p + 1);

						p++;

					}

					*p='\0';

					runningy--;

					// remove the character from the string 

					move(x,y);

					addstr(string);

					COLORS_NORMAL;

					addstr(" ");

					COLORS_INVERSE;

				}

				break;

			case KEY_DOWN:	// Down

				rc=0x5000U;

				done=TRUE;

				break;

			case KEY_UP:	// Up

				rc=0x4800U;

				done=TRUE;

				break;

			case 0x014b:

				insert=!insert;

				move(0,68);

				if (insert)

					printw("insert ");

				else

					printw("replace");

				break;

			default:

				move(0,70);

				printw("%08x",*ch);

				// ignore all other characters

				break;

			} // end switch on non-printable character

		} // end non-printable character

		move(x,runningy);

		refresh();

	} // while !done

	if (sz>0)

		string[sz]='\0';

	COLORS_NORMAL;

	return rc;

}/* bobgets */

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

** instr - instructions

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

static void gfs2instr(const char *s1, const char *s2)

{

	COLORS_HIGHLIGHT;

	move(line,0);

	printw(s1);

	COLORS_NORMAL;

	move(line,17);

	printw(s2);

	line++;

}

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

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

**

** void print_usage()

**

** Description:

**   This routine prints out the appropriate commands for this application.

**

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

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

static void print_usage(void)

{

	int ch;

	line = 2;

	Erase();

	display_title_lines();

	move(line++,0);

	printw("Supported commands: (roughly conforming to the rules of 'less')");

	line++;

	move(line++,0);

	printw("Navigation:");

	gfs2instr("<pg up>/<down>","Move up or down one screen full");

	gfs2instr("<up>/<down>","Move up or down one line");

	gfs2instr("<left>/<right>","Move left or right one byte");

	gfs2instr("<home>","Return to the superblock.");

	gfs2instr("   f","Forward one 4K block");

	gfs2instr("   b","Backward one 4K block");

	gfs2instr("   g","Goto a given block (number, master, root, rindex, jindex, etc)");

	gfs2instr("   j","Jump to the highlighted 64-bit block number.");

	gfs2instr("    ","(You may also arrow up to the block number and hit enter)");

	gfs2instr("<backspace>","Return to a previous block (a block stack is kept)");

	gfs2instr("<space>","Jump forward to block before backspace (opposite of backspace)");

	line++;

	move(line++, 0);

	printw("Other commands:");

	gfs2instr("   h","This Help display");

	gfs2instr("   c","Toggle the color scheme");

	gfs2instr("   m","Switch display mode: hex -> GFS2 structure -> Extended");

	gfs2instr("   q","Quit (same as hitting <escape> key)");

	gfs2instr("<enter>","Edit a value (enter to save, esc to discard)");

	gfs2instr("       ","(Currently only works on the hex display)");

	gfs2instr("<escape>","Quit the program");

	line++;

	move(line++, 0);

	printw("Notes: Areas shown in red are outside the bounds of the struct/file.");

	move(line++, 0);

	printw("       Areas shown in blue are file contents.");

	move(line++, 0);

	printw("       Characters shown in green are selected for edit on <enter>.");

	move(line++, 0);

	move(line++, 0);

	printw("Press any key to return.");

	refresh();

	while ((ch=getch()) == 0); // wait for input

	Erase();

}

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

/* get_block_type                                                           */

/* returns: metatype if block is a GFS2 structure block type                */

/*          0 if block is not a GFS2 structure                              */

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

uint32_t get_block_type(const struct gfs2_buffer_head *lbh, int *structlen)

{

	uint32_t ty = lgfs2_get_block_type(lbh);

	if (ty != 0 && structlen != NULL) {

		unsigned ver = sbd.gfs1 ? LGFS2_MD_GFS1 : LGFS2_MD_GFS2;

		const struct lgfs2_metadata *mtype = lgfs2_find_mtype(ty, ver);

		if (mtype != NULL)

			*structlen = mtype->size;

		else

			*structlen = sbd.bsize;

	}

	return ty;

}

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

/* display_block_type                                                       */

/* returns: metatype if block is a GFS2 structure block type                */

/*          0 if block is not a GFS2 structure                              */

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

int display_block_type(struct gfs2_buffer_head *dbh, int from_restore)

{

	const struct gfs2_meta_header *mh;

	int ret_type = 0; /* return type */

	/* first, print out the kind of GFS2 block this is */

	if (termlines) {

		line = 1;

		move(line, 0);

	}

	print_gfs2("Block #");

	if (termlines) {

		if (edit_row[dmode] == -1)

			COLORS_HIGHLIGHT;

	}

	if (block == RGLIST_DUMMY_BLOCK)

		print_gfs2("RG List       ");

	else if (block == JOURNALS_DUMMY_BLOCK)

		print_gfs2("Journal Status:      ");

	else

		print_gfs2("%"PRIu64"    (0x%"PRIx64")", dbh->b_blocknr, dbh->b_blocknr);

	if (termlines) {

		if (edit_row[dmode] == -1)

			COLORS_NORMAL;

	}

	print_gfs2(" ");

	if (!from_restore)

		print_gfs2("of %"PRIu64" (0x%"PRIx64") ", max_block, max_block);

	if (block == RGLIST_DUMMY_BLOCK) {

		ret_type = GFS2_METATYPE_RG;

		struct_len = sbd.gfs1 ? sizeof(struct gfs_rgrp) :

			sizeof(struct gfs2_rgrp);

	} else if (block == JOURNALS_DUMMY_BLOCK) {

		ret_type = GFS2_METATYPE_DI;

		struct_len = 0;

	} else {

		ret_type = get_block_type(dbh, &struct_len);

		switch (ret_type) {

		case GFS2_METATYPE_SB:   /* 1 */

			print_gfs2("(superblock)");

			break;

		case GFS2_METATYPE_RG:   /* 2 */

			print_gfs2("(rsrc grp hdr)");

			break;

		case GFS2_METATYPE_RB:   /* 3 */

			print_gfs2("(rsrc grp bitblk)");

			break;

		case GFS2_METATYPE_DI:   /* 4 */

			print_gfs2("(disk inode)");

			break;

		case GFS2_METATYPE_IN:   /* 5 */

			print_gfs2("(indir blklist)");

			break;

		case GFS2_METATYPE_LF:   /* 6 */

			print_gfs2("(directory leaf)");

			break;

		case GFS2_METATYPE_JD:

			print_gfs2("(journal data)");

			break;

		case GFS2_METATYPE_LH:

			print_gfs2("(log header)");

			break;

		case GFS2_METATYPE_LD:

		 	print_gfs2("(log descriptor)");

			break;

		case GFS2_METATYPE_EA:

			print_gfs2("(extended attr hdr)");

			break;

		case GFS2_METATYPE_ED:

			print_gfs2("(extended attr data)");

			break;

		case GFS2_METATYPE_LB:

			print_gfs2("(log buffer)");

			break;

		case GFS2_METATYPE_QC:

			print_gfs2("(quota change)");

			break;

		case 0:

			struct_len = sbd.bsize;

			break;

		default:

			print_gfs2("(wtf?)");

			break;

		}

	}

	mh = dbh->iov.iov_base;

	eol(0);

	if (from_restore)

		return ret_type;

	if (termlines && dmode == HEX_MODE) {

		int type;

		struct rgrp_tree *rgd;

		rgd = gfs2_blk2rgrpd(&sbd, block);

		if (rgd) {

			gfs2_rgrp_read(&sbd, rgd);

			if ((be32_to_cpu(mh->mh_type) == GFS2_METATYPE_RG) ||

			    (be32_to_cpu(mh->mh_type) == GFS2_METATYPE_RB))

				type = 4;

			else {

				type = lgfs2_get_bitmap(&sbd, block, rgd);

			}

		} else

			type = 4;

		screen_chunk_size = ((termlines - 4) * 16) >> 8 << 8;

		if (!screen_chunk_size)

			screen_chunk_size = 256;

		pgnum = (offset / screen_chunk_size);

		if (type >= 0) {

			print_gfs2("(p.%d of %d--%s)", pgnum + 1,

				   (sbd.bsize % screen_chunk_size) > 0 ?

				   sbd.bsize / screen_chunk_size + 1 : sbd.bsize /

				   screen_chunk_size, allocdesc[sbd.gfs1][type]);

		}

		/*eol(9);*/

		if ((be32_to_cpu(mh->mh_type) == GFS2_METATYPE_RG)) {

			int ptroffset = edit_row[dmode] * 16 + edit_col[dmode];

			if (rgd && (ptroffset >= struct_len || pgnum)) {

				int blknum, b, btype;

				blknum = pgnum * screen_chunk_size;

				blknum += (ptroffset - struct_len);

				blknum *= 4;

				blknum += rgd->ri.ri_data0;

				print_gfs2(" blk ");

				for (b = blknum; b < blknum + 4; b++) {

					btype = lgfs2_get_bitmap(&sbd, b, rgd);

					if (btype >= 0) {

						print_gfs2("0x%x-%s  ", b,

							   allocdesc[sbd.gfs1][btype]);

					}

				}

			}

		} else if ((be32_to_cpu(mh->mh_type) == GFS2_METATYPE_RB)) {

			int ptroffset = edit_row[dmode] * 16 + edit_col[dmode];

			if (rgd && (ptroffset >= struct_len || pgnum)) {

				int blknum, b, btype, rb_number;

				rb_number = block - rgd->ri.ri_addr;

				blknum = 0;

				/* count the number of bytes representing

				   blocks prior to the displayed screen. */

				for (b = 0; b < rb_number; b++) {

					struct_len = (b ?

					      sizeof(struct gfs2_meta_header) :

					      sizeof(struct gfs2_rgrp));

					blknum += (sbd.bsize - struct_len);

				}

				struct_len = sizeof(struct gfs2_meta_header);

				/* add the number of bytes on this screen */

				blknum += (ptroffset - struct_len);

				/* factor in the page number */

				blknum += pgnum * screen_chunk_size;

				/* convert bytes to blocks */

				blknum *= GFS2_NBBY;

				/* add the starting offset for this rgrp */

				blknum += rgd->ri.ri_data0;

				print_gfs2(" blk ");

				for (b = blknum; b < blknum + 4; b++) {

					btype = lgfs2_get_bitmap(&sbd, b, rgd);

					if (btype >= 0) {

						print_gfs2("0x%x-%s  ", b,

							   allocdesc[sbd.gfs1][btype]);

					}

				}

			}

		}

		if (rgd)

			gfs2_rgrp_relse(rgd);

 	}

	if (block == sbd.sd_sb.sb_root_dir.no_addr)

		print_gfs2("--------------- Root directory ------------------");

	else if (!sbd.gfs1 && block == sbd.sd_sb.sb_master_dir.no_addr)

		print_gfs2("-------------- Master directory -----------------");

	else if (!sbd.gfs1 && block == RGLIST_DUMMY_BLOCK)

		print_gfs2("------------------ RG List ----------------------");

	else if (!sbd.gfs1 && block == JOURNALS_DUMMY_BLOCK)

		print_gfs2("-------------------- Journal List --------------------");

	else {

		if (sbd.gfs1) {

			if (block == sbd1->sb_rindex_di.no_addr)

				print_gfs2("---------------- rindex file -------------------");

			else if (block == gfs1_quota_di.no_addr)

				print_gfs2("---------------- Quota file --------------------");

			else if (block == sbd1->sb_jindex_di.no_addr)

				print_gfs2("--------------- Journal Index ------------------");

			else if (block == gfs1_license_di.no_addr)

				print_gfs2("--------------- License file -------------------");

		}

		else {

			int d;

			for (d = 2; d < 8; d++) {

				if (block == masterdir.dirent[d].block) {

					if (!strncmp(masterdir.dirent[d].filename, "jindex", 6))

						print_gfs2("--------------- Journal Index ------------------");

					else if (!strncmp(masterdir.dirent[d].filename, "per_node", 8))

						print_gfs2("--------------- Per-node Dir -------------------");

					else if (!strncmp(masterdir.dirent[d].filename, "inum", 4))

						print_gfs2("---------------- Inum file ---------------------");

					else if (!strncmp(masterdir.dirent[d].filename, "statfs", 6))

						print_gfs2("---------------- statfs file -------------------");

					else if (!strncmp(masterdir.dirent[d].filename, "rindex", 6))

						print_gfs2("---------------- rindex file -------------------");

					else if (!strncmp(masterdir.dirent[d].filename, "quota", 5))

						print_gfs2("---------------- Quota file --------------------");

				}

			}

		}

	}

	eol(0);

	return ret_type;

}

static const struct lgfs2_metadata *find_mtype(uint32_t mtype, const unsigned versions)

{

	const struct lgfs2_metadata *m = lgfs2_metadata;

	unsigned n = 0;

	do {

		if ((m[n].versions & versions) && m[n].mh_type == mtype)

			return &m[n];

		n++;

	} while (n < lgfs2_metadata_size);

	return NULL;

}

static int get_pnum(int ptroffset)

{

	int pnum;

	pnum = pgnum * screen_chunk_size;

	pnum += (ptroffset - struct_len);

	pnum /= sizeof(uint64_t);

	return pnum;

}

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

/* hexdump - hex dump the filesystem block to the screen                    */

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

static int hexdump(uint64_t startaddr, int len, int trunc_zeros,

		   uint64_t flagref, uint64_t ref_blk)

{

	const unsigned char *pointer, *ptr2;

	int i;

	uint64_t l;

	const char *lpBuffer = bh->b_data;

	const char *zeros_strt = lpBuffer + sbd.bsize;

	int print_field, cursor_line;

	const uint32_t block_type = get_block_type(bh, NULL);

	uint64_t *ref;

	int ptroffset = 0;

	strcpy(edit_fmt,"%02x");

	pointer = (unsigned char *)lpBuffer + offset;

	ptr2 = (unsigned char *)lpBuffer + offset;

	ref = (uint64_t *)lpBuffer + offset;

	if (trunc_zeros) {

		while (zeros_strt > lpBuffer && (*(zeros_strt - 1) == 0))

			zeros_strt--;

	}

	l = offset;

	print_entry_ndx = 0;

	while (((termlines && line < termlines &&

		 line <= ((screen_chunk_size / 16) + 2)) ||

		(!termlines && l < len)) && l < sbd.bsize) {

		int ptr_not_null = 0;

		if (termlines) {

			move(line, 0);

			COLORS_OFFSETS; /* cyan for offsets */

		}

		if (startaddr < 0xffffffff)

			print_gfs2("%.8"PRIx64, startaddr + l);

		else

			print_gfs2("%.16"PRIx64, startaddr + l);

		if (termlines) {

			if (l < struct_len)

				COLORS_NORMAL; /* normal part of structure */

			else if (gfs2_struct_type == GFS2_METATYPE_DI &&

					 l < struct_len + di.di_size)

				COLORS_CONTENTS; /* after struct but not eof */

			else

				COLORS_SPECIAL; /* beyond end of the struct */

		}

		print_field = -1;

		cursor_line = 0;

		for (i = 0; i < 16; i++) { /* first print it in hex */

			/* Figure out if we have a null pointer--for colors */

			if (((gfs2_struct_type == GFS2_METATYPE_IN) ||

			     (gfs2_struct_type == GFS2_METATYPE_DI &&

			      l < struct_len + di.di_size &&

			      (di.di_height > 0 || !S_ISREG(di.di_mode)))) &&

			    (i==0 || i==8)) {

				int j;

				ptr_not_null = 0;

				for (j = 0; j < 8; j++) {

					if (*(pointer + j)) {

						ptr_not_null = 1;

						break;

					}

				}

			}

			if (termlines) {

				if (l + i < struct_len)

					COLORS_NORMAL; /* in the structure */

				else if (gfs2_struct_type == GFS2_METATYPE_DI

					 && l + i < struct_len + di.di_size) {

					if ((!di.di_height &&

					     S_ISREG(di.di_mode)) ||

					    !ptr_not_null)

						COLORS_CONTENTS;/*stuff data */

					else

						COLORS_SPECIAL;/* non-null */

				}

				else if (gfs2_struct_type == GFS2_METATYPE_IN){

					if (ptr_not_null)

						COLORS_SPECIAL;/* non-null */

					else

						COLORS_CONTENTS;/* null */

				} else

					COLORS_SPECIAL; /* past the struct */

			}

			if (i%4 == 0)

				print_gfs2(" ");

			if (termlines && line == edit_row[dmode] + 3 &&

				i == edit_col[dmode]) {

				COLORS_HIGHLIGHT; /* in the structure */

				memset(estring,0,3);

				sprintf(estring,"%02x",*pointer);

				cursor_line = 1;

				print_field = (char *)pointer - bh->b_data;

			}

			print_gfs2("%02x",*pointer);

			if (termlines && line == edit_row[dmode] + 3 &&

				i == edit_col[dmode]) {

				if (l < struct_len + offset)

					COLORS_NORMAL; /* in the structure */

				else

					COLORS_SPECIAL; /* beyond structure */

			}

			pointer++;

		}

		print_gfs2(" [");

		for (i=0; i<16; i++) { /* now print it in character format */

			if ((*ptr2 >=' ') && (*ptr2 <= '~'))

				print_gfs2("%c",*ptr2);

			else

				print_gfs2(".");

			ptr2++;

		}

		print_gfs2("] ");

		if (print_field >= 0) {

			const struct lgfs2_metadata *m = find_mtype(block_type,

			               sbd.gfs1 ? LGFS2_MD_GFS1 : LGFS2_MD_GFS2);

			if (m) {

				const struct lgfs2_metafield *f;

				unsigned n;

				for (n = 0; n < m->nfields; n++) {

					f = &m->fields[n];

					if (print_field >= f->offset &&

					    print_field < (f->offset + f->length)) {

						print_gfs2("%s", m->fields[n].name);

						break;

					}

				}

			}

		}

		if (cursor_line) {

			if (block_type == GFS2_METATYPE_IN ||

			    block_type == GFS2_METATYPE_LD ||

			    ((block_type == GFS2_METATYPE_DI) &&

			     ((struct gfs2_dinode*)bh->b_data)->di_height) ||

			     S_ISDIR(di.di_mode)) {

				ptroffset = edit_row[dmode] * 16 +

					edit_col[dmode];

				if (ptroffset >= struct_len || pgnum) {

					int pnum = get_pnum(ptroffset);

					if (block_type == GFS2_METATYPE_LD)

						print_gfs2("*");

					print_gfs2("pointer 0x%x", pnum);

				}

			}

		}

		if (line - 3 > last_entry_onscreen[dmode])

			last_entry_onscreen[dmode] = line - 3;

		if (flagref && be64_to_cpu(*ref) == flagref)

			print_gfs2("<------------------------- ref in 0x%"PRIx64" "

				   "to 0x%"PRIx64, ref_blk, flagref);

		ref++;

		if (flagref && be64_to_cpu(*ref) == flagref)

			print_gfs2("<------------------------- ref in 0x%"PRIx64" "

				   "to 0x%"PRIx64, ref_blk, flagref);

		ref++;

		eol(0);

		l += 16;

		print_entry_ndx++;

		/* This should only happen if trunc_zeros is specified: */

		if ((const char *)pointer >= zeros_strt)

			break;

	} /* while */

	if (block_type == GFS2_METATYPE_LD && ptroffset >= struct_len) {

		COLORS_NORMAL;

		eol(0);

		print_gfs2("         * 'j' will jump to the journaled block, "

			   "not the absolute block.");

		eol(0);

	}

	if (sbd.gfs1) {

		COLORS_NORMAL;

		print_gfs2("         *** This seems to be a GFS-1 file system ***");

		eol(0);

	}

	return (offset+len);

}/* hexdump */

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

/* masterblock - find a file (by name) in the master directory and return   */

/*               its block number.                                          */

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

uint64_t masterblock(const char *fn)

{

	int d;

	for (d = 2; d < 8; d++)

		if (!strncmp(masterdir.dirent[d].filename, fn, strlen(fn)))

			return (masterdir.dirent[d].block);

	return 0;

}

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

/* rgcount - return how many rgrps there are.                               */

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

static void rgcount(void)

{

	printf("%lld RGs in this file system.\n",

	       (unsigned long long)sbd.md.riinode->i_di.di_size /

	       sizeof(struct gfs2_rindex));

	inode_put(&sbd.md.riinode);

	gfs2_rgrp_free(&sbd.rgtree);

	exit(EXIT_SUCCESS);

}

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

/* find_rgrp_block - locate the block for a given rgrp number               */

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

static uint64_t find_rgrp_block(struct gfs2_inode *dif, int rg)

{

	int amt;

	struct gfs2_rindex fbuf, ri;

	uint64_t foffset, gfs1_adj = 0;

	foffset = rg * sizeof(struct gfs2_rindex);

	if (sbd.gfs1) {

		uint64_t sd_jbsize =

			(sbd.bsize - sizeof(struct gfs2_meta_header));

		gfs1_adj = (foffset / sd_jbsize) *

			sizeof(struct gfs2_meta_header);

		gfs1_adj += sizeof(struct gfs2_meta_header);

	}

	amt = gfs2_readi(dif, (void *)&fbuf, foffset + gfs1_adj,

			 sizeof(struct gfs2_rindex));

	if (!amt) /* end of file */

		return 0;

	gfs2_rindex_in(&ri, (void *)&fbuf);

	return ri.ri_addr;

}

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

/* gfs_rgrp_print - print a gfs1 resource group                             */

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

void gfs_rgrp_print(struct gfs_rgrp *rg)

{

	gfs2_meta_header_print(&rg->rg_header);

	pv(rg, rg_flags, "%u", "0x%x");

	pv(rg, rg_free, "%u", "0x%x");

	pv(rg, rg_useddi, "%u", "0x%x");

	pv(rg, rg_freedi, "%u", "0x%x");

	gfs2_inum_print(&rg->rg_freedi_list);

	pv(rg, rg_usedmeta, "%u", "0x%x");

	pv(rg, rg_freemeta, "%u", "0x%x");

}

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

/* get_rg_addr                                                              */

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

static uint64_t get_rg_addr(int rgnum)

{

	uint64_t rgblk = 0, gblock;

	struct gfs2_inode *riinode;

	if (sbd.gfs1)

		gblock = sbd1->sb_rindex_di.no_addr;

	else

		gblock = masterblock("rindex");

	riinode = lgfs2_inode_read(&sbd, gblock);

	if (riinode == NULL)

		return 0;

	if (rgnum < riinode->i_di.di_size / sizeof(struct gfs2_rindex))

		rgblk = find_rgrp_block(riinode, rgnum);

	else

		fprintf(stderr, "Error: File system only has %lld RGs.\n",

			(unsigned long long)riinode->i_di.di_size /

			sizeof(struct gfs2_rindex));

	inode_put(&riinode);

	return rgblk;

}

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

/* set_rgrp_flags - Set an rgrp's flags to a given value                    */

/* rgnum: which rg to print or modify flags for (0 - X)                     */

/* new_flags: value to set new rg_flags to (if modify == TRUE)              */

/* modify: TRUE if the value is to be modified, FALSE if it's to be printed */

/* full: TRUE if the full RG should be printed.                             */

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

static void set_rgrp_flags(int rgnum, uint32_t new_flags, int modify, int full)

{

	union {

		struct gfs2_rgrp rg2;

		struct gfs_rgrp rg1;

	} rg;

	struct gfs2_buffer_head *rbh;

	uint64_t rgblk;

	rgblk = get_rg_addr(rgnum);

	rbh = bread(&sbd, rgblk);

	if (sbd.gfs1)

		gfs_rgrp_in(&rg.rg1, rbh);

	else

		gfs2_rgrp_in(&rg.rg2, rbh->b_data);

	if (modify) {

		printf("RG #%d (block %llu / 0x%llx) rg_flags changed from 0x%08x to 0x%08x\n",

		       rgnum, (unsigned long long)rgblk,

		       (unsigned long long)rgblk, rg.rg2.rg_flags, new_flags);

		rg.rg2.rg_flags = new_flags;

		if (sbd.gfs1)

			gfs_rgrp_out(&rg.rg1, rbh);

		else

			gfs2_rgrp_out(&rg.rg2, rbh->b_data);

		bmodified(rbh);

		brelse(rbh);

	} else {

		if (full) {

			print_gfs2("RG #%d", rgnum);

			print_gfs2(" located at: %"PRIu64" (0x%"PRIx64")", rgblk, rgblk);

                        eol(0);

			if (sbd.gfs1)

				gfs_rgrp_print(&rg.rg1);

			else

				gfs2_rgrp_print(&rg.rg2);

		}

		else

			printf("RG #%d (block %llu / 0x%llx) rg_flags = 0x%08x\n",

			       rgnum, (unsigned long long)rgblk,

			       (unsigned long long)rgblk, rg.rg2.rg_flags);