/*
* Copyright (c) 2009 Sun Microsystems, Inc. All rights reserved.
* Copyright (c) 2004-2009 Voltaire, Inc. All rights reserved.
* Copyright (c) 2002-2015 Mellanox Technologies LTD. All rights reserved.
* Copyright (c) 1996-2003 Intel Corporation. All rights reserved.
*
* This software is available to you under a choice of one of two
* licenses. You may choose to be licensed under the terms of the GNU
* General Public License (GPL) Version 2, available from the file
* COPYING in the main directory of this source tree, or the
* OpenIB.org BSD license below:
*
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
*
* - Redistributions of source code must retain the above
* copyright notice, this list of conditions and the following
* disclaimer.
*
* - Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials
* provided with the distribution.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
/*
* Abstract:
* Various OpenSM dumpers
*/
#if HAVE_CONFIG_H
# include <config.h>
#endif /* HAVE_CONFIG_H */
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <iba/ib_types.h>
#include <complib/cl_qmap.h>
#include <complib/cl_debug.h>
#include <opensm/osm_file_ids.h>
#define FILE_ID OSM_FILE_DUMP_C
#include <opensm/osm_opensm.h>
#include <opensm/osm_log.h>
#include <opensm/osm_node.h>
#include <opensm/osm_switch.h>
#include <opensm/osm_helper.h>
#include <opensm/osm_msgdef.h>
#include <opensm/osm_opensm.h>
static void dump_ucast_path_distribution(cl_map_item_t * item, FILE * file,
void *cxt)
{
osm_node_t *p_node;
osm_node_t *p_remote_node;
uint8_t i;
uint8_t num_ports;
uint32_t num_paths;
ib_net64_t remote_guid_ho;
osm_switch_t *p_sw = (osm_switch_t *) item;
p_node = p_sw->p_node;
num_ports = p_sw->num_ports;
fprintf(file, "dump_ucast_path_distribution: Switch 0x%" PRIx64 "\n"
"Port : Path Count Through Port",
cl_ntoh64(osm_node_get_node_guid(p_node)));
for (i = 0; i < num_ports; i++) {
num_paths = osm_switch_path_count_get(p_sw, i);
fprintf(file, "\n %03u : %u", i, num_paths);
if (i == 0) {
fprintf(file, " (switch management port)");
continue;
}
p_remote_node = osm_node_get_remote_node(p_node, i, NULL);
if (p_remote_node == NULL)
continue;
remote_guid_ho =
cl_ntoh64(osm_node_get_node_guid(p_remote_node));
switch (osm_node_get_type(p_remote_node)) {
case IB_NODE_TYPE_SWITCH:
fprintf(file, " (link to switch");
break;
case IB_NODE_TYPE_ROUTER:
fprintf(file, " (link to router");
break;
case IB_NODE_TYPE_CA:
fprintf(file, " (link to CA");
break;
default:
fprintf(file, " (link to unknown node type");
break;
}
fprintf(file, " 0x%" PRIx64 ")", remote_guid_ho);
}
fprintf(file, "\n");
}
static void dump_ucast_routes(cl_map_item_t * item, FILE * file, void *cxt)
{
const osm_node_t *p_node;
osm_port_t *p_port;
uint8_t port_num;
uint8_t num_hops;
uint8_t best_hops;
uint8_t best_port;
uint16_t max_lid_ho;
uint16_t lid_ho, base_lid;
boolean_t direct_route_exists = FALSE;
boolean_t dor;
osm_switch_t *p_sw = (osm_switch_t *) item;
osm_opensm_t *p_osm = cxt;
p_node = p_sw->p_node;
max_lid_ho = p_sw->max_lid_ho;
fprintf(file, "dump_ucast_routes: "
"Switch 0x%016" PRIx64 "\nLID : Port : Hops : Optimal\n",
cl_ntoh64(osm_node_get_node_guid(p_node)));
dor = (p_osm->routing_engine_used &&
p_osm->routing_engine_used->type == OSM_ROUTING_ENGINE_TYPE_DOR);
for (lid_ho = 1; lid_ho <= max_lid_ho; lid_ho++) {
fprintf(file, "0x%04X : ", lid_ho);
p_port = osm_get_port_by_lid_ho(&p_osm->subn, lid_ho);
if (!p_port) {
fprintf(file, "UNREACHABLE\n");
continue;
}
port_num = osm_switch_get_port_by_lid(p_sw, lid_ho,
OSM_NEW_LFT);
if (port_num == OSM_NO_PATH) {
/*
This may occur if there are 'holes' in the existing
LID assignments. Running SM with --reassign_lids
will reassign and compress the LID range. The
subnet should work fine either way.
*/
fprintf(file, "UNREACHABLE\n");
continue;
}
/*
Switches can lie about which port routes a given
lid due to a recent reconfiguration of the subnet.
Therefore, ensure that the hop count is better than
OSM_NO_PATH.
*/
if (p_port->p_node->sw) {
/* Target LID is switch.
Get its base lid and check hop count for this base LID only. */
base_lid = osm_node_get_base_lid(p_port->p_node, 0);
base_lid = cl_ntoh16(base_lid);
num_hops =
osm_switch_get_hop_count(p_sw, base_lid, port_num);
} else {
/* Target LID is not switch (CA or router).
Check if we have route to this target from current switch. */
num_hops =
osm_switch_get_hop_count(p_sw, lid_ho, port_num);
if (num_hops != OSM_NO_PATH) {
direct_route_exists = TRUE;
base_lid = lid_ho;
} else {
osm_physp_t *p_physp = p_port->p_physp;
if (!p_physp || !p_physp->p_remote_physp ||
!p_physp->p_remote_physp->p_node->sw)
num_hops = OSM_NO_PATH;
else {
base_lid =
osm_node_get_base_lid(p_physp->
p_remote_physp->
p_node, 0);
base_lid = cl_ntoh16(base_lid);
num_hops =
p_physp->p_remote_physp->p_node->
sw ==
p_sw ? 0 :
osm_switch_get_hop_count(p_sw,
base_lid,
port_num);
}
}
}
if (num_hops == OSM_NO_PATH) {
fprintf(file, "%03u : HOPS UNKNOWN\n", port_num);
continue;
}
best_hops = osm_switch_get_least_hops(p_sw, base_lid);
if (!p_port->p_node->sw && !direct_route_exists) {
best_hops++;
num_hops++;
}
fprintf(file, "%03u : %02u : ", port_num, num_hops);
if (best_hops == num_hops)
fprintf(file, "yes");
else {
/* No LMC Optimization */
best_port = osm_switch_recommend_path(p_sw, p_port,
lid_ho, 1, TRUE,
FALSE, dor,
p_osm->subn.opt.port_shifting,
p_osm->subn.opt.scatter_ports,
OSM_NEW_LFT);
fprintf(file, "No %u hop path possible via port %u!",
best_hops, best_port);
}
fprintf(file, "\n");
}
}
static void dump_mcast_routes(cl_map_item_t * item, FILE * file, void *cxt)
{
osm_switch_t *p_sw = (osm_switch_t *) item;
osm_mcast_tbl_t *p_tbl;
int16_t mlid_ho = 0;
int16_t mlid_start_ho;
uint8_t position = 0;
int16_t block_num = 0;
boolean_t first_mlid;
boolean_t first_port;
const osm_node_t *p_node;
uint16_t i, j;
uint16_t mask_entry;
char sw_hdr[256];
char mlid_hdr[32];
p_node = p_sw->p_node;
p_tbl = osm_switch_get_mcast_tbl_ptr(p_sw);
sprintf(sw_hdr, "\nSwitch 0x%016" PRIx64 "\nLID : Out Port(s)\n",
cl_ntoh64(osm_node_get_node_guid(p_node)));
first_mlid = TRUE;
while (block_num <= p_tbl->max_block_in_use) {
mlid_start_ho = (uint16_t) (block_num * IB_MCAST_BLOCK_SIZE);
for (i = 0; i < IB_MCAST_BLOCK_SIZE; i++) {
mlid_ho = mlid_start_ho + i;
position = 0;
first_port = TRUE;
sprintf(mlid_hdr, "0x%04X :",
mlid_ho + IB_LID_MCAST_START_HO);
while (position <= p_tbl->max_position) {
mask_entry =
cl_ntoh16((*p_tbl->
p_mask_tbl)[mlid_ho][position]);
if (mask_entry == 0) {
position++;
continue;
}
for (j = 0; j < 16; j++) {
if ((1 << j) & mask_entry) {
if (first_mlid) {
fprintf(file, "%s",
sw_hdr);
first_mlid = FALSE;
}
if (first_port) {
fprintf(file, "%s",
mlid_hdr);
first_port = FALSE;
}
fprintf(file, " 0x%03X ",
j + (position * 16));
}
}
position++;
}
if (first_port == FALSE)
fprintf(file, "\n");
}
block_num++;
}
}
static void dump_lid_matrix(cl_map_item_t * item, FILE * file, void *cxt)
{
osm_switch_t *p_sw = (osm_switch_t *) item;
osm_opensm_t *p_osm = cxt;
osm_node_t *p_node = p_sw->p_node;
unsigned max_lid = p_sw->max_lid_ho;
unsigned max_port = p_sw->num_ports;
uint16_t lid;
uint8_t port;
fprintf(file, "Switch: guid 0x%016" PRIx64 "\n",
cl_ntoh64(osm_node_get_node_guid(p_node)));
for (lid = 1; lid <= max_lid; lid++) {
osm_port_t *p_port;
if (osm_switch_get_least_hops(p_sw, lid) == OSM_NO_PATH)
continue;
fprintf(file, "0x%04x:", lid);
for (port = 0; port < max_port; port++)
fprintf(file, " %02x",
osm_switch_get_hop_count(p_sw, lid, port));
p_port = osm_get_port_by_lid_ho(&p_osm->subn, lid);
if (p_port)
fprintf(file, " # portguid 0x%016" PRIx64,
cl_ntoh64(osm_port_get_guid(p_port)));
fprintf(file, "\n");
}
}
static void dump_ucast_lfts(cl_map_item_t * item, FILE * file, void *cxt)
{
osm_switch_t *p_sw = (osm_switch_t *) item;
osm_opensm_t *p_osm = cxt;
osm_node_t *p_node = p_sw->p_node;
unsigned max_lid = p_sw->max_lid_ho;
unsigned max_port = p_sw->num_ports;
uint16_t lid;
uint8_t port;
fprintf(file, "Unicast lids [0-%u] of switch Lid %u guid 0x%016"
PRIx64 " (\'%s\'):\n",
max_lid, cl_ntoh16(osm_node_get_base_lid(p_node, 0)),
cl_ntoh64(osm_node_get_node_guid(p_node)), p_node->print_desc);
for (lid = 0; lid <= max_lid; lid++) {
osm_port_t *p_port;
port = osm_switch_get_port_by_lid(p_sw, lid, OSM_NEW_LFT);
if (port >= max_port)
continue;
fprintf(file, "0x%04x %03u # ", lid, port);
p_port = osm_get_port_by_lid_ho(&p_osm->subn, lid);
if (p_port) {
p_node = p_port->p_node;
fprintf(file, "%s portguid 0x%016" PRIx64 ": \'%s\'",
ib_get_node_type_str(osm_node_get_type(p_node)),
cl_ntoh64(osm_port_get_guid(p_port)),
p_node->print_desc);
} else
fprintf(file, "unknown node and type");
fprintf(file, "\n");
}
fprintf(file, "%u lids dumped\n", max_lid);
}
static void dump_topology_node(cl_map_item_t * item, FILE * file, void *cxt)
{
osm_node_t *p_node = (osm_node_t *) item;
uint32_t cPort;
osm_node_t *p_nbnode;
osm_physp_t *p_physp, *p_default_physp, *p_rphysp;
uint8_t link_speed_act;
const char *link_speed_act_str, *link_width_act_str;
if (!p_node->node_info.num_ports)
return;
for (cPort = 1; cPort < osm_node_get_num_physp(p_node); cPort++) {
uint8_t port_state;
p_physp = osm_node_get_physp_ptr(p_node, cPort);
if (!p_physp)
continue;
p_rphysp = p_physp->p_remote_physp;
if (!p_rphysp)
continue;
CL_ASSERT(cPort == p_physp->port_num);
if (p_node->node_info.node_type == IB_NODE_TYPE_SWITCH)
p_default_physp = osm_node_get_physp_ptr(p_node, 0);
else
p_default_physp = p_physp;
fprintf(file, "{ %s%s Ports:%02X SystemGUID:%016" PRIx64
" NodeGUID:%016" PRIx64 " PortGUID:%016" PRIx64
" VenID:%06X DevID:%04X Rev:%08X {%s} LID:%04X PN:%02X } ",
p_node->node_info.node_type == IB_NODE_TYPE_SWITCH ?
"SW" : p_node->node_info.node_type ==
IB_NODE_TYPE_CA ? "CA" : p_node->node_info.node_type ==
IB_NODE_TYPE_ROUTER ? "Rt" : "**",
p_default_physp->port_info.base_lid ==
p_default_physp->port_info.
master_sm_base_lid ? "-SM" : "",
p_node->node_info.num_ports,
cl_ntoh64(p_node->node_info.sys_guid),
cl_ntoh64(p_node->node_info.node_guid),
cl_ntoh64(p_physp->port_guid),
cl_ntoh32(ib_node_info_get_vendor_id
(&p_node->node_info)),
cl_ntoh16(p_node->node_info.device_id),
cl_ntoh32(p_node->node_info.revision),
p_node->print_desc,
cl_ntoh16(p_default_physp->port_info.base_lid), cPort);
p_nbnode = p_rphysp->p_node;
if (p_nbnode->node_info.node_type == IB_NODE_TYPE_SWITCH)
p_default_physp = osm_node_get_physp_ptr(p_nbnode, 0);
else
p_default_physp = p_rphysp;
fprintf(file, "{ %s%s Ports:%02X SystemGUID:%016" PRIx64
" NodeGUID:%016" PRIx64 " PortGUID:%016" PRIx64
" VenID:%08X DevID:%04X Rev:%08X {%s} LID:%04X PN:%02X } ",
p_nbnode->node_info.node_type == IB_NODE_TYPE_SWITCH ?
"SW" : p_nbnode->node_info.node_type ==
IB_NODE_TYPE_CA ? "CA" :
p_nbnode->node_info.node_type == IB_NODE_TYPE_ROUTER ?
"Rt" : "**",
p_default_physp->port_info.base_lid ==
p_default_physp->port_info.
master_sm_base_lid ? "-SM" : "",
p_nbnode->node_info.num_ports,
cl_ntoh64(p_nbnode->node_info.sys_guid),
cl_ntoh64(p_nbnode->node_info.node_guid),
cl_ntoh64(p_rphysp->port_guid),
cl_ntoh32(ib_node_info_get_vendor_id
(&p_nbnode->node_info)),
cl_ntoh32(p_nbnode->node_info.device_id),
cl_ntoh32(p_nbnode->node_info.revision),
p_nbnode->print_desc,
cl_ntoh16(p_default_physp->port_info.base_lid),
p_rphysp->port_num);
port_state = ib_port_info_get_port_state(&p_physp->port_info);
link_speed_act =
ib_port_info_get_link_speed_active(&p_physp->port_info);
if (link_speed_act == IB_LINK_SPEED_ACTIVE_2_5)
link_speed_act_str = "2.5";
else if (link_speed_act == IB_LINK_SPEED_ACTIVE_5)
link_speed_act_str = "5";
else if (link_speed_act == IB_LINK_SPEED_ACTIVE_10)
link_speed_act_str = "10";
else
link_speed_act_str = "??";
if (p_physp->ext_port_info.link_speed_active & FDR10)
link_speed_act_str = "FDR10";
if (p_default_physp->port_info.capability_mask & IB_PORT_CAP_HAS_EXT_SPEEDS) {
link_speed_act =
ib_port_info_get_link_speed_ext_active(&p_physp->port_info);
if (link_speed_act == IB_LINK_SPEED_EXT_ACTIVE_14)
link_speed_act_str = "14";
else if (link_speed_act == IB_LINK_SPEED_EXT_ACTIVE_25)
link_speed_act_str = "25";
else if (link_speed_act == IB_LINK_SPEED_EXT_ACTIVE_50)
link_speed_act_str = "50";
else if (link_speed_act != IB_LINK_SPEED_EXT_ACTIVE_NONE)
link_speed_act_str = "??";
}
if (p_physp->port_info.link_width_active == 1)
link_width_act_str = "1x";
else if (p_physp->port_info.link_width_active == 2)
link_width_act_str = "4x";
else if (p_physp->port_info.link_width_active == 4)
link_width_act_str = "8x";
else if (p_physp->port_info.link_width_active == 8)
link_width_act_str = "12x";
else link_width_act_str = "??";
if (p_default_physp->port_info.capability_mask2 &
IB_PORT_CAP2_IS_LINK_WIDTH_2X_SUPPORTED) {
if (p_physp->port_info.link_width_active == 16)
link_width_act_str = "2x";
}
fprintf(file, "PHY=%s LOG=%s SPD=%s\n",
link_width_act_str,
port_state == IB_LINK_ACTIVE ? "ACT" :
port_state == IB_LINK_ARMED ? "ARM" :
port_state == IB_LINK_INIT ? "INI" : "DWN",
link_speed_act_str);
}
}
static void dump_sl2vl_tbl(cl_map_item_t * item, FILE * file, void *cxt)
{
osm_port_t *p_port = (osm_port_t *) item;
osm_node_t *p_node = p_port->p_node;
uint32_t in_port, out_port,
num_ports = p_node->node_info.num_ports;
ib_net16_t base_lid = osm_port_get_base_lid(p_port);
osm_physp_t *p_physp;
ib_slvl_table_t *p_tbl;
int i, n;
char buf[1024];
const char * header_line = "#in out : 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15";
const char * separator_line = "#--------------------------------------------------------";
if (!num_ports)
return;
fprintf(file, "%s 0x%016" PRIx64 ", base LID %d, "
"\"%s\"\n%s\n%s\n",
ib_get_node_type_str(p_node->node_info.node_type),
cl_ntoh64(p_port->guid), cl_ntoh16(base_lid),
p_node->print_desc, header_line, separator_line);
if (p_node->node_info.node_type == IB_NODE_TYPE_SWITCH) {
for (out_port = 0; out_port <= num_ports; out_port++){
p_physp = osm_node_get_physp_ptr(p_node, out_port);
/* no need to print SL2VL table for port that is down */
if (!p_physp || !p_physp->p_remote_physp)
continue;
for (in_port = 0; in_port <= num_ports; in_port++) {
p_tbl = osm_physp_get_slvl_tbl(p_physp, in_port);
for (i = 0, n = 0; i < 16; i++)
n += sprintf(buf + n, " %-2d",
ib_slvl_table_get(p_tbl, i));
fprintf(file, "%-3d %-3d :%s\n",
in_port, out_port, buf);
}
}
} else {
p_physp = p_port->p_physp;
p_tbl = osm_physp_get_slvl_tbl(p_physp, 0);
for (i = 0, n = 0; i < 16; i++)
n += sprintf(buf + n, " %-2d",
ib_slvl_table_get(p_tbl, i));
fprintf(file, "%-3d %-3d :%s\n", 0, 0, buf);
}
fprintf(file, "%s\n\n", separator_line);
}
static void print_node_report(cl_map_item_t * item, FILE * file, void *cxt)
{
osm_node_t *p_node = (osm_node_t *) item;
osm_opensm_t *osm = cxt;
const osm_physp_t *p_physp, *p_remote_physp;
const ib_port_info_t *p_pi;
uint8_t port_num;
uint32_t num_ports;
uint8_t node_type;
node_type = osm_node_get_type(p_node);
num_ports = osm_node_get_num_physp(p_node);
port_num = node_type == IB_NODE_TYPE_SWITCH ? 0 : 1;
for (; port_num < num_ports; port_num++) {
p_physp = osm_node_get_physp_ptr(p_node, port_num);
if (!p_physp)
continue;
fprintf(file, "%-11s : %s : %02X :",
osm_get_manufacturer_str(cl_ntoh64
(osm_node_get_node_guid
(p_node))),
osm_get_node_type_str_fixed_width(node_type), port_num);
p_pi = &p_physp->port_info;
/*
* Port state is not defined for base switch port 0
*/
if (port_num == 0 &&
ib_switch_info_is_enhanced_port0(&p_node->sw->switch_info) == FALSE)
fprintf(file, " :");
else
fprintf(file, " %s :",
osm_get_port_state_str_fixed_width
(ib_port_info_get_port_state(p_pi)));
/*
* LID values are only meaningful in select cases.
*/
if (ib_port_info_get_port_state(p_pi) != IB_LINK_DOWN
&& ((node_type == IB_NODE_TYPE_SWITCH && port_num == 0)
|| node_type != IB_NODE_TYPE_SWITCH))
fprintf(file, " %04X : %01X :",
cl_ntoh16(p_pi->base_lid),
ib_port_info_get_lmc(p_pi));
else
fprintf(file, " : :");
if (port_num == 0 &&
ib_switch_info_is_enhanced_port0(&p_node->sw->switch_info) == FALSE)
fprintf(file, " : : ");
else
fprintf(file, " %s : %s : %s ",
osm_get_mtu_str
(ib_port_info_get_neighbor_mtu(p_pi)),
osm_get_lwa_str(p_pi->link_width_active),
osm_get_lsa_str
(ib_port_info_get_link_speed_active(p_pi),
ib_port_info_get_link_speed_ext_active(p_pi),
ib_port_info_get_port_state(p_pi),
p_physp->ext_port_info.link_speed_active & FDR10));
if (osm_physp_get_port_guid(p_physp) == osm->subn.sm_port_guid)
fprintf(file, "* %016" PRIx64 " *",
cl_ntoh64(osm_physp_get_port_guid(p_physp)));
else
fprintf(file, ": %016" PRIx64 " :",
cl_ntoh64(osm_physp_get_port_guid(p_physp)));
if (port_num
&& (ib_port_info_get_port_state(p_pi) != IB_LINK_DOWN)) {
p_remote_physp = osm_physp_get_remote(p_physp);
if (p_remote_physp)
fprintf(file, " %016" PRIx64 " (%02X)",
cl_ntoh64(osm_physp_get_port_guid
(p_remote_physp)),
osm_physp_get_port_num(p_remote_physp));
else
fprintf(file, " UNKNOWN");
}
fprintf(file, "\n");
}
fprintf(file, "------------------------------------------------------"
"------------------------------------------------\n");
}
struct dump_context {
osm_opensm_t *p_osm;
FILE *file;
void (*func) (cl_map_item_t *, FILE *, void *);
void *cxt;
};
static void dump_item(cl_map_item_t * item, void *cxt)
{
((struct dump_context *)cxt)->func(item,
((struct dump_context *)cxt)->file,
((struct dump_context *)cxt)->cxt);
}
static void dump_qmap(FILE * file, cl_qmap_t * map,
void (*func) (cl_map_item_t *, FILE *, void *), void *cxt)
{
struct dump_context dump_context;
dump_context.file = file;
dump_context.func = func;
dump_context.cxt = cxt;
cl_qmap_apply_func(map, dump_item, &dump_context);
}
void osm_dump_qmap_to_file(osm_opensm_t * p_osm, const char *file_name,
cl_qmap_t * map,
void (*func) (cl_map_item_t *, FILE *, void *),
void *cxt)
{
char path[1024];
FILE *file;
snprintf(path, sizeof(path), "%s/%s",
p_osm->subn.opt.dump_files_dir, file_name);
file = fopen(path, "w");
if (!file) {
OSM_LOG(&p_osm->log, OSM_LOG_ERROR,
"cannot create file \'%s\': %s\n",
path, strerror(errno));
return;
}
dump_qmap(file, map, func, cxt);
fclose(file);
}
static void print_report(osm_opensm_t * osm, FILE * file)
{
fprintf(file, "\n==================================================="
"====================================================\n"
"Vendor : Ty : # : Sta : LID : LMC : MTU : LWA :"
" LSA : Port GUID : Neighbor Port (Port #)\n");
dump_qmap(stdout, &osm->subn.node_guid_tbl, print_node_report, osm);
}
void osm_dump_mcast_routes(osm_opensm_t * osm)
{
if (OSM_LOG_IS_ACTIVE_V2(&osm->log, OSM_LOG_ROUTING))
/* multicast routes */
osm_dump_qmap_to_file(osm, "opensm.mcfdbs",
&osm->subn.sw_guid_tbl,
dump_mcast_routes, osm);
}
void osm_dump_all(osm_opensm_t * osm)
{
if (OSM_LOG_IS_ACTIVE_V2(&osm->log, OSM_LOG_ROUTING)) {
/* unicast routes */
osm_dump_qmap_to_file(osm, "opensm-lid-matrix.dump",
&osm->subn.sw_guid_tbl, dump_lid_matrix,
osm);
osm_dump_qmap_to_file(osm, "opensm-lfts.dump",
&osm->subn.sw_guid_tbl, dump_ucast_lfts,
osm);
if (OSM_LOG_IS_ACTIVE_V2(&osm->log, OSM_LOG_DEBUG))
dump_qmap(stdout, &osm->subn.sw_guid_tbl,
dump_ucast_path_distribution, osm);
/* An attempt to get osm_switch_recommend_path to report the
same routes that a sweep would assign. */
if (osm->subn.opt.scatter_ports)
srandom(osm->subn.opt.scatter_ports);
osm_dump_qmap_to_file(osm, "opensm.fdbs",
&osm->subn.sw_guid_tbl,
dump_ucast_routes, osm);
/* multicast routes */
osm_dump_qmap_to_file(osm, "opensm.mcfdbs",
&osm->subn.sw_guid_tbl,
dump_mcast_routes, osm);
/* SL2VL tables */
if (osm->subn.opt.qos ||
(osm->routing_engine_used &&
osm->routing_engine_used->update_sl2vl))
osm_dump_qmap_to_file(osm, "opensm-sl2vl.dump",
&osm->subn.port_guid_tbl,
dump_sl2vl_tbl, osm);
}
osm_dump_qmap_to_file(osm, "opensm-subnet.lst",
&osm->subn.node_guid_tbl, dump_topology_node,
osm);
if (OSM_LOG_IS_ACTIVE_V2(&osm->log, OSM_LOG_VERBOSE))
print_report(osm, stdout);
}