directory.c

在Linux内核从2.4升级到2.6时需要升级的软件包

			case 4:
				xtree->header.self.len = strtoul(token, 0, 0);
				break;
			case 5:
				xtree->header.self.addr1 = strtoul(token, 0, 0);
				break;
			case 6:
				xtree->header.self.addr2 = strtoul(token, 0, 0);
				break;
			}

			/* swap if on big endian machine */
			ujfs_swap_dinode(&inode, PUT, type_jfs);

			if (xWrite(inode_address, sizeof (struct dinode), (char *) &inode)) {
				fputs("xtree: error writing inode\n\n", stderr);
				/* swap back if on big endian machine */
				ujfs_swap_dinode(&inode, GET, type_jfs);
				return;
			}

			/* swap back if on big endian machine */
			ujfs_swap_dinode(&inode, GET, type_jfs);

			goto redisplay;
		}
	}
	if (xtree->header.nextindex <= 2)
		return;

	if (xtree->header.flag & BT_LEAF)
		result = display_leaf_xads(xtree->xad, xtree->header.nextindex, &changed);
	else
		result = display_internal_xads(xtree->xad, xtree->header.nextindex, &changed);

	if (changed) {

		/* swap if on big endian machine */
		ujfs_swap_dinode(&inode, PUT, type_jfs);

		if (xWrite(inode_address, sizeof (struct dinode), (char *) &inode)) {
			fputs("xtree: error writing inode\n\n", stderr);
			/* swap back if on big endian machine */
			ujfs_swap_dinode(&inode, GET, type_jfs);
			return;
		}

		/* swap back if on big endian machine */
		ujfs_swap_dinode(&inode, GET, type_jfs);

		changed = 0;
	}

	if (result == 'u')
		goto redisplay;

	return;
}

void display_xtpage(xtpage_t * xtree)
{

	char flag_names[64];

	*flag_names = 0;
	if (xtree->header.flag & BT_ROOT)
		strcat(flag_names, "BT_ROOT  ");
	if (xtree->header.flag & BT_LEAF)
		strcat(flag_names, "BT_LEAF  ");
	if (xtree->header.flag & BT_INTERNAL)
		strcat(flag_names, "BT_INTERNAL  ");
	if (xtree->header.flag & BT_RIGHTMOST)
		strcat(flag_names, "BT_RIGHTMOST  ");
	if (xtree->header.flag & BT_LEFTMOST)
		strcat(flag_names, "BT_LEFTMOST  ");

	printf("[1] flag\t0x%02x\t%s\n", xtree->header.flag, flag_names);
	printf("[2] nextindex\t%d\t\t", xtree->header.nextindex);
	printf("[5] self.addr1\t0x%02x\n", xtree->header.self.addr1);
	printf("[3] maxentry\t%d\t\t", xtree->header.maxentry);
	printf("[6] self.addr2\t0x%08x\n", xtree->header.self.addr2);
	printf("[4] self.len\t0x%06x\t", xtree->header.self.len);
	printf("    self.addr\t%lld\n", (long long) addressPXD(&xtree->header.self));
}				/* end display_xtpage */

char display_leaf_slots(struct dtslot *slot, int8_t * stbl, int8_t nextindex, int *changed)
{
	char cmd_line[512];
	int i;
	int field;
	struct ldtentry *leaf;
	char result = 'u';	/* default returned if no leaf->next */
	int slot_number;
	char *token;
	int nfields = (type_jfs & JFS_DIR_INDEX) ? 5 : 4;

	for (i = 0; i < nextindex; i++) {
		slot_number = stbl[i];
		leaf = (struct ldtentry *) & (slot[slot_number]);

	      redisplay2:
		printf("stbl[%d] = %d\n", i, slot_number);
		printf("[1] inumber\t%d\n", leaf->inumber);
		printf("[2] next\t%d\n", leaf->next);
		printf("[3] namlen\t%d\n", leaf->namlen);
		/* Clear the UTF8 conversion buffer. */
		memset(UTF8_Buffer, 0, sizeof (UTF8_Buffer));

		/* Convert the name into UTF8 */
		Unicode_String_to_UTF8_String(UTF8_Buffer, leaf->name, leaf->namlen);

		printf("[4] name\t%s\n", UTF8_Buffer);
		if (type_jfs & JFS_DIR_INDEX)
			printf("[5] index\t%d\n", leaf->index);

	      retry2:
		fputs("dtree: Press enter for next, [m]odify, [u]p, or e[x]it > ", stdout);
		fgets(cmd_line, 512, stdin);
		token = strtok(cmd_line, "      \n");
		if (token) {
			if (*token == 'u' || *token == 'x')
				return *token;
			if (*token == 'm') {
				field = m_parse(cmd_line, nfields, &token);
				if (field == 0)
					goto retry2;

				switch (field) {
				case 1:
					leaf->inumber = strtoul(token, 0, 0);
					break;
				case 2:
					leaf->next = strtoul(token, 0, 0);
					break;
				case 3:
					leaf->namlen = strtoul(token, 0, 0);
					break;
				case 4:
					strToUcs(leaf->name, token, DTLHDRDATALEN);
					break;
				case 5:
					leaf->index = strtoul(token, 0, 0);
					break;
				}
				*changed = 1;
				goto redisplay2;
			}
		}

		if (leaf->next >= 0) {
			result = display_slot(slot, leaf->next, 1, changed);
			if (result == 'u' || result == 'x')
				return result;
		}
	}
	return result;
}

char display_slot(struct dtslot *slot, int8_t index, int isleaf, int *changed)
{
	char result;

	printf("[1] next\t%d\n", slot[index].next);
	printf("[2] cnt\t\t%d\n", slot[index].cnt);
	/* Clear the UTF8 conversion buffer. */
	memset(UTF8_Buffer, 0, sizeof (UTF8_Buffer));

	/* Convert the name into UTF8 */
	Unicode_String_to_UTF8_String(UTF8_Buffer, slot[index].name, JFS_PATH_MAX);

	printf("[3] name\t%.15s\n", UTF8_Buffer);

	if (isleaf)
		result = prompt("dtree: press enter for next or [u]p or e[x]it > ");
	else
		result = prompt("dtree: press enter for next or [u]p, [d]own or e[x]it > ");

	if (result == 'u' || result == 'd' || result == 'x')
		return result;

	if (slot[index].next >= 0)
		return display_slot(slot, slot[index].next, isleaf, changed);
	else
		return result;
}

char display_internal_slots(struct dtslot *slot, int8_t *stbl, int8_t nextindex, int *changed)
{
	int i;
	struct idtentry *entry;
	int64_t node_address;
	char result = 0;
	int slot_number;

	for (i = 0; i < nextindex; i++) {
		slot_number = stbl[i];
		entry = (struct idtentry *) & (slot[slot_number]);
		node_address = addressPXD(&(entry->xd));

		printf("stbl[%d] = %d\n", i, slot_number);
		printf("[1] xd.len\t    0x%06x\t\t", entry->xd.len);
		printf("[4] next\t%d\n", entry->next);
		printf("[2] xd.addr1\t  0x%02x\t\t\t", entry->xd.addr1);
		printf("[5] namlen\t%d\n", entry->namlen);
		printf("[3] xd.addr2\t  0x%08x\t\t", entry->xd.addr2);
		printf("     xd.addr\t%lld\n", (long long) node_address);
		/* Clear the UTF8 conversion buffer. */
		memset(UTF8_Buffer, 0, sizeof (UTF8_Buffer));

		/* Convert the name into UTF8 */
		Unicode_String_to_UTF8_String(UTF8_Buffer, entry->name, entry->namlen);

		printf("[6] name\t%.11s\n", UTF8_Buffer);
		printf("addressPXD(xd)\t%lld\n", (long long) node_address);

		result = prompt("dtree: press enter for next or [u]p, [d]own or e[x]it > ");
		if (result == 'x' || result == 'u')
			return result;
		else if (result != 'd' && entry->next >= 0) {
			result = display_slot(slot, entry->next, 0, changed);
			if (result == 'x' || result == 'u')
				return result;
		}
		if (result == 'd')
			/* descend to the child node */
			return (display_extent_page(node_address));
	}
	return result;
}

char display_leaf_xads(xad_t * xad, short nextindex, int *changed)
{
	int i;
	char result = 0;

	for (i = 2; i < nextindex; i++) {
		printf("XAD # = %d\n", i);
		printf("[1] xad.flag\t  %x\t\t", xad[i].flag);
		printf("[4] xad.len\t  0x%06x\n", xad[i].len);
		printf("[2] xad.off1\t  0x%02x\t\t", xad[i].off1);
		printf("[5] xad.addr1\t  0x%02x\n", xad[i].addr1);
		printf("[3] xad.off2\t  0x%08x\t", xad[i].off2);
		printf("[6] xad.addr2\t  0x%08x\n", xad[i].addr2);
		printf("    xad.off  \t  %lld\t\t", (long long) offsetXAD(&(xad[i])));
		printf("    xad.addr\t  %lld\n", (long long) addressXAD(&(xad[i])));

		result = prompt("xtree: press enter for next or e[x]it > ");
		if (result == 'x' || result == 'u')
			return result;
	}
	return result;
}
char display_internal_xads(xad_t * xad, short nextindex, int *changed)
{
	int i;
	char result = 0;

	for (i = 2; i < nextindex; i++) {
		printf("XAD # = %d\n", i);
		printf("[1] xad.flag\t  %x\t\t", xad[i].flag);
		printf("[4] xad.len\t  0x%06x\n", xad[i].len);
		printf("[2] xad.off1\t  0x%02x\t\t", xad[i].off1);
		printf("[5] xad.addr1\t  0x%02x\n", xad[i].addr1);
		printf("[3] xad.off2\t  0x%08x\t", xad[i].off2);
		printf("[6] xad.addr2\t  0x%08x\n", xad[i].addr2);
		printf("    xad.off  \t  %lld\t\t", (long long) offsetXAD(&(xad[i])));
		printf("    xad.addr\t  %lld\n", (long long) addressXAD(&(xad[i])));

		result = prompt("xtree: press enter for next or [u]p, [d]own or e[x]it > ");
		if (result == 'x' || result == 'u')
			return result;
		else if (result == 'd') {
			result = display_internal_xtpage(xad[i]);
			return result;
		}
	}
	return result;
}

char display_internal_xtpage(xad_t xad)
{
	int changed = 0;
	char cmd_line[80];
	xtpage_t xtree_area;
	xtpage_t *xtree = &xtree_area;
	int field;
	int64_t xtpage_address;
	char result = 'u';
	char *token;

	xtpage_address = addressXAD(&xad);
	xtpage_address = xtpage_address * bsize;

	if (xRead(xtpage_address, sizeof (xtpage_t), (char *) xtree)) {
		fputs("xtree: error reading xtpage\n\n", stderr);
	} else {

		/* swap if on big endian machine */
		ujfs_swap_xtpage_t(xtree);

	      redisplay:

		display_xtpage(xtree);

	      retry:
		if (xtree->header.nextindex > 2) {
			fputs("xtree: Hit enter to see entries, [m]odify, or e[x]it: ", stdout);
		} else {
			fputs("xtree: [m]odify, or e[x]it: ", stdout);
		}

		fgets(cmd_line, 80, stdin);
		token = strtok(cmd_line, "      \n");
		if (token) {
			if (*token == 'x')
				return result;

			if (*token == 'm') {
				field = m_parse(cmd_line, 6, &token);
				if (field == 0)
					goto retry;

				switch (field) {
				case 1:
					xtree->header.flag = strtoul(token, 0, 16);
					break;
				case 2:
					xtree->header.nextindex = strtoul(token, 0, 0);
					break;
				case 3:
					xtree->header.maxentry = strtoul(token, 0, 0);
					break;
				case 4:
					xtree->header.self.len = strtoul(token, 0, 0);
					break;
				case 5:
					xtree->header.self.addr1 = strtoul(token, 0, 0);
					break;
				case 6:
					xtree->header.self.addr2 = strtoul(token, 0, 0);
					break;
				}

				/* swap if on big endian machine */
				ujfs_swap_xtpage_t(xtree);

				if (xWrite(xtpage_address, sizeof (xtpage_t), (char *) xtree)) {
					fputs("xtree: error writing xtpage\n\n", stderr);
					/* swap back if on big endian machine */
					ujfs_swap_xtpage_t(xtree);
					return result;
				}

				/* swap back if on big endian machine */
				ujfs_swap_xtpage_t(xtree);

				goto redisplay;
			}
		}
		if (xtree->header.nextindex <= 2)
			return result;

		if (xtree->header.flag & BT_LEAF)
			result = display_leaf_xads(xtree->xad, xtree->header.nextindex, &changed);
		else
			result = display_internal_xads(xtree->xad,
						       xtree->header.nextindex, &changed);

		if (changed) {

			/* swap if on big endian machine */
			ujfs_swap_xtpage_t(xtree);

			if (xWrite(xtpage_address, sizeof (xtpage_t), (char *) xtree)) {
				fputs("xtree: error writing xtpage\n\n", stderr);
				/* swap back if on big endian machine */
				ujfs_swap_xtpage_t(xtree);
				return result;
			}

			/* swap back if on big endian machine */
			ujfs_swap_xtpage_t(xtree);

			changed = 0;
		}

		if (result == 'u')
			goto redisplay;
	}			/* end else */

	return result;
}

char display_extent_page(int64_t address)
{
	int changed = 0;
	char flag_names[64];
	dtpage_t node;
	char result;
	int8_t *stbl;

	if (xRead(address << l2bsize, sizeof (dtpage_t), (char *) &node)) {
		fprintf(stderr, "display_extent_page: Error reading node\n");
		return 'u';
	}

	/* swap if on big endian machine */
	ujfs_swap_dtpage_t(&node, type_jfs);

      redisplay5:
	*flag_names = 0;
	if (node.header.flag & BT_ROOT) {
		fputs("display_extent_page:  Warning!  extent dtree page has BT_ROOT flag set!\n",
		      stderr);
		strcat(flag_names, "BT_ROOT  ");
	}
	if (node.header.flag & BT_LEAF)
		strcat(flag_names, "BT_LEAF  ");
	if (node.header.flag & BT_INTERNAL)
		strcat(flag_names, "BT_INTERNAL  ");
	if (node.header.flag & BT_RIGHTMOST)
		strcat(flag_names, "BT_RIGHTMOST  ");
	if (node.header.flag & BT_LEFTMOST)
		strcat(flag_names, "BT_LEFTMOST  ");

	printf("Internal D-tree node at block %lld\n", (long long) address);

	printf("[1] flag\t0x%02x\t\t%s\n", node.header.flag, flag_names);
	printf("[2] nextindex\t%3d\n", node.header.nextindex);
	printf("[3] freecnt\t%3d\t\t", node.header.freecnt);
	printf("[7] rsrvd\tNOT DISPLAYED\n");
	printf("[4] freelist\t%3d\t\t", node.header.freelist);
	printf("[8] self.len\t0x%06x\n", node.header.self.len);
	printf("[5] maxslot\t%3d\t\t", node.header.maxslot);
	printf("[8] self.addr1\t0x%02x\n", node.header.self.addr1);
	printf("[6] stblindex\t%d\t\t", node.header.stblindex);
	printf("[9] \t0x%08x\n", node.header.self.addr2);

	if (node.header.nextindex) {
		result = prompt("dtree: Hit enter to see entries, [u]p or e[x]it: ");
		if (result == 'u' || result == 'x')
			return (result);
	} else {
		fputs("display_extent_page: Strange ... empty d-tree node.\n", stderr);
		return 'u';
	}

	stbl = (int8_t *) & (node.slot[node.header.stblindex]);

	if (node.header.flag & BT_LEAF)
		result = display_leaf_slots(node.slot, stbl, node.header.nextindex, &changed);
	else
		result = display_internal_slots(node.slot, stbl, node.header.nextindex, &changed);

	if (changed) {

		/* swap if on big endian machine */
		ujfs_swap_dtpage_t(&node, type_jfs);

		if (xWrite(address << l2bsize, sizeof (dtpage_t), (char *) &node)) {
			fputs("display_extent_page: error writing node\n\n", stderr);
			/* swap back if on big endian machine */
			ujfs_swap_dtpage_t(&node, type_jfs);
			return 0;
		}

		/* swap back if on big endian machine */
		ujfs_swap_dtpage_t(&node, type_jfs);

		changed = 0;
	}
	if (result == 'u')
		goto redisplay5;

	return result;
}

void strToUcs(UniChar * target, char *source, int len)
{
	while ((*(target++) = *(source++)) && --len) ;
	return;
}