int main(int argc, char **argv)
{
	char *guid_file = "port_guids.list";
	int mgmt_classes[2] = { IB_SMI_CLASS, IB_SMI_DIRECT_CLASS };
	ib_portid_t dport_id;
	int port, agent;
	uint8_t *umad;
	int len;

	if (argc > 1)
		guid_file = argv[1];

	srcport = mad_rpc_open_port(NULL, 0, mgmt_classes, 2);
	if (!srcport)
		err("Failed to open port");

	resolve_sm_portid(NULL, 0, &dport_id);
	dport_id.qp = 1;
	if (!dport_id.qkey)
		dport_id.qkey = IB_DEFAULT_QP1_QKEY;

	len = umad_size() + 256;
	umad = calloc(1, len);
	if (!umad) {
		err("cannot alloc mem for umad: %s\n", strerror(errno));
		return -1;
	}
	port = mad_rpc_portid(srcport);

	agent = umad_register(port, IB_SA_CLASS, 2, 0, NULL);

	rereg_and_test_port(guid_file, port, agent, &dport_id, TMO);

	free(umad);
	umad_unregister(port, agent);
	umad_close_port(port);
	umad_done();

	return 0;
}
Esempio n. 2
0
static void done(int fd)
{
	umad_close_port(fd);
	umad_done();
}
Esempio n. 3
0
/**
 * Get the type of a device, from name.
 *
 * Output in hca_type
 *
 */
int hcaNameToType(char *dev_name, HCA_Type* hca_type)
{
    MPIDI_STATE_DECL(MPID_STATE_HCANAMETOTYPE);
    MPIDI_FUNC_ENTER(MPID_STATE_HCANAMETOTYPE);
    int mpi_errno = MPI_SUCCESS;
    int rate;

    *hca_type = UNKNOWN_HCA;

    if (!strncmp(dev_name, "mlx4", 4) || !strncmp(dev_name, "mthca", 5)) {
        umad_ca_t umad_ca;

        *hca_type = MLX_PCI_X;

        if (umad_init() < 0) {
            MPIU_ERR_SETANDJUMP(mpi_errno, MPI_ERR_OTHER, "**umadinit");
        }

        memset(&umad_ca, 0, sizeof(umad_ca_t));
        if (umad_get_ca(dev_name, &umad_ca) < 0) {
            MPIU_ERR_SETANDJUMP(mpi_errno, MPI_ERR_OTHER, "**umadgetca");
        }

        rate = get_rate(&umad_ca);
        if (!rate) {
            umad_release_ca(&umad_ca);
            umad_done();
            MPIU_ERR_SETANDJUMP(mpi_errno, MPI_ERR_OTHER, "**umadgetrate");
        }

        if (!strncmp(dev_name, "mthca", 5)) {
            *hca_type = MLX_PCI_X;

            if (!strncmp(umad_ca.ca_type, "MT25", 4)) {
                switch (rate) {
                case 20:
                    *hca_type = MLX_PCI_EX_DDR;
                    break;
                case 10:
                    *hca_type = MLX_PCI_EX_SDR;
                    break;
                default:
                    *hca_type = MLX_PCI_EX_SDR;
                    break;
                }
            } else if (!strncmp(umad_ca.ca_type, "MT23", 4)) {
                *hca_type = MLX_PCI_X;
            } else {
                *hca_type = MLX_PCI_EX_SDR;
            }
        } else { /* mlx4 */
            switch(rate) {
            case 40:
                *hca_type = MLX_CX_QDR;
                break;
            case 20:
                *hca_type = MLX_CX_DDR;
                break;
            case 10:
                *hca_type = MLX_CX_SDR;
                break;
            default:
                *hca_type = MLX_CX_SDR;
                break;
            }
        }

        umad_release_ca(&umad_ca);
        umad_done();
    } else if(!strncmp(dev_name, "ipath", 5)) {
        *hca_type = PATH_HT;
    } else if(!strncmp(dev_name, "ehca", 4)) {
        *hca_type = IBM_EHCA;
    } else if (!strncmp(dev_name, "cxgb3", 5)) {
        *hca_type = CHELSIO_T3;
    } else if (!strncmp(dev_name, "cxgb4", 5)) {
        *hca_type = CHELSIO_T4;
    } else {
        *hca_type = UNKNOWN_HCA;
    }

fn_fail:
    MPIDI_FUNC_EXIT(MPID_STATE_HCANAMETOTYPE);
    return mpi_errno;
}