/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2020 Peter Tribble.
 *
 * Opl Platform specific functions.
 *
 *	called when :
 *	machine_type == MTYPE_OPL
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <string.h>
#include <varargs.h>
#include <fcntl.h>
#include <assert.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/utsname.h>
#include <sys/systeminfo.h>
#include <sys/openpromio.h>
#include <libintl.h>
#include <syslog.h>
#include <sys/dkio.h>
#include <pdevinfo.h>
#include <libprtdiag.h>
#include <libdevinfo.h>
#include <kstat.h>

/*
 * Globals and externs
 */
#define	KBYTE	1024
#define	MBYTE	(KBYTE * KBYTE)
#define	HZ_TO_MHZ(x)	((((uint64_t)(x)) + 500000) / 1000000)
#define	SCF_SECURE_MODE_KSTAT_NAMED	"secure_mode"
#define	SCF_STAT_MODE_UNLOCK	0
#define	SCF_STAT_MODE_LOCK	1
#define	SCF_SYSTEM_KSTAT_NAME	"scf"
#ifndef	TEXT_DOMAIN
#define	TEXT_DOMAIN	"SYS_TEST"
#endif	/* TEXT_DOMAIN */

/*
 * Global functions and variables
 * these functions will overlay the symbol table of libprtdiag
 * at runtime (Opl systems only)
 */
struct  cs_status {
	int cs_number;
	int status;
	uint_t avail_hi;
	uint_t avail_lo;
	uint_t dimm_hi;
	uint_t dimm_lo;
	int dimms;
};

int	do_prominfo(int syserrlog, char *pgname, int log_flag, int prt_flag);
void	*get_prop_val(Prop *prop);
void	display_ffb(Board_node *, int);
void	display_sbus(Board_node *board);
void	display_cpu_devices(Sys_tree *tree);
void	display_cpus(Board_node *board);
void	display_memoryconf(Sys_tree *tree);
void	display_io_cards(struct io_card *list);
void	display_io_devices(Sys_tree *tree);
void	display_diaginfo(int flag, Prom_node *root, Sys_tree *tree,
    struct system_kstat_data *kstats);
Prop	*find_prop(Prom_node *pnode, char *name);
int	do_piclinfo(int);
int	get_proc_mode(void);

/* Local functions */
static	void opl_disp_environ(void);
static	void opl_disp_hw_revisions(Sys_tree *tree, Prom_node *root);
static	uint64_t print_opl_memory_line(int lsb, struct cs_status *cs_stat,
    int ngrps, int mirror_mode);
static	uint64_t get_opl_mem_regs(Board_node *bnode);
void 	add_node(Sys_tree *root, Prom_node *pnode);
static	int get_prop_size(Prop *prop);

static int v_flag = 0;

/*
 * Linked list of IO card info for display.
 * Using file scope for use in a recursive function.
 */
static struct io_card *card_list = NULL;

/*
 * Check prom node for a class-code. If it exists and it's not a bridge device
 * then add an io_card to card_list. Then recursively call this function for
 * its child and sibling nodes.
 */
static void
walk_tree_for_pci_devices(Prom_node *node, int board_number)
{
	struct io_card card;
	char	*str;
	void	*val;
	int	ccode;

	if (node == NULL) {
		return;
	}

	/* Look for a class-code property. Skip, if it's a bridge */
	ccode = -1;
	val = get_prop_val(find_prop(node, "class-code"));
	if (val != NULL) {
		ccode = *(int *)val;
	}
	if ((ccode != -1) && (ccode < 0x60000 || ccode > 0x6ffff)) {
		(void) memset(&card, 0, sizeof (card));
		card.board = board_number;

		str = (char *)get_prop_val(find_prop(node, "name"));
		(void) strlcpy(card.name, (str == NULL ? "N/A":str),
		    sizeof (card.name));

		str = (char *)get_prop_val(find_prop(node, "model"));
		(void) strlcpy(card.model, (str == NULL ? "N/A":str),
		    sizeof (card.model));

		/* insert card to the list */
		card_list = insert_io_card(card_list, &card);
	}
	/* Call this function for its child/sibling */
	walk_tree_for_pci_devices(node->child, board_number);
	walk_tree_for_pci_devices(node->sibling, board_number);
}

/*
 * For display of I/O devices for "prtdiag"
 */
void
display_io_devices(Sys_tree *tree)
{
	Board_node *bnode;

	if (v_flag) {
		/*
		 * OPL's PICL interface for display of PCI I/O devices
		 * for "prtdiag -v"
		 */
		(void) do_piclinfo(v_flag);
	} else {
		log_printf("\n", 0);
		log_printf("=========================", 0);
		log_printf(dgettext(TEXT_DOMAIN, " IO Cards "), 0);
		log_printf("=========================", 0);
		log_printf("\n", 0);
		log_printf("\n", 0);
		bnode = tree->bd_list;
		while (bnode != NULL) {
			walk_tree_for_pci_devices(bnode->nodes,
			    bnode->board_num);
			bnode = bnode->next;
		}
		display_io_cards(card_list);
		free_io_cards(card_list);
	}
}

/*
 * There are no FFB's on OPL.
 */
/*ARGSUSED*/
void
display_ffb(Board_node *board, int table)
{
}

/*
 * There are no Sbus's on OPL.
 */
/*ARGSUSED*/
void
display_sbus(Board_node *board)
{
}

/*
 * Details of I/O information. Print out all the io cards.
 */
void
display_io_cards(struct io_card *list)
{
	char	*hdrfmt = "%-6.6s %-14.14s %-12.12s\n";

	struct io_card *p;

	if (list == NULL)
		return;

	(void) textdomain(TEXT_DOMAIN);

	log_printf(hdrfmt, gettext("LSB"), gettext("Name"), gettext("Model"),
	    0);

	log_printf(hdrfmt, "---", "-----------------", "------------", 0);

	for (p = list; p != NULL; p = p->next) {

		/* Board number */
		log_printf(" %02d    ", p->board, 0);

		/* Card name */
		log_printf("%-15.15s", p->name, 0);

		/* Card model */
		log_printf("%-12.12s", p->model, 0);

		log_printf("\n", 0);
	}
	log_printf("\n", 0);
}

/*
 * Details of CPU information.
 */
void
display_cpu_devices(Sys_tree *tree)
{
	Board_node *bnode;
	char *hdrfmt =
	    "%-4.4s  %-4.4s  %-40.40s  %-5.5s  %-5.5s  %-5.5s %-4.4s\n";

	(void) textdomain(TEXT_DOMAIN);

	/*
	 * Display the table header for CPUs . Then display the CPU
	 * frequency, cache size, and processor revision of all cpus.
	 */
	log_printf("\n", 0);
	log_printf("====================================", 0);
	log_printf(gettext(" CPUs "), 0);
	log_printf("====================================", 0);
	log_printf("\n\n", 0);

	log_printf(hdrfmt,
	    "",
	    gettext("CPU"),
	    gettext("              CPU                  "),
	    gettext("Run"),
	    gettext("L2$"),
	    gettext("CPU"),
	    gettext("CPU"), 0);

	log_printf(hdrfmt,
	    gettext("LSB"),
	    gettext("Chip"),
	    gettext("               ID                 "),
	    gettext("MHz"),
	    gettext(" MB"),
	    gettext("Impl."),
	    gettext("Mask"), 0);

	log_printf(hdrfmt,
	"---", "----", "----------------------------------------", "----",
	"---",  "-----", "----", 0);

	/* Now display all of the cpus on each board */
	for (bnode = tree->bd_list; bnode != NULL; bnode = bnode->next) {
		display_cpus(bnode);
	}

	log_printf("\n", 0);
}

/*
 * Display the CPUs present on this board.
 */
void
display_cpus(Board_node *board)
{
	int *impl, *mask, *cpuid, *portid, *l2cache_size;
	uint_t freq;		/* CPU clock frequency */
	Prom_node *pnode, *cpu;
	char *name;

	(void) textdomain(TEXT_DOMAIN);

	/*
	 * Get the Cpus' properties for display
	 */
	for (pnode = board->nodes; pnode != NULL; pnode = pnode->sibling) {
		char cpu_str[MAXSTRLEN], fcpu_str[MAXSTRLEN] = {0};

		name = get_node_name(pnode);
		if ((name == NULL) || (strncmp(name, "cmp", 3) != 0)) {
			continue;
		}

		portid = (int *)get_prop_val(find_prop(pnode, "portid"));
		freq = (HZ_TO_MHZ(get_cpu_freq(pnode->child)));
		l2cache_size = (int *)get_prop_val(find_prop(pnode->child,
		    "l2-cache-size"));
		impl = (int *)get_prop_val(find_prop(pnode->child,
		    "implementation#"));
		mask = (int *)get_prop_val(find_prop(pnode->child, "mask#"));

		/* Lsb id */
		log_printf(" %02d   ", board->board_num, 0);

		if (portid != NULL)
			log_printf("%3d   ", (((*portid)>>3)&0x3), 0);

		/*
		 * OPL
		 * Specific parsing of the CMP/CORE/CPU chain.
		 * The internal cpu tree built by walk_di_tree()
		 * in common code can be illustrated by the diagram
		 * below:
		 *
		 * Olympus:
		 *
		 *   cmp->cpu->cpu->cpu->cpu->(next board nodes)
		 *   / \
		 * core core
		 *
		 * Jupiter:
		 *
		 * cmp->cpu->cpu->cpu->cpu->cpu->cpu->cpu->cpu->(board nodes)
		 *   |
		 *  _____________
		 * /   \    \    \
		 * core core core core
		 *
		 *
		 * where "/" or "\" are children
		 *    and "->" are siblings
		 *
		 */
		for (cpu = pnode->sibling; cpu != NULL; ) {
			Prom_node	*cpu_next = NULL;

			name = get_node_name(cpu);
			if ((name == NULL) || (strncmp(name, "cpu", 3) != 0)) {
				break;
			}

			/* Id assigned to Virtual processor core */
			cpuid = (int *)get_prop_val(find_prop(cpu, "cpuid"));
			cpu_next = cpu->sibling;

			if (cpu_next != NULL) {
				name = get_node_name(cpu_next);

				if ((name == NULL) ||
				    (strncmp(name, "cpu", 3) != 0)) {
					cpu_next = NULL;
				}
			}

			if (cpuid != NULL) {
				/* Used for printing in comma format */
				(void) sprintf(cpu_str, "%4d", *cpuid);
				(void) strlcat(fcpu_str, cpu_str, MAXSTRLEN);

				if (cpu_next != NULL) {
					(void) strlcat(fcpu_str, ",",
					    MAXSTRLEN);
				}
			} else {
				(void) sprintf(cpu_str, "%4s", "N/A");
				(void) strlcat(fcpu_str, cpu_str, MAXSTRLEN);

				if (cpu_next != NULL) {
					(void) strlcat(fcpu_str, ",",
					    MAXSTRLEN);
				}
			}
			cpu = cpu_next;
		}

		log_printf("%-40.40s", fcpu_str, 0);

		/* Running frequency */
		if (freq != 0)
			log_printf("  %4ld  ", freq, 0);
		else
			log_printf("  %4s  ", "N/A", 0);

		/* L2 cache size */
		if (l2cache_size == NULL)
			log_printf(" %3s    ", "N/A", 0);
		else {
			log_printf("%4.1f   ",
			    (float)(*l2cache_size) / (float)(1<<20), 0);
		}


		/* Implementation number of processor */
		if (impl != NULL)
			log_printf("  %4d  ", *impl, 0);
		else
			log_printf(" %4s     ", "N/A", 0);

		/* Mask Set version */
		/* Bits 31:24 of VER register is mask. */
		/* Mask value : Non MTP mode - 00-7f, MTP mode - 80-ff */
		if (mask == NULL)
			log_printf("%3s", "N/A", 0);
		else
			log_printf("%-3d", (*mask)&0xff, 0);

		log_printf("\n", 0);

	}
}

/*
 * Gather memory information: Details of memory information.
 */
static uint64_t
get_opl_mem_regs(Board_node *bnode)
{
	Prom_node	*pnode;
	struct		cs_status	*cs_stat;
	uint64_t	total_mem = 0;
	int		cs_size, ngrps;

	pnode = dev_find_node(bnode->nodes, "pseudo-mc");
	while (pnode != NULL) {

		cs_size = get_prop_size(find_prop(pnode, "cs-status"));

		if (cs_size > 0) {
			int	*mirror_mode = NULL;
			int	mode = 0;

			/* OBP returns lists of 7 ints */
			cs_stat = (struct cs_status *)get_prop_val
			    (find_prop(pnode, "cs-status"));

			mirror_mode = (int *)(get_prop_val
			    (find_prop(pnode, "mirror-mode")));

			if (mirror_mode != NULL)
				mode = (*mirror_mode);

			/*
			 * The units of cs_size will be either number of bytes
			 * or number of int array elements as this is derived
			 * from the libprtdiag Prop node size field which has
			 * inconsistent units.   Until this is addressed in
			 * libprtdiag, we need a heuristic to determine the
			 * number of CS groups.  Given that the maximum number
			 * of CS groups is 2, the maximum number of cs-status
			 * array elements will be 2*7=14.  Since this is smaller
			 * than the byte size of a single struct status, we use
			 * this to decide if we are dealing with bytes or array
			 * elements in determining the number of CS groups.
			 */
			if (cs_size < sizeof (struct cs_status)) {
				/* cs_size is number of total int [] elements */
				ngrps = cs_size / 7;
			} else {
				/* cs_size is total byte count */
				ngrps = cs_size/sizeof (struct cs_status);
			}

			if (cs_stat != NULL) {
				total_mem +=
				    print_opl_memory_line(bnode->board_num,
				    cs_stat, ngrps, mode);
			}
		}

		pnode = dev_next_node(pnode, "pseudo-mc");
	}
	return (total_mem);
}

/*
 * Display memory information.
 */
void
display_memoryconf(Sys_tree *tree)
{
	Board_node	*bnode = tree->bd_list;
	uint64_t	total_mem = 0, total_sys_mem = 0;
	char *hdrfmt =  "\n%-5.5s  %-6.6s  %-18.18s  %-10.10s"
	    " %-6.6s  %-5.5s %-7.7s %-10.10s";

	(void) textdomain(TEXT_DOMAIN);

	log_printf("============================", 0);
	log_printf(gettext(" Memory Configuration "), 0);
	log_printf("============================", 0);
	log_printf("\n", 0);

	log_printf(hdrfmt,
	    "",
	    gettext("Memory"),
	    gettext("Available"),
	    gettext("Memory"),
	    gettext("DIMM"),
	    gettext("# of"),
	    gettext("Mirror"),
	    gettext("Interleave"),
	    0);

	log_printf(hdrfmt,
	    gettext("LSB"),
	    gettext("Group"),
	    gettext("Size"),
	    gettext("Status"),
	    gettext("Size"),
	    gettext("DIMMs"),
	    gettext("Mode"),
	    gettext("Factor"), 0);

	log_printf(hdrfmt,
	    "---", "-------", "------------------", "-------", "------",
	    "-----", "-------", "----------",  0);

	log_printf("\n", 0);

	for (bnode = tree->bd_list; bnode != NULL; bnode = bnode->next) {
		total_mem += get_opl_mem_regs(bnode);
	}

	/*
	 * Sanity check to ensure that the total amount of system
	 * memory matches the total number of memory that
	 * we find here. Display error message if there is a mis-match.
	 */
	total_sys_mem = (((uint64_t)sysconf(_SC_PAGESIZE) * (uint64_t)sysconf
	    (_SC_PHYS_PAGES)) / MBYTE);

	if (total_mem != total_sys_mem) {
		log_printf(dgettext(TEXT_DOMAIN, "\nError:total available "
		    "size [%lldMB] does not match total system memory "
		    "[%lldMB]\n"), total_mem, total_sys_mem, 0);
	}

}

/*
 * This function provides Opl's formatting of the memory config
 * information that get_opl_mem_regs() has gathered.
 */
static uint64_t
print_opl_memory_line(int lsb, struct cs_status *cs_stat, int ngrps,
	int mirror_mode)
{
	int	i;
	uint64_t	total_board_mem = 0;
	int		i_factor = 2;   /* default to non-mirror mode */
	int		interleave;

	(void) textdomain(TEXT_DOMAIN);

	if (mirror_mode)
		i_factor *= 2;

	/*
	 * Interleave factor calculation:
	 * Obtain "mirror-mode" property from pseudo-mc.
	 * cs_stat[0].dimms/i_factor represents interleave factor per
	 * pseudo-mc node. Must use cs_stat[0].dimms since this will yield
	 * interleave factor even if some DIMMs are isolated, except for
	 * the case where the entire memory group has been deconfigured (eg. due
	 * to DIMM failure); in this case, we use the second memory group
	 * (i.e. cs_stat[1]).
	 *
	 * Mirror mode:
	 *   interleave factor = (# of DIMMs on cs_stat[0]/4)
	 *
	 * Non-mirror mode:
	 *   interleave factor = (# of DIMMs on cs_stat[0]/2)
	 */

	if (cs_stat[0].dimms == 0)
		interleave = cs_stat[1].dimms/i_factor;
	else
		interleave = cs_stat[0].dimms/i_factor;


	for (i = 0; i < ngrps; i++) {
		uint64_t	mem_size;

		mem_size = ((((uint64_t)cs_stat[i].avail_hi)<<32) +
		    cs_stat[i].avail_lo);

		if (mem_size == 0)
			continue;

		/* Lsb Id */
		log_printf(" %02d    ", lsb, 0);

		/* Memory Group Number */
		if ((cs_stat[i].cs_number) == 0)
			log_printf("%-6.6s", "A", 0);
		else
			log_printf("%-6.6s", "B", 0);

		/* Memory Group Size */
		log_printf("%8lldMB            ", mem_size/MBYTE, 0);

		total_board_mem += (mem_size/MBYTE);

		/* Memory Group Status */
		log_printf("%-11.11s",
		    cs_stat[i].status ? "partial": "okay", 0);

		/* DIMM Size */
		log_printf("%4lldMB   ",
		    ((((uint64_t)cs_stat[i].dimm_hi)<<32)
		    + cs_stat[i].dimm_lo)/MBYTE, 0);

		/* Number of DIMMs */
		log_printf("  %2d", cs_stat[i].dimms);

		/* Mirror Mode */
		if (mirror_mode) {
			log_printf("%-4.4s", " yes");
		} else
			log_printf("%-4.4s", " no ");

		/* Interleave Factor */
		if (interleave)
			log_printf("      %d-way\n", interleave);
		else
			log_printf("      None\n");
	}
	return (total_board_mem);
}

/*
 * Details of hardware revision and environmental status.
 */
/*ARGSUSED*/
void
display_diaginfo(int flag, Prom_node *root, Sys_tree *tree,
	struct system_kstat_data *kstats)
{
	/* Print the PROM revisions */
	opl_disp_hw_revisions(tree, root);
}

/*
 * Gather and display hardware revision and environmental status
 */
/*ARGSUSED*/
static void
opl_disp_hw_revisions(Sys_tree *tree, Prom_node *root)
{
	char		*version;
	Prom_node	*pnode;
	int		value;

	(void) textdomain(TEXT_DOMAIN);

	/* Print the header */
	log_printf("\n", 0);
	log_printf("====================", 0);
	log_printf(gettext(" Hardware Revisions "), 0);
	log_printf("====================", 0);
	log_printf("\n\n", 0);

	/* Display Prom revision header */
	log_printf(gettext("System PROM revisions:"), 0);
	log_printf("\n----------------------\n", 0);
	log_printf("\n", 0);

	/* Display OBP version info */
	pnode = dev_find_node(root, "openprom");
	if (pnode != NULL) {
		version = (char *)get_prop_val(find_prop(pnode, "version"));
		if (version != NULL)
			log_printf("%s\n\n", version, 0);
		else
			log_printf("%s\n\n", "N/A", 0);
	}

	/* Print the header */
	log_printf("\n", 0);
	log_printf("===================", 0);
	log_printf(gettext(" Environmental Status "), 0);
	log_printf("===================", 0);
	log_printf("\n\n", 0);

	opl_disp_environ();

	/*
	 * PICL interface needs to be used for system processor mode display.
	 * Check existence of OBP property "SPARC64-VII-mode".
	 * No display if property does not exist.
	 * If property exists then system is in (Jupiter) SPARC64-VII-mode.
	 */
	value = get_proc_mode();

	if (value == 0) {
		/* Print the header */
		log_printf("\n", 0);
		log_printf("===================", 0);
		log_printf(gettext(" System Processor Mode "), 0);
		log_printf("===================", 0);
		log_printf("\n\n", 0);

		/* Jupiter mode */
		log_printf("%s\n\n", "SPARC64-VII mode");
	}
}

/*
 * Gather environmental information
 */
static void
opl_disp_environ(void)
{
	kstat_ctl_t *kc;
	kstat_t *ksp;
	kstat_named_t   *k;

	if ((kc = kstat_open()) == NULL)
		return;

	if ((ksp = kstat_lookup
	    (kc, "scfd", 0, SCF_SYSTEM_KSTAT_NAME)) == NULL) {
		(void) kstat_close(kc);
		return;
	}

	if (kstat_read(kc, ksp, NULL) == -1) {
		(void) kstat_close(kc);
		return;
	}

	if ((k = (kstat_named_t *)kstat_data_lookup
	    (ksp, SCF_SECURE_MODE_KSTAT_NAMED)) == NULL) {
		(void) kstat_close(kc);
		return;
	}

	if (k->value.c[0] == SCF_STAT_MODE_LOCK)
		log_printf("Mode switch is in LOCK mode ", 0);
	else if (k->value.c[0] == SCF_STAT_MODE_UNLOCK)
		log_printf("Mode switch is in UNLOCK mode", 0);
	else
		log_printf("Mode switch is in UNKNOWN mode", 0);

	log_printf("\n", 0);

	(void) kstat_close(kc);
}


/*
 * Calls do_devinfo() in order to use the libdevinfo device tree
 * instead of OBP's device tree.
 */
int
do_prominfo(int syserrlog, char *pgname, int log_flag, int prt_flag)
{
	v_flag = syserrlog;
	return (do_devinfo(syserrlog, pgname, log_flag, prt_flag));
}

/*
 * Return the property value for the Prop
 * passed in. (When using libdevinfo)
 */
void *
get_prop_val(Prop *prop)
{
	if (prop == NULL)
		return (NULL);

	return ((void *)(prop->value.val_ptr));
}

/*
 * Return the property size for the Prop
 * passed in. (When using libdevinfo)
 */
static int
get_prop_size(Prop *prop)
{

	if ((prop != NULL) && (prop->size > 0))
		return (prop->size);
	else
		return (0);
}


/*
 * Search a Prom node and retrieve the property with the correct
 * name. (When using libdevinfo)
 */
Prop *
find_prop(Prom_node *pnode, char *name)
{
	Prop *prop;

	if (pnode == NULL)
		return (NULL);

	for (prop = pnode->props; prop != NULL; prop = prop->next) {
		if (prop->name.val_ptr != NULL &&
		    strcmp((char *)(prop->name.val_ptr), name) == 0)
			break;
	}

	return (prop);
}

/*
 * This function adds a board node to the board structure where that
 * that node's physical component lives.
 */
void
add_node(Sys_tree *root, Prom_node *pnode)
{
	int board;
	Board_node *bnode;
	Prom_node *p;
	char *type;

	if ((board = get_board_num(pnode)) == -1) {
		type = get_node_type(pnode);
		if ((type != NULL) && (strcmp(type, "cpu") == 0))
			board = get_board_num((pnode->parent)->parent);
	}

	/* find the node with the same board number */
	if ((bnode = find_board(root, board)) == NULL) {
		bnode = insert_board(root, board);
		bnode->board_type = UNKNOWN_BOARD;
	}

	/* now attach this prom node to the board list */
	/* Insert this node at the end of the list */
	pnode->sibling = NULL;
	if (bnode->nodes == NULL)
		bnode->nodes = pnode;
	else {
		p = bnode->nodes;
		while (p->sibling != NULL)
			p = p->sibling;
		p->sibling = pnode;
	}

}